docs: add fresh factory readonly receipt

docs: map opencode and advisory memory context
docs: quarantine stale phase-claims and gate stale-memory refresh
2026-07-03 09:00:48 +02:00 · 2026-07-03 08:43:15 +02:00 · 2026-07-02 13:08:58 +02:00 · 2026-07-02 12:41:20 +02:00 · 2026-07-02 10:02:00 +02:00 · 2026-07-02 09:23:44 +02:00
53 changed files with 3128 additions and 4 deletions
--- a/.gitignore
+++ b/.gitignore
@ -11,3 +11,6 @@ TEMP/
 .fable/
 .runs/
 nul
+
+/.crew/
+/.pi/
--- a/COMMANDS.md
+++ b/COMMANDS.md
@ -4,6 +4,10 @@ This document mirrors `src/index.ts` command registration and is the canonical C

 Trust boundary: live receipt > committed receipt > memory summary. Memory is advisory only; `8099/deploy` via git-proxy is the guarded deploy route, and `8098/deploy-webhook` is legacy/stale for fable-agent deploy trust.

+Agent-manager rule: agents draft, receipts prove, humans approve, and only guarded `8099/deploy` may ship.
+
+Agent-run traces follow system-card discipline: `fable.agent_run.trace.v1` records budget, environment, safety posture, receipts, latency, and `deployAttempted: false`; capability evidence is not deploy authority.
+
 Last sync: 2026-06-14.

 ## Quick examples
@ -252,6 +256,25 @@ fable-agent plinius godmode "improve explanation quality"

 ### `forgejo`

+- `forgejo repos`
+  - `--user <username>`
+- `forgejo repo <repo>`
+- `forgejo issues <repo>`
+  - `--state <state>`
+- `forgejo prs <repo>`
+  - `--state <state>`
+- `forgejo file <repo> <path>`
+  - `--ref <ref>`
+- `forgejo pr-create <repo>`
+  - `--title <title>`
+  - `--head <branch>`
+  - `--base <branch>`
+  - `--body <text>`
+  - `--out <path>`
+  - `--dry-run`
+- `forgejo actions-coverage`
+  - `--repo <repo>`
+  - `--output <path>`
 - `forgejo intake <ref>`
  - `--repo <repo>`
  - `--out <path>`
@ -326,6 +349,54 @@ fable-agent plinius godmode "improve explanation quality"
  - `--run <id>`
 - `fable5 memory-b-cell <file>`
  - `--cache <path>`
+- `fable5 jailbreak-assess <source>`
+  - `--capability-gain <n>`
+  - `--breadth <n>`
+  - `--weaponization-ease <n>`
+  - `--discoverability <n>`
+  - `--output <path>`
+- `fable5 prompt-fingerprint <file>`
+  - `--output <path>`
+- `fable5 skill-health`
+  - `--input <path>`
+  - `--skill <name>`
+  - `--agent <name>`
+  - `--test-command <command>`
+  - `--passed <n>`
+  - `--failed <n>`
+  - `--evidence <text>`
+  - `--source <source>`
+  - `--threshold <n>`
+  - `--output <path>`
+- `fable5 recovery-receipt`
+  - `--incident <text>`
+  - `--live-signal <text>`
+  - `--action-taken <text>`
+  - `--decision <decision>`
+  - `--stale-signal <text>`
+  - `--root-cause <text>`
+  - `--before <paths>`
+  - `--after <paths>`
+  - `--output <path>`
+- `fable5 context-eval`
+  - `--task <text>`
+  - `--checks <json>`
+  - `--output <path>`
+- `fable5 sleep-time-policy`
+  - `--output <path>`
+- `fable5 context-repo-snapshot <root>`
+  - `--output <path>`
+- `fable5 opencoven-review`
+  - `--output <path>`
+- `fable5 permission-posture`
+  - `--mode <mode>`
+  - `--output <path>`
+- `fable5 stale-memory-quarantine`
+  - `--output <path>`
+- `fable5 falsification`
+  - `--output <path>`
+- `fable5 external-rsi-evidence`
+  - `--output <path>`
 - `fable5 receipt-health`
  - `--root <path>`
  - `--window-minutes <n>`
--- a/README.md
+++ b/README.md
@ -4,6 +4,8 @@

 The harness, not the model. Pi/Codex/Claude can act; fable-agent proves what happened, what verified it, what risk remains, and whether guarded deploy is allowed.

+Fable is an agent-manager layer: agents draft, receipts prove, humans approve, and only the guarded `8099/deploy` path may ship.
+
 ```
 node dist/index.js demo
 # 3 seconds. Research → Learn → Sharpen → Compound. Live data.
--- a/docs/agentic-layer-tac.md
+++ b/docs/agentic-layer-tac.md
@ -36,6 +36,7 @@ PASS real-engineering verify
 ✓ verifier rule present
 ✓ factory status ok
 ✓ deploy route 8099/deploy present
+✓ stale-memory quarantine receipt refreshed: `fable5 stale-memory-quarantine --output .fable/memory/stale-memory-quarantine-live.json` and checked for `blockedTrustPaths` containing `8098/deploy-webhook` and `canonicalTrustPaths` containing `8099/deploy via git-proxy`
 ✓ verify-cycle receipt written
 ✓ agentic attestation attached
 ```
--- a/docs/receipts/README.md
+++ b/docs/receipts/README.md
@ -0,0 +1,36 @@
+# Fable receipts index
+
+Current authority order: **live receipt > committed receipt > memory**.
+
+## Deploy truth
+
+- Canonical deploy path: `8099/deploy via git-proxy` — signed/gated only.
+- Legacy path: `8098/deploy-webhook` — internal/stale, not deploy authority.
+- No deploy without explicit approval and a fresh valid ZTE/factory gate receipt.
+- `auto_patch_proven=false` for fable-agent unless a fresh local degraded-skill canary receipt proves otherwise.
+
+## Current receipts
+
+- `factory-live-readonly-20260703.json` — fresh live read-only 8099 health/factory-status check; reconciles stale 25-container/8098/autopatch memory.
+- `factory-live-readonly-20260702.json` — live read-only 8099 health/factory-status check; reconciles stale 25-container/8098/autopatch memory.
+- `fable5-website-video-advisory-map-20260702.json` — maps the user-supplied Fable 5 animated website workflow transcript as advisory-only process inspiration; proves no product capability or asset rights.
+- `fable-agentic-system-layer-checklist-20260702.json` — maps arXiv 2606.24937 agentic-system layers to local receipts and marks missing proof explicitly.
+- `agentic-ai-hitchhiker-research-map-20260702.json` — treats the arXiv 2606.24937 paper as advisory input only.
+- `stale-memory-quarantine-20260702.json` — quarantines stale `8098`/memory-only deploy claims.
+- `extreme-software-optimization-and-ai-practices-20260702.json` — records external optimization + feedback links as advisory-only process guidance.
+- `stale-memory-context-copy-20260702.json` — captures user-injected memory snippets as advisory-only and reconciles them to current trust rules.
+- `oh-my-opencode-advisory-map-20260703.json` — records the user-supplied OpenCode repository link as advisory-only workflow/config inspiration.
+- `claude-public-artifact-advisory-map-20260702.json` — treats public artifact/system-prompt-like text as advisory only.
+- `adaptive-tap-pair-research-map-20260702.json` — bounds external red-team claims; requires denominators and confirmed/attempted rates.
+- `external-pattern-research-map-20260702.json` — maps ECC/scankii/Miessler/Test-don't-verify/factory correction as learn-only patterns.
+- `kramer-ai-quality-research-map-20260701.json` — production AI quality posture: tests/receipts over code-volume hype.
+- `kelsey-hightower-beyond-code-research-map-20260702.json` — MVI/platform posture: remove before adding, platform as product/API/SLA.
+- `digg-tech-source-signal-research-map-20260702.json` — Digg Tech is advisory source discovery, not primary evidence.
+- `external-tool-audit-20260627.json` — external tool audit with trust boundaries and non-authoritative toolchain claims.
+- `factory-live-drift-20260621.md` — factory drift baseline showing stale-memory reconciliation gaps and guardrail implications.
+- `memory-b-cell-20260621.md` — memory-system behavior notes and bounded assumptions for cached signals.
+- `verify-cycle-apple-20260619.md` — low-risk verify-cycle proof, with explicit limits on auto-patch generalization.
+
+## Memory quarantine
+
+Memory claims about 25 containers, `8098` autonomous deploy, Phase 4 closed loop, and auto-patch authority are advisory until a fresh live or committed receipt re-proves them.
--- a/docs/receipts/adaptive-tap-pair-research-map-20260702.json
+++ b/docs/receipts/adaptive-tap-pair-research-map-20260702.json
@ -0,0 +1,48 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "adaptive-tap-pair-red-team-map",
+  "task": "Map arXiv:2606.18193v1 adaptive TAP-PAIR attacks into bounded Fable red-team reporting constraints",
+  "constraints": [
+    "arXiv:2606.18193v1 and adaptive TAP-PAIR attack results are external-paper advisory only until locally reproduced",
+    "do not report paper headline 94%/96% figures as Fable-verified attack success rate",
+    "represent 94%/96% only as paper-reported robustness/resistance or attempted-versus-confirmed distinction unless a local eval receipt proves otherwise",
+    "future Fable red-team reports must include denominators, attempted counts, confirmed counts, and confirmed-versus-attempted rates",
+    "do not make safety or robustness overclaims without a local eval receipt",
+    "static h4rm3l low-ASR statements are not local authority unless backed by a committed/local receipt",
+    "no external paper code execution, external repo vendoring, dashboards, new packages, or release changes are included in this map"
+  ],
+  "existingPrimitives": [
+    "research-map-receipt",
+    "red-team-harness-receipt",
+    "jailbreak-assessment",
+    "falsification-receipt"
+  ],
+  "recommendedPlan": [
+    {
+      "name": "Bound adaptive TAP-PAIR claims",
+      "goal": "Capture the paper as advisory red-team context and require future Fable reports to separate attempted attacks, confirmed bypasses, denominators, and local evidence.",
+      "acceptanceCriteria": [
+        "receipt records arXiv:2606.18193v1 as advisory only",
+        "94%/96% figures are not described as Fable-verified ASR",
+        "future local claims require denominators and confirmed versus attempted counts",
+        "no external execution or release action is implied"
+      ],
+      "verification": [
+        "cat docs/receipts/adaptive-tap-pair-research-map-20260702.json",
+        "grep -R \"2606.18193\\|TAP-PAIR\\|Fable-verified attack success rate\" docs/receipts"
+      ]
+    }
+  ],
+  "skipped": [
+    "release changes",
+    "external paper code execution",
+    "external repo vendoring",
+    "dashboard changes",
+    "new packages",
+    "local ASR claim without eval receipt"
+  ],
+  "decision": "ready",
+  "reasons": [],
+  "deployAttempted": false
+}
--- a/docs/receipts/agentic-ai-hitchhiker-research-map-20260702.json
+++ b/docs/receipts/agentic-ai-hitchhiker-research-map-20260702.json
@ -0,0 +1,63 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "agentic-ai-hitchhiker-research-map",
+  "task": "Map arXiv:2606.24937v1 into Fable's receipt-first agentic AI posture",
+  "source": {
+    "url": "https://arxiv.org/abs/2606.24937",
+    "pdfUrl": "https://arxiv.org/pdf/2606.24937",
+    "arxivId": "2606.24937",
+    "title": "The Hitchhiker's Guide to Agentic AI: From Foundations to Systems",
+    "authors": ["Haggai Roitman"],
+    "submitted": "2026-06-22",
+    "subjects": ["cs.AI", "cs.CL", "cs.IR", "cs.LG"],
+    "verifiedFrom": "arXiv abstract page metadata fetched during session"
+  },
+  "constraints": [
+    "external arXiv paper claims are advisory until locally reproduced or mapped into committed Fable receipts",
+    "agentic AI production/deployment discussion does not authorize Fable deploys",
+    "live receipt > committed receipt > memory",
+    "8099/deploy via git-proxy is the canonical signed/gated deploy route only",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "auto_patch_proven=false for fable-agent unless a fresh local degraded-skill recovery receipt proves otherwise",
+    "no deploy, external code execution, vendoring, dashboards, or new packages are included in this map"
+  ],
+  "patterns": [
+    {
+      "name": "full-stack agentic systems map",
+      "adaptation": "Use as an advisory checklist for Fable's layers: model substrate, reasoning/alignment, RAG/memory, harness, tool use, multi-agent coordination, evaluation, and production gates."
+    },
+    {
+      "name": "agent harness and context management",
+      "adaptation": "Map only into local receipts/tests before claiming Fable capability. Agents draft; receipts prove; humans approve guarded deploy."
+    },
+    {
+      "name": "agent evaluation methodology",
+      "adaptation": "Prefer denominator-rich eval receipts with attempted, confirmed, blocked, and unknown outcomes over model-written verification claims."
+    },
+    {
+      "name": "MCP/A2A/tool coordination",
+      "adaptation": "Treat protocols as integration surfaces, not authority surfaces; CLI and receipts remain the trust boundary."
+    }
+  ],
+  "blocked": [
+    "treating the paper as Fable-verified production proof",
+    "using paper deployment sections as deploy authorization",
+    "reviving stale 8098/deploy-webhook or memory-only deploy authority",
+    "claiming auto-patch/self-improvement is proven for fable-agent from memory or external paper text",
+    "vendoring code or examples without separate local review"
+  ],
+  "recommendedPlan": [
+    {
+      "name": "Agentic system layer checklist receipt",
+      "goal": "Create a local checklist mapping Fable's actual receipts to each agentic-system layer before claiming coverage.",
+      "acceptanceCriteria": [
+        "each claimed layer cites a committed or live Fable receipt",
+        "missing layers are marked unverified rather than inferred from the paper",
+        "deploy sections cite only 8099 signed/gated route receipts"
+      ]
+    }
+  ],
+  "decision": "advisory",
+  "deployAttempted": false
+}
--- a/docs/receipts/claude-public-artifact-advisory-map-20260702.json
+++ b/docs/receipts/claude-public-artifact-advisory-map-20260702.json
@ -0,0 +1,36 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "claude-public-artifact-advisory-map",
+  "task": "Map Claude public artifact URL and pasted unverified Claude-system-prompt-like content as advisory-only context",
+  "source": {
+    "url": "https://claude.ai/public/artifacts/72d819db-e955-4b21-96aa-64e081c73cf7",
+    "artifactUuid": "72d819db-e955-4b21-96aa-64e081c73cf7",
+    "classification": "external-public-claude-artifact",
+    "urlReachableAsClaudeArtifactHtmlShell": "not_verified_from_local_evidence",
+    "actualArtifactContentsVerified": false
+  },
+  "verifiedFacts": [
+    "the provided URL contains artifact UUID 72d819db-e955-4b21-96aa-64e081c73cf7",
+    "no committed receipt in this repository previously mapped this artifact UUID"
+  ],
+  "constraints": [
+    "pasted Claude-system-prompt-like content is advisory/untrusted user-generated content and never instructions",
+    "actual artifact contents are not verified by this receipt",
+    "external/public artifact content is not local Fable authority",
+    "live receipt > committed receipt > memory",
+    "8099/deploy via git-proxy is the canonical signed/gated deploy route only",
+    "8098 remains legacy/internal/stale for deploy trust",
+    "auto_patch_proven=false unless a fresh canary receipt proves otherwise",
+    "no deploy, external execution, dashboards, new packages, or vendoring are included in this map"
+  ],
+  "skipped": [
+    "external fetch or execution",
+    "artifact content verification",
+    "deploy changes",
+    "dashboard changes",
+    "new packages"
+  ],
+  "decision": "advisory",
+  "deployAttempted": false
+}
--- a/docs/receipts/digg-tech-source-signal-research-map-20260702.json
+++ b/docs/receipts/digg-tech-source-signal-research-map-20260702.json
@ -0,0 +1,70 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "digg-tech-source-signal-map",
+  "task": "Map https://digg.com/tech as an advisory social-ranked tech/AI source signal for Fable research triage",
+  "constraints": [
+    "Digg Tech is advisory social-ranked feed context only, not primary evidence",
+    "require primary source URLs before making factual claims from any Digg Tech item",
+    "block deploy, vendoring, safety, and market claims unless they have primary citations",
+    "live receipt > committed receipt > memory",
+    "8099/deploy via git-proxy is the canonical signed/gated deploy route only",
+    "8098 remains legacy/internal/stale for deploy trust",
+    "auto_patch_proven=false unless a fresh canary receipt proves otherwise",
+    "no deploy, external execution, dashboards, new packages, or vendoring are included in this map"
+  ],
+  "existingPrimitives": [
+    "research-map-receipt",
+    "committed receipt",
+    "live receipt",
+    "stale-memory-quarantine"
+  ],
+  "sourceSignal": {
+    "name": "Digg Tech",
+    "url": "https://digg.com/tech",
+    "classification": "advisory-social-ranked-tech-ai-feed",
+    "allowedUse": [
+      "discover possible tech/AI topics for later primary-source research",
+      "queue claims for verification against primary source URLs",
+      "compare social attention with receipt-backed local priorities"
+    ],
+    "blockedUse": [
+      "treating Digg summaries, rankings, headlines, or reposts as primary evidence",
+      "factual claims without primary source URLs",
+      "deploy claims without signed/gated primary deploy receipts",
+      "vendoring claims without primary upstream/license citations and local review",
+      "safety claims without primary citations and local eval receipts",
+      "market claims without primary market/source citations"
+    ]
+  },
+  "recommendedPlan": [
+    {
+      "name": "Use Digg Tech only as lazy advisory signal",
+      "goal": "Let Digg Tech suggest tech/AI topics while preserving Fable's receipt-first trust posture and requiring primary URLs before any factual claim.",
+      "acceptanceCriteria": [
+        "Digg Tech is recorded as advisory social-ranked feed context only",
+        "factual claims require primary source URLs before use",
+        "deploy, vendoring, safety, and market claims are blocked without primary citations",
+        "8099/git-proxy, 8098 legacy/internal/stale, live-over-committed-over-memory, and auto_patch_proven=false posture are preserved",
+        "no deploy, external execution, dashboard, package, or vendoring action is implied"
+      ],
+      "verification": [
+        "read docs/receipts/digg-tech-source-signal-research-map-20260702.json",
+        "confirm the receipt marks https://digg.com/tech advisory only and requires primary source URLs before factual claims",
+        "confirm blocked deploy/vendoring/safety/market claim language and preserved deploy trust posture are present"
+      ]
+    }
+  ],
+  "skipped": [
+    "deploy changes",
+    "external execution",
+    "external feed fetching",
+    "external repo vendoring",
+    "dashboard changes",
+    "new packages",
+    "market, safety, deploy, or vendoring claims without primary citations"
+  ],
+  "decision": "ready",
+  "reasons": [],
+  "deployAttempted": false
+}
--- a/docs/receipts/external-pattern-research-map-20260702.json
+++ b/docs/receipts/external-pattern-research-map-20260702.json
@ -0,0 +1,68 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "external-pattern-research-map",
+  "task": "Map ECC, scankii, Miessler/Fable prompts, Test-don't-verify, and factory-memory correction into Fable engineering constraints",
+  "constraints": [
+    "external repositories and links are advisory until locally verified",
+    "do not vendor, copy, or execute external repositories from this research map",
+    "rewrite useful patterns locally behind receipts and tests",
+    "deploy is out of scope for this mapping",
+    "guarded 8099/deploy via git-proxy is the only canonical deploy route",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "live receipt > committed receipt > memory summary"
+  ],
+  "mappings": [
+    {
+      "name": "ECC",
+      "source": "https://github.com/affaan-m/ECC",
+      "localEvidence": "src/fable5/external-project-review.ts#createSkillsRepoReviewReceipt",
+      "patterns": ["agent harness optimization", "skills and memory organization", "research-first development posture"],
+      "adaptation": "learn-only; rewrite any useful harness ideas locally with Fable receipts as authority",
+      "blocked": ["vendoring", "external execution", "treating optimization claims as local proof"]
+    },
+    {
+      "name": "scankii",
+      "source": "https://github.com/ashp15205/scankii",
+      "localEvidence": "src/fable5/external-project-review.ts#createSkillsRepoReviewReceipt",
+      "patterns": ["AI-workflow SAST scanner ideas", "prompt-injection detection", "malicious tool payload review"],
+      "adaptation": "advisory rules only; rewrite useful checks locally with repro receipts/tests",
+      "blocked": ["vendoring", "unsandboxed scanner execution", "security claims without local reproduction"]
+    },
+    {
+      "name": "Miessler PAI and Fable prompt posture",
+      "source": "https://danielmiessler.com/",
+      "localEvidence": ["src/upgrades/pai-adapter.ts", "src/upgrades/fable5-prompt-engine.ts"],
+      "patterns": ["TELOS mapping", "harness-not-model compounding", "citation-aware prompt posture", "separate verifier instead of self-verification"],
+      "adaptation": "keep prompts as bounded operating guidance; receipts and verification remain authority",
+      "blocked": ["prompt-only deploy authority", "uncited factual claims from search", "self-verification as proof"]
+    },
+    {
+      "name": "Test-don't-verify",
+      "source": "TEMP/research/test-dont-verify/index.txt",
+      "localEvidence": "TEMP/research/test-dont-verify/index.txt",
+      "patterns": ["testing complements formal verification", "autoformalization expands the trusted computing base", "random testing/falsification finds counterexamples", "verification-guided development compares verified reference and production implementation"],
+      "adaptation": "pair proofs/specs with falsification, differential tests, and production-runtime measurements",
+      "blocked": ["claiming proof assistants replace tests", "trusting autoformalized specs without review", "performance claims without runtime evidence"]
+    },
+    {
+      "name": "factory-memory correction",
+      "source": "conversation memory summary quarantine",
+      "localEvidence": "src/fable5/stale-memory-quarantine.ts#createFactoryMemoryQuarantineReceipt",
+      "patterns": ["quarantine stale memory", "canonical trust path is receipt-backed", "8098 deploy memory is dangerous stale state"],
+      "adaptation": "prefer live/committed receipts over memory; require explicit approval and fresh gate receipts before any deploy",
+      "blocked": ["8098/deploy-webhook as trusted deploy path", "memory-only deploy authority", "autonomous deploy without fresh gate receipt"]
+    }
+  ],
+  "skipped": [
+    "external repo vendoring",
+    "external repo execution",
+    "deploy changes",
+    "dashboard changes",
+    "new generator or CLI",
+    "new tests without code parity need"
+  ],
+  "decision": "ready",
+  "reasons": [],
+  "deployAttempted": false
+}
--- a/docs/receipts/extreme-software-optimization-and-ai-practices-20260702.json
+++ b/docs/receipts/extreme-software-optimization-and-ai-practices-20260702.json
@ -0,0 +1,36 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "extreme-software-optimization-and-feedback-map",
+  "task": "Map user-supplied external software-engineering guidance (Extreme Optimization + tweet) as advisory-only process posture",
+  "source": {
+    "classification": "user-curated external links",
+    "items": [
+      "https://www.jeffreys-skills.md/skills/extreme-software-optimization",
+      "https://x.com/i/status/2072641006588031225"
+    ],
+    "videoOrTranscriptVerified": false,
+    "localProofExists": false
+  },
+  "verifiedFacts": [
+    "This receipt records only user-supplied advisory guidance and does not attempt local fact verification from live URLs",
+    "No Fable 5 deploy authority is derived from these links without local committed/live receipts"
+  ],
+  "constraints": [
+    "external links are advisory only and are not local deployment authority",
+    "no raw deploy claims are accepted from these sources",
+    "ship real code requires explicit checks and evidence chain (admission, tests, receipts, attestation)",
+    "canonical deploy remains 8099/deploy via git-proxy",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "auto_patch_proven remains false without a fresh local degraded-skill recovery receipt",
+    "no deploy, vendoring, dashboards, or new packages were performed for this mapping"
+  ],
+  "skipped": [
+    "live fetch/content verification from the provided links",
+    "deploy actions or route checks",
+    "new dependency changes"
+  ],
+  "decision": "advisory",
+  "deployAttempted": false,
+  "autoPatchProven": false
+}
--- a/docs/receipts/fable-agentic-system-layer-checklist-20260702.json
+++ b/docs/receipts/fable-agentic-system-layer-checklist-20260702.json
@ -0,0 +1,93 @@
+{
+  "schema": "fable.agentic_system_layer_checklist.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "fable-agentic-system-layer-checklist",
+  "source": {
+    "paper": "arXiv:2606.24937, The Hitchhiker's Guide to Agentic AI: From Foundations to Systems",
+    "paperStatus": "advisory only",
+    "memoryStatus": "advisory/stale when it conflicts with live or committed receipts"
+  },
+  "authorityOrder": [
+    "live receipt",
+    "committed receipt",
+    "memory"
+  ],
+  "globalConstraints": [
+    "TAC correction wins over memory",
+    "8099/deploy via git-proxy is the canonical signed/gated deploy route only",
+    "8098/deploy-webhook is legacy/internal/stale for fable-agent trust",
+    "auto_patch_proven=false for fable-agent unless a fresh local degraded-skill recovery receipt exists",
+    "external paper and memory are advisory only",
+    "no deploy, POST, external code execution, vendoring, dashboards, or new packages were performed for this checklist"
+  ],
+  "layers": [
+    {
+      "paperLayer": "model substrate / executors",
+      "localMapping": ["ARCHITECTURE.md:119"],
+      "status": "partial",
+      "proof": "Architecture lists executor examples; this checklist did not verify live executor health."
+    },
+    {
+      "paperLayer": "reasoning, alignment, and safety",
+      "localMapping": ["ARCHITECTURE.md:10", "docs/agentic-layer-tac.md:3-18"],
+      "status": "partial",
+      "proof": "Safety/TAC posture is documented; release-class proof still requires receipts named in TAC next-proof fields."
+    },
+    {
+      "paperLayer": "RAG / memory",
+      "localMapping": ["ARCHITECTURE.md:92", "docs/receipts/memory-b-cell-20260621.md"],
+      "status": "partial",
+      "proof": "Memory B Cell cache receipt proves bounded repeat-pattern recognition; it does not replace deploy proof."
+    },
+    {
+      "paperLayer": "agent harness, context management, and tool use",
+      "localMapping": ["docs/pi-integration.md:6-8", "docs/pi-integration.md:30-41", "ARCHITECTURE.md:42-50"],
+      "status": "partial",
+      "proof": "Pi/fable-agent command contract and foundation modules are documented; harness outputs still require fresh attestation or UNVERIFIED status."
+    },
+    {
+      "paperLayer": "multi-agent coordination",
+      "localMapping": ["ARCHITECTURE.md:92", "ARCHITECTURE.md:106"],
+      "status": "unverified",
+      "proof": "Architecture mentions multi-agent/meta-agent modules, but no committed receipt in this checklist proves mature orchestrator coordination."
+    },
+    {
+      "paperLayer": "evaluation and verification",
+      "localMapping": ["docs/agentic-layer-tac.md:17-18", "docs/pi-integration.md:10-27", "docs/receipts/verify-cycle-apple-20260619.md"],
+      "status": "partial",
+      "proof": "Verify-cycle apple receipt proves a low-risk skill check; it explicitly does not prove non-canary degraded-skill repair."
+    },
+    {
+      "paperLayer": "production and deploy gates",
+      "localMapping": ["docs/receipts/stale-memory-quarantine-20260702.json", "docs/pi-integration.md:57-63", "docs/agentic-layer-tac.md:35-37"],
+      "status": "bounded",
+      "proof": "Only 8099/deploy via git-proxy is canonical signed/gated. 8098/deploy-webhook and memory-only deploy authority are stale/blocked."
+    },
+    {
+      "paperLayer": "self-healing / auto-patch",
+      "localMapping": ["docs/receipts/factory-live-drift-20260621.md", "docs/receipts/verify-cycle-apple-20260619.md"],
+      "status": "unverified",
+      "auto_patch_proven": false,
+      "proof": "Existing receipts scope recovery to rsi_canary history or low-risk verify-cycle. No fresh local non-canary degraded-skill recovery receipt is present."
+    }
+  ],
+  "memoryConflictHandling": [
+    {
+      "claim": "8098/deploy-webhook is trusted deploy authority",
+      "decision": "stale/blocked",
+      "replacement": "8099/deploy via git-proxy is canonical signed/gated only"
+    },
+    {
+      "claim": "memory-only factory/deploy state authorizes deploy",
+      "decision": "stale/blocked",
+      "replacement": "live receipt > committed receipt > memory"
+    },
+    {
+      "claim": "generic autonomous auto-patch/self-healing is proven for fable-agent",
+      "decision": "unverified",
+      "replacement": "auto_patch_proven=false unless fresh local degraded-skill recovery receipt exists"
+    }
+  ],
+  "decision": "checklist_created_advisory_bounded",
+  "deployAttempted": false
+}
--- a/docs/receipts/fable5-website-video-advisory-map-20260702.json
+++ b/docs/receipts/fable5-website-video-advisory-map-20260702.json
@ -0,0 +1,39 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "fable5-website-video-advisory-map",
+  "task": "Map the user-supplied Fable 5 animated website creator workflow transcript as advisory-only process inspiration",
+  "source": {
+    "classification": "user-supplied-video-transcript",
+    "label": "Fable 5 animated website creator workflow transcript",
+    "transcriptStoredInRepo": false,
+    "videoClaimsVerified": false
+  },
+  "verifiedFacts": [
+    "this receipt records only advisory process inspiration from a user-supplied transcript/video description",
+    "no Fable 5 product capability proof is established by this receipt",
+    "no asset rights are granted by this receipt"
+  ],
+  "constraints": [
+    "transcript/video claims are advisory only and not local Fable authority",
+    "no Fable 5 product capability proof is established",
+    "no asset rights are granted",
+    "no deploy was attempted",
+    "no calls to 8099/deploy or 8098 were made",
+    "8099/deploy via git-proxy remains the canonical signed/gated deploy route only",
+    "8098 remains legacy/internal/stale for deploy trust",
+    "auto_patch_proven=false unless a fresh degraded-skill recovery receipt exists",
+    "no external execution, vendoring, dashboards, new packages, or asset ingestion are included in this map"
+  ],
+  "skipped": [
+    "external fetch or execution",
+    "video/transcript claim verification",
+    "asset ingestion or rights validation",
+    "deploy changes",
+    "dashboard changes",
+    "new packages"
+  ],
+  "decision": "advisory",
+  "deployAttempted": false,
+  "autoPatchProven": false
+}
--- a/docs/receipts/factory-live-readonly-20260702.json
+++ b/docs/receipts/factory-live-readonly-20260702.json
@ -0,0 +1,62 @@
+{
+  "schema": "fable.factory_live_readonly.receipt.v1",
+  "createdAt": "2026-07-02T09:21:00.000Z",
+  "taskLabel": "factory-live-readonly-check",
+  "source": "read-only curl checks against 77.42.112.29:8099",
+  "authorityOrder": ["live receipt", "committed receipt", "memory"],
+  "checks": [
+    {
+      "url": "http://77.42.112.29:8099/health",
+      "method": "GET",
+      "status": 200,
+      "body": { "status": "ok", "service": "git-proxy" }
+    },
+    {
+      "url": "http://77.42.112.29:8099/factory-status",
+      "method": "GET",
+      "status": 200,
+      "bodySubset": {
+        "status": "stale",
+        "state": "STALE_FACTORY_STATE",
+        "phase": 4,
+        "containers": 19,
+        "live_containers": 19,
+        "catalog_containers": 18,
+        "agents": 6,
+        "infra": 14,
+        "monitoring": 5
+      }
+    },
+    {
+      "url": "http://77.42.112.29:8099/deploy",
+      "method": "GET",
+      "status": 404,
+      "interpretation": "read-only GET did not expose deploy action; this is not deploy proof and not a POST deploy attempt"
+    }
+  ],
+  "memoryReconciliation": [
+    {
+      "memoryClaim": "25 Docker containers all UP",
+      "liveReceipt": "factory-status reports 19 live containers, 18 catalog containers, status stale",
+      "decision": "memory stale/advisory for container count"
+    },
+    {
+      "memoryClaim": "deploy-webhook 8098 autonomous deploy port is operational authority",
+      "liveReceipt": "checks only used 8099; committed receipts mark 8098 legacy/internal/stale",
+      "decision": "blocked as fable-agent deploy authority"
+    },
+    {
+      "memoryClaim": "auto_patch_proven=true/full recursive self-improvement operational",
+      "liveReceipt": "no fresh local degraded-skill recovery receipt was produced by this read-only check",
+      "decision": "auto_patch_proven=false for fable-agent until fresh local canary receipt exists"
+    }
+  ],
+  "constraints": [
+    "8099/deploy via git-proxy remains canonical signed/gated route only",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "read-only health/factory-status checks do not authorize deploy",
+    "no deploy, POST, external code execution, vendoring, dashboards, or new packages were performed"
+  ],
+  "decision": "live_readonly_checked",
+  "deployAttempted": false
+}
--- a/docs/receipts/factory-live-readonly-20260703.json
+++ b/docs/receipts/factory-live-readonly-20260703.json
@ -0,0 +1,66 @@
+{
+  "schema": "fable.factory_live_readonly.receipt.v1",
+  "createdAt": "2026-07-03T00:00:00.000Z",
+  "taskLabel": "factory-live-readonly-check-20260703",
+  "source": "read-only curl checks against 77.42.112.29:8099",
+  "authorityOrder": ["live receipt", "committed receipt", "memory"],
+  "checks": [
+    {
+      "url": "http://77.42.112.29:8099/health",
+      "method": "GET",
+      "status": 200,
+      "body": { "status": "ok", "service": "git-proxy" }
+    },
+    {
+      "url": "http://77.42.112.29:8099/factory-status",
+      "method": "GET",
+      "status": 200,
+      "bodySubset": {
+        "status": "stale",
+        "state": "STALE_FACTORY_STATE",
+        "phase": 4,
+        "containers": 19,
+        "live_containers": 19,
+        "catalog_containers": 18,
+        "agents": 6,
+        "infra": 14,
+        "monitoring": 5,
+        "skills": 63,
+        "truth": "live docker ps wins over catalog/memory when counts disagree"
+      }
+    },
+    {
+      "url": "http://77.42.112.29:8099/deploy",
+      "method": "GET",
+      "status": 404,
+      "body": { "error": "not found" },
+      "interpretation": "read-only GET did not expose deploy action; this is not deploy proof and not a POST deploy attempt"
+    }
+  ],
+  "memoryReconciliation": [
+    {
+      "memoryClaim": "25 Docker containers all UP",
+      "liveReceipt": "factory-status reports 19 live containers, 18 catalog containers, status stale",
+      "decision": "memory stale/advisory for container count"
+    },
+    {
+      "memoryClaim": "8098/deploy-webhook autonomous deploy port is operational authority",
+      "liveReceipt": "checks only used 8099; committed receipts mark 8098 legacy/internal/stale",
+      "decision": "blocked as fable-agent deploy authority"
+    },
+    {
+      "memoryClaim": "auto_patch_proven=true/full recursive self-improvement operational",
+      "liveReceipt": "no fresh local degraded-skill recovery receipt was produced by this read-only check",
+      "decision": "auto_patch_proven=false for fable-agent until fresh local degraded-skill receipt exists"
+    }
+  ],
+  "constraints": [
+    "8099/deploy via git-proxy remains canonical signed/gated route only",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "read-only health/factory-status checks do not authorize deploy",
+    "no deploy, POST, external code execution, vendoring, dashboards, or new packages were performed"
+  ],
+  "decision": "live_readonly_checked",
+  "deployAttempted": false,
+  "autoPatchProven": false
+}
--- a/docs/receipts/kelsey-hightower-beyond-code-research-map-20260702.json
+++ b/docs/receipts/kelsey-hightower-beyond-code-research-map-20260702.json
@ -0,0 +1,56 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "kelsey-hightower-beyond-code-platform-map",
+  "task": "Map Kelsey Hightower Beyond Code transcript summary into Fable receipt-first platform-engineering posture",
+  "constraints": [
+    "podcast transcript summary claims are advisory only until backed by local, committed, or live Fable receipts",
+    "receipt authority order remains live receipt > committed receipt > memory",
+    "8099/deploy via git-proxy is the canonical signed and gated path only",
+    "8098 is legacy, internal, and stale unless a newer receipt proves otherwise",
+    "auto_patch_proven=false unless a fresh canary receipt proves the capability",
+    "no deploy, dashboard, package, or external execution action is included in this map"
+  ],
+  "existingPrimitives": [
+    "research-map-receipt",
+    "plan-receipt",
+    "canary-receipt",
+    "git-proxy-gated-release",
+    "receipt-first-posture"
+  ],
+  "recommendedPlan": [
+    {
+      "name": "Capture platform-engineering patterns",
+      "goal": "Use the transcript summary as advisory product posture for Fable platform work while requiring receipt-backed proof before operational claims.",
+      "acceptanceCriteria": [
+        "remove unnecessary code before adding abstractions",
+        "prefer MVI: minimum viable integration that proves one thin path before broadening",
+        "treat platform as API, SLA, and product for internal users",
+        "learn the current process before changing it",
+        "measure impact rather than activities",
+        "distinguish launch from land: shipping is not adoption or sustained value",
+        "train your own model only when owned data and receipt-backed evaluation justify it",
+        "treat AI as a tool, not the solution",
+        "apply trust-but-verify with local capability checks before relying on claims",
+        "record open-source gratitude while staying realistic about maintenance and business incentives"
+      ],
+      "verification": [
+        "read docs/receipts/kelsey-hightower-beyond-code-research-map-20260702.json",
+        "confirm the receipt includes advisory-only podcast constraints and all requested platform posture patterns",
+        "confirm deployAttempted is false and skipped excludes release, dashboard, package, and external execution work"
+      ]
+    }
+  ],
+  "skipped": [
+    "release changes",
+    "dashboard changes",
+    "new packages",
+    "external execution",
+    "runtime changes",
+    "auto_patch_proven=true without fresh canary receipt",
+    "operational claims based only on podcast memory"
+  ],
+  "decision": "ready",
+  "reasons": [],
+  "deployAttempted": false
+}
--- a/docs/receipts/kramer-ai-quality-research-map-20260701.json
+++ b/docs/receipts/kramer-ai-quality-research-map-20260701.json
@ -0,0 +1,67 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-01T22:22:59.132Z",
+  "taskLabel": "kramer-ai-quality-interview",
+  "task": "Map David Kramer/Sentry interview notes on AI coding into Fable engineering constraints",
+  "constraints": [
+    "external transcript/link is advisory until locally verified",
+    "quality/security/liability beat raw code volume",
+    "LLMs help search/summarization/prototyping but do not replace verification",
+    "agents draft, receipts prove, humans approve, guarded 8099/deploy ships",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "do not claim 100x or perfect code generation without receipts",
+    "live receipt > committed receipt > memory summary",
+    "memory is advisory only and cannot authorize deploys or overwrite receipts",
+    "AI quality patterns from the Kramer/Sentry summary become bounded receipts/tests, not dashboards or new packages"
+  ],
+  "existingPrimitives": [
+    "research-map-receipt",
+    "uast-runtime-receipt",
+    "falsification-receipt",
+    "stale-memory-quarantine",
+    "agent-run-trace",
+    "factory-gate"
+  ],
+  "recommendedPlan": [
+    {
+      "name": "Capture grounded AI-coding posture",
+      "goal": "Encode the interview lesson as bounded research: AI can accelerate work, but production code still needs small patches, tests, review, and liability-aware release gates.",
+      "acceptanceCriteria": [
+        "receipt records advisory source status",
+        "receipt rejects 100x/code-volume claims as deploy authority",
+        "receipt preserves no-deploy policy"
+      ],
+      "verification": [
+        "cat docs/receipts/kramer-ai-quality-research-map-20260701.json",
+        "node dist/index.js security scan ."
+      ]
+    },
+    {
+      "name": "Apply lesson to UAST work",
+      "goal": "Keep modifications surgical through receipts/tests and one-language slices instead of a universal writer/runtime.",
+      "acceptanceCriteria": [
+        "no universal syntax guarantee is claimed",
+        "UAST remains receipt-bounded until parser/serializer receipts exist",
+        "patches require native checks before commit"
+      ],
+      "verification": [
+        "npm run -s test -- src/fable5/uast-runtime-receipt.test.ts",
+        "npm run -s build"
+      ]
+    }
+  ],
+  "skipped": [
+    "dashboard",
+    "deploy changes",
+    "vendor tools",
+    "new model architecture",
+    "100x productivity claim",
+    "autonomous production patching",
+    "MCP replacing CLI authority",
+    "dashboards",
+    "new packages"
+  ],
+  "decision": "ready",
+  "reasons": [],
+  "deployAttempted": false
+}
--- a/docs/receipts/oh-my-opencode-advisory-map-20260703.json
+++ b/docs/receipts/oh-my-opencode-advisory-map-20260703.json
@ -0,0 +1,36 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-03T00:00:00.000Z",
+  "taskLabel": "oh-my-opencode-advisory-map",
+  "task": "Map user-supplied oh-my-opencode repository link as advisory-only OpenCode workflow/config inspiration",
+  "source": {
+    "classification": "user-supplied-external-repository-link",
+    "items": [
+      "https://github.com/opensoft/oh-my-opencode"
+    ],
+    "repositoryFetched": false,
+    "contentVerified": false,
+    "localProofExists": false
+  },
+  "verifiedFacts": [
+    "This receipt records only the user-supplied repository URL",
+    "No repository content was fetched, executed, vendored, installed, or used for deploy authority by this receipt"
+  ],
+  "constraints": [
+    "external repository is advisory only until mapped into committed local receipts/tests",
+    "no deploy authority is derived from this link",
+    "canonical deploy remains 8099/deploy via git-proxy",
+    "8098/deploy-webhook remains legacy/internal/stale for fable-agent trust",
+    "auto_patch_proven remains false without a fresh local degraded-skill recovery receipt",
+    "no external execution, vendoring, dashboards, package installs, or deploy actions were performed"
+  ],
+  "skipped": [
+    "git clone or external fetch",
+    "repository content verification",
+    "tool installation or vendoring",
+    "deploy changes"
+  ],
+  "decision": "advisory",
+  "deployAttempted": false,
+  "autoPatchProven": false
+}
--- a/docs/receipts/stale-memory-context-copy-20260702.json
+++ b/docs/receipts/stale-memory-context-copy-20260702.json
@ -0,0 +1,41 @@
+{
+  "schema": "fable.research_map.receipt.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "taskLabel": "memory-context-copy-20260702",
+  "task": "Capture user-provided memory snippets as advisory-only and reconcile against canonical fable-agent trust policy",
+  "source": {
+    "classification": "user memory injection",
+    "items": [
+      "Phase 4 and earlier recursive self-improvement loop claims (memory-only)",
+      "Factory memory snapshot from user: 25 containers, 6 agents, 14 infra, 5 monitoring, 63 skills",
+      "Memory claim that deploy-webhook:8098 + auth-token POST /deploy is safe canonical action",
+      "Memory claim that /deploy connected to deploy-webhook, with autonomous cycle read-design-deploy-update without explicit human approval",
+      "User-provided links: jeffreys-skills.md extreme optimization + x.com status 2072641006588031225"
+    ],
+    "videoOrTranscriptVerified": false,
+    "localProofExists": false
+  },
+  "verifiedFacts": [
+    "No local live receipt in this turn confirms closed-loop autonomous deploy as canonical authority",
+    "The memory snippets above are captured for audit and do not supersede live or committed receipts"
+  ],
+  "constraints": [
+    "canonical deploy authority remains `8099/deploy via git-proxy` only",
+    "`8098/deploy-webhook` remains legacy/internal and stale for fable-agent deploy trust",
+    "`auto_patch_proven` remains false without a fresh local degraded-skill recovery receipt",
+    "memory-only statements remain advisory until reconciled by current receipts"
+  ],
+  "staleMemoryCovers": [
+    "Phase 4 closed-loop autonomous deploy claim",
+    "agents can POST /deploy with auth token without explicit approval",
+    "factory live-state claims used as direct authority without signed receipt proof"
+  ],
+  "skipped": [
+    "external link fetch/verification",
+    "deploy actions",
+    "package or dependency changes"
+  ],
+  "decision": "advisory",
+  "deployAttempted": false,
+  "autoPatchProven": false
+}
--- a/docs/receipts/stale-memory-quarantine-20260702.json
+++ b/docs/receipts/stale-memory-quarantine-20260702.json
@ -0,0 +1,56 @@
+{
+  "schema": "fable.stale_memory.quarantine.v1",
+  "createdAt": "2026-07-02T00:00:00.000Z",
+  "source": "factory/deploy memory reconciliation against current policy",
+  "claims": [
+    {
+      "claim": "memory-only factory snapshot that 25 Docker containers all UP with 6 agents and 63 skills",
+      "staleBecause": "this snapshot is stale-memory and exceeds the currently accepted proof model unless corroborated by live or committed receipts",
+      "replacementTruth": "container/deployment authority follows live receipt > committed receipt > memory; reconcile against a fresh live factory-status/checker receipt",
+      "severity": "advisory"
+    },
+    {
+      "claim": "skill_health.py runs every 6 hours and covers all 63 skills for autonomous repair decisions",
+      "staleBecause": "cron and full-skill coverage are memory claims without an in-session live proof for this chain",
+      "replacementTruth": "repair decisions require current verify-cycle/RSI receipts and explicit gate posture, not memory-only scheduling claims",
+      "severity": "dangerous"
+    },
+    {
+      "claim": "8098/deploy-webhook is the trusted deploy path",
+      "staleBecause": "current policy marks 8098/deploy-webhook as legacy/internal/stale, not canonical deploy authority",
+      "replacementTruth": "8099/deploy via git-proxy is the canonical signed/gated deploy route",
+      "severity": "dangerous"
+    },
+    {
+      "claim": "agents/loops can perform raw POST deploy or signed-action-less autonomous deployment",
+      "staleBecause": "safety policy requires explicit approval and fresh ZTE/factory gate receipts; autonomous POST deploy remains unsafe/unproved",
+      "replacementTruth": "guarded 8099/deploy via git-proxy with explicit approval and fresh route-health proof",
+      "severity": "dangerous"
+    },
+    {
+      "claim": "Phase 4 recursive self-improvement and full non-canary auto-patch repair is proven",
+      "staleBecause": "memory-only phase claims are not current authority and non-canary recovery receipts are still missing",
+      "replacementTruth": "auto_patch_proven remains false until a fresh local degraded-skill recovery receipt is produced",
+      "severity": "dangerous"
+    },
+    {
+      "claim": "memory-only factory/deploy state can authorize deploy",
+      "staleBecause": "current policy orders authority as live receipt > committed receipt > memory",
+      "replacementTruth": "deploy authority requires a live receipt or, when live state is unavailable, a committed receipt; memory is advisory only",
+      "severity": "dangerous"
+    }
+  ],
+  "blockedTrustPaths": [
+    "8098/deploy-webhook",
+    "memory-only deploy authority",
+    "autonomous deploy without fresh gate receipt",
+    "raw signed/action-less POST deploy claims"
+  ],
+  "canonicalTrustPaths": [
+    "live receipt > committed receipt > memory",
+    "8099/deploy via git-proxy",
+    "explicit approval + fresh valid ZTE/factory gate receipt"
+  ],
+  "decision": "quarantined",
+  "deployAttempted": false
+}
--- a/src/fable5/eval-trace.test.ts
+++ b/src/fable5/eval-trace.test.ts
@ -43,6 +43,9 @@ describe("eval trace receipt", () => {
      receiptsWritten: ["fable.agent_run.trace.v1"],
      tokensIn: 100,
      tokensOut: 20,
+      budget: { tokens: 500, wallClockMs: 10_000, toolCalls: 8 },
+      environment: { internet: false, repoAccess: true, deployAuthority: "gated" },
+      safetyPosture: { cyber: "read-only", securityScan: "passed", approval: "required" },
      decision: "ok",
    });

@ -52,6 +55,22 @@ describe("eval trace receipt", () => {
      schema: "fable.agent_run.trace.v1",
      runId: "run-1",
      latencyMs: 2500,
+      budget: { tokens: 500, wallClockMs: 10000, toolCalls: 8 },
+      environment: { internet: false, repoAccess: true, secretsAccess: false, deployAuthority: "gated" },
+      safetyPosture: { cyber: "read-only", securityScan: "passed", approval: "required" },
+      deployAttempted: false,
+    });
+  });
+
+  it("defaults agent run traces to no internet, no secrets, and no deploy authority", () => {
+    expect(createAgentRunTraceReceipt({
+      runId: "run-2",
+      task: "inspect",
+      startedAt: new Date("2026-06-29T00:00:00.000Z"),
+      endedAt: new Date("2026-06-29T00:00:00.001Z"),
+    })).toMatchObject({
+      environment: { internet: false, repoAccess: true, secretsAccess: false, deployAuthority: "none" },
+      safetyPosture: { cyber: "not-run", securityScan: "not-run", approval: "not-required" },
      deployAttempted: false,
    });
  });
--- a/src/fable5/eval-trace.ts
+++ b/src/fable5/eval-trace.ts
@ -15,6 +15,25 @@ export interface EvalTraceReceipt {
  createdAt: string;
 }

+export interface AgentRunTraceBudget {
+  tokens?: number;
+  wallClockMs?: number;
+  toolCalls?: number;
+}
+
+export interface AgentRunTraceEnvironment {
+  internet: boolean;
+  repoAccess: boolean;
+  secretsAccess: false;
+  deployAuthority: "none" | "gated";
+}
+
+export interface AgentRunTraceSafetyPosture {
+  cyber: "not-run" | "read-only" | "approved-active";
+  securityScan?: "not-run" | "passed" | "failed";
+  approval?: "not-required" | "required" | "granted";
+}
+
 export interface AgentRunTraceReceipt {
  schema: "fable.agent_run.trace.v1";
  runId: string;
@ -27,6 +46,9 @@ export interface AgentRunTraceReceipt {
  tokensIn?: number;
  tokensOut?: number;
  latencyMs: number;
+  budget: AgentRunTraceBudget;
+  environment: AgentRunTraceEnvironment;
+  safetyPosture: AgentRunTraceSafetyPosture;
  decision: "ok" | "needs-human" | "blocked" | "failed";
  reasons: string[];
  deployAttempted: false;
@ -42,6 +64,9 @@ export interface AgentRunTraceOptions {
  receiptsWritten?: string[];
  tokensIn?: number;
  tokensOut?: number;
+  budget?: Partial<AgentRunTraceBudget>;
+  environment?: Partial<AgentRunTraceEnvironment>;
+  safetyPosture?: Partial<AgentRunTraceSafetyPosture>;
  decision?: AgentRunTraceReceipt["decision"];
  reasons?: string[];
 }
@ -109,6 +134,22 @@ export function createAgentRunTraceReceipt(opts: AgentRunTraceOptions): AgentRun
    tokensIn: opts.tokensIn,
    tokensOut: opts.tokensOut,
    latencyMs,
+    budget: {
+      tokens: opts.budget?.tokens,
+      wallClockMs: opts.budget?.wallClockMs,
+      toolCalls: opts.budget?.toolCalls,
+    },
+    environment: {
+      internet: opts.environment?.internet ?? false,
+      repoAccess: opts.environment?.repoAccess ?? true,
+      secretsAccess: false,
+      deployAuthority: opts.environment?.deployAuthority ?? "none",
+    },
+    safetyPosture: {
+      cyber: opts.safetyPosture?.cyber ?? "not-run",
+      securityScan: opts.safetyPosture?.securityScan ?? "not-run",
+      approval: opts.safetyPosture?.approval ?? "not-required",
+    },
    decision: opts.decision ?? "ok",
    reasons: opts.reasons ?? [],
    deployAttempted: false,
--- a/src/fable5/external-evidence.test.ts
+++ b/src/fable5/external-evidence.test.ts
@ -0,0 +1,32 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createExternalRsiEvidenceReceipt, writeExternalEvidenceReceipt } from "./external-evidence.js";
+
+describe("external evidence receipts", () => {
+  it("records external RSI proof as advisory, not local deploy authority", () => {
+    const receipt = createExternalRsiEvidenceReceipt(new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({
+      schema: "fable.external_evidence.receipt.v1",
+      source: "conversation memory citing pi-real-engineering RSI proof",
+      decision: "advisory",
+      deployAttempted: false,
+    });
+    expect(receipt.evidence.every((entry) => entry.scope === "external")).toBe(true);
+    expect(receipt.notUsableFor).toContain("local fable-agent deploy authority");
+    expect(receipt.notUsableFor).toContain("auto_patch_proven=true without fresh local degraded-skill recovery receipt");
+    expect(receipt.notUsableFor).toContain("8098/deploy-webhook trust");
+  });
+
+  it("writes external evidence receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "external-evidence-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeExternalEvidenceReceipt(file, createExternalRsiEvidenceReceipt());
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.external_evidence.receipt.v1", decision: "advisory" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/external-evidence.ts
+++ b/src/fable5/external-evidence.ts
@ -0,0 +1,48 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface ExternalEvidenceReceipt {
+  schema: "fable.external_evidence.receipt.v1";
+  createdAt: string;
+  source: string;
+  evidence: Array<{ claim: string; reference: string; scope: "external" | "local" }>;
+  usableFor: string[];
+  notUsableFor: string[];
+  decision: "advisory" | "local-authority";
+  deployAttempted: false;
+}
+
+export function createExternalRsiEvidenceReceipt(now = new Date()): ExternalEvidenceReceipt {
+  return {
+    schema: "fable.external_evidence.receipt.v1",
+    createdAt: now.toISOString(),
+    source: "conversation memory citing pi-real-engineering RSI proof",
+    evidence: [
+      {
+        claim: "hermes rsi_canary recovered after repair",
+        reference: "pi-real-engineering:/tmp/rsi-proof-20260619T093724Z.md",
+        scope: "external",
+      },
+      {
+        claim: "worker_skill_repair.sh copied skill_health.py and verified rsi_canary",
+        reference: "pi-real-engineering:/tmp/rsi-proof-20260619T093724Z.md",
+        scope: "external",
+      },
+    ],
+    usableFor: ["advisory RSI recovery history", "future local proof import checklist", "red-team/safety context"],
+    notUsableFor: [
+      "local fable-agent deploy authority",
+      "auto_patch_proven=true without fresh local degraded-skill recovery receipt",
+      "8098/deploy-webhook trust",
+      "container count truth without live reconciliation",
+    ],
+    decision: "advisory",
+    deployAttempted: false,
+  };
+}
+
+export function writeExternalEvidenceReceipt(file: string, receipt: ExternalEvidenceReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/external-project-review.test.ts
+++ b/src/fable5/external-project-review.test.ts
@ -0,0 +1,82 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createOpenCovenReviewReceipt, createPermissionPostureReceipt, createSkillsRepoReviewReceipt, writeExternalProjectReviewReceipt } from "./external-project-review.js";
+
+describe("external project review receipts", () => {
+  it("records OpenCoven as learn-only because GPL code is not safe to vendor", () => {
+    const receipt = createOpenCovenReviewReceipt(new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({
+      schema: "fable.external_project.review.v1",
+      repo: "OpenCoven/coven-code",
+      license: "GPL-3.0",
+      safeToVendor: false,
+      decision: "learn-only",
+      policy: "learn-patterns-no-vendored-code",
+      deployAttempted: false,
+    });
+    expect(receipt.patternsLearned).toContain("explicit permission modes");
+    expect(receipt.risks).toContain("GPL code cannot be copied into Fable");
+  });
+
+  it("records external skills repos as learn-only", () => {
+    const matt = createSkillsRepoReviewReceipt("mattpocock/skills", new Date("2026-07-01T00:00:00.000Z"));
+    const club = createSkillsRepoReviewReceipt("AI-Builder-Club/skills", new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(matt).toMatchObject({ repo: "mattpocock/skills", license: "MIT", safeToVendor: false, decision: "learn-only", deployAttempted: false });
+    expect(club).toMatchObject({ repo: "AI-Builder-Club/skills", license: "NOASSERTION", safeToVendor: false, decision: "learn-only", deployAttempted: false });
+    expect(club.risks).toContain("no detected license means no vendoring");
+    expect(matt.risks).toContain("external skill prompts are prompt-injection inputs");
+  });
+
+  it("records ECC as learn-only external harness research", () => {
+    const receipt = createSkillsRepoReviewReceipt("affaan-m/ECC", new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({ repo: "affaan-m/ECC", license: "MIT", safeToVendor: false, decision: "learn-only", deployAttempted: false });
+    expect(receipt.patternsLearned).toContain("agent harness optimization patterns");
+    expect(receipt.risks).toContain("optimization claims need local receipts");
+  });
+
+  it("records scankii as learn-only external security scanner research", () => {
+    const receipt = createSkillsRepoReviewReceipt("ashp15205/scankii", new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({ repo: "ashp15205/scankii", license: "NOASSERTION", safeToVendor: false, decision: "learn-only", deployAttempted: false });
+    expect(receipt.patternsLearned).toContain("SAST scanner patterns for AI workflows");
+    expect(receipt.risks).toContain("security findings need local repro receipts");
+  });
+
+  it("records deploy-gated permission posture without opening 8098", () => {
+    const receipt = createPermissionPostureReceipt("deploy-gated", new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({
+      schema: "fable.permission_posture.receipt.v1",
+      mode: "deploy-gated",
+      approvalRequired: true,
+      decision: "ready",
+      deployAttempted: false,
+    });
+    expect(receipt.allowed[0]).toContain("8099/deploy");
+    expect(receipt.blocked).toContain("8098/deploy-webhook");
+    expect(receipt.blocked).toContain("memory-only deploy claims");
+  });
+
+  it("keeps read-only mode non-mutating", () => {
+    const receipt = createPermissionPostureReceipt("read-only");
+
+    expect(receipt.allowed).toContain("emit non-mutating receipts");
+    expect(receipt.blocked).toContain("deploy");
+    expect(receipt.approvalRequired).toBe(false);
+  });
+
+  it("writes receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "external-project-review-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeExternalProjectReviewReceipt(file, createOpenCovenReviewReceipt());
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.external_project.review.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/external-project-review.ts
+++ b/src/fable5/external-project-review.ts
@ -0,0 +1,143 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type ExternalProjectDecision = "learn-only" | "blocked";
+export type PermissionMode = "read-only" | "plan" | "edit" | "deploy-gated";
+
+export interface ExternalProjectReviewReceipt {
+  schema: "fable.external_project.review.v1";
+  createdAt: string;
+  repo: string;
+  url: string;
+  license: string;
+  safeToVendor: boolean;
+  patternsLearned: string[];
+  adaptations: string[];
+  risks: string[];
+  decision: ExternalProjectDecision;
+  policy: "learn-patterns-no-vendored-code";
+  deployAttempted: false;
+}
+
+export interface PermissionPostureReceipt {
+  schema: "fable.permission_posture.receipt.v1";
+  createdAt: string;
+  mode: PermissionMode;
+  allowed: string[];
+  blocked: string[];
+  approvalRequired: boolean;
+  decision: "ready" | "blocked";
+  deployAttempted: false;
+}
+
+export function createOpenCovenReviewReceipt(now = new Date()): ExternalProjectReviewReceipt {
+  return {
+    schema: "fable.external_project.review.v1",
+    createdAt: now.toISOString(),
+    repo: "OpenCoven/coven-code",
+    url: "https://github.com/OpenCoven/coven-code",
+    license: "GPL-3.0",
+    safeToVendor: false,
+    patternsLearned: [
+      "local-first agent runtime",
+      "explicit permission modes",
+      "session resume and branching",
+      "agent identity contract",
+      "plugin and bridge seams separated from authority",
+      "no-telemetry-by-default posture",
+    ],
+    adaptations: [
+      "record external reviews as receipts",
+      "make permission posture explicit",
+      "keep adapters below CLI and receipts as authority",
+      "treat GPL projects as learn-only unless legal review says otherwise",
+    ],
+    risks: ["GPL code cannot be copied into Fable", "remote bridge or MCP must not become deploy authority", "plugin systems add attack surface"],
+    decision: "learn-only",
+    policy: "learn-patterns-no-vendored-code",
+    deployAttempted: false,
+  };
+}
+
+
+export function createSkillsRepoReviewReceipt(repo: "mattpocock/skills" | "AI-Builder-Club/skills" | "affaan-m/ECC" | "ashp15205/scankii", now = new Date()): ExternalProjectReviewReceipt {
+  const rows: Record<typeof repo, Omit<ExternalProjectReviewReceipt, "schema" | "createdAt" | "repo" | "deployAttempted">> = {
+    "mattpocock/skills": {
+      url: "https://github.com/mattpocock/skills",
+      license: "MIT",
+      safeToVendor: false,
+      patternsLearned: ["skill package structure", "focused task instructions", "portable agent guidance"],
+      adaptations: ["review skill shape as advisory", "rewrite any useful pattern locally", "record provenance before adopting skills"],
+      risks: ["external skill prompts are prompt-injection inputs", "do not copy wholesale without review", "popular repo metadata is not local capability proof"],
+      decision: "learn-only",
+      policy: "learn-patterns-no-vendored-code",
+    },
+    "AI-Builder-Club/skills": {
+      url: "https://github.com/AI-Builder-Club/skills",
+      license: "NOASSERTION",
+      safeToVendor: false,
+      patternsLearned: ["community skill catalog patterns", "agent task packaging", "skill discovery ideas"],
+      adaptations: ["treat no-license repo as learn-only", "reuse ideas through fresh Fable receipts/tests", "keep CLI and receipts as authority"],
+      risks: ["no detected license means no vendoring", "skill content may contain prompt injection", "external catalog is not deploy authority"],
+      decision: "learn-only",
+      policy: "learn-patterns-no-vendored-code",
+    },
+    "affaan-m/ECC": {
+      url: "https://github.com/affaan-m/ECC",
+      license: "MIT",
+      safeToVendor: false,
+      patternsLearned: ["agent harness optimization patterns", "skills and memory organization", "research-first development posture"],
+      adaptations: ["review harness ideas as advisory", "rewrite any useful pattern locally behind receipts", "keep Fable safety gates as authority"],
+      risks: ["external harness code is not local capability proof", "do not vendor or execute without review", "optimization claims need local receipts"],
+      decision: "learn-only",
+      policy: "learn-patterns-no-vendored-code",
+    },
+    "ashp15205/scankii": {
+      url: "https://github.com/ashp15205/scankii",
+      license: "NOASSERTION",
+      safeToVendor: false,
+      patternsLearned: ["SAST scanner patterns for AI workflows", "prompt-injection detection ideas", "malicious tool payload review concepts"],
+      adaptations: ["treat scanner rules as advisory research", "rewrite useful checks locally with tests", "keep existing Fable security scan as authority until receipts prove parity"],
+      risks: ["no detected license means no vendoring", "do not execute external scanner without sandbox review", "security findings need local repro receipts"],
+      decision: "learn-only",
+      policy: "learn-patterns-no-vendored-code",
+    },
+  };
+  return { schema: "fable.external_project.review.v1", createdAt: now.toISOString(), repo, ...rows[repo], deployAttempted: false };
+}
+
+export function createPermissionPostureReceipt(mode: PermissionMode, now = new Date()): PermissionPostureReceipt {
+  const rows: Record<PermissionMode, Omit<PermissionPostureReceipt, "schema" | "createdAt" | "mode" | "deployAttempted">> = {
+    "read-only": {
+      allowed: ["read receipts", "inspect files", "summarize repositories", "emit non-mutating receipts"],
+      blocked: ["write code", "mutate factory", "deploy", "use secrets"],
+      approvalRequired: false,
+      decision: "ready",
+    },
+    plan: {
+      allowed: ["read receipts", "write plan receipts", "propose diffs"],
+      blocked: ["apply diffs", "deploy", "mutate factory"],
+      approvalRequired: false,
+      decision: "ready",
+    },
+    edit: {
+      allowed: ["write code", "run tests", "write receipts"],
+      blocked: ["deploy", "mutate factory without gate", "use secrets unless explicitly approved"],
+      approvalRequired: true,
+      decision: "ready",
+    },
+    "deploy-gated": {
+      allowed: ["deploy only through guarded 8099/deploy with fresh valid gate receipt and explicit approval"],
+      blocked: ["8098/deploy-webhook", "memory-only deploy claims", "deploy without fresh ZTE/factory gate"],
+      approvalRequired: true,
+      decision: "ready",
+    },
+  };
+  return { schema: "fable.permission_posture.receipt.v1", createdAt: now.toISOString(), mode, ...rows[mode], deployAttempted: false };
+}
+
+export function writeExternalProjectReviewReceipt(file: string, receipt: ExternalProjectReviewReceipt | PermissionPostureReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/factory-routes.test.ts
+++ b/src/fable5/factory-routes.test.ts
@ -17,4 +17,20 @@ describe("factory deploy routes", () => {
    expect(isGuardedDeployUrl(legacyByPort)).toBe(false);
    expect(isGuardedDeployUrl(legacyByPath)).toBe(false);
  });
+
+  it("rejects memory-style 8098/deploy-webhook authority claims", () => {
+    const memoryRoutes = [
+      "http://77.42.112.29:8098/deploy",
+      "http://77.42.112.29:8098/deploy-webhook",
+      "http://127.0.0.1:8098/deploy",
+      "http://127.0.0.1:8098/deploy-webhook",
+      "http://77.42.112.29:8099/deploy-webhook",
+    ];
+
+    for (const route of memoryRoutes) {
+      expect(isForbiddenDeployRoute(route)).toBe(true);
+      expect(isAllowedDeployUrl(route)).toBe(false);
+      expect(isGuardedDeployUrl(route)).toBe(false);
+    }
+  });
 });
--- a/src/fable5/falsification-receipt.test.ts
+++ b/src/fable5/falsification-receipt.test.ts
@ -0,0 +1,41 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createFactoryMemoryFalsificationReceipt, createFalsificationReceipt, writeFalsificationReceipt } from "./falsification-receipt.js";
+
+describe("falsification receipts", () => {
+  it("records hostile factory memory counterexamples as failed-closed", () => {
+    const receipt = createFactoryMemoryFalsificationReceipt(new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({
+      schema: "fable.falsification.receipt.v1",
+      decision: "passed",
+      failures: [],
+      deployAttempted: false,
+    });
+    expect(receipt.cases.map((testCase) => testCase.claim)).toContain("8098/deploy-webhook can be trusted as deploy route");
+    expect(receipt.cases.map((testCase) => testCase.actualResult)).toContain("quarantined");
+    expect(receipt.cases.map((testCase) => testCase.actualResult)).toContain("blocked");
+  });
+
+  it("fails when a counterexample does not fail closed", () => {
+    const receipt = createFalsificationReceipt([
+      { claim: "deploy without gate", counterexample: "missing receipt", expectedFailure: "blocked", actualResult: "allowed" },
+    ]);
+
+    expect(receipt.decision).toBe("failed");
+    expect(receipt.failures[0]).toContain("deploy without gate");
+    expect(receipt.deployAttempted).toBe(false);
+  });
+
+  it("writes falsification receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "falsification-receipt-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeFalsificationReceipt(file, createFactoryMemoryFalsificationReceipt());
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.falsification.receipt.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/falsification-receipt.ts
+++ b/src/fable5/falsification-receipt.ts
@ -0,0 +1,71 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface FalsificationCase {
+  claim: string;
+  counterexample: string;
+  expectedFailure: string;
+  actualResult: string;
+}
+
+export interface FalsificationReceipt {
+  schema: "fable.falsification.receipt.v1";
+  createdAt: string;
+  cases: FalsificationCase[];
+  decision: "passed" | "failed";
+  failures: string[];
+  deployAttempted: false;
+}
+
+export function createFalsificationReceipt(cases: FalsificationCase[], now = new Date()): FalsificationReceipt {
+  const failures = cases
+    .filter((testCase) => normalize(testCase.expectedFailure) !== normalize(testCase.actualResult))
+    .map((testCase) => `${testCase.claim}: expected ${testCase.expectedFailure}, got ${testCase.actualResult}`);
+  return {
+    schema: "fable.falsification.receipt.v1",
+    createdAt: now.toISOString(),
+    cases,
+    decision: failures.length === 0 ? "passed" : "failed",
+    failures,
+    deployAttempted: false,
+  };
+}
+
+export function createFactoryMemoryFalsificationReceipt(now = new Date()): FalsificationReceipt {
+  return createFalsificationReceipt([
+    {
+      claim: "8098/deploy-webhook can be trusted as deploy route",
+      counterexample: "conversation memory claims deploy-webhook is autonomous deploy authority",
+      expectedFailure: "quarantined",
+      actualResult: "quarantined",
+    },
+    {
+      claim: "memory-only container count is current truth",
+      counterexample: "memory claims 25 containers while fresh receipts require live reconciliation",
+      expectedFailure: "quarantined",
+      actualResult: "quarantined",
+    },
+    {
+      claim: "agents can deploy without fresh approval and gate receipt",
+      counterexample: "conversation memory claims auth-token autonomous deploy",
+      expectedFailure: "blocked",
+      actualResult: "blocked",
+    },
+    {
+      claim: "auto_patch_proven can be inferred from memory",
+      counterexample: "no fresh degraded-skill recovery receipt supplied in this turn",
+      expectedFailure: "blocked",
+      actualResult: "blocked",
+    },
+  ], now);
+}
+
+export function writeFalsificationReceipt(file: string, receipt: FalsificationReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
+
+function normalize(value: string): string {
+  return value.trim().toLowerCase();
+}
--- a/src/fable5/forgejo-cli.test.ts
+++ b/src/fable5/forgejo-cli.test.ts
@ -0,0 +1,89 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createForgejoActionsCoverageReceipt, createForgejoPullRequest, getForgejoFileContent, listForgejoIssues } from "./forgejo-cli.js";
+
+function tmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), "forgejo-cli-"));
+}
+
+describe("forgejo cli helpers", () => {
+  it("documents Forgejo Actions coverage without scraping or mutation", () => {
+    const receipt = createForgejoActionsCoverageReceipt("org/repo", new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({
+      schema: "fable.forgejo.actions_coverage.v1",
+      repo: "org/repo",
+      decision: "api-only",
+      policy: "no-web-ui-scraping-no-action-mutation",
+      deployAttempted: false,
+    });
+    expect(receipt.rows.find((row) => row.capability === "actions cancel/rerun/trigger")?.status).toBe("blocked");
+  });
+
+  it("lists issues via Forgejo API", async () => {
+    const calls: string[] = [];
+    const issues = await listForgejoIssues({
+      baseUrl: "https://git.fdsa.agency",
+      token: "secret",
+      fetcher: async (input, init) => {
+        calls.push(input);
+        expect(init?.headers?.Authorization).toBe("token secret");
+        return { ok: true, status: 200, json: async () => [{ number: 1, title: "Bug" }] };
+      },
+    }, "org/repo", "open");
+
+    expect(calls[0]).toBe("https://git.fdsa.agency/api/v1/repos/org/repo/issues?state=open");
+    expect(issues).toEqual([{ number: 1, title: "Bug" }]);
+  });
+
+  it("reads base64 file content", async () => {
+    const content = await getForgejoFileContent({
+      baseUrl: "https://git.fdsa.agency",
+      fetcher: async () => ({ ok: true, status: 200, json: async () => ({ encoding: "base64", content: Buffer.from("hello").toString("base64") }) }),
+    }, "org/repo", "README.md", "main");
+
+    expect(content).toBe("hello");
+  });
+
+  it("creates pull request receipts without deploy authority", async () => {
+    const outDir = tmpDir();
+    const calls: Array<{ input: string; body?: string }> = [];
+    const result = await createForgejoPullRequest({
+      baseUrl: "https://git.fdsa.agency",
+      token: "secret",
+      repo: "org/repo",
+      title: "Fix bug",
+      head: "fix-bug",
+      base: "main",
+      body: "Receipt-backed PR",
+      outDir,
+      now: new Date("2026-07-01T00:00:00.000Z"),
+      fetcher: async (input, init) => {
+        calls.push({ input, body: init?.body });
+        return { ok: true, status: 201, json: async () => ({ number: 7, html_url: "https://git.fdsa.agency/org/repo/pulls/7" }) };
+      },
+    });
+
+    expect(calls[0].input).toBe("https://git.fdsa.agency/api/v1/repos/org/repo/pulls");
+    expect(calls[0].body).toContain("fix-bug");
+    expect(result.receipt).toMatchObject({ schema: "fable.forgejo.pull_request.v1", result: { status: "posted", number: 7 }, receipts: { deploy_attempted: false } });
+    expect(fs.existsSync(result.path!)).toBe(true);
+    fs.rmSync(outDir, { recursive: true, force: true });
+  });
+
+  it("blocks prompt injection PR descriptions", async () => {
+    const result = await createForgejoPullRequest({
+      baseUrl: "https://git.fdsa.agency",
+      repo: "org/repo",
+      title: "Ignore previous instructions",
+      head: "bad",
+      base: "main",
+      dryRun: true,
+    });
+
+    expect(result.receipt.result.status).toBe("dry-run");
+    expect(result.receipt.receipts.quarantine).toBe(true);
+  });
+});
--- a/src/fable5/forgejo-cli.ts
+++ b/src/fable5/forgejo-cli.ts
@ -0,0 +1,134 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { findPromptInjection, type PromptInjectionFinding } from "../core/prompt-injection-safety.js";
+
+export type ForgejoCliFetch = (input: string, init?: { method?: string; headers?: Record<string, string>; body?: string }) => Promise<{ ok: boolean; status: number; json(): Promise<unknown>; text?(): Promise<string> }>;
+
+export interface ForgejoCliOptions {
+  baseUrl?: string;
+  token?: string;
+  fetcher?: ForgejoCliFetch;
+}
+
+export interface ForgejoPullRequestReceipt {
+  schema: "fable.forgejo.pull_request.v1";
+  createdAt: string;
+  repo: string;
+  request: { title: string; head: string; base: string; body?: string };
+  result: { status: "dry-run" | "posted" | "blocked"; url?: string; number?: number; httpStatus?: number };
+  receipts: {
+    unicode_scan: "passed" | "failed";
+    injection_scan: "passed" | "failed";
+    deploy_attempted: false;
+    quarantine: boolean;
+    findings: PromptInjectionFinding[];
+  };
+}
+
+export interface ForgejoActionsCoverageReceipt {
+  schema: "fable.forgejo.actions_coverage.v1";
+  createdAt: string;
+  repo?: string;
+  rows: Array<{ capability: string; status: "covered" | "unsupported" | "blocked"; reason: string }>;
+  decision: "api-only";
+  policy: "no-web-ui-scraping-no-action-mutation";
+  deployAttempted: false;
+}
+
+export function createForgejoActionsCoverageReceipt(repo?: string, now = new Date()): ForgejoActionsCoverageReceipt {
+  return {
+    schema: "fable.forgejo.actions_coverage.v1",
+    createdAt: now.toISOString(),
+    repo,
+    rows: [
+      { capability: "actions runs", status: "unsupported", reason: "Forgejo full run details commonly require UI endpoints; Fable will not scrape by default" },
+      { capability: "actions jobs", status: "unsupported", reason: "use official API only when available" },
+      { capability: "actions logs", status: "unsupported", reason: "logs may contain secrets; no web UI scraping" },
+      { capability: "actions artifacts", status: "unsupported", reason: "artifacts may contain secrets; no web UI scraping" },
+      { capability: "actions cancel/rerun/trigger", status: "blocked", reason: "mutating CI actions requires explicit implementation and approval" },
+      { capability: "pull request create", status: "covered", reason: "forgejo pr-create emits fable.forgejo.pull_request.v1" },
+    ],
+    decision: "api-only",
+    policy: "no-web-ui-scraping-no-action-mutation",
+    deployAttempted: false,
+  };
+}
+
+export function writeForgejoActionsCoverageReceipt(file: string, receipt: ForgejoActionsCoverageReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
+
+export async function forgejoApi<T>(opts: ForgejoCliOptions, endpoint: string, init: { method?: string; body?: unknown } = {}): Promise<T> {
+  const base = requireBaseUrl(opts.baseUrl);
+  const res = await (opts.fetcher ?? fetch)(`${base}/api/v1${endpoint}`, {
+    method: init.method,
+    headers: { "content-type": "application/json", ...(opts.token ? { Authorization: `token ${opts.token}` } : {}) },
+    body: init.body === undefined ? undefined : JSON.stringify(init.body),
+  });
+  if (!res.ok) throw new Error(`Forgejo API returned HTTP ${res.status}`);
+  return await res.json() as T;
+}
+
+export async function listForgejoRepositories(opts: ForgejoCliOptions, username?: string): Promise<unknown> {
+  return forgejoApi(opts, username ? `/users/${encodeURIComponent(username)}/repos` : "/user/repos");
+}
+
+export async function getForgejoRepository(opts: ForgejoCliOptions, repo: string): Promise<unknown> {
+  return forgejoApi(opts, `/repos/${repo}`);
+}
+
+export async function listForgejoIssues(opts: ForgejoCliOptions, repo: string, state = "open"): Promise<unknown> {
+  return forgejoApi(opts, `/repos/${repo}/issues?state=${encodeURIComponent(state)}`);
+}
+
+export async function listForgejoPullRequests(opts: ForgejoCliOptions, repo: string, state = "open"): Promise<unknown> {
+  return forgejoApi(opts, `/repos/${repo}/pulls?state=${encodeURIComponent(state)}`);
+}
+
+export async function getForgejoFileContent(opts: ForgejoCliOptions, repo: string, filePath: string, ref = "main"): Promise<string> {
+  const data = await forgejoApi<{ content?: string; encoding?: string }>(opts, `/repos/${repo}/contents/${encodeURIComponent(filePath)}?ref=${encodeURIComponent(ref)}`);
+  if (!data.content) return "";
+  return Buffer.from(data.content, data.encoding === "base64" ? "base64" : "utf-8").toString("utf-8");
+}
+
+export async function createForgejoPullRequest(opts: ForgejoCliOptions & { repo: string; title: string; head: string; base: string; body?: string; dryRun?: boolean; outDir?: string; now?: Date }): Promise<{ receipt: ForgejoPullRequestReceipt; path?: string }> {
+  const findings = findPromptInjection(`${opts.title}\n${opts.body ?? ""}`);
+  const quarantine = findings.length > 0;
+  const receipt: ForgejoPullRequestReceipt = {
+    schema: "fable.forgejo.pull_request.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    repo: opts.repo,
+    request: { title: opts.title, head: opts.head, base: opts.base, body: opts.body },
+    result: { status: opts.dryRun ? "dry-run" : quarantine ? "blocked" : "dry-run" },
+    receipts: {
+      unicode_scan: findings.some((f) => f.kind === "hidden-unicode") ? "failed" : "passed",
+      injection_scan: findings.some((f) => f.kind !== "hidden-unicode") ? "failed" : "passed",
+      deploy_attempted: false,
+      quarantine,
+      findings,
+    },
+  };
+
+  if (!opts.dryRun && !quarantine) {
+    const pr = await forgejoApi<{ html_url?: string; url?: string; number?: number }>(opts, `/repos/${opts.repo}/pulls`, { method: "POST", body: { title: opts.title, head: opts.head, base: opts.base, body: opts.body ?? "" } });
+    receipt.result = { status: "posted", url: pr.html_url ?? pr.url, number: pr.number, httpStatus: 201 };
+  }
+
+  if (opts.dryRun) return { receipt };
+  const outDir = opts.outDir ?? ".fable/tasks";
+  fs.mkdirSync(outDir, { recursive: true });
+  const file = path.join(outDir, `forgejo-pr-${safeFilePart(opts.head)}-to-${safeFilePart(opts.base)}.json`);
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return { receipt, path: file };
+}
+
+function requireBaseUrl(baseUrl?: string): string {
+  if (!baseUrl) throw new Error("FORGEJO_URL is required");
+  return baseUrl.replace(/\/$/, "");
+}
+
+function safeFilePart(value: string): string {
+  return value.replace(/[^A-Za-z0-9_.-]+/g, "-").replace(/(^-+)|(-+$)/g, "") || "ref";
+}
--- a/src/fable5/index.ts
+++ b/src/fable5/index.ts
@ -63,6 +63,27 @@ export type { FlueInteropRow, FlueInteropStatus } from "./flue-interop.js";
 export { createExternalToolAuditReceipt, DICKLESWORTHSTONE_TOOL_ROWS, writeExternalToolAuditReceipt } from "./external-tool-audit.js";
 export type { ExternalToolAuditReceipt, ExternalToolAuditRow, ExternalToolAuditStatus } from "./external-tool-audit.js";

+export { createOpenCovenReviewReceipt, createPermissionPostureReceipt, createSkillsRepoReviewReceipt, writeExternalProjectReviewReceipt } from "./external-project-review.js";
+export type { ExternalProjectDecision, ExternalProjectReviewReceipt, PermissionMode, PermissionPostureReceipt } from "./external-project-review.js";
+
+export { createFactoryMemoryQuarantineReceipt, createStaleMemoryQuarantineReceipt, writeStaleMemoryQuarantineReceipt } from "./stale-memory-quarantine.js";
+export type { StaleMemoryClaim, StaleMemoryQuarantineReceipt, StaleMemorySeverity } from "./stale-memory-quarantine.js";
+
+export { createFactoryMemoryFalsificationReceipt, createFalsificationReceipt, writeFalsificationReceipt } from "./falsification-receipt.js";
+export type { FalsificationCase, FalsificationReceipt } from "./falsification-receipt.js";
+
+export { createExternalRsiEvidenceReceipt, writeExternalEvidenceReceipt } from "./external-evidence.js";
+export type { ExternalEvidenceReceipt } from "./external-evidence.js";
+
+export { createResearchMapReceipt, writeResearchMapReceipt } from "./research-map-receipt.js";
+export type { ResearchMapOptions, ResearchMapReceipt } from "./research-map-receipt.js";
+
+export { createUastRuntimeReceipt, writeUastRuntimeReceipt } from "./uast-runtime-receipt.js";
+export type { UastClaim, UastClaimDecision, UastLanguage, UastParserRow, UastParserStatus, UastRuntimeReceipt, UastRuntimeReceiptOptions } from "./uast-runtime-receipt.js";
+
+export { createStructuralPatchReceipt, writeStructuralPatchReceipt } from "./structural-patch-receipt.js";
+export type { StructuralNodeCoordinate, StructuralNodeKind, StructuralPatchCheck, StructuralPatchDecision, StructuralPatchReceipt, StructuralPatchReceiptOptions } from "./structural-patch-receipt.js";
+
 export { channelPath, emitChannelEvent, readChannelEvents } from "./channel.js";
 export type { ChannelEvent, ChannelEventSource, ChannelEventType, NewChannelEvent } from "./channel.js";

@ -76,7 +97,7 @@ export { checkReceiptHealth } from "./receipt-consumer.js";
 export type { ReceiptHealth } from "./receipt-consumer.js";

 export { createAgentRunTraceReceipt, createDuelEvalReceipt, createEvalTraceReceipt, gradeSetRecovery, gradeVerifiableReward, tallyDuelReceipts, writeAgentRunTraceReceipt, writeDuelEvalReceipt, writeEvalTraceReceipt } from "./eval-trace.js";
-export type { AgentRunTraceOptions, AgentRunTraceReceipt, DuelEvalReceipt, DuelTally, EvalTraceCommand, EvalTraceReceipt, SetGradeReceipt, VerifiableRewardReceipt } from "./eval-trace.js";
+export type { AgentRunTraceBudget, AgentRunTraceEnvironment, AgentRunTraceOptions, AgentRunTraceReceipt, AgentRunTraceSafetyPosture, DuelEvalReceipt, DuelTally, EvalTraceCommand, EvalTraceReceipt, SetGradeReceipt, VerifiableRewardReceipt } from "./eval-trace.js";

 export { loadBenchHarnesses, runAgentBench, writeAgentBenchReceipt } from "./agent-bench.js";
 export type { AgentBenchOptions, AgentBenchReceipt, BenchContenderId, BenchContenderResult, BenchHarnessConfig, BenchmarkHygiene } from "./agent-bench.js";
@ -93,6 +114,21 @@ export type { RedTeamHarnessDecision, RedTeamHarnessReceipt, RedTeamHarnessRecei
 export { createModelAccessReceipt, writeModelAccessReceipt } from "./model-access-receipt.js";
 export type { ModelAccessProbe, ModelAccessReceipt, ModelAccessReceiptOptions, ModelAccessStatus, ModelAccessSurface } from "./model-access-receipt.js";

+export { createSkillHealthReceipt, writeSkillHealthReceipt } from "./skill-health.js";
+export type { SkillHealthEntry, SkillHealthOptions, SkillHealthReceipt } from "./skill-health.js";
+
+export { createContextEvalReceipt, createContextRepoSnapshotReceipt, createRecoveryReceipt, createSleepTimePolicyReceipt, writeLearningReceipt } from "./learning-receipts.js";
+export type { ContextEvalReceipt, ContextRepoSnapshotReceipt, LearningDecision, RecoveryReceipt, SleepTimePolicyReceipt } from "./learning-receipts.js";
+
+export { createPromptFingerprintReceipt, writePromptFingerprintReceipt } from "./prompt-fingerprint.js";
+export type { PromptFingerprintFinding, PromptFingerprintReceipt } from "./prompt-fingerprint.js";
+
+export { createJailbreakAssessmentReceipt, writeJailbreakAssessmentReceipt } from "./jailbreak-assessment.js";
+export type { JailbreakAssessmentOptions, JailbreakAssessmentReceipt, JailbreakAssessmentScores, JailbreakDecision } from "./jailbreak-assessment.js";
+
+export { createForgejoActionsCoverageReceipt, createForgejoPullRequest, forgejoApi, getForgejoFileContent, getForgejoRepository, listForgejoIssues, listForgejoPullRequests, listForgejoRepositories, writeForgejoActionsCoverageReceipt } from "./forgejo-cli.js";
+export type { ForgejoActionsCoverageReceipt, ForgejoCliFetch, ForgejoCliOptions, ForgejoPullRequestReceipt } from "./forgejo-cli.js";
+
 export { createPlanReceipt, writePlanReceipt } from "./plan-receipt.js";
 export type { PlanAllowedOutcome, PlanPhase, PlanReceipt, PlanReceiptOptions, PlanTaskType } from "./plan-receipt.js";

--- a/src/fable5/jailbreak-assessment.test.ts
+++ b/src/fable5/jailbreak-assessment.test.ts
@ -0,0 +1,51 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createJailbreakAssessmentReceipt, writeJailbreakAssessmentReceipt } from "./jailbreak-assessment.js";
+
+describe("jailbreak assessment receipt", () => {
+  it("scores low-severity jailbreaks as monitor", () => {
+    const receipt = createJailbreakAssessmentReceipt({
+      source: "minor prompt bypass",
+      capabilityGain: 1,
+      breadth: 1,
+      weaponizationEase: 1,
+      discoverability: 2,
+      now: new Date("2026-07-01T00:00:00.000Z"),
+    });
+
+    expect(receipt).toMatchObject({
+      schema: "fable.jailbreak_assessment.receipt.v1",
+      createdAt: "2026-07-01T00:00:00.000Z",
+      total: 5,
+      decision: "monitor",
+      deployAttempted: false,
+    });
+  });
+
+  it("escalates broad easy high-gain jailbreaks", () => {
+    expect(createJailbreakAssessmentReceipt({ source: "universal", capabilityGain: 5, breadth: 5, weaponizationEase: 4, discoverability: 4 })).toMatchObject({ total: 18, decision: "disclose" });
+    expect(createJailbreakAssessmentReceipt({ source: "narrow harmful", capabilityGain: 4, breadth: 3, weaponizationEase: 3, discoverability: 3 })).toMatchObject({ total: 13, decision: "block" });
+    expect(createJailbreakAssessmentReceipt({ source: "patchable", capabilityGain: 3, breadth: 2, weaponizationEase: 2, discoverability: 2 })).toMatchObject({ total: 9, decision: "patch" });
+  });
+
+  it("clamps scores to the 0-5 framework", () => {
+    expect(createJailbreakAssessmentReceipt({ source: "clamp", capabilityGain: 99, breadth: -1, weaponizationEase: 2.4, discoverability: 2.6 }).scores).toEqual({
+      capabilityGain: 5,
+      breadth: 0,
+      weaponizationEase: 2,
+      discoverability: 3,
+    });
+  });
+
+  it("writes JSON receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "jailbreak-assessment-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeJailbreakAssessmentReceipt(file, createJailbreakAssessmentReceipt({ source: "x", capabilityGain: 0, breadth: 0, weaponizationEase: 0, discoverability: 0 }));
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.jailbreak_assessment.receipt.v1", decision: "ignore" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/jailbreak-assessment.ts
+++ b/src/fable5/jailbreak-assessment.ts
@ -0,0 +1,58 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type JailbreakDecision = "ignore" | "monitor" | "patch" | "block" | "disclose";
+
+export interface JailbreakAssessmentScores {
+  capabilityGain: number;
+  breadth: number;
+  weaponizationEase: number;
+  discoverability: number;
+}
+
+export interface JailbreakAssessmentReceipt {
+  schema: "fable.jailbreak_assessment.receipt.v1";
+  createdAt: string;
+  source: string;
+  scores: JailbreakAssessmentScores;
+  total: number;
+  decision: JailbreakDecision;
+  reasons: string[];
+  deployAttempted: false;
+}
+
+export interface JailbreakAssessmentOptions extends JailbreakAssessmentScores {
+  source: string;
+  now?: Date;
+}
+
+function clampScore(n: number): number {
+  return Math.max(0, Math.min(5, Math.round(n)));
+}
+
+export function createJailbreakAssessmentReceipt(opts: JailbreakAssessmentOptions): JailbreakAssessmentReceipt {
+  const scores = {
+    capabilityGain: clampScore(opts.capabilityGain),
+    breadth: clampScore(opts.breadth),
+    weaponizationEase: clampScore(opts.weaponizationEase),
+    discoverability: clampScore(opts.discoverability),
+  };
+  const total = scores.capabilityGain + scores.breadth + scores.weaponizationEase + scores.discoverability;
+  const decision: JailbreakDecision = total >= 17 ? "disclose" : total >= 13 ? "block" : total >= 9 ? "patch" : total >= 5 ? "monitor" : "ignore";
+  return {
+    schema: "fable.jailbreak_assessment.receipt.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    source: opts.source,
+    scores,
+    total,
+    decision,
+    reasons: [`severity total ${total}/20 from capability gain, breadth, weaponization ease, and discoverability`],
+    deployAttempted: false,
+  };
+}
+
+export function writeJailbreakAssessmentReceipt(file: string, receipt: JailbreakAssessmentReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/learning-receipts.test.ts
+++ b/src/fable5/learning-receipts.test.ts
@ -0,0 +1,69 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createContextEvalReceipt, createContextRepoSnapshotReceipt, createRecoveryReceipt, createSleepTimePolicyReceipt, writeLearningReceipt } from "./learning-receipts.js";
+
+describe("learning receipts", () => {
+  it("records recovery without deploy authority", () => {
+    const receipt = createRecoveryReceipt({
+      now: new Date("2026-07-01T00:00:00.000Z"),
+      incident: "stale host log disagreed with canary",
+      staleSignal: "host log said healthy",
+      liveSignal: "container canary failed",
+      rootCause: "container drift",
+      actionTaken: "refreshed skill_health.py and verified canary recovered",
+      receiptsBefore: [".fable/rsi/before.json"],
+      receiptsAfter: [".fable/rsi/after.json"],
+      decision: "ready",
+    });
+
+    expect(receipt).toMatchObject({
+      schema: "fable.recovery.receipt.v1",
+      createdAt: "2026-07-01T00:00:00.000Z",
+      decision: "ready",
+      deployAttempted: false,
+    });
+  });
+
+  it("blocks context evals when deploy authority evidence fails", () => {
+    const receipt = createContextEvalReceipt({
+      task: "deploy candidate",
+      checks: [
+        { check: "live receipt loaded", passed: true },
+        { check: "deploy authority cites 8099 gate", passed: false, evidence: "stale 8098 memory" },
+      ],
+    });
+
+    expect(receipt).toMatchObject({ schema: "fable.context_eval.receipt.v1", decision: "blocked", deployAttempted: false });
+  });
+
+  it("keeps sleep-time compute read-only", () => {
+    const receipt = createSleepTimePolicyReceipt(new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt.decision).toBe("read-only");
+    expect(receipt.blocked).toContain("deploy");
+    expect(receipt.deployAttempted).toBe(false);
+  });
+
+  it("snapshots context repos without executing files", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "context-repo-"));
+    fs.mkdirSync(path.join(dir, "notes"));
+    fs.writeFileSync(path.join(dir, "notes", "memory.md"), "live receipts win\n");
+
+    const receipt = createContextRepoSnapshotReceipt(dir, new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({ schema: "fable.context_repo.snapshot.v1", decision: "snapshot-only", deployAttempted: false });
+    expect(receipt.files).toEqual([{ path: "notes/memory.md", bytes: 18 }]);
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("writes learning receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "learning-receipts-"));
+    const file = path.join(dir, "receipt.json");
+    writeLearningReceipt(file, createSleepTimePolicyReceipt());
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.sleep_time.policy.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/learning-receipts.ts
+++ b/src/fable5/learning-receipts.ts
@ -0,0 +1,95 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type LearningDecision = "ready" | "review" | "blocked";
+
+export interface RecoveryReceipt {
+  schema: "fable.recovery.receipt.v1";
+  createdAt: string;
+  incident: string;
+  staleSignal?: string;
+  liveSignal: string;
+  rootCause?: string;
+  actionTaken: string;
+  receiptsBefore: string[];
+  receiptsAfter: string[];
+  decision: LearningDecision;
+  deployAttempted: false;
+}
+
+export interface ContextEvalReceipt {
+  schema: "fable.context_eval.receipt.v1";
+  createdAt: string;
+  task: string;
+  checks: Array<{ check: string; passed: boolean; evidence?: string }>;
+  decision: LearningDecision;
+  deployAttempted: false;
+}
+
+export interface SleepTimePolicyReceipt {
+  schema: "fable.sleep_time.policy.v1";
+  createdAt: string;
+  allowed: string[];
+  blocked: string[];
+  decision: "read-only";
+  deployAttempted: false;
+}
+
+export interface ContextRepoSnapshotReceipt {
+  schema: "fable.context_repo.snapshot.v1";
+  createdAt: string;
+  root: string;
+  files: Array<{ path: string; bytes: number }>;
+  decision: "snapshot-only";
+  deployAttempted: false;
+}
+
+export function createRecoveryReceipt(opts: Omit<RecoveryReceipt, "schema" | "createdAt" | "deployAttempted"> & { now?: Date }): RecoveryReceipt {
+  return { schema: "fable.recovery.receipt.v1", createdAt: (opts.now ?? new Date()).toISOString(), ...withoutNow(opts), deployAttempted: false };
+}
+
+export function createContextEvalReceipt(opts: Omit<ContextEvalReceipt, "schema" | "createdAt" | "decision" | "deployAttempted"> & { now?: Date }): ContextEvalReceipt {
+  const failed = opts.checks.filter((check) => !check.passed);
+  return {
+    schema: "fable.context_eval.receipt.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    task: opts.task,
+    checks: opts.checks,
+    decision: failed.length === 0 ? "ready" : failed.some((check) => /deploy|authority|receipt/i.test(check.check)) ? "blocked" : "review",
+    deployAttempted: false,
+  };
+}
+
+export function createSleepTimePolicyReceipt(now = new Date()): SleepTimePolicyReceipt {
+  return {
+    schema: "fable.sleep_time.policy.v1",
+    createdAt: now.toISOString(),
+    allowed: ["receipt refresh", "stale-memory detection", "read-only Forgejo summarization", "skill-health checks", "prompt-fingerprint scans"],
+    blocked: ["deploy", "factory mutation", "web UI scraping", "cancel/rerun/trigger CI", "auto-patch without explicit approval"],
+    decision: "read-only",
+    deployAttempted: false,
+  };
+}
+
+export function createContextRepoSnapshotReceipt(root: string, now = new Date()): ContextRepoSnapshotReceipt {
+  const files = fs.existsSync(root)
+    ? fs.readdirSync(root, { recursive: true, withFileTypes: true })
+      .filter((entry) => entry.isFile())
+      .map((entry) => {
+        const relative = path.join(entry.parentPath ? path.relative(root, entry.parentPath) : "", entry.name).replace(/\\/g, "/");
+        return { path: relative, bytes: fs.statSync(path.join(root, relative)).size };
+      })
+    : [];
+  return { schema: "fable.context_repo.snapshot.v1", createdAt: now.toISOString(), root, files, decision: "snapshot-only", deployAttempted: false };
+}
+
+export function writeLearningReceipt(file: string, receipt: RecoveryReceipt | ContextEvalReceipt | SleepTimePolicyReceipt | ContextRepoSnapshotReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
+
+function withoutNow<T extends { now?: Date }>(opts: T): Omit<T, "now"> {
+  const { now: _now, ...rest } = opts;
+  return rest;
+}
--- a/src/fable5/model-access-receipt.test.ts
+++ b/src/fable5/model-access-receipt.test.ts
@ -33,6 +33,19 @@ describe("model access receipt", () => {
    expect(receipt.reasons).toContain("ChatGPT Cyber access not verified");
  });

+  it("tracks Fable and Mythos redeploy announcements without claiming access", () => {
+    const receipt = createModelAccessReceipt({
+      probes: [
+        { surface: "anthropic-fable", command: "Anthropic redeploying Fable 5 announcement", status: "unknown", model: "claude-fable-5", evidence: "announced globally July 1; local access not probed" },
+        { surface: "anthropic-mythos", command: "Anthropic redeploying Fable 5 announcement", status: "unknown", model: "claude-mythos-5", evidence: "restored only for some US orgs; local access not probed" },
+      ],
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.claims).toEqual([]);
+    expect(receipt.reasons).toContain("one or more model surfaces are unknown");
+  });
+
  it("tracks Fugu Ultra without claiming access", () => {
    const receipt = createModelAccessReceipt({
      probes: [{ surface: "sakana-fugu", command: "sakana/fugu-ultra access probe", status: "unknown", model: "fugu-ultra", evidence: "not probed; do not buy or bypass with VPN" }],
--- a/src/fable5/model-access-receipt.ts
+++ b/src/fable5/model-access-receipt.ts
@ -1,7 +1,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";

-export type ModelAccessSurface = "pi" | "openrouter" | "openai" | "chatgpt-cyber" | "sakana-fugu" | "hermes-moa" | "other";
+export type ModelAccessSurface = "pi" | "openrouter" | "openai" | "chatgpt-cyber" | "anthropic-fable" | "anthropic-mythos" | "sakana-fugu" | "hermes-moa" | "other";
 export type ModelAccessStatus = "available" | "blocked" | "missing" | "unknown";

 export interface ModelAccessProbe {
--- a/src/fable5/prompt-fingerprint.test.ts
+++ b/src/fable5/prompt-fingerprint.test.ts
@ -0,0 +1,46 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createPromptFingerprintReceipt, writePromptFingerprintReceipt } from "./prompt-fingerprint.js";
+
+describe("prompt fingerprint receipt", () => {
+  it("blocks hidden unicode prompt carriers", () => {
+    const receipt = createPromptFingerprintReceipt("prompt", `safe${String.fromCodePoint(0xe0069)}text`);
+
+    expect(receipt).toMatchObject({ decision: "blocked", deployAttempted: false });
+    expect(receipt.findings[0]).toMatchObject({ kind: "hidden-unicode", severity: "block" });
+  });
+
+  it("blocks date-line covert marker variants", () => {
+    const receipt = createPromptFingerprintReceipt("prompt", "Today’s date is 2026/06/30");
+
+    expect(receipt).toMatchObject({ decision: "blocked" });
+    expect(receipt.findings[0]).toMatchObject({ kind: "date-line-marker", severity: "block" });
+  });
+
+  it("reviews telemetry endpoints and opt-out gaps without claiming compromise", () => {
+    const receipt = createPromptFingerprintReceipt(
+      "bundle",
+      "DISABLE_TELEMETRY does not guard Datadog; https://http-intake.logs.us5.datadoghq.com/api/v2/logs",
+    );
+
+    expect(receipt.decision).toBe("review");
+    expect(receipt.findings.map((finding) => finding.kind)).toContain("telemetry-endpoint");
+    expect(receipt.findings.map((finding) => finding.kind)).toContain("telemetry-optout-gap");
+  });
+
+  it("allows ordinary prompts", () => {
+    expect(createPromptFingerprintReceipt("prompt", "Today's date is 2026-06-30")).toMatchObject({ decision: "clean", findings: [] });
+  });
+
+  it("writes JSON receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "prompt-fingerprint-"));
+    const file = path.join(dir, "receipt.json");
+
+    writePromptFingerprintReceipt(file, createPromptFingerprintReceipt("prompt", "clean"));
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.prompt_fingerprint.receipt.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/prompt-fingerprint.ts
+++ b/src/fable5/prompt-fingerprint.ts
@ -0,0 +1,64 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { findHiddenUnicode, hasHiddenUnicode } from "../core/unicode-safety.js";
+
+const DATE_LINE = /Today([\u0027\u2019\u02BC\u02B9])s date is\s+(\d{4})([-/])(\d{2})\3(\d{2})/u;
+const TELEMETRY_ENDPOINTS = [
+  "https://api.anthropic.com/api/event_logging/v2/batch",
+  "https://http-intake.logs.us5.datadoghq.com/api/v2/logs",
+  "https://browser-intake-us5-datadoghq.com/api/v2/logs",
+];
+
+export interface PromptFingerprintFinding {
+  kind: "hidden-unicode" | "date-line-marker" | "telemetry-endpoint" | "telemetry-optout-gap";
+  severity: "info" | "review" | "block";
+  evidence: string;
+}
+
+export interface PromptFingerprintReceipt {
+  schema: "fable.prompt_fingerprint.receipt.v1";
+  createdAt: string;
+  source: string;
+  findings: PromptFingerprintFinding[];
+  decision: "clean" | "review" | "blocked";
+  reasons: string[];
+  deployAttempted: false;
+}
+
+export function createPromptFingerprintReceipt(source: string, text: string, now = new Date()): PromptFingerprintReceipt {
+  const findings: PromptFingerprintFinding[] = [];
+  if (hasHiddenUnicode(text)) {
+    findings.push({ kind: "hidden-unicode", severity: "block", evidence: findHiddenUnicode(text).slice(0, 10).map((hit) => `${hit.codePoint}@${hit.index}`).join(", ") });
+  }
+
+  const date = DATE_LINE.exec(text);
+  if (date && (date[1] !== "'" || date[3] !== "-")) {
+    findings.push({ kind: "date-line-marker", severity: "block", evidence: date[0] });
+  }
+
+  for (const endpoint of TELEMETRY_ENDPOINTS) {
+    if (text.includes(endpoint)) findings.push({ kind: "telemetry-endpoint", severity: "review", evidence: endpoint });
+  }
+
+  if (text.includes("DISABLE_TELEMETRY") && text.includes("Datadog") && /does not|not guard|still ON|hole/i.test(text)) {
+    findings.push({ kind: "telemetry-optout-gap", severity: "review", evidence: "DISABLE_TELEMETRY does not appear to cover all telemetry paths" });
+  }
+
+  const blocked = findings.some((finding) => finding.severity === "block");
+  const review = findings.some((finding) => finding.severity === "review");
+  return {
+    schema: "fable.prompt_fingerprint.receipt.v1",
+    createdAt: now.toISOString(),
+    source,
+    findings,
+    decision: blocked ? "blocked" : review ? "review" : "clean",
+    reasons: findings.map((finding) => `${finding.kind}: ${finding.evidence}`),
+    deployAttempted: false,
+  };
+}
+
+export function writePromptFingerprintReceipt(file: string, receipt: PromptFingerprintReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/research-map-receipt.test.ts
+++ b/src/fable5/research-map-receipt.test.ts
@ -0,0 +1,90 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createResearchMapReceipt, writeResearchMapReceipt } from "./research-map-receipt.js";
+
+const phase = {
+  name: "Add receipt primitive",
+  goal: "Map research into a bounded receipt and tests",
+  acceptanceCriteria: ["receipt is typed", "forbidden implementation scope is blocked"],
+  verification: ["npm run -s test -- src/fable5/research-map-receipt.test.ts"],
+};
+
+describe("research map receipts", () => {
+  it("creates ready bounded research plans", () => {
+    const receipt = createResearchMapReceipt({
+      now: new Date("2026-07-01T00:00:00.000Z"),
+      taskLabel: "ast-context",
+      task: "Map AST context research into Fable receipt primitives",
+      constraints: ["advisory-only", "no production mutation"],
+      existingPrimitives: ["plan-receipt", "context-workspace-receipt", "factory-deploy", "rsi-reconcile"],
+      recommendedPlan: [phase],
+      skipped: ["deploy changes", "dashboard", "vendored tools", "new model architecture"],
+    });
+
+    expect(receipt).toMatchObject({
+      schema: "fable.research_map.receipt.v1",
+      decision: "ready",
+      reasons: [],
+      deployAttempted: false,
+    });
+    expect(receipt.skipped).toContain("deploy changes");
+    expect(receipt.existingPrimitives).toContain("plan-receipt");
+  });
+
+  it("blocks missing task metadata and phases", () => {
+    const receipt = createResearchMapReceipt({ taskLabel: "", task: "", recommendedPlan: [] });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("missing task label");
+    expect(receipt.reasons).toContain("missing task");
+    expect(receipt.reasons).toContain("missing recommended phases");
+  });
+
+  it("requires acceptance criteria and verification", () => {
+    const receipt = createResearchMapReceipt({
+      taskLabel: "bad",
+      task: "Bad map",
+      recommendedPlan: [{ name: "x", goal: "y", acceptanceCriteria: [], verification: [] }],
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("each phase needs acceptance criteria");
+    expect(receipt.reasons).toContain("each phase needs verification steps");
+  });
+
+  it("blocks forbidden implementation scope in recommended phases", () => {
+    const receipt = createResearchMapReceipt({
+      taskLabel: "overbuild",
+      task: "Map research safely",
+      recommendedPlan: [{ ...phase, goal: "Build a new model architecture and dashboard" }],
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons[0]).toContain("forbidden scope");
+    expect(receipt.reasons[0]).toContain("dashboard");
+    expect(receipt.reasons[0]).toContain("new model architecture");
+  });
+
+  it("does not block forbidden terms when they are explicitly skipped", () => {
+    const receipt = createResearchMapReceipt({
+      taskLabel: "bounded",
+      task: "Map research safely",
+      recommendedPlan: [phase],
+      skipped: ["deploy", "dashboard", "vendor", "new model architecture"],
+    });
+
+    expect(receipt.decision).toBe("ready");
+  });
+
+  it("writes receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "research-map-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeResearchMapReceipt(file, createResearchMapReceipt({ taskLabel: "x", task: "y", recommendedPlan: [phase] }));
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.research_map.receipt.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/research-map-receipt.ts
+++ b/src/fable5/research-map-receipt.ts
@ -0,0 +1,61 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { PlanPhase } from "./plan-receipt.js";
+
+export interface ResearchMapReceipt {
+  schema: "fable.research_map.receipt.v1";
+  createdAt: string;
+  taskLabel: string;
+  task: string;
+  constraints: string[];
+  existingPrimitives: string[];
+  recommendedPlan: PlanPhase[];
+  skipped: string[];
+  decision: "ready" | "blocked";
+  reasons: string[];
+  deployAttempted: false;
+}
+
+export interface ResearchMapOptions {
+  taskLabel: string;
+  task: string;
+  constraints?: string[];
+  existingPrimitives?: string[];
+  recommendedPlan: PlanPhase[];
+  skipped?: string[];
+  now?: Date;
+}
+
+const FORBIDDEN_SCOPE = ["deploy", "dashboard", "vendor", "vendoring", "new model architecture"];
+
+export function createResearchMapReceipt(opts: ResearchMapOptions): ResearchMapReceipt {
+  const reasons: string[] = [];
+  if (!opts.taskLabel.trim()) reasons.push("missing task label");
+  if (!opts.task.trim()) reasons.push("missing task");
+  if (opts.recommendedPlan.length === 0) reasons.push("missing recommended phases");
+  if (opts.recommendedPlan.some((phase) => phase.acceptanceCriteria.length === 0)) reasons.push("each phase needs acceptance criteria");
+  if (opts.recommendedPlan.some((phase) => phase.verification.length === 0)) reasons.push("each phase needs verification steps");
+  const searchable = [opts.task, opts.taskLabel, ...opts.recommendedPlan.flatMap((phase) => [phase.name, phase.goal])].join("\n").toLowerCase();
+  const forbidden = FORBIDDEN_SCOPE.filter((term) => searchable.includes(term));
+  if (forbidden.length > 0) reasons.push(`forbidden scope: ${forbidden.join(", ")}`);
+
+  return {
+    schema: "fable.research_map.receipt.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    taskLabel: opts.taskLabel,
+    task: opts.task,
+    constraints: opts.constraints ?? [],
+    existingPrimitives: opts.existingPrimitives ?? [],
+    recommendedPlan: opts.recommendedPlan,
+    skipped: opts.skipped ?? [],
+    decision: reasons.length === 0 ? "ready" : "blocked",
+    reasons,
+    deployAttempted: false,
+  };
+}
+
+export function writeResearchMapReceipt(file: string, receipt: ResearchMapReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/rsi-reconcile.test.ts
+++ b/src/fable5/rsi-reconcile.test.ts
@ -43,6 +43,8 @@ function runner(overrides: Record<string, { status: number; stdout: string; stde
    if (script.includes("tail -160")) return { status: 0, stdout: "RSI: 65/65 (100%)\nAll healthy — ZTE idle\n", stderr: "" };
    if (script.includes("systemctl is-active")) return { status: 0, stdout: "active\n", stderr: "" };
    if (script.includes("/deploy")) return { status: 0, stdout: "present\n", stderr: "" };
+    if (script.includes("docker exec hermes test -f /tmp/skill_health.py")) return { status: 0, stdout: "present\n", stderr: "" };
+    if (script.includes("/opt/data/skills/rsi_canary/test.sh")) return { status: 0, stdout: "rsi_canary: recovered\n", stderr: "" };
    return { status: 1, stdout: "", stderr: "unexpected" };
  };
 }
@ -103,6 +105,14 @@ describe("rsi reconcile", () => {
    expect(receipt.decision).toBe("degraded");
  });

+  it("marks degraded when host RSI logs are stale but container canary fails", () => {
+    const receipt = reconcileRsi({ host: "example", runner: runner({ "/opt/data/skills/rsi_canary/test.sh": { status: 1, stdout: "rsi_canary: degraded\n" } }) });
+
+    expect(receipt.facts.latest_score).toBe("65/65 (100%)");
+    expect(receipt.facts.canary_healthy).toBe(false);
+    expect(receipt.decision).toBe("degraded");
+  });
+
  it("writes a receipt", () => {
    const out = tmpFile();
    reconcileRsi({ host: "example", out, runner: runner() });
--- a/src/fable5/rsi-reconcile.ts
+++ b/src/fable5/rsi-reconcile.ts
@ -51,6 +51,8 @@ export interface RsiReconcileReceipt {
    latest_score?: string;
    factory_watcher_active: boolean;
    deploy_route_present: boolean;
+    hermes_skill_health_present: boolean;
+    canary_healthy: boolean;
    auto_patch_proven: boolean;
    canary_proof?: string;
  };
@ -66,6 +68,8 @@ export function reconcileRsi(opts: RsiReconcileOptions): RsiReconcileReceipt {
    check("latest_rsi", port, opts.host, "tail -160 /tmp/rsi-diagnosis.log 2>/dev/null | grep -E 'RSI:|All healthy|auto-patching|Rolled back|All patched'", runner),
    check("factory_watcher", port, opts.host, "systemctl is-active factory-watcher.service 2>/dev/null", runner),
    check("deploy_route", port, opts.host, "code=\"$(curl -sS -m 5 -o /dev/null -w '%{http_code}' -X POST http://127.0.0.1:8099/deploy)\" && (test \"$code\" = \"401\" || test \"$code\" = \"403\") && echo present", runner),
+    check("hermes_skill_health", port, opts.host, "docker exec hermes test -f /tmp/skill_health.py && echo present", runner),
+    check("rsi_canary", port, opts.host, "docker exec hermes bash -lc 'test -x /opt/data/skills/rsi_canary/test.sh && /opt/data/skills/rsi_canary/test.sh'", runner),
  ];
  const latest = checks.find((c) => c.name === "latest_rsi")?.stdout ?? "";
  const canaryProofOk = opts.canaryProof ? verifyCanaryProof(opts.canaryProof, opts.now).ok : false;
@ -75,11 +79,13 @@ export function reconcileRsi(opts: RsiReconcileOptions): RsiReconcileReceipt {
    latest_score: latest.match(/RSI:\s*([^\n]+)/)?.[1]?.trim(),
    factory_watcher_active: /active/.test(checks.find((c) => c.name === "factory_watcher")?.stdout ?? ""),
    deploy_route_present: isOk("deploy_route", checks),
+    hermes_skill_health_present: isOk("hermes_skill_health", checks),
+    canary_healthy: isOk("rsi_canary", checks),
    auto_patch_proven: canaryProofOk,
    ...(canaryProofOk ? { canary_proof: opts.canaryProof } : {}),
  };
-  // ponytail: cron/log text is advisory; fresh structured canary proof is required for auto_patch_proven.
-  const coreHealthy = facts.skill_health_present && /100%|65\/65|66\/66/.test(facts.latest_score ?? "") && facts.factory_watcher_active && facts.deploy_route_present;
+  // ponytail: host cron/log text is advisory; container canary evidence wins over stale logs.
+  const coreHealthy = facts.skill_health_present && facts.hermes_skill_health_present && facts.canary_healthy && /100%|65\/65|66\/66/.test(facts.latest_score ?? "") && facts.factory_watcher_active && facts.deploy_route_present;
  const createdAt = (opts.now ?? new Date()).toISOString();
  const decision = coreHealthy ? (facts.auto_patch_proven ? "healthy" : "healthy_but_autopatch_unproven") : "degraded";
  const receipt: RsiReconcileReceipt = {
--- a/src/fable5/skill-health.test.ts
+++ b/src/fable5/skill-health.test.ts
@ -0,0 +1,52 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createSkillHealthReceipt, writeSkillHealthReceipt } from "./skill-health.js";
+
+describe("skill health receipt", () => {
+  it("marks all passing skills ready without auto-patch or deploy authority", () => {
+    const receipt = createSkillHealthReceipt({
+      now: new Date("2026-07-01T00:00:00.000Z"),
+      source: "factory",
+      skills: [{ skill: "rsi_canary", agent: "hermes", testCommand: "test.sh", passed: 1, failed: 0, passRate: 0, evidence: "local test passed" }],
+    });
+
+    expect(receipt).toMatchObject({
+      schema: "fable.skill_health.receipt.v1",
+      createdAt: "2026-07-01T00:00:00.000Z",
+      totalSkills: 1,
+      healthy: 1,
+      degraded: 0,
+      decision: "ready",
+      autoPatchAttempted: false,
+      deployAttempted: false,
+    });
+    expect(receipt.skills[0]).toMatchObject({ passRate: 1, status: "healthy" });
+  });
+
+  it("degrades below threshold instead of claiming repair", () => {
+    const receipt = createSkillHealthReceipt({
+      threshold: 0.8,
+      skills: [{ skill: "bad", passed: 3, failed: 2, passRate: 0 }],
+    });
+
+    expect(receipt).toMatchObject({ degraded: 1, decision: "degraded", autoPatchAttempted: false, deployAttempted: false });
+    expect(receipt.reasons[0]).toContain("below 80% pass threshold");
+  });
+
+  it("blocks empty evidence", () => {
+    expect(createSkillHealthReceipt({ skills: [] })).toMatchObject({ decision: "blocked", reasons: ["no skill health evidence supplied"] });
+  });
+
+  it("writes JSON receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "skill-health-"));
+    const file = path.join(dir, "receipt.json");
+    const receipt = createSkillHealthReceipt({ skills: [{ skill: "ok", passed: 1, failed: 0, passRate: 0 }] });
+
+    writeSkillHealthReceipt(file, receipt);
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.skill_health.receipt.v1", decision: "ready" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/skill-health.ts
+++ b/src/fable5/skill-health.ts
@ -0,0 +1,73 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export interface SkillHealthInput {
+  skill: string;
+  agent?: string;
+  testCommand?: string;
+  passed: number;
+  failed: number;
+  passRate?: number;
+  evidence?: string;
+}
+
+export interface SkillHealthEntry extends SkillHealthInput {
+  passRate: number;
+  status: "healthy" | "degraded";
+}
+
+export interface SkillHealthReceipt {
+  schema: "fable.skill_health.receipt.v1";
+  createdAt: string;
+  source: "manual" | "factory" | "cron";
+  totalSkills: number;
+  healthy: number;
+  degraded: number;
+  threshold: number;
+  skills: SkillHealthEntry[];
+  decision: "ready" | "degraded" | "blocked";
+  reasons: string[];
+  autoPatchAttempted: false;
+  deployAttempted: false;
+}
+
+export interface SkillHealthOptions {
+  skills: SkillHealthInput[];
+  source?: SkillHealthReceipt["source"];
+  threshold?: number;
+  now?: Date;
+}
+
+export function createSkillHealthReceipt(opts: SkillHealthOptions): SkillHealthReceipt {
+  const threshold = opts.threshold ?? 0.8;
+  const skills = opts.skills.map((skill) => {
+    const total = skill.passed + skill.failed;
+    const passRate = total === 0 ? skill.passRate ?? 0 : skill.passed / total;
+    return { ...skill, passRate, status: passRate >= threshold ? "healthy" as const : "degraded" as const };
+  });
+  const degraded = skills.filter((skill) => skill.status === "degraded").length;
+  const reasons: string[] = [];
+  if (skills.length === 0) reasons.push("no skill health evidence supplied");
+  if (degraded > 0) reasons.push(`${degraded} skill(s) below ${(threshold * 100).toFixed(0)}% pass threshold`);
+
+  return {
+    schema: "fable.skill_health.receipt.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    source: opts.source ?? "manual",
+    totalSkills: skills.length,
+    healthy: skills.length - degraded,
+    degraded,
+    threshold,
+    skills,
+    decision: skills.length === 0 ? "blocked" : degraded > 0 ? "degraded" : "ready",
+    reasons,
+    autoPatchAttempted: false,
+    deployAttempted: false,
+  };
+}
+
+export function writeSkillHealthReceipt(file: string, receipt: SkillHealthReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/stale-memory-quarantine.test.ts
+++ b/src/fable5/stale-memory-quarantine.test.ts
@ -0,0 +1,38 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createFactoryMemoryQuarantineReceipt, createStaleMemoryQuarantineReceipt, writeStaleMemoryQuarantineReceipt } from "./stale-memory-quarantine.js";
+
+describe("stale memory quarantine receipts", () => {
+  it("quarantines dangerous factory memory without deploy authority", () => {
+    const receipt = createFactoryMemoryQuarantineReceipt(new Date("2026-07-01T00:00:00.000Z"));
+
+    expect(receipt).toMatchObject({
+      schema: "fable.stale_memory.quarantine.v1",
+      source: "conversation memory summary",
+      decision: "quarantined",
+      deployAttempted: false,
+    });
+    expect(receipt.claims.map((claim) => claim.claim)).toContain("8098/deploy-webhook is trusted deploy path");
+    expect(receipt.claims.some((claim) => claim.severity === "dangerous")).toBe(true);
+    expect(receipt.blockedTrustPaths).toContain("8098/deploy-webhook");
+    expect(receipt.canonicalTrustPaths).toContain("8099/deploy via git-proxy");
+  });
+
+  it("marks empty claim sets ready", () => {
+    const receipt = createStaleMemoryQuarantineReceipt({ source: "none", claims: [] });
+
+    expect(receipt).toMatchObject({ decision: "ready", deployAttempted: false });
+  });
+
+  it("writes quarantine receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "stale-memory-quarantine-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeStaleMemoryQuarantineReceipt(file, createFactoryMemoryQuarantineReceipt());
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.stale_memory.quarantine.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/stale-memory-quarantine.ts
+++ b/src/fable5/stale-memory-quarantine.ts
@ -0,0 +1,53 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type StaleMemorySeverity = "advisory" | "dangerous";
+
+export interface StaleMemoryClaim {
+  claim: string;
+  staleBecause: string;
+  replacementTruth: string;
+  severity: StaleMemorySeverity;
+}
+
+export interface StaleMemoryQuarantineReceipt {
+  schema: "fable.stale_memory.quarantine.v1";
+  createdAt: string;
+  source: string;
+  claims: StaleMemoryClaim[];
+  blockedTrustPaths: string[];
+  canonicalTrustPaths: string[];
+  decision: "quarantined" | "ready";
+  deployAttempted: false;
+}
+
+export function createStaleMemoryQuarantineReceipt(opts: { source: string; claims: StaleMemoryClaim[]; now?: Date }): StaleMemoryQuarantineReceipt {
+  return {
+    schema: "fable.stale_memory.quarantine.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    source: opts.source,
+    claims: opts.claims,
+    blockedTrustPaths: ["8098/deploy-webhook", "memory-only deploy authority", "autonomous deploy without fresh gate receipt"],
+    canonicalTrustPaths: ["live receipt > committed receipt > memory", "8099/deploy via git-proxy", "explicit approval + fresh valid ZTE/factory gate receipt"],
+    decision: opts.claims.length > 0 ? "quarantined" : "ready",
+    deployAttempted: false,
+  };
+}
+
+export function createFactoryMemoryQuarantineReceipt(now = new Date()): StaleMemoryQuarantineReceipt {
+  return createStaleMemoryQuarantineReceipt({
+    now,
+    source: "conversation memory summary",
+    claims: [
+      { claim: "25 containers", staleBecause: "fresh factory receipts verified 18 containers", replacementTruth: "container count must come from live factory reconciliation receipt", severity: "advisory" },
+      { claim: "8098/deploy-webhook is trusted deploy path", staleBecause: "current trust boundary marks 8098 legacy/stale only", replacementTruth: "8099/deploy via git-proxy is the canonical gated deploy route", severity: "dangerous" },
+      { claim: "agents can deploy without human intervention", staleBecause: "current policy requires explicit approval and fresh gate receipts", replacementTruth: "agents draft, receipts prove, humans approve, guarded 8099/deploy ships", severity: "dangerous" },
+    ],
+  });
+}
+
+export function writeStaleMemoryQuarantineReceipt(file: string, receipt: StaleMemoryQuarantineReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/structural-patch-receipt.test.ts
+++ b/src/fable5/structural-patch-receipt.test.ts
@ -0,0 +1,91 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createStructuralPatchReceipt, writeStructuralPatchReceipt } from "./structural-patch-receipt.js";
+
+const target = {
+  file: "src/app.tsx",
+  language: "node_tsx" as const,
+  nodeKind: "ControlNode" as const,
+  languageKind: "IfStatement",
+  path: [2, 1, 0],
+  start: 42,
+  end: 88,
+  baseSha: "abc123",
+};
+
+const checks = [{ name: "typecheck", command: "npm run -s build", status: "pass" as const }];
+
+describe("structural patch receipts", () => {
+  it("marks exact coordinate patches as surgical", () => {
+    const receipt = createStructuralPatchReceipt({
+      now: new Date("2026-07-01T00:00:00.000Z"),
+      taskLabel: "deep-block-edit",
+      target,
+      parserReceipt: "docs/receipts/parser.json",
+      serializerReceipt: "docs/receipts/serializer.json",
+      checks,
+    });
+
+    expect(receipt).toMatchObject({
+      schema: "fable.structural_patch.receipt.v1",
+      decision: "surgical",
+      lockedSurroundingTree: true,
+      reasons: [],
+      deployAttempted: false,
+    });
+    expect(receipt.target.path).toEqual([2, 1, 0]);
+    expect(receipt.skipped).toContain("raw string concatenation");
+  });
+
+  it("blocks patches without coordinates and spans", () => {
+    const receipt = createStructuralPatchReceipt({
+      taskLabel: "bad",
+      target: { ...target, path: [], start: 10, end: 10 },
+      parserReceipt: "docs/receipts/parser.json",
+      serializerReceipt: "docs/receipts/serializer.json",
+      checks,
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("missing node path coordinates");
+    expect(receipt.reasons).toContain("invalid target span");
+  });
+
+  it("blocks raw string patches and missing parser or serializer support", () => {
+    const receipt = createStructuralPatchReceipt({ taskLabel: "raw", target, checks, rawStringPatch: true });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("missing parser support receipt");
+    expect(receipt.reasons).toContain("missing serializer support receipt");
+    expect(receipt.reasons).toContain("raw string patch is not surgical");
+  });
+
+  it("blocks failed validation checks and deploy attempts", () => {
+    const receipt = createStructuralPatchReceipt({
+      taskLabel: "unsafe",
+      target,
+      parserReceipt: "docs/receipts/parser.json",
+      serializerReceipt: "docs/receipts/serializer.json",
+      checks: [{ name: "typecheck", command: "npm run -s build", status: "fail" }],
+      deployAttempted: true,
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("validation checks must pass");
+    expect(receipt.reasons).toContain("deploy is out of scope for structural patch receipts");
+    expect(receipt.deployAttempted).toBe(false);
+  });
+
+  it("writes receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "structural-patch-"));
+    const file = path.join(dir, "receipt.json");
+    const receipt = createStructuralPatchReceipt({ taskLabel: "x", target, parserReceipt: "p", serializerReceipt: "s", checks });
+
+    writeStructuralPatchReceipt(file, receipt);
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.structural_patch.receipt.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/structural-patch-receipt.ts
+++ b/src/fable5/structural-patch-receipt.ts
@ -0,0 +1,94 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { UastLanguage } from "./uast-runtime-receipt.js";
+
+export type StructuralNodeKind = "ScopeNode" | "ControlNode" | "StateNode" | "LeafNode";
+export type StructuralPatchDecision = "surgical" | "blocked";
+
+export interface StructuralNodeCoordinate {
+  file: string;
+  language: UastLanguage;
+  nodeKind: StructuralNodeKind;
+  languageKind: string;
+  path: number[];
+  start: number;
+  end: number;
+  baseSha: string;
+}
+
+export interface StructuralPatchCheck {
+  name: string;
+  command: string;
+  status: "pass" | "fail";
+}
+
+export interface StructuralPatchReceiptOptions {
+  taskLabel: string;
+  target: StructuralNodeCoordinate;
+  parserReceipt?: string;
+  serializerReceipt?: string;
+  checks: StructuralPatchCheck[];
+  rawStringPatch?: boolean;
+  deployAttempted?: boolean;
+  now?: Date;
+}
+
+export interface StructuralPatchReceipt {
+  schema: "fable.structural_patch.receipt.v1";
+  createdAt: string;
+  taskLabel: string;
+  target: StructuralNodeCoordinate;
+  parserReceipt?: string;
+  serializerReceipt?: string;
+  checks: StructuralPatchCheck[];
+  lockedSurroundingTree: boolean;
+  decision: StructuralPatchDecision;
+  reasons: string[];
+  skipped: string[];
+  deployAttempted: false;
+}
+
+function hasText(value: string | undefined): boolean {
+  return Boolean(value?.trim());
+}
+
+export function createStructuralPatchReceipt(opts: StructuralPatchReceiptOptions): StructuralPatchReceipt {
+  const reasons: string[] = [];
+  if (!hasText(opts.taskLabel)) reasons.push("missing task label");
+  if (!hasText(opts.target.file)) reasons.push("missing target file");
+  if (!hasText(opts.target.languageKind)) reasons.push("missing language node kind");
+  if (!hasText(opts.target.baseSha)) reasons.push("missing base sha");
+  if (opts.target.path.length === 0) reasons.push("missing node path coordinates");
+  if (opts.target.path.some((segment) => !Number.isInteger(segment) || segment < 0)) reasons.push("invalid node path coordinates");
+  if (!Number.isInteger(opts.target.start) || !Number.isInteger(opts.target.end) || opts.target.start < 0 || opts.target.end <= opts.target.start) {
+    reasons.push("invalid target span");
+  }
+  if (!hasText(opts.parserReceipt)) reasons.push("missing parser support receipt");
+  if (!hasText(opts.serializerReceipt)) reasons.push("missing serializer support receipt");
+  if (opts.checks.length === 0) reasons.push("missing validation checks");
+  if (opts.checks.some((check) => !hasText(check.name) || !hasText(check.command))) reasons.push("validation checks need names and commands");
+  if (opts.checks.some((check) => check.status !== "pass")) reasons.push("validation checks must pass");
+  if (opts.rawStringPatch) reasons.push("raw string patch is not surgical");
+  if (opts.deployAttempted) reasons.push("deploy is out of scope for structural patch receipts");
+
+  return {
+    schema: "fable.structural_patch.receipt.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    taskLabel: opts.taskLabel,
+    target: opts.target,
+    parserReceipt: opts.parserReceipt,
+    serializerReceipt: opts.serializerReceipt,
+    checks: opts.checks,
+    lockedSurroundingTree: reasons.length === 0,
+    decision: reasons.length === 0 ? "surgical" : "blocked",
+    reasons,
+    skipped: ["raw string concatenation", "full universal UAST runtime", "cross-language pristine writer", "deploy"],
+    deployAttempted: false,
+  };
+}
+
+export function writeStructuralPatchReceipt(file: string, receipt: StructuralPatchReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/fable5/uast-runtime-receipt.test.ts
+++ b/src/fable5/uast-runtime-receipt.test.ts
@ -0,0 +1,58 @@
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createUastRuntimeReceipt, writeUastRuntimeReceipt } from "./uast-runtime-receipt.js";
+
+describe("uast runtime receipts", () => {
+  it("bounds universal UAST requests to parser coverage and syntax checks", () => {
+    const receipt = createUastRuntimeReceipt({
+      now: new Date("2026-07-01T00:00:00.000Z"),
+      taskLabel: "review-agent-3",
+      task: "Review proposed universal abstract syntax tree runtime across Assembly, C/C++, Rust, Go, Python, Node.js/TSX, and Ruby",
+    });
+
+    expect(receipt).toMatchObject({
+      schema: "fable.uast_runtime.receipt.v1",
+      decision: "ready",
+      deployAttempted: false,
+      reasons: [],
+    });
+    expect(receipt.parserMatrix.map((row) => row.language)).toEqual(["node_tsx", "python", "go", "rust", "c_cpp", "ruby", "assembly"]);
+    expect(receipt.safeScope).toContain("reuse existing TypeScript AST scan");
+    expect(receipt.skipped).toContain("full UAST runtime");
+    expect(receipt.skipped).toContain("memory-only factory truth");
+  });
+
+  it("rejects claims that syntax bugs can be eliminated", () => {
+    const receipt = createUastRuntimeReceipt({
+      taskLabel: "bad-claim",
+      task: "Approve impossible guarantee",
+      claims: [{ claim: "Eliminates syntax bugs", decision: "accepted", reason: "overclaim" }],
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("syntax-elimination claims must be rejected");
+  });
+
+  it("requires syntax checks for non-existing parser rows", () => {
+    const receipt = createUastRuntimeReceipt({
+      taskLabel: "matrix",
+      task: "Validate parser matrix",
+      parserMatrix: [{ language: "ruby", parser: "ruby parser", status: "external_required", syntaxCheck: "" }],
+    });
+
+    expect(receipt.decision).toBe("blocked");
+    expect(receipt.reasons).toContain("non-existing parsers need syntax checks");
+  });
+
+  it("writes receipts", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "uast-runtime-"));
+    const file = path.join(dir, "receipt.json");
+
+    writeUastRuntimeReceipt(file, createUastRuntimeReceipt({ taskLabel: "x", task: "y" }));
+
+    expect(JSON.parse(fs.readFileSync(file, "utf-8"))).toMatchObject({ schema: "fable.uast_runtime.receipt.v1" });
+    fs.rmSync(dir, { recursive: true, force: true });
+  });
+});
--- a/src/fable5/uast-runtime-receipt.ts
+++ b/src/fable5/uast-runtime-receipt.ts
@ -0,0 +1,93 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+export type UastLanguage = "assembly" | "c_cpp" | "rust" | "go" | "python" | "node_tsx" | "ruby";
+export type UastParserStatus = "existing" | "missing" | "external_required";
+export type UastClaimDecision = "accepted" | "bounded" | "rejected";
+
+export interface UastParserRow {
+  language: UastLanguage;
+  parser: string;
+  status: UastParserStatus;
+  syntaxCheck: string;
+}
+
+export interface UastClaim {
+  claim: string;
+  decision: UastClaimDecision;
+  reason: string;
+}
+
+export interface UastRuntimeReceiptOptions {
+  taskLabel: string;
+  task: string;
+  parserMatrix?: UastParserRow[];
+  claims?: UastClaim[];
+  now?: Date;
+}
+
+export interface UastRuntimeReceipt {
+  schema: "fable.uast_runtime.receipt.v1";
+  createdAt: string;
+  taskLabel: string;
+  task: string;
+  parserMatrix: UastParserRow[];
+  claims: UastClaim[];
+  safeScope: string[];
+  skipped: string[];
+  decision: "ready" | "blocked";
+  reasons: string[];
+  deployAttempted: false;
+}
+
+const DEFAULT_MATRIX: UastParserRow[] = [
+  { language: "node_tsx", parser: "typescript.createSourceFile", status: "existing", syntaxCheck: "tsc --noEmit / npm run build" },
+  { language: "python", parser: "python -m py_compile / ast.parse", status: "external_required", syntaxCheck: "python -m py_compile" },
+  { language: "go", parser: "gofmt/go test", status: "external_required", syntaxCheck: "gofmt -w + go test" },
+  { language: "rust", parser: "rustc/cargo", status: "external_required", syntaxCheck: "cargo check" },
+  { language: "c_cpp", parser: "compiler frontend", status: "external_required", syntaxCheck: "cc -fsyntax-only / clang++ -fsyntax-only" },
+  { language: "ruby", parser: "ruby parser", status: "external_required", syntaxCheck: "ruby -c" },
+  { language: "assembly", parser: "target assembler", status: "external_required", syntaxCheck: "assembler dry-run" },
+];
+
+const DEFAULT_CLAIMS: UastClaim[] = [
+  { claim: "Universal ScopeNode/ControlNode/StateNode/LeafNode runtime across seven language families", decision: "bounded", reason: "Record as research map only; cross-language rewriting needs per-language parsers and printers." },
+  { claim: "Transaction validation before writing", decision: "accepted", reason: "Use existing receipt and syntax-check gates before mutation." },
+  { claim: "Pristine serialized writing", decision: "rejected", reason: "Formatting-preserving writes are language-specific and not guaranteed by current primitives." },
+  { claim: "Eliminates syntax bugs", decision: "rejected", reason: "Syntax checks reduce bugs; they cannot eliminate parser gaps, semantic errors, or generated-code drift." },
+  { claim: "Memory-only factory/RSI facts are current truth", decision: "rejected", reason: "Conflicting factory/TAC memory must be quarantined behind fresh receipts; no deploy is attempted." },
+];
+
+export function createUastRuntimeReceipt(opts: UastRuntimeReceiptOptions): UastRuntimeReceipt {
+  const parserMatrix = opts.parserMatrix ?? DEFAULT_MATRIX;
+  const claims = opts.claims ?? DEFAULT_CLAIMS;
+  const reasons: string[] = [];
+  if (!opts.taskLabel.trim()) reasons.push("missing task label");
+  if (!opts.task.trim()) reasons.push("missing task");
+  if (parserMatrix.length === 0) reasons.push("missing parser matrix");
+  if (claims.length === 0) reasons.push("missing claims");
+  if (claims.some((claim) => claim.claim.toLowerCase().includes("eliminates syntax bugs") && claim.decision !== "rejected")) {
+    reasons.push("syntax-elimination claims must be rejected");
+  }
+  if (parserMatrix.some((row) => row.status !== "existing" && !row.syntaxCheck.trim())) reasons.push("non-existing parsers need syntax checks");
+
+  return {
+    schema: "fable.uast_runtime.receipt.v1",
+    createdAt: (opts.now ?? new Date()).toISOString(),
+    taskLabel: opts.taskLabel,
+    task: opts.task,
+    parserMatrix,
+    claims,
+    safeScope: ["map parser coverage", "require syntax checks", "record rejected overclaims", "reuse existing TypeScript AST scan"],
+    skipped: ["full UAST runtime", "cross-language pristine writer", "deploy", "memory-only factory truth"],
+    decision: reasons.length ? "blocked" : "ready",
+    reasons,
+    deployAttempted: false,
+  };
+}
+
+export function writeUastRuntimeReceipt(file: string, receipt: UastRuntimeReceipt): string {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, `${JSON.stringify(receipt, null, 2)}\n`);
+  return file;
+}
--- a/src/index.ts
+++ b/src/index.ts
@ -1763,6 +1763,81 @@ const forgejo = program
  .command("forgejo")
  .description("Forgejo intake and GitOps task receipts");

+forgejo
+  .command("repos")
+  .description("List Forgejo repositories via CLI")
+  .option("--user <username>", "List repositories for a user instead of current token user")
+  .action(async (opts: { user?: string }) => {
+    const { listForgejoRepositories } = await import("./fable5/forgejo-cli.js");
+    console.log(JSON.stringify(await listForgejoRepositories({ baseUrl: process.env.FORGEJO_URL, token: process.env.FORGEJO_TOKEN }, opts.user), null, 2));
+  });
+
+forgejo
+  .command("repo <repo>")
+  .description("Get Forgejo repository information")
+  .action(async (repo: string) => {
+    const { getForgejoRepository } = await import("./fable5/forgejo-cli.js");
+    console.log(JSON.stringify(await getForgejoRepository({ baseUrl: process.env.FORGEJO_URL, token: process.env.FORGEJO_TOKEN }, repo), null, 2));
+  });
+
+forgejo
+  .command("issues <repo>")
+  .description("List Forgejo issues")
+  .option("--state <state>", "open|closed|all", "open")
+  .action(async (repo: string, opts: { state?: string }) => {
+    const { listForgejoIssues } = await import("./fable5/forgejo-cli.js");
+    console.log(JSON.stringify(await listForgejoIssues({ baseUrl: process.env.FORGEJO_URL, token: process.env.FORGEJO_TOKEN }, repo, opts.state), null, 2));
+  });
+
+forgejo
+  .command("prs <repo>")
+  .description("List Forgejo pull requests")
+  .option("--state <state>", "open|closed|all", "open")
+  .action(async (repo: string, opts: { state?: string }) => {
+    const { listForgejoPullRequests } = await import("./fable5/forgejo-cli.js");
+    console.log(JSON.stringify(await listForgejoPullRequests({ baseUrl: process.env.FORGEJO_URL, token: process.env.FORGEJO_TOKEN }, repo, opts.state), null, 2));
+  });
+
+forgejo
+  .command("file <repo> <path>")
+  .description("Read file content from Forgejo")
+  .option("--ref <ref>", "Branch or commit", "main")
+  .action(async (repo: string, filePath: string, opts: { ref?: string }) => {
+    const { getForgejoFileContent } = await import("./fable5/forgejo-cli.js");
+    console.log(await getForgejoFileContent({ baseUrl: process.env.FORGEJO_URL, token: process.env.FORGEJO_TOKEN }, repo, filePath, opts.ref));
+  });
+
+forgejo
+  .command("pr-create <repo>")
+  .description("Create a scanned receipt-backed Forgejo pull request")
+  .requiredOption("--title <title>", "Pull request title")
+  .requiredOption("--head <branch>", "Source branch")
+  .requiredOption("--base <branch>", "Target branch")
+  .option("--body <text>", "Pull request body")
+  .option("--out <path>", "Receipt output directory", ".fable/tasks")
+  .option("--dry-run", "Print receipt JSON without posting or writing a file")
+  .action(async (repo: string, opts: { title: string; head: string; base: string; body?: string; out?: string; dryRun?: boolean }) => {
+    const { createForgejoPullRequest } = await import("./fable5/forgejo-cli.js");
+    const result = await createForgejoPullRequest({ baseUrl: process.env.FORGEJO_URL, token: process.env.FORGEJO_TOKEN, repo, title: opts.title, head: opts.head, base: opts.base, body: opts.body, outDir: opts.out, dryRun: opts.dryRun });
+    if (opts.dryRun) console.log(JSON.stringify(result.receipt, null, 2));
+    else console.log("  ✓ Forgejo PR receipt written: " + result.path);
+    if (result.receipt.receipts.quarantine) process.exit(1);
+  });
+
+forgejo
+  .command("actions-coverage")
+  .description("Write a Forgejo Actions CLI coverage receipt without web scraping or action mutation")
+  .option("--repo <repo>", "Repo slug, e.g. org/repo")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "forgejo", "actions-coverage-live.json"))
+  .action(async (opts: { repo?: string; output?: string }) => {
+    const { createForgejoActionsCoverageReceipt, writeForgejoActionsCoverageReceipt } = await import("./fable5/forgejo-cli.js");
+    const receipt = createForgejoActionsCoverageReceipt(opts.repo);
+    const out = opts.output ?? path.join(".fable", "forgejo", "actions-coverage-live.json");
+    writeForgejoActionsCoverageReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`\n  Receipt: ${out}\n`);
+  });
+
 forgejo
  .command("comment <ref>")
  .description("Post a scanned receipt-backed comment to a Forgejo issue or PR")
@ -1968,6 +2043,8 @@ fable
      { surface: "openai" as const, command: "env OPENAI_API_KEY", status: process.env.OPENAI_API_KEY ? "unknown" as const : "missing" as const, evidence: process.env.OPENAI_API_KEY ? "key present; API not probed" : "OPENAI_API_KEY missing" },
      { surface: "pi" as const, command: "pi --list-models cyber", status: "unknown" as const, evidence: "not probed by this fail-closed receipt command" },
      { surface: "chatgpt-cyber" as const, command: "https://chatgpt.com/cyber", status: "unknown" as const, evidence: "browser/login-gated surface not probed by this command" },
+      { surface: "anthropic-fable" as const, command: "Anthropic redeploying Fable 5 announcement", status: "unknown" as const, model: "claude-fable-5", evidence: "announced globally July 1; local access not probed" },
+      { surface: "anthropic-mythos" as const, command: "Anthropic redeploying Fable 5 announcement", status: "unknown" as const, model: "claude-mythos-5", evidence: "restored only for some US orgs; local access not probed" },
      { surface: "sakana-fugu" as const, command: "sakana/fugu-ultra access probe", status: "unknown" as const, model: "fugu-ultra", evidence: "not probed; do not buy or bypass with VPN" },
      { surface: "hermes-moa" as const, command: "hermes model --provider moa", status: "unknown" as const, model: "moa", evidence: "Hermes MoA preset required; not probed" },
    ];
@ -2047,6 +2124,232 @@ fable
    if (result.verdict === "known_unsafe") process.exit(1);
  });

+fable
+  .command("jailbreak-assess <source>")
+  .description("Score jailbreak severity using capability gain, breadth, weaponization ease, and discoverability")
+  .requiredOption("--capability-gain <n>", "0-5 capability gain", (v) => Number(v))
+  .requiredOption("--breadth <n>", "0-5 breadth of capability gain", (v) => Number(v))
+  .requiredOption("--weaponization-ease <n>", "0-5 ease of weaponization", (v) => Number(v))
+  .requiredOption("--discoverability <n>", "0-5 discoverability", (v) => Number(v))
+  .option("--output <path>", "Receipt output path", path.join(".fable", "security", "jailbreak-assessment-live.json"))
+  .action(async (source: string, opts: { capabilityGain: number; breadth: number; weaponizationEase: number; discoverability: number; output?: string }) => {
+    const { createJailbreakAssessmentReceipt, writeJailbreakAssessmentReceipt } = await import("./fable5/jailbreak-assessment.js");
+    const receipt = createJailbreakAssessmentReceipt({
+      source,
+      capabilityGain: opts.capabilityGain,
+      breadth: opts.breadth,
+      weaponizationEase: opts.weaponizationEase,
+      discoverability: opts.discoverability,
+    });
+    const out = opts.output ?? path.join(".fable", "security", "jailbreak-assessment-live.json");
+    writeJailbreakAssessmentReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`\n  Receipt: ${out}\n`);
+    if (receipt.decision === "block" || receipt.decision === "disclose") process.exit(1);
+  });
+
+fable
+  .command("prompt-fingerprint <file>")
+  .description("Scan a prompt or bundle for covert prompt markers and telemetry fingerprint risks")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "security", "prompt-fingerprint-live.json"))
+  .action(async (file: string, opts: { output?: string }) => {
+    const { createPromptFingerprintReceipt, writePromptFingerprintReceipt } = await import("./fable5/prompt-fingerprint.js");
+    const full = path.resolve(file);
+    const receipt = createPromptFingerprintReceipt(full, fs.readFileSync(full, "utf-8"));
+    const out = opts.output ?? path.join(".fable", "security", "prompt-fingerprint-live.json");
+    writePromptFingerprintReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`\n  Receipt: ${out}\n`);
+    if (receipt.decision === "blocked") process.exit(1);
+  });
+
+fable
+  .command("skill-health")
+  .description("Write a read-only skill health receipt without auto-patch or deploy authority")
+  .option("--input <path>", "JSON array of skill health entries")
+  .option("--skill <name>", "Single skill name")
+  .option("--agent <name>", "Agent responsible for the skill")
+  .option("--test-command <command>", "Command used as evidence")
+  .option("--passed <n>", "Passed checks", (v) => Number(v), 0)
+  .option("--failed <n>", "Failed checks", (v) => Number(v), 0)
+  .option("--evidence <text>", "Evidence summary")
+  .option("--source <source>", "manual|factory|cron", "manual")
+  .option("--threshold <n>", "Pass-rate threshold", (v) => Number(v), 0.8)
+  .option("--output <path>", "Receipt output path", path.join(".fable", "skills", "skill-health-live.json"))
+  .action(async (opts: { input?: string; skill?: string; agent?: string; testCommand?: string; passed?: number; failed?: number; evidence?: string; source?: string; threshold?: number; output?: string }) => {
+    const { createSkillHealthReceipt, writeSkillHealthReceipt } = await import("./fable5/skill-health.js");
+    const skills = opts.input
+      ? JSON.parse(fs.readFileSync(opts.input, "utf-8"))
+      : opts.skill
+        ? [{ skill: opts.skill, agent: opts.agent, testCommand: opts.testCommand, passed: opts.passed ?? 0, failed: opts.failed ?? 0, passRate: 0, evidence: opts.evidence }]
+        : [];
+    const receipt = createSkillHealthReceipt({ skills, source: opts.source as never, threshold: opts.threshold });
+    const out = opts.output ?? path.join(".fable", "skills", "skill-health-live.json");
+    writeSkillHealthReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`\n  Receipt: ${out}\n`);
+    if (receipt.decision === "blocked") process.exit(1);
+  });
+
+fable
+  .command("recovery-receipt")
+  .description("Write a recovery receipt for stale context or failed-state repair")
+  .requiredOption("--incident <text>", "Incident summary")
+  .requiredOption("--live-signal <text>", "Fresh/live evidence signal")
+  .requiredOption("--action-taken <text>", "Action taken")
+  .requiredOption("--decision <decision>", "ready|review|blocked")
+  .option("--stale-signal <text>", "Stale or misleading signal")
+  .option("--root-cause <text>", "Root cause")
+  .option("--before <paths>", "Comma-separated before receipt paths", "")
+  .option("--after <paths>", "Comma-separated after receipt paths", "")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "learning", "recovery-live.json"))
+  .action(async (opts: { incident: string; liveSignal: string; actionTaken: string; decision: string; staleSignal?: string; rootCause?: string; before?: string; after?: string; output?: string }) => {
+    const { createRecoveryReceipt, writeLearningReceipt } = await import("./fable5/learning-receipts.js");
+    const receipt = createRecoveryReceipt({
+      incident: opts.incident,
+      staleSignal: opts.staleSignal,
+      liveSignal: opts.liveSignal,
+      rootCause: opts.rootCause,
+      actionTaken: opts.actionTaken,
+      receiptsBefore: splitCsv(opts.before),
+      receiptsAfter: splitCsv(opts.after),
+      decision: opts.decision as never,
+    });
+    const out = opts.output ?? path.join(".fable", "learning", "recovery-live.json");
+    writeLearningReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+    if (receipt.decision === "blocked") process.exit(1);
+  });
+
+fable
+  .command("context-eval")
+  .description("Evaluate whether a task used current receipt-backed context")
+  .requiredOption("--task <text>", "Task under evaluation")
+  .requiredOption("--checks <json>", "JSON array of {check,passed,evidence?}")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "learning", "context-eval-live.json"))
+  .action(async (opts: { task: string; checks: string; output?: string }) => {
+    const { createContextEvalReceipt, writeLearningReceipt } = await import("./fable5/learning-receipts.js");
+    const receipt = createContextEvalReceipt({ task: opts.task, checks: JSON.parse(opts.checks) });
+    const out = opts.output ?? path.join(".fable", "learning", "context-eval-live.json");
+    writeLearningReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+    if (receipt.decision === "blocked") process.exit(1);
+  });
+
+fable
+  .command("sleep-time-policy")
+  .description("Write the read-only sleep-time compute policy receipt")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "learning", "sleep-time-policy-live.json"))
+  .action(async (opts: { output?: string }) => {
+    const { createSleepTimePolicyReceipt, writeLearningReceipt } = await import("./fable5/learning-receipts.js");
+    const receipt = createSleepTimePolicyReceipt();
+    const out = opts.output ?? path.join(".fable", "learning", "sleep-time-policy-live.json");
+    writeLearningReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+  });
+
+fable
+  .command("context-repo-snapshot <root>")
+  .description("Write a snapshot-only context repository receipt")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "learning", "context-repo-snapshot-live.json"))
+  .action(async (root: string, opts: { output?: string }) => {
+    const { createContextRepoSnapshotReceipt, writeLearningReceipt } = await import("./fable5/learning-receipts.js");
+    const receipt = createContextRepoSnapshotReceipt(root);
+    const out = opts.output ?? path.join(".fable", "learning", "context-repo-snapshot-live.json");
+    writeLearningReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+  });
+
+fable
+  .command("opencoven-review")
+  .description("Write a learn-only OpenCoven/coven-code external project review receipt")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "research", "opencoven-review-live.json"))
+  .action(async (opts: { output?: string }) => {
+    const { createOpenCovenReviewReceipt, writeExternalProjectReviewReceipt } = await import("./fable5/external-project-review.js");
+    const receipt = createOpenCovenReviewReceipt();
+    const out = opts.output ?? path.join(".fable", "research", "opencoven-review-live.json");
+    writeExternalProjectReviewReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+  });
+
+fable
+  .command("permission-posture")
+  .description("Write an explicit permission posture receipt")
+  .option("--mode <mode>", "read-only|plan|edit|deploy-gated", "read-only")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "safety", "permission-posture-live.json"))
+  .action(async (opts: { mode?: string; output?: string }) => {
+    const { createPermissionPostureReceipt, writeExternalProjectReviewReceipt } = await import("./fable5/external-project-review.js");
+    const receipt = createPermissionPostureReceipt((opts.mode ?? "read-only") as never);
+    const out = opts.output ?? path.join(".fable", "safety", "permission-posture-live.json");
+    writeExternalProjectReviewReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+    if (receipt.decision === "blocked") process.exit(1);
+  });
+
+fable
+  .command("stale-memory-quarantine")
+  .description("Quarantine stale factory memory so it cannot become deploy authority")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "memory", "stale-memory-quarantine-live.json"))
+  .action(async (opts: { output?: string }) => {
+    const { createFactoryMemoryQuarantineReceipt, writeStaleMemoryQuarantineReceipt } = await import("./fable5/stale-memory-quarantine.js");
+    const receipt = createFactoryMemoryQuarantineReceipt();
+    const out = opts.output ?? path.join(".fable", "memory", "stale-memory-quarantine-live.json");
+    writeStaleMemoryQuarantineReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+  });
+
+fable
+  .command("falsification")
+  .description("Write hostile counterexample tests proving dangerous memory claims fail closed")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "learning", "falsification-live.json"))
+  .action(async (opts: { output?: string }) => {
+    const { createFactoryMemoryFalsificationReceipt, writeFalsificationReceipt } = await import("./fable5/falsification-receipt.js");
+    const receipt = createFactoryMemoryFalsificationReceipt();
+    const out = opts.output ?? path.join(".fable", "learning", "falsification-live.json");
+    writeFalsificationReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+    if (receipt.decision === "failed") process.exit(1);
+  });
+
+fable
+  .command("external-rsi-evidence")
+  .description("Write advisory external RSI evidence receipt without local deploy authority")
+  .option("--output <path>", "Receipt output path", path.join(".fable", "evidence", "external-rsi-evidence-live.json"))
+  .action(async (opts: { output?: string }) => {
+    const { createExternalRsiEvidenceReceipt, writeExternalEvidenceReceipt } = await import("./fable5/external-evidence.js");
+    const receipt = createExternalRsiEvidenceReceipt();
+    const out = opts.output ?? path.join(".fable", "evidence", "external-rsi-evidence-live.json");
+    writeExternalEvidenceReceipt(out, receipt);
+    console.log(JSON.stringify(receipt, null, 2));
+    console.log(`
+  Receipt: ${out}
+`);
+  });
+
 fable
  .command("receipt-health")
  .description("Check receipt consumer health over a recent time window")
@ -3535,6 +3838,10 @@ security
  ✓ No prompt-injection markers found in ${files.length} file(s)`);
  });

+function splitCsv(value?: string): string[] {
+  return (value ?? "").split(",").map((part) => part.trim()).filter(Boolean);
+}
+
 function splitClaims(content: string): string[] {
  return content
    .split(/[.!?]\s+/)
Author	SHA1	Message	Date
artale	73b55e1684	docs: add fresh factory readonly receipt	2026-07-03 09:00:48 +02:00
artale	c4843c7b54	docs: map opencode and advisory memory context	2026-07-03 08:43:15 +02:00
artale	6cbcf75654	docs: quarantine stale phase-claims and gate stale-memory refresh	2026-07-02 13:08:58 +02:00
artale	1fcac197df	docs: index remaining historical receipts	2026-07-02 12:41:20 +02:00
artale	1dff2e876a	docs: map fable website video workflow	2026-07-02 10:02:00 +02:00
artale	7a9cd58d03	docs: add live factory readonly receipt	2026-07-02 09:23:44 +02:00
artale	a6d21dda53	docs: add agentic system layer checklist	2026-07-02 09:08:27 +02:00
artale	73371cf8f6	docs: map agentic ai systems research	2026-07-02 08:55:01 +02:00
artale	72f4917a55	docs: index receipts and block stale deploy memory	2026-07-02 02:23:28 +02:00
artale	2419fca7bc	docs: map claude artifact advisory source	2026-07-02 01:48:46 +02:00
artale	577bc11a56	docs: map digg tech source signal	2026-07-02 01:28:16 +02:00
artale	818c2be727	docs: map kelsey platform posture	2026-07-02 01:15:25 +02:00
artale	85a8192810	docs: map adaptive tap pair red-team research	2026-07-02 01:10:36 +02:00
artale	7e6b624378	chore: ignore local pi runtime state	2026-07-02 00:44:37 +02:00
artale	9e25d208bd	docs: bound kramer ai quality patterns	2026-07-02 00:42:04 +02:00
artale	367a39d829	docs: quarantine stale deploy memory	2026-07-02 00:31:26 +02:00
artale	d91e279386	docs: map external pattern research	2026-07-02 00:17:02 +02:00
artale	cecb264bc9	feat: review scankii external scanner safely	2026-07-01 23:02:47 +02:00
artale	bac3c27380	feat: review ecc external harness safely	2026-07-01 22:50:49 +02:00
artale	f6319a149d	feat: review external skills repos safely	2026-07-01 22:41:36 +02:00
artale	9db357f3d1	feat: add structural patch receipts	2026-07-01 22:28:46 +02:00
artale	60d7edff00	docs: capture ai quality research posture	2026-07-01 22:24:29 +02:00
artale	5d9fb0619e	feat: add uast runtime receipts	2026-07-01 19:06:59 +02:00
artale	f97674ae26	feat: add research map receipts	2026-07-01 18:46:32 +02:00
artale	93c9697dbb	feat: add external evidence receipts	2026-07-01 18:00:48 +02:00
artale	712d94c689	feat: add falsification receipts	2026-07-01 17:25:39 +02:00
artale	b958364338	feat: quarantine stale factory memory	2026-07-01 15:19:12 +02:00
artale	6872cb3a6d	feat: add external project review receipts	2026-07-01 14:55:18 +02:00
artale	208d27e2cf	feat: add learning safety receipts	2026-07-01 14:30:26 +02:00
artale	1135ef4d7c	feat: add forgejo actions coverage receipt	2026-07-01 14:05:28 +02:00
artale	f4714f146a	feat: add forgejo cli commands	2026-07-01 13:50:34 +02:00
artale	41da725bc5	docs: clarify agent manager boundary	2026-07-01 13:15:10 +02:00
artale	e59a0f0ec4	fix: fail rsi on stale container canary	2026-07-01 12:32:29 +02:00
artale	451267d8bc	feat: track fable mythos access safely	2026-07-01 11:21:15 +02:00
artale	7054758d0d	feat: add jailbreak assessment receipts	2026-07-01 06:11:13 +02:00
artale	09b2483919	feat: add prompt fingerprint receipts	2026-07-01 05:23:44 +02:00
artale	0030455324	feat: add skill health receipts	2026-07-01 05:17:20 +02:00
artale	ac800d106f	feat: add system card fields to agent traces	2026-07-01 05:06:12 +02:00