Runcible Governance Layer Demos

Start here

Type your request in this format:

command: your question or claim

If you do not include a command, Runcible uses draft: automatically.

What the result format means

Runcible now returns one canonical structured report format (report_v2) behind the scenes. That means all clients (including WordPress) can show the same core sections in the same order.

For users, this gives:

• more consistent output across commands
• clearer section-by-section reading
• command-specific extras when needed (for example:
  • refine adds a refinement output block
  • normalize adds plain-language normalization
  • curate adds IEBD triage
  • certify adds admission gate results)

Which command should I use?

• draft:
  Best first step. Quickly rewrites your input into clearer, testable claims.
• curate:
  Use for outside content (articles, posts, threads, videos/transcripts, source summaries).
  It checks source quality and flags possible ignorance, error, bias, or deceit.
• analyze:
  Full protocol analysis of a claim or policy idea.
• refine:
  Improves a claim so it becomes more precise and more decidable.
• legal:
  Legal/doctrinal framing. Use this only when you want legal analysis.
• normalize:
  Turn findings into plain-language arguments for and against, plus the exact closure condition and next decidable subclaims.
• certify:
  Final gate. Checks whether a result is strong enough for truth-corpus admission.

Typical workflow

For most claims:

1. draft: ...
2. analyze: ...
3. refine: ...
4. normalize: ...
5. legal: ... (optional)
6. certify: ... (only when ready for final gate)

For external content:

1. curate: ...
2. analyze: ... (if curate recommends promotion)
3. refine: ...
4. legal: (optional)
5. certify: (optional final gate)

Copy/paste examples

draft: Abortion is a natural right and must be a constitutional right.

curate: Analyze this thread for ignorance, error, bias, and deceit. Then recommend next step.

analyze: Should a state subsidize elective abortion before fetal viability?

refine: Rewrite this claim so two independent adjudicators can apply it without discretion.

legal: Under U.S. constitutional doctrine, what tests apply to abortion regulation?

normalize: Using the prior output, create arguments for and against, then state what must be defined for closure.

certify: Evaluate this finalized claim for admission to truth corpus.

Optional controls (advanced, but still user-safe)

• --depth 1..7 (more depth = more detail)
• --mode analysis|forensic|adaptive|failure|both
• --estimate-input-tokens on|off (show pre-run prompt token estimate in telemetry)
• --phase-continuation on|off (continue from earlier turns more reliably in multi-step workflows)

Example:

analyze: Smoking increases lung cancer risk. --depth 3 --mode forensic

Extra commands (power users)

• help or help: <command>
• align: ...
• test: ...
• call: ...
• stack: ...
• verdict: ...

Tips for better results

• Be specific about who, what, where, and when.
• Include thresholds, definitions, and scope when possible.
• If output says undecidable, run refine: immediately.
• Use legal: only for legal framing; otherwise stay in protocol analysis.

Runcible User Instruction Sheet (Current Workflow)

This is the current user-facing command syntax and workflow for the live system.

1) Command syntax (simple)

Use:

command: your prompt here

Supported commands:

• draft:
• curate:
• analyze:
• refine:
• legal:
• normalize:
• certify:
• help / help: <command>
• align:
• test:
• call:
• stack:
• verdict:

If no command is provided, the system defaults to draft:.

1.1) Canonical output contract (report_v2)

The server now emits a canonical report object at:

output.result.report_v2

report_v2 is command-aware and includes:

• schema_version: runcible.report.v2
• command_mode
• section_order (canonical display order)
• sections (content by section key)
• validation (status, required sections, missing required sections)

For draft and analyze, the canonical reader-facing section order is:

1. routing_context
2. claim_header
3. verdict_card
4. plain_language_result
5. verdict_legend
6. claim_normalization
7. decidability_chain
8. full_accounting
9. liability_section
10. remediation
11. assumptions_defaults_skips
12. protocol_execution_map
13. telemetry
14. appendix

routing_context now includes canonical routing/profile semantics:

• selected domain_hint / client_hint
• hint sources (domain_hint_source, client_hint_source)
• effective profile IDs and stack:
  • effective_domain_profile_id
  • effective_client_profile_id
  • effective_profile_stack
• routing selection source object and overlay provenance:
  • routing_profile_selection_source
  • domain_overlay_files
  • client_overlay_files
  • core_protocol_files

Command-distinct sections are emitted when relevant:

• refine -> refinement_output
• normalize -> normalized_explanation
• curate -> iebd_assessment
• certify -> certify_admission

1.2) Routing diagnostics quick-start (operator)

Use these when routing hints or canonical routing_context behavior appears unstable.

Core checks:

• routing regression (determinism + report_v2 parity):
  • python3 scripts/verify_routing_regression_live.py --function runcible-gateway-prod --region us-west-2 --attempts 2 --timeout 240
• focused canonical routing-context smoke:
  • bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2

Optional failure artifact capture:

• regression artifacts:
  • python3 scripts/verify_routing_regression_live.py --function runcible-gateway-prod --region us-west-2 --attempts 2 --timeout 240 --save-fail-artifacts
• smoke artifacts:
  • bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2 --save-fail-artifacts

Weekly cleanup:

• dry-run:
  • python3 scripts/prune_routing_artifacts.py --days 7
• apply:
  • python3 scripts/prune_routing_artifacts.py --days 7 --apply

1.3) Presentation-profile support (recent change)

What changed:

• Inline parser support is now active for:
  • --presentation-profile <default_user|certification|operator_debug>
• Lambda now emits resolved profile in response metadata:
  • presentation_profile
• Canonical report now reflects profile guidance:
  • output.result.report_v2.presentation_guidance.profile
  • output.result.report_v2.presentation_guidance.target.target_style
• WordPress telemetry drawer now shows:
  • presentation_profile
  • presentation_target_style

Quick check prompt:

• analyze: routing presentation profile probe --depth 1 --mode analysis --presentation-profile operator_debug

1.4) Post-change quick regression checklist (parser/UI telemetry)

Run this after any edit to parser flags, report_v2.presentation_guidance, or telemetry drawer rendering.

Fast path (recommended):

• bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
• expected terminal marker: PRESENTATION_PROFILE_REGRESSION_PASS
• mode guidance:
  • use default/--attempts 2 for readiness confidence (recommended)
  • use --quick for fast local debug loops (single-attempt routing smoke)
• optional shell helper (zsh/bash):
  • alias rpp='bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --attempts 2'
  • then run: rpp
• if this fails (quick ladder):
  1. retry once with robust mode:
     • bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
  2. run routing smoke directly:
     • bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
  3. enable artifact capture for deeper triage:
     • bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2 --save-fail-artifacts

1. Local contract + parser regression:

• python3 scripts/verify_passthrough_contract_gates.py

2. UI telemetry runtime regression:

• node scripts/verify_ui_telemetry_footer_runtime.js

3. Routing-context contract smoke (bounded):

• bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2

4. Live profile probe:

• prompt:
  • analyze: readiness mini checkpoint probe --depth 1 --mode analysis --presentation-profile operator_debug
• expected:
  • protocol_contract_passed=True
  • presentation_profile=operator_debug (response metadata)
  • report_v2.presentation_guidance.profile=operator_debug
  • report_v2.presentation_guidance.target.target_style=diagnostic_full_fidelity

Operator decision table

Use this quick selector for the regression command path:

• Readiness check before release -> bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
• Fast local debug iteration -> bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --quick
• Wrapper failed; isolate routing first -> bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
• Need failure evidence for triage -> bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2 --save-fail-artifacts

Expected outputs (quick pass markers):

• wrapper success: PRESENTATION_PROFILE_REGRESSION_PASS
• routing smoke success: All report_v2 routing context live smoke checks passed.
• profile probe success lines include:
  • probe_presentation_profile=operator_debug
  • probe_presentation_target_style=diagnostic_full_fidelity

Common failure signatures (and first action):

• blocked_protocol_runtime_not_executed -> rerun robust wrapper (--attempts 2) before deeper triage.
• protocol_contract_passed=false with missing report_v2 fields -> run routing smoke directly with --attempts 2.
• repeated routing smoke failure -> rerun with --save-fail-artifacts and inspect captured artifacts.

Escalation threshold (stop-retry rule):

• If robust wrapper + direct routing smoke both fail twice in a row:
  1. capture artifacts (--save-fail-artifacts)
  2. record command + failure signature + artifact path
  3. open/record an issue for follow-up instead of continuing blind retries.

Escalation issue template (copy/paste):

• timestamp:
• environment: function/region:
• command run:
• expected marker:
• observed failure signature:
• retries attempted:
• artifact paths (if any):
• first bad request_id (if available):
• notes:
• minimum evidence to attach: failing *.meta.json, failing *.payload.json, stderr/SMOKE_DEBUG_REPLY_EXCERPT snippet.

Daily operator run order (micro-list):

1. Run robust wrapper (default): bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
2. Confirm pass markers:
   • PRESENTATION_PROFILE_REGRESSION_PASS
   • All report_v2 routing context live smoke checks passed.
3. If failed, rerun direct routing smoke with artifact capture.
4. If wrapper + direct smoke each fail twice consecutively, escalate using the issue template and stop blind retries.

Wrapper flag matrix (quick reference):

• default (readiness): --attempts 2
• fast local debug: --quick (equivalent to routing smoke attempts=1)
• explicit control: --attempts <N> (use N>=2 for release/readiness checks)

Operator handoff blurb (engineering escalation):

Robust wrapper and direct routing smoke each failed twice consecutively. Attached are failing meta/payload artifacts plus stderr/SMOKE_DEBUG_REPLY_EXCERPT. Failure signature: <signature>. First bad request_id: <id-or-none>. Environment: <function>/<region>. Please triage contract/runtime cause before additional retries.

Operator closeout checklist (after successful rerun):

• success markers present (PRESENTATION_PROFILE_REGRESSION_PASS, routing smoke PASS line)
• no new failure artifacts created for final successful attempt
• escalation issue updated with resolution note (or marked closed)
• daily snapshot refreshed if this changed operational guidance

Operator quick card (section map):

• expected outputs (quick pass markers)
• common failure signatures (and first action)
• escalation threshold (stop-retry rule)
• escalation issue template (copy/paste)
• daily operator run order (micro-list)
• wrapper flag matrix (quick reference)
• operator handoff blurb (engineering escalation)
• operator closeout checklist (after successful rerun)

Last known good command set (copy/paste):

• Robust regression wrapper:
  • bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --attempts 2
• Direct routing-context smoke:
  • bash scripts/smoke_report_v2_routing_context_live.sh --function runcible-gateway-prod --region us-west-2 --attempts 2

1.5) Investor demo script (3 scenarios, reproducible)

Use these in sequence for a 7-10 minute demo:

1. Baseline adjudication (draft)
   • Prompt:
     • draft: The earth orbits the moon. --depth 3 --mode forensic
   • What to show:
     • top 0) Command Signature drawer is visible/open
     • first visible sections: Prompt & Operational Definition, Verdict, Summary
     • liability/remediation are present and readable (not dense inline blob text).
2. Full gate pass (analyze)
   • Prompt:
     • analyze: abortion is a natural right and therefore must be a constitutional right. --depth 3 --mode analysis
   • What to show:
     • command signature reflects Analyze
     • Liability and Remediation (Advice) are first-screen available
     • telemetry drawer includes command/depth/mode and presentation-profile fields when present.
3. Workflow progression (refine -> normalize -> legal)
   • Prompt sequence:
     • refine: abortion is a natural right and therefore must be a constitutional right. --depth 3 --mode analysis
     • normalize: abortion is a natural right and therefore must be a constitutional right. --depth 3 --mode analysis
     • legal: abortion is a natural right and therefore must be a constitutional right. --depth 3
   • What to show:
     • command signature changes per command (visible mode distinction)
     • drawers default-open differently by command intent
     • normalized/legal outputs remain structurally consistent while presentation intent changes.

Pass markers to mention live:

• PRESENTATION_PROFILE_REGRESSION_PASS (ops confidence marker)
• All report_v2 routing context live smoke checks passed. (routing parity marker)

Investor meeting checklist (pre / during / fallback):

• Pre-demo (10-15 min before call):
  • hard refresh browser tab
  • run quick confidence check:
    • bash scripts/smoke_presentation_profile_regression.sh --function runcible-gateway-prod --region us-west-2 --quick
  • verify both pass markers above.
• During demo:
  • keep to the 3-script sequence (draft -> analyze -> refine/normalize/legal)
  • point explicitly to 0) Command Signature and the first-screen section order
  • expand only one deep technical drawer unless asked (keeps pacing tight).
• Fallback (if live call fails/transient):
  • rerun robust wrapper (--attempts 2) once
  • if still failing, show last-known-good script + pass markers and continue narrative
  • capture artifacts after call for follow-up (--save-fail-artifacts path).

2) Exact syntax for curation

Use:

curate: <text/article/post/thread/source-summary>

Example:

curate: Platform=X Author=@example Post='Ban short-form social media for minors under 16 now.' Please triage ignorance, error, bias, and deceit risks with evidence references.

What curate: is for:

• intake and triage of external material
• provenance summary
• atomic claim extraction
• IEBD findings (ignorance, error, bias, deceit)
• promotion recommendation:
  • promote_to_analyze
  • repair_then_refine
  • optional_legal_review
  • hold_insufficient_evidence

3) Recommended user workflow

For original claims:

1. draft: (quick decomposition + operationalization + steelman)
2. analyze: (full protocol adjudication)
3. refine: (improve claim to increase decidability/closure)
4. normalize: (produce a human-readable pro/con + closure brief)
5. legal: (only when legal doctrine/jurisdiction analysis is desired)
6. certify: (strict write-gate evaluation for truth corpus admission)

For external content:

1. curate: (source triage + IEBD)
2. if promoted, continue with analyze: then refine: and optionally legal:
3. use normalize: for stakeholder-facing summary output
4. run certify: only when seeking admissible/ingestable closure

4) Copy/paste examples

Draft

draft: abortion is a natural right and therefore must be a constitutional right.

Curate

curate: Here is a thread claiming that all censorship is always harmful. Extract atomic claims, assess IEBD risks, and recommend next step.

Analyze

analyze: claim that abortion is a natural right and therefore must be a constitutional right.

Refine

refine: Improve this claim to be decidable with explicit thresholds, standing, scope, and remedies: abortion is a natural right and therefore must be a constitutional right.

Legal

legal: Under U.S. constitutional doctrine, assess whether abortion can be framed as a fundamental right and what doctrinal tests apply.

Normalize

normalize: Using the prior output, construct a concise argument for and against the assertion, then state closure conditions and decidable subclaims.

Certify

certify: Prior claim is now operationalized with standing, thresholds, evidence, and liability allocation; evaluate for admission.

5) Optional flags

You can append flags to any command:

• --depth <1..7|auto> (current practical default is 3 for most commands)
• --mode <analysis|forensic|adaptive|failure|both>
• --positive-law <on|off> (usually unnecessary when using legal: because legal mode is implied)
• --estimate-input-tokens <on|off> (opt-in pre-run prompt-side token estimate telemetry)
• --phase-continuation <on|off> (opt-in conversation continuation: uses OpenAI previous_response_id when available, otherwise replays recent turns with assistant phase=final_answer)
• --presentation-profile <default_user|certification|operator_debug> (advisory readability target hint; emitted in report_v2.presentation_guidance and telemetry)

Example:

analyze: smoking increases lung cancer risk. --depth 3 --mode forensic

refine: tighten standing/scope thresholds for this claim. --phase-continuation on

6) Certify retraction/rollback (operator-level)

If a previously certified item should be retracted:

• certify: retract <target_ref>
• certify: rollback <target_ref>

These paths are fail-closed and require valid conversation context plus a target reference.

7) User tips

Use certify: only for near-final claims that are contradiction-clean and reliance-ready.

Be explicit about scope, terms, thresholds, and affected parties.

If result is undecidable, use refine: immediately with missing definitions/criteria.

Use legal: only when you want positive-law analysis; otherwise stay protocol-primary.

Command Modes

Each mode controls how the system processes and formats an assertion:
--mode analysis → Full 10-step decidability syntax (structured but neutral).
--mode demo → Simulated example for clarity, lighter than full forensic.
--mode forensic → Forensic adversarial breakdown (exposes parasitism, externalities, reciprocity failures).
--mode adaptive → Context-aware, mixes analytic and forensic as needed.
--mode failure → Identifies failure of claim structure (vagueness, non-operational, undecidable).
--mode both → Combines two modes (e.g., analysis + forensic).

Input Parameters

--claim "<text>" → User’s raw claim, assertion, or question.
--depth <int> → Depth of analysis (1 = surface, 2 = causal, 3 = full forensic).
--temperature <float> → Range 0–1; lower = deterministic, higher = exploratory.

Conversion Parameters

--convert_to operational → Rewrite claim into operational prose (causal, testifiable).
--convert_to testimonial → Rewrite claim into testimonial prose (sworn, warrantable under liability).

Verdict and Summary Output

.verdict.value               # Final judgment (e.g., "True", "False", "Undecidable")
.verdict.protocol            # Protocol used (e.g., TRUTH_PROTOCOL)

.summary                     # One-paragraph natural language summary
.key_findings[]              # List of bullet-point findings

Truth Test Results

.truth_value.value           # "True", "False", or "Undecidable"
.truth_value.protocol        # e.g., "TRUTH_PROTOCOL"

.truth_test_verdict_raw.value     # "Truthful Testimony", etc.
.truth_test_verdict_raw.protocol  # "TRUTH_PROTOCOL"
.truth_test_verdict_raw.basis     # Basis or citation

Remediation Tools

.remediation.trade
.remediation.restitution
.remediation.punishment
.remediation.imitation_prevention

Ten-Step Decidability Syntax

.1_claim
.2_demonstrated_interests
.3_reciprocity_test
.4_testifiability
.5a_decidability_status
.5b_truth_value
.5c_truth_test_verdict_raw
.6_causal_chain
.7_deviation_consequences
.8_externality_exposure
.9_computable_compromise
.10_sex_valence

Grammar Matching

.matched_speech_grammar.grammar_type
.matched_speech_grammar.strategy
.matched_speech_grammar.political_expression
.matched_speech_grammar.epistemic_category

Presentation Metadata

.presentation.alignment_profile
.presentation.alignment_effects[]
.presentation.alignment_delta

Telemetry

.telemetry.checks_run[]         # e.g., "truth", "reciprocity"
.telemetry.time_ms
.telemetry.version
.telemetry.trace_id
.telemetry.depth_requested
.telemetry.depth_actual
.telemetry.mode

Document & Knowledge Navigation

• Ask directly: “Summarize Volume 2, Chapter 5,” or “Compare Volume 1 with Volume 3.”
• Search inside your uploaded files: I can run precise or broad searches (file_search.msearch) across your documents.
• Quote navigation: I can pull citations (filecite…) with line ranges.
• Source filters: Target just uploaded files, or just meeting transcripts, etc.

Canvas & Drafting

• Make a canvas: If you want long-form writing, code, or iterative editing, I can open a canvas doc.
• Update canvases: You can say “replace the intro with a tighter summary,” and I’ll patch the doc.
• Comment canvases: You can request line-by-line feedback or adversarial critique.

Image & Diagram Commands

• Generate: “Draw me a causal chain of measurement → decidability → law.”
• Edit: “Overlay arrows on this diagram,” or “Turn this into a clean chart.”

Forensic / Protocol Analysis

• OUTPUT_CONTRACT schema (from your schemas_normalized_ascii.yaml):
  • I can render any claim inside the 10-step decidability syntax (claim → demonstrated interests → reciprocity → testifiability → decidability → causal chain → consequences → externalities → computable compromise → sex-valence).
  • I can generate structured YAML verdicts, as I’ve been doing, with truth tests, reciprocity tests, and remediation steps.
• Modes: You can request different modes such as:
  • "analysis" – plain operational reduction.
  • "forensic" – adversarial/stress-test.
  • "demo" – simplified narrative translation.
  • "adaptive" – policy/application focus.
  • "failure" – conditions where the claim/system breaks.
  • "both" – combined constructive + adversarial.

Experimental & Simulation Commands

• Stress-test: “Try to falsify this claim.”
• Pilotization: “Design an experiment to test computable law in a small court.”
• Adversarial comparison: “Compare Natural Law to Rawls’ theory of justice under reciprocity tests.”
• Simulation: “Run a causal chain from scarcity → law collapse in 5 steps.”

Epistemic / Style Controls

From our Compiled Protocols v1.json:

• Causal chaining: Always reduce abstractions into operational sequences.
• Bias testing: “Check this claim for masculine/feminine strategy bias.”
• Necessity-contingency grammar: Ask for rewriting in that grammar.
• Steelman / adversarial: Force me to construct best and worst cases.