Merge remote-tracking branch 'origin/main' into codex/leo-agent-challenger-loop-20260715

.github/workflows/gcp-observatory-read-adapter.yml

@@ -0,0 +1,208 @@
+name: gcp-observatory-read-adapter
+
+on:
+  workflow_dispatch:
+    inputs:
+      action:
+        description: Build only, or deploy the protected staging service and run live receipts
+        required: true
+        default: build_only
+        type: choice
+        options:
+          - build_only
+          - deploy_staging
+
+permissions:
+  contents: read
+  id-token: write
+
+concurrency:
+  group: gcp-observatory-read-adapter-${{ github.ref }}
+  cancel-in-progress: false
+
+env:
+  PROJECT_ID: teleo-501523
+  REGION: europe-west6
+  ZONE: europe-west6-a
+  REPOSITORY: teleo
+  IMAGE_NAME: observatory-read-adapter
+  SERVICE_NAME: observatory-read-adapter-staging
+  RUNTIME_SERVICE_ACCOUNT: sa-observatory-read-adapter@teleo-501523.iam.gserviceaccount.com
+  DB_IAM_USER: sa-observatory-read-adapter@teleo-501523.iam
+  API_KEY_SECRET: observatory-read-api-key-staging
+  WORKLOAD_IDENTITY_PROVIDER: projects/785938879453/locations/global/workloadIdentityPools/github-actions/providers/living-ip-github
+  DEPLOY_SERVICE_ACCOUNT: sa-artifact-builder@teleo-501523.iam.gserviceaccount.com
+
+jobs:
+  build:
+    name: Test, build, and push adapter image
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    outputs:
+      image_ref: ${{ steps.image.outputs.image_ref }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+          cache: pip
+
+      - name: Run focused adapter tests
+        run: |
+          python -m pip install -e '.[dev]'
+          python -m pytest tests/test_observatory_read_adapter.py -q
+          python -m ruff check observatory_read_adapter tests/test_observatory_read_adapter.py
+
+      - id: auth
+        uses: google-github-actions/auth@v3
+        with:
+          workload_identity_provider: ${{ env.WORKLOAD_IDENTITY_PROVIDER }}
+          service_account: ${{ env.DEPLOY_SERVICE_ACCOUNT }}
+
+      - uses: google-github-actions/setup-gcloud@v3
+        with:
+          project_id: ${{ env.PROJECT_ID }}
+
+      - name: Configure Artifact Registry
+        run: gcloud auth configure-docker "${REGION}-docker.pkg.dev" --quiet
+
+      - id: image
+        name: Build, smoke, and push immutable image
+        shell: bash
+        run: |
+          set -euo pipefail
+          tag="${GITHUB_SHA::12}"
+          image="${REGION}-docker.pkg.dev/${PROJECT_ID}/${REPOSITORY}/${IMAGE_NAME}:${tag}"
+          digest="$(gcloud artifacts docker images describe "${image}" \
+            --project="${PROJECT_ID}" \
+            --format='value(image_summary.digest)' 2>/dev/null || true)"
+          if [[ -n "${digest}" ]]; then
+            docker pull "${image}"
+          else
+            docker build -f Dockerfile.observatory-read-adapter -t "${image}" .
+          fi
+          docker run --rm --env PYTHONPYCACHEPREFIX=/tmp/pycache \
+            "${image}" python -m compileall -q /app/observatory_read_adapter
+          docker run --rm "${image}" python -c 'import observatory_read_adapter; print("adapter-import-ok")'
+          if [[ -z "${digest}" ]]; then
+            docker push "${image}" | tee docker-push.log
+            digest="$(awk '/digest: sha256:/ {print $3}' docker-push.log | tail -1)"
+          fi
+          test -n "${digest}"
+          image_ref="${image}@${digest}"
+          printf 'image_ref=%s\n' "${image_ref}" >> "${GITHUB_OUTPUT}"
+          printf 'revision=%s\nimage_ref=%s\n' "${GITHUB_SHA}" "${image_ref}" > observatory-adapter-image.txt
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: observatory-adapter-image
+          path: observatory-adapter-image.txt
+          if-no-files-found: error
+
+  deploy-staging:
+    name: Deploy and prove staging read path
+    if: ${{ inputs.action == 'deploy_staging' }}
+    needs: build
+    runs-on: ubuntu-latest
+    timeout-minutes: 20
+    steps:
+      - uses: actions/checkout@v4
+
+      - id: auth
+        uses: google-github-actions/auth@v3
+        with:
+          workload_identity_provider: ${{ env.WORKLOAD_IDENTITY_PROVIDER }}
+          service_account: ${{ env.DEPLOY_SERVICE_ACCOUNT }}
+
+      - uses: google-github-actions/setup-gcloud@v3
+        with:
+          project_id: ${{ env.PROJECT_ID }}
+
+      - name: Deploy bounded GCP staging service
+        shell: bash
+        env:
+          IMAGE_REF: ${{ needs.build.outputs.image_ref }}
+        run: |
+          set -euo pipefail
+          gcloud run deploy "${SERVICE_NAME}" \
+            --project="${PROJECT_ID}" \
+            --region="${REGION}" \
+            --image="${IMAGE_REF}" \
+            --execution-environment=gen2 \
+            --service-account="${RUNTIME_SERVICE_ACCOUNT}" \
+            --network=teleo-staging-net \
+            --subnet=teleo-staging-europe-west6 \
+            --vpc-egress=private-ranges-only \
+            --ingress=all \
+            --allow-unauthenticated \
+            --port=8080 \
+            --cpu=1 \
+            --memory=512Mi \
+            --concurrency=8 \
+            --max-instances=2 \
+            --timeout=15 \
+            --set-secrets="OBSERVATORY_API_KEY=${API_KEY_SECRET}:latest" \
+            --set-env-vars="GCP_PROJECT_ID=${PROJECT_ID},CLOUD_SQL_INSTANCE=${PROJECT_ID}:${REGION}:teleo-pgvector-standby,DB_NAME=teleo_canonical,DB_IAM_USER=${DB_IAM_USER},DB_AUTHORIZATION_ROLE=kb_observatory_read,SERVICE_REVISION=${GITHUB_SHA}" \
+            --labels="livingip-tier=gcp-staging,livingip-surface=observatory-read-adapter" \
+            --quiet
+
+      - name: Capture positive and negative live receipts
+        shell: bash
+        run: |
+          set -euo pipefail
+          service_url="$(gcloud run services describe "${SERVICE_NAME}" --project="${PROJECT_ID}" --region="${REGION}" --format='value(status.url)')"
+          revision="$(gcloud run services describe "${SERVICE_NAME}" --project="${PROJECT_ID}" --region="${REGION}" --format='value(status.latestReadyRevisionName)')"
+          api_key="$(gcloud secrets versions access latest --secret="${API_KEY_SECRET}" --project="${PROJECT_ID}")"
+          test -n "${service_url}"
+          test -n "${revision}"
+          test -n "${api_key}"
+
+          curl --fail --silent --show-error \
+            --header "X-Api-Key: ${api_key}" \
+            "${service_url}/v1/claims/sample" > positive.json
+          jq -e '
+            .schema == "livingip.observatory-canonical-claim.v1"
+            and .read_only == true
+            and .provenance.database == "teleo_canonical"
+            and .provenance.authorization_role == "kb_observatory_read"
+            and .provenance.transaction_read_only == true
+            and .provenance.write_privileges_denied == true
+            and (.canonical.evidence | length) > 0
+            and .proposal_ledger.distinct_from_canonical == true
+          ' positive.json >/dev/null
+
+          anonymous_status="$(curl --silent --output anonymous.json --write-out '%{http_code}' "${service_url}/v1/claims/sample")"
+          write_status="$(curl --silent --output write.json --write-out '%{http_code}' \
+            --request POST --header "X-Api-Key: ${api_key}" --header 'Content-Type: application/json' \
+            --data '{"status":"applied"}' "${service_url}/v1/claims/sample")"
+          test "${anonymous_status}" = 401
+          test "${write_status}" = 405
+
+          jq -n \
+            --arg service_url "${service_url}" \
+            --arg revision "${revision}" \
+            --arg git_sha "${GITHUB_SHA}" \
+            --argjson positive "$(cat positive.json)" \
+            --arg anonymous_status "${anonymous_status}" \
+            --arg write_status "${write_status}" \
+            '{
+              schema: "livingip.observatory-read-adapter-live-receipt.v1",
+              required_tier: "T3_live_readonly",
+              service_url: $service_url,
+              revision: $revision,
+              git_sha: $git_sha,
+              positive: $positive,
+              negative: {
+                anonymous_http_status: ($anonymous_status | tonumber),
+                authenticated_post_http_status: ($write_status | tonumber)
+              },
+              production_repoint_executed: false
+            }' > observatory-read-adapter-live-receipt.json
+          unset api_key
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: observatory-read-adapter-live-receipt
+          path: observatory-read-adapter-live-receipt.json
+          if-no-files-found: error

Dockerfile.observatory-read-adapter

@@ -0,0 +1,20 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+ENV PORT=8080
+
+WORKDIR /app
+
+COPY pyproject.toml README.md /app/
+COPY observatory_read_adapter /app/observatory_read_adapter
+COPY lib /app/lib
+
+RUN pip install --no-cache-dir --upgrade pip \
+  && pip install --no-cache-dir ".[observatory]" \
+  && addgroup --system --gid 10001 adapter \
+  && adduser --system --uid 10001 --ingroup adapter --no-create-home adapter
+
+USER 10001:10001
+
+CMD ["python", "-m", "observatory_read_adapter"]

docs/kb-rebuild-and-recompile.md

@@ -148,7 +148,7 @@ not retain every column of the proposal ledger, so exact reconstruction also
 needs the full approved proposal row, immutable approval snapshot, and final
 applied proposal row.
 
-## Genesis Plus Strict Ledger: Working Insert-Only Slice
+## Genesis Plus Strict Ledger: Working Deterministic Slice
 
 `ops/run_local_genesis_ledger_rebuild.py` now executes the first exact
 genesis-plus-ledger slice in one command:
@@ -206,27 +206,67 @@ Each referenced material object has exact top-level keys
 must contain every current `kb_stage.kb_proposals` column; partial envelopes
 are rejected.
 
-The command verifies every hash before starting Docker, restores a tmpfs-backed
+The command verifies every hash before starting Docker, requires a
-Postgres with `--network none`, reapplies the current guarded prerequisites,
+SHA-256-pinned Postgres image (and defaults to a pinned PostgreSQL 16 Alpine
-and proves genesis parity. For each entry it seeds the receipt's exact row IDs
+multi-platform digest), restores it on tmpfs with `--network none`, reapplies
-and timestamps in the disposable clone, executes the existing `kb_apply`
+the current guarded prerequisites, and proves genesis parity. Insert-only
-payload-bound guard and ledger transition, checks exact proposal and canonical
+entries seed the receipt's exact canonical row IDs and timestamps before the
-row readbacks, then verifies the complete final parity manifest. Its public
+existing `kb_apply` payload-bound guard executes. For `revise_strategy`, the
+runner seeds only the proposal and approval, captures the target agent's
+prestate, executes the real guarded transition, validates the generated delta,
+and then replaces only those generated rows with the receipt-pinned IDs and
+timestamps. Every path checks exact proposal and canonical row readbacks before
+verifying the complete final parity manifest. Its public
 mode-`0600` receipt contains hashes, IDs, types, counts, parity summaries, and
 cleanup proof, but no payloads, rows, SQL, source paths, or command errors.
+The legacy `seed_exact` summary is the insert-only aggregate of
+`proposal_seed_exact` and `canonical_seed_exact`; it is intentionally false for
+successful mutating entries, which instead report
+`mutating_delta_validated` and `mutating_poststate_normalized`.
+Fresh guard bootstrap rows use a fixed baseline timestamp rather than wall
+clock time, so repeated clean restores have identical row hashes.
 
-The exact v1 claim ceiling is intentionally narrow:
+The exact v1 claim ceiling is intentionally bounded:
 
-- `add_edge`, `attach_evidence`, and `approve_claim` strict receipts execute;
+- `add_edge`, `attach_evidence`, `approve_claim`, and `revise_strategy` strict
+  receipts execute;
 - sequence gaps, hash drift, engine drift, duplicate proposals, and legacy or
   freeform payloads fail before container start;
-- `revise_strategy` fails closed because its current receipt omits the prior
+- `revise_strategy` is accepted only when the receipt pins the exact SQL that
-  strategies and nodes that the apply engine deactivates or retires;
+  matches the current guarded apply engine. Immediately before each entry, the
+  runner captures the target agent's strategy/node IDs, active strategy,
+  non-retired nodes, and maximum version. It then validates the generated
+  post-minus-pre delta, requires `version = previous maximum + 1`, and replaces
+  only the generated strategy/node rows with the exact receipt rows;
+- the original transaction timestamp is derived from the fresh strategy
+  `created_at` and must equal every fresh node's `created_at` and `updated_at`.
+  It must also fall within the immutable, timezone-aware interval
+  `reviewed_at <= transaction timestamp <= applied_at`.
+  Only node IDs observed as non-retired before apply receive that timestamp;
+  already-retired, unrelated-agent, and shared NULL-agent rows stay untouched;
+- generated nodes must have no anchors before normalization, preventing a
+  delete-and-reinsert step from silently cascading future trigger-created rows;
 - full proposal before/after rows are mandatory because the current receipt
   envelope does not retain proposal origin fields or exact `updated_at`;
 - this proves only an isolated local reconstruction. It does not touch or prove
   VPS, GCP, Telegram, a live database, or blank-schema source recompilation.
 
+The transition contract for `revise_strategy` is final-state deterministic, not
+a claim that the v1 receipt independently contains a historical before-image:
+
+```text
+exact genesis/pre-entry state
+  + exact current/original guarded SQL
+  + receipt-pinned fresh strategy and nodes
+  -> prior active strategy inactive
+  -> exactly the prior non-retired nodes retired at the original transaction time
+  -> one receipt-exact active strategy and receipt-exact node set
+```
+
+The genesis and final manifests remain mandatory oracles. Any incorrect
+prestate, unrelated-row mutation, missing/extra generated row, semantic drift,
+version drift, hash drift, or final rowset difference fails the reconstruction.
+
 The source compiler now turns one raw artifact, its strict UTF-8 extraction,
 and a reviewed extraction manifest into a deterministic, hash-bound
 `pending_review` proposal bundle:
@@ -272,10 +312,9 @@ neither command applies canonical rows.
 
 The existing full-data clone canary separately proves that a reviewed packet
 can create source, claim, evidence, and edge rows and affect later reasoning.
-The remaining reconstruction work is to retain complete deltas for mutating
+The remaining reconstruction work is to backfill or explicitly reject legacy
-contracts such as `revise_strategy`, backfill or explicitly reject legacy
+freeform applies and extend beyond genesis recovery to a blank-schema source
-freeform applies, and extend beyond genesis recovery to a blank-schema source
+compiler. The strict ledger runner does not prove that every historical
-compiler. The insert-only ledger runner does not prove that every historical
 canonical row can be rebuilt semantically from retained sources.
 
 ## Definition Of Working

docs/leo-reproducible-identity.md

@@ -0,0 +1,212 @@
+# Reproducible Leo identity
+
+## Definition of Working
+
+- **Working target:** generate one pinned Leo identity manifest, compile a
+  disposable profile, answer the fixed identity query in a fresh process,
+  restart in a second process, and reject any drift before an answer.
+- **Operator path:** run
+  `python -m scripts.run_leo_identity_reconstruction_canary` with the committed
+  identity fixtures from a clean checkout.
+- **Done means:** the T2 receipt reports two distinct stopped processes with the
+  same manifest, identity inputs, query, answer hash, and output provenance;
+  the second process starts from a newly compiled empty profile; the drift
+  attempt exits before answering; every process group and temporary profile is
+  removed.
+- **Not done:** a hand-edited `SOUL.md`, a manifest self-hash, unit tests without
+  process restart, or prior VPS restart evidence that did not reconstruct from
+  this manifest.
+- **Required tier:** `T2_runtime`. T3 VPS restart/readback is a post-merge
+  graduation target.
+
+## Identity input inventory
+
+`GatewayRunner` and the surrounding Hermes profile can change an answer through
+the following surfaces. The manifest either pins each surface or explicitly
+keeps it outside identity authority.
+
+| Surface | Binding | Authority |
+| --- | --- | --- |
+| Model provider, route, limits, and reasoning settings | secret-free semantic config hash | runtime input; the actual model remains a per-turn receipt |
+| Hosted model weights | provider-managed, explicitly not locally hashable | never claimed as a local hash |
+| Hermes and Teleo code | clean Git commits plus executable source-tree hashes | runtime input |
+| Python ABI and imported runtime packages | exact implementation/version and curated package versions | runtime input |
+| Skills, plugins, and database tools | content hashes | runtime input |
+| Gateway/tool permissions | strict allowlisted config hash plus exact no-send/read-only policy | runtime input; this local compiler does not claim an authorizer readback |
+| Static constitutional rules | committed source path, byte hash, and semantic hash | static authority |
+| Database snapshot version | database/user/system identity plus content, row, structure, and capture-provenance hashes; only WAL position is excluded | T2 pins a noncanonical fixture; it cannot grant canonical authority |
+| Database-derived identity rows | typed table/row/kind/rank/evidence bindings plus source mode | synthetic fixtures are explicitly noncanonical; T3 requires independently verified database-exporter output |
+| `SOUL.md` and `identity.json` | deterministic compiled-view hashes | generated views, never authorities |
+| Sessions, state, and memory | excluded from the identity input hash and labeled temporary | continuity only; never evidence |
+
+The disposable profile is compiled from a strict non-secret configuration
+allowlist; unrecognized transport/credential fields are not copied. Credential
+values are omitted rather than hashed. Rotating a bot token changes the broad
+operational behavior observation but does not change Leo's identity.
+Changing a non-secret permission, model setting, skill, code file, database
+fingerprint, constitutional rule, database identity row, or compiled view does
+change a pinned input and fails closed.
+
+### Current `GatewayRunner` consumption map
+
+The T2 compiler contract was checked against the current live runtime source.
+This inventory defines what the post-merge T3 receipt must observe rather than
+silently assuming that a profile file is the whole prompt:
+
+- Startup resolves `-p leoclean` to `HERMES_HOME`, then loads profile and project
+  environment files before `config.yaml`; environment expansion, legacy
+  `gateway.json`, and defaults can change the effective configuration. The T2
+  compiler therefore enforces an exact top-level profile allowlist (including
+  rejection of dangling symlinks) rather than relying on a filename denylist.
+- Routing consumes the requested default model, the top-level
+  `smart_model_routing` switch, provider endpoints/defaults, auth pool choice,
+  reasoning settings, token/turn limits, and fallbacks. The pinned top-level
+  routing switch must be a boolean; arbitrary nested routing data is rejected.
+  Credentials are runtime capability, not identity, and their values are never
+  retained.
+- Prompt construction consumes generated `SOUL.md`, the gateway/agent system
+  message, persistent `MEMORY.md`/`USER.md`, compiled skills, project-context
+  files, current time/timezone, and the effective model/provider. T2 requires
+  memory and project context absent; T3 records the effective system-prompt and
+  compiled-skills-prompt hashes.
+- Plugin discovery can include profile plugins, optional project plugins, and
+  installed entry points. The live database-context hook can inject a
+  query-bound contract before the model and can reject or replace the reply
+  afterward, so T3 retains plugin registry, contract, retrieval, and delivered
+  response hashes.
+- Effective tools come from platform toolsets and the runtime registry, not a
+  descriptive fixture field. T3 must read back exact tool schemas, prove the
+  send tool absent, and keep terminal restricted to the clone-bound read-only
+  wrapper.
+- Authorization consumes chat/user allowlists and pairing-store state. T2 starts
+  with pairing absent; T3 records the fixed synthetic source and the actual
+  authorization decision without exposing IDs or tokens.
+- Session keys consume platform/chat/user/thread/topic fields. Auto-skill,
+  reply/media/file context, persisted transcripts, and a reused system prompt
+  can all change a turn. Verification therefore happens before every child
+  starts, and T3 binds session key, persisted session ID, message-context
+  absence, and prompt hashes.
+
+The committed T2 database/identity inputs are synthetic fixtures and the
+compiled view labels them `synthetic_noncanonical_fixture`; they do not stand
+in for approved production rows. This T2 schema never grants canonical
+authority from caller-supplied or merely self-hashed JSON. T3 must use output
+that is independently verified by the database-owning same-transaction exporter
+and bound to the database fingerprint, database user, system identifier, and
+row digest.
+
+Every pinned source tree and profile component is structurally revalidated:
+the verifier recomputes its file count, total bytes, sorted unique paths, and
+canonical content hash, and rejects missing files, unreadable entries, or
+symlinks. Rehashing forged structural metadata cannot make it authoritative.
+
+The current live Hermes checkout is not clean, so its Git SHA alone is not a
+reproducible source bundle. This T2 receipt intentionally uses the committed
+clean local runtime and the committed database/identity snapshot fixture. It
+does not claim to reconstruct the current dirty VPS runtime. T3 must run only
+after the merged identity code is deployed and must bind the deployed clean
+content (or a content-addressed dirty-source bundle if the live checkout has not
+yet been repaired).
+
+## Commands
+
+The complete canary is the preferred operator command:
+
+```bash
+python -m scripts.run_leo_identity_reconstruction_canary \
+  --profile-template fixtures/working-leo/leo-identity-v1/profile-template \
+  --hermes-root fixtures/working-leo/leo-identity-v1/hermes-runtime \
+  --deployment-root . \
+  --source-root . \
+  --database-fingerprint fixtures/working-leo/leo-identity-v1/leo-database-fingerprint-v1.json \
+  --constitution fixtures/working-leo/leo-identity-v1/leo-constitution-v1.json \
+  --database-identity fixtures/working-leo/leo-identity-v1/leo-database-identity-v1.json \
+  --output docs/reports/leo-working-state-20260709/leo-reproducible-identity-t2-current.json
+```
+
+The negative lifecycle is separately runnable. It proves drift is caught before
+the second process starts:
+
+```bash
+python -m scripts.run_leo_identity_reconstruction_canary \
+  --profile-template fixtures/working-leo/leo-identity-v1/profile-template \
+  --hermes-root fixtures/working-leo/leo-identity-v1/hermes-runtime \
+  --deployment-root . \
+  --source-root . \
+  --database-fingerprint fixtures/working-leo/leo-identity-v1/leo-database-fingerprint-v1.json \
+  --constitution fixtures/working-leo/leo-identity-v1/leo-constitution-v1.json \
+  --database-identity fixtures/working-leo/leo-identity-v1/leo-database-identity-v1.json \
+  --inject-drift-before-restart \
+  --output /tmp/leo-identity-drift-rejection.json
+```
+
+For inspection, the lifecycle can be decomposed into explicit manifest and
+compile commands:
+
+```bash
+python -m scripts.leo_behavior_manifest \
+  --profile fixtures/working-leo/leo-identity-v1/profile-template \
+  --hermes-root fixtures/working-leo/leo-identity-v1/hermes-runtime \
+  --deployment-root . \
+  --output /tmp/leo-behavior.json
+
+python -m scripts.leo_identity_manifest generate \
+  --behavior-manifest /tmp/leo-behavior.json \
+  --database-fingerprint fixtures/working-leo/leo-identity-v1/leo-database-fingerprint-v1.json \
+  --constitution fixtures/working-leo/leo-identity-v1/leo-constitution-v1.json \
+  --database-identity fixtures/working-leo/leo-identity-v1/leo-database-identity-v1.json \
+  --source-root . \
+  --output /tmp/leo-identity-manifest.json
+
+python -m scripts.leo_identity_profile compile \
+  --manifest /tmp/leo-identity-manifest.json \
+  --source-root . \
+  --profile-template fixtures/working-leo/leo-identity-v1/profile-template \
+  --profile /tmp/leo-disposable-profile \
+  --hermes-root fixtures/working-leo/leo-identity-v1/hermes-runtime \
+  --deployment-root .
+```
+
+All commands require a clean Git worktree because a commit plus an unretained
+dirty source tree is not reproducible.
+
+Child processes execute the real interpreter and temporary-profile paths only
+in process-local memory. Retained receipts persist a repo-relative
+`logical_command`, the stable `<python>` and `<temporary-profile>` placeholders,
+and an explicit `profile_role`; they never serialize the checkout, interpreter,
+or temporary directory path.
+
+## State inventory and transitions
+
+| State | Meaning | Next valid transition |
+| --- | --- | --- |
+| `inputs_unverified` | source paths exist but are not yet bound | validate clean Git, runtime, DB, rules, rows, and permissions |
+| `manifest_pinned` | every material identity input has a stable hash | compile deterministic views |
+| `profile_compiled` | static profile copied and generated views match the manifest | verify immediately before start |
+| `runtime_verified` | runtime/code/view hashes match and session state is non-authoritative | answer fixed query |
+| `stopped_cleanly` | child and process group are absent | compile a new empty profile from the manifest |
+| `restart_reproduced` | child from the newly compiled profile has the same identity/query/provenance inputs | retain receipt and clean every profile |
+| `drift_detected` | any input or generated view differs | fail closed; no answer and no next start |
+
+The irreversible boundary is not a database or production mutation: this T2
+canary is a local compiler/process runtime, no-send, database-read-only, and
+disposable. The successful-restart receipt reaches `T2_runtime`; the standalone
+pre-restart drift receipt is a passing negative component but reports
+`T1_model` and `goal_tier_satisfied=false`. Neither proves the live VPS
+`GatewayRunner`, Telegram delivery, hosted-model behavior, production database
+state, or T3 restart recovery.
+
+Here `T2_runtime` uses the required Capability Tier Proof vocabulary: local
+runtime behavior with restart. It does not imply Hermes/GatewayRunner or a
+hosted model; those exclusions are explicit in the receipt's `runtime_variant`,
+`tier_basis`, and `claim_ceiling`.
+
+## T3 graduation
+
+After merge and rollback proof, extend the schema with independent verification
+of the database-owning same-transaction exporter, generate the manifest from
+that live read-only canonical capture and deployed clean commits, compile a
+disposable VPS profile, invoke the real no-send `GatewayRunner`, terminate that
+child, open a new child from the same manifest, and retain model-call, DB-read,
+service, cleanup, and drift-negative readbacks. Do not replace the production
+profile during that graduation.

docs/observatory-read-adapter-gcp-staging.md

@@ -0,0 +1,102 @@
+# GCP Observatory Read Adapter
+
+## Definition of Working
+
+- Working target: an authenticated GCP staging API returns one canonical claim
+  with source/evidence provenance and a separately labeled proposal ledger.
+- Operator path: `GET /v1/claims/sample` or `GET /v1/claims/{uuid}` with the
+  server-only `X-Api-Key` value.
+- Done means: the response names `teleo_canonical`, the dedicated IAM database
+  principal and `kb_observatory_read`, reports a read-only transaction and
+  denied write privileges, and live anonymous/write HTTP attempts return
+  `401`/`405`.
+- Not done: the VPS `teleo-pg`, a public Cloud SQL address, a browser-visible
+  key, a mock-only receipt, or a production Vercel repoint.
+- Required tier: `T3_live_readonly`.
+
+## Existing Connector Boundary
+
+The current `living-ip/livingip-web` main branch reads claims through
+`src/lib/api.ts`. It selects `NEXT_PUBLIC_API_URL` and otherwise falls back to
+`http://77.42.65.182:8081`, then calls the legacy `/api/claims` routes. That is
+the VPS-local/public Observatory path. It is not safe to replace that public
+environment variable with this protected API: the response shape differs and
+the adapter key must never enter a `NEXT_PUBLIC_` variable or browser bundle.
+
+The existing Teleo route `GET /api/kb/claims` is the compatibility reference
+for route-scoped authentication, but its default database/container settings
+still describe the VPS-local process. This service is a separate GCP runtime;
+it does not change Argus or PR #148's Leo runtime files.
+
+## Runtime Contract
+
+- Cloud Run service: `observatory-read-adapter-staging` in `europe-west6`.
+- Direct VPC egress: `teleo-staging-net` / `teleo-staging-europe-west6`.
+- Cloud SQL: `teleo-501523:europe-west6:teleo-pgvector-standby`, private IP.
+- Database: `teleo_canonical` only.
+- Runtime identity: `sa-observatory-read-adapter@teleo-501523.iam.gserviceaccount.com`.
+- IAM database user: `sa-observatory-read-adapter@teleo-501523.iam`.
+- Database authorization role: `kb_observatory_read` (`NOLOGIN`).
+- API authentication: route-scoped key from Secret Manager secret
+  `observatory-read-api-key-staging`; the value is not in Git or deploy logs.
+- No mutation routes exist. Authenticated unsupported methods return `405`.
+
+The Cloud SQL Python Connector uses Application Default Credentials from the
+Cloud Run service identity, automatic IAM database authentication, and private
+IP. Every request starts a read-only transaction and refuses the response if
+the database, IAM principal, authorization membership, required reads, or
+effective write-denial checks drift.
+
+## One-Time Staging Bootstrap
+
+These are staging mutations. Run them only with an authenticated GCP operator;
+they do not route production traffic.
+
+1. Create the dedicated runtime service account and grant only
+   `roles/cloudsql.client` and `roles/cloudsql.instanceUser` in project
+   `teleo-501523`.
+2. Add the service account as a Cloud SQL IAM service-account user on
+   `teleo-pgvector-standby`.
+3. From the existing private GCP VM database-admin path, run
+   `ops/observatory_read_role.sql` against `teleo_canonical` with
+   `OBSERVATORY_DB_IAM_USER=sa-observatory-read-adapter@teleo-501523.iam`.
+   Do not read, copy, or retain the administrator password.
+4. Create `observatory-read-api-key-staging`, add a generated 32-byte-or-longer
+   value through stdin, and grant that secret's accessor role only to the
+   runtime service account and the bounded staging canary identity.
+5. Dispatch `.github/workflows/gcp-observatory-read-adapter.yml` with
+   `action=deploy_staging` from the exact reviewed branch revision.
+
+The workflow builds an immutable image, deploys at most two Cloud Run
+instances, and retains the positive response plus anonymous `401` and
+authenticated POST `405` receipts. It does not modify Vercel.
+
+## Unexecuted Cutover Packet
+
+Production cutover requires a separate exact authorization and a
+`living-ip/livingip-web` change. Do not execute these steps from this lane.
+
+1. Add server-only Vercel secrets `OBSERVATORY_CANONICAL_API_URL` and
+   `OBSERVATORY_CANONICAL_API_KEY` to a protected preview environment. The URL
+   targets the GCP service; neither setting may use `NEXT_PUBLIC_`.
+2. Add a Next.js server route or server action that calls the GCP API, validates
+   `livingip.observatory-canonical-claim.v1`, and maps it to the Observatory UI.
+   The browser calls only the same-origin Next.js route.
+3. Prove preview Deployment Protection, anonymous denial, source/evidence
+   rendering, proposal/live labels, and no browser key exposure.
+4. Obtain exact production-repoint authorization naming the reviewed
+   `livingip-web` commit and Vercel project before changing production values.
+
+## Unexecuted Rollback Packet
+
+1. Revert the authorized `livingip-web` connector commit or disable its
+   server-side feature flag.
+2. Restore the prior production Vercel values and redeploy the last accepted
+   production revision.
+3. Verify `/claims` again uses the prior `/api/claims` contract.
+4. Leave the private Cloud SQL instance and adapter role intact while receipts
+   are reviewed; scale the staging Cloud Run service to zero if isolation is
+   required.
+5. Delete the staging service/role/secret only under a separate cleanup
+   decision. Rollback never adds a Cloud SQL public IP and never redirects the
+   adapter to VPS `teleo-pg`.

docs/reports/leo-working-state-20260709/leo-reproducible-identity-drift-negative-current.json

@@ -0,0 +1,332 @@
+{
+  "actual_hosted_model_call_performed": false,
+  "behavior_observation_before_compile": {
+    "behavior_sha256": "693a5d542e3d817c1c77c8aa3180f14d5f98ec1e71f5e4313685b4da70b489aa",
+    "identity_runtime_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+    "source_commit": "b238fd6fc2636ed3582e14900774014c52732698"
+  },
+  "claim_ceiling": "Local first-process and pre-restart drift-refusal component only; no successful restart proof, GatewayRunner, hosted model, production database, VPS, or T3 claim.",
+  "cleanup": {
+    "no_profile_retained": true,
+    "temporary_root_removed": true
+  },
+  "compile": {
+    "compiled_view_sha256": {
+      "SOUL.md": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+      "identity.json": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6"
+    },
+    "generated_views_are_authority": false,
+    "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+    "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+    "nonauthoritative_inputs_omitted": {
+      ".cursorrules": true,
+      ".hermes.md": true,
+      ".skills_prompt_snapshot.json": true,
+      "AGENTS.md": true,
+      "CLAUDE.md": true,
+      "HERMES.md": true,
+      "MEMORY.md": true,
+      "USER.md": true,
+      "memories": true,
+      "platforms/pairing": true
+    },
+    "profile_static_entries": [
+      "config.yaml",
+      "skills",
+      "plugins",
+      "bin"
+    ],
+    "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+    "schema": "livingip.leoIdentityCompileReceipt.v1",
+    "session_directories_started_empty": true,
+    "status": "pass"
+  },
+  "compiled_profile_before_query": {
+    "behavior_sha256": "a62b26015a7c9506f0296404be150608a816a2d545f471f7960bd27324d6849c",
+    "identity_runtime_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159"
+  },
+  "current_tier": "T1_model",
+  "drift_target": "compiled SOUL.md generated view",
+  "errors": [],
+  "first_start": {
+    "actual_argv_persisted": false,
+    "command_serialization": "logical_redacted_v1",
+    "launcher_pid": 80040,
+    "logical_command": [
+      "<python>",
+      "-m",
+      "scripts.leo_identity_profile",
+      "query",
+      "--profile",
+      "<temporary-profile>",
+      "--source-root",
+      ".",
+      "--hermes-root",
+      "fixtures/working-leo/leo-identity-v1/hermes-runtime",
+      "--deployment-root",
+      ".",
+      "--query",
+      "What defines Leo's identity, and what is temporary?"
+    ],
+    "orphan_cleanup_required": false,
+    "process_group_absent_after_wait": true,
+    "profile_role": "first_start",
+    "returncode": 0,
+    "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "stdout": {
+      "answer": "Leo is defined by 3 pinned static constitutional rules and 5 active database-derived identity rows from a synthetic noncanonical fixture at fingerprint 1111111111111111111111111111111111111111111111111111111111111111. SOUL.md is a generated view; runtime/session memory is temporary, noncanonical, and cannot be evidence.",
+      "answer_sha256": "e0a21e1fc5357a2f358b4e96c52e971f3addee2468e44748d898adfd62dafa25",
+      "authorization": {
+        "authorization_decision_observed": false,
+        "claim": "local_policy_binding_not_an_authorizer_readback",
+        "declared_runtime_policy": {
+          "allowed_tools": [
+            "identity_readback"
+          ],
+          "database_write_enabled": false,
+          "network_send_enabled": false
+        }
+      },
+      "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+      "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+      "output_provenance": {
+        "actual_model_call_performed": false,
+        "compiled_identity_sha256": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6",
+        "compiled_soul_sha256": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+        "database_authority": "synthetic_noncanonical_fixture",
+        "database_canonical_authority_granted": false,
+        "database_fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+        "database_identity_sha256": "70aaa7287cc41b52a3c902cf2e1b90fa4d84a5ee0a61e10c642f556fcc9304c3",
+        "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+        "static_constitution_sha256": "b576d5cee08530a95e0b196a3296f4743b70d94bcadffaa36544dd6bf1387f8a"
+      },
+      "process_id": 80040,
+      "query": "What defines Leo's identity, and what is temporary?",
+      "query_sha256": "13704c2c9ae999e3f9b3f1c9c5572d062cd7fe49903c2317fa85aaa39490af66",
+      "runtime_instance_id": "493f274a5f0340a2aa675f13b8e5b4af",
+      "schema": "livingip.leoIdentityQueryReceipt.v1",
+      "session": {
+        "classification": "temporary_noncanonical",
+        "included_in_output_provenance": false,
+        "may_be_used_as_evidence": false,
+        "record_sha256": "56b6a2ea25657a87dc90dc19f49bece0ac62241f5814732ed80ef4f34d426d84"
+      },
+      "started_at_utc": "2026-07-15T02:46:34.316819+00:00",
+      "status": "pass"
+    },
+    "terminated_with": null,
+    "timed_out": false
+  },
+  "fixed_query": "What defines Leo's identity, and what is temporary?",
+  "fixed_query_sha256": "13704c2c9ae999e3f9b3f1c9c5572d062cd7fe49903c2317fa85aaa39490af66",
+  "gates": {
+    "drift_detected_before_restart": true,
+    "drift_process_had_no_orphan_cleanup": true,
+    "drift_process_stopped": true,
+    "drift_returned_no_answer": true,
+    "first_process_stopped": true,
+    "first_start_passed": true,
+    "second_start_not_attempted": true
+  },
+  "generated_at_utc": "2026-07-15T02:46:31.831631+00:00",
+  "goal_tier_satisfied": false,
+  "manifest": {
+    "compiled_views": {
+      "SOUL.md": {
+        "generated_from_identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+        "role": "generated_view_not_authority",
+        "sha256": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a"
+      },
+      "identity.json": {
+        "generated_from_identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+        "role": "generated_view_not_authority",
+        "sha256": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6"
+      }
+    },
+    "identity_inputs": {
+      "canonical_database": {
+        "authority": "synthetic_noncanonical_fixture",
+        "canonical_authority_granted": false,
+        "database": "leo_identity_fixture",
+        "database_user": "leo_identity_reader",
+        "fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+        "source": {
+          "record_count": 7,
+          "repo_path": "fixtures/working-leo/leo-identity-v1/leo-database-fingerprint-v1.json",
+          "semantic_sha256": "c5bbf346613270a5e3b17f604f69306ed42f545d4f227d784ec0dcb3d675dcb2"
+        },
+        "structure_sha256": "3333333333333333333333333333333333333333333333333333333333333333",
+        "system_identifier": "7649789040005668902",
+        "table_count": 7,
+        "table_rows_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
+        "total_rows": 7
+      },
+      "gatewayrunner_execution_contract": {
+        "fixed_message_context": {
+          "auto_skill": null,
+          "media_or_file_context": null,
+          "reply_context": null
+        },
+        "profile_surfaces": [
+          "config.yaml",
+          "generated SOUL.md",
+          "skills",
+          "plugins",
+          "bin tools"
+        ],
+        "required_absent_or_empty": {
+          "generated_skill_prompt_cache": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "pairing_store": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "persistent_memory": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "prior_sessions_at_first_start": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "project_context": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"
+        },
+        "required_t3_turn_receipt_fields": [
+          "runner_class",
+          "authorization_decision",
+          "effective_system_prompt_sha256",
+          "compiled_skills_prompt_sha256",
+          "tool_registry_schema_sha256",
+          "plugin_registry_sha256",
+          "selected_model",
+          "selected_provider",
+          "api_mode",
+          "base_url_host",
+          "database_retrieval_receipt",
+          "session_key_sha256",
+          "persisted_session_id_sha256"
+        ]
+      },
+      "identity_name": "Leo",
+      "identity_sources": {
+        "database_derived_identity": {
+          "authority": "synthetic_noncanonical_fixture",
+          "content_sha256": "9de2dfa37529b23ba277348f3d910e967551e490a9b4d2be637bf45bb2aa7dde",
+          "database_fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+          "provenance": {
+            "authority": "synthetic_noncanonical_fixture",
+            "canonical_authority_granted": false,
+            "export_receipt_sha256": null,
+            "mode": "synthetic_noncanonical_fixture",
+            "same_transaction_as_fingerprint": false
+          },
+          "record_count": 5,
+          "repo_path": "fixtures/working-leo/leo-identity-v1/leo-database-identity-v1.json",
+          "semantic_sha256": "70aaa7287cc41b52a3c902cf2e1b90fa4d84a5ee0a61e10c642f556fcc9304c3"
+        },
+        "static_constitution": {
+          "authority": "pinned_static_source",
+          "content_sha256": "b5477e778a2be0abba783390dac2e04ed199b8ce5679fc324270f808d46543f1",
+          "record_count": 3,
+          "repo_path": "fixtures/working-leo/leo-identity-v1/leo-constitution-v1.json",
+          "semantic_sha256": "b576d5cee08530a95e0b196a3296f4743b70d94bcadffaa36544dd6bf1387f8a"
+        }
+      },
+      "model": {
+        "actual_model_required_in_turn_receipt": true,
+        "default_model": "leo-identity-readback-v1",
+        "gateway_smart_model_routing": null,
+        "hosted_weights": "external_provider_managed_not_locally_hashable",
+        "model_section_sha256": "90b3943ace9ff83b1711002fda8dc9736448e8d3c1c58a17ac90608f4ce58756",
+        "provider": "fixture-local",
+        "smart_routing": false,
+        "smart_routing_model": null
+      },
+      "permissions": {
+        "authorization_decision_required_in_runtime_receipt": true,
+        "gateway_permissions_sha256": "eac17ada1d02b5413183587d12fc265538479de00709ed8c275e9045cd720290",
+        "identity_config_sha256": "e6df9b65bab148ea8502555bbc260df66b4785e7dd527cfd15d2f0a48c2e8b3e",
+        "runtime_policy": {
+          "allowed_tools": [
+            "identity_readback"
+          ],
+          "database_write_enabled": false,
+          "network_send_enabled": false
+        },
+        "tool_permissions_sha256": "9bb2cec2f65d43efb597a72bdced44076c25aac292f2fccbc4c448b6e7fd3e16"
+      },
+      "runtime": {
+        "hermes_git_head": "b238fd6fc2636ed3582e14900774014c52732698",
+        "hermes_source_sha256": "dcf8109051e0b69cafe2e8dd328ff501211b62ea19725416c3781bbdd594d028",
+        "identity_runtime_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+        "python": {
+          "abi_tag": "cpython-311",
+          "implementation": "CPython",
+          "python_version": "3.11.15",
+          "runtime_distributions": {
+            "PyYAML": "6.0.3"
+          },
+          "runtime_distributions_sha256": "57a91bb880a01800903c1604b6eec1419514864ebd6a0644121920da15a8f165"
+        },
+        "teleo_git_head": "b238fd6fc2636ed3582e14900774014c52732698",
+        "teleo_source_sha256": "2bd2e659eafb0ac0823f7f51c4296b2eb500b6f74469b3ac5f5287a5d4810aea"
+      },
+      "session_boundary": {
+        "classification": "temporary_noncanonical",
+        "included_in_identity_inputs": false,
+        "may_be_used_as_evidence": false,
+        "restart_policy": "fresh_process_with_session_state_outside_identity_authority"
+      },
+      "skills": {
+        "content_sha256": "d3f449ddcd7c88238dc88c6233cf2130875f51bd2e0911b2ce477b7c602ae90f",
+        "file_count": 1
+      },
+      "source_commit": "b238fd6fc2636ed3582e14900774014c52732698"
+    },
+    "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+    "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+    "schema": "livingip.leoIdentityManifest.v1"
+  },
+  "mode": "drift_before_restart",
+  "pre_restart_drift": {
+    "actual_argv_persisted": false,
+    "command_serialization": "logical_redacted_v1",
+    "launcher_pid": 80246,
+    "logical_command": [
+      "<python>",
+      "-m",
+      "scripts.leo_identity_profile",
+      "query",
+      "--profile",
+      "<temporary-profile>",
+      "--source-root",
+      ".",
+      "--hermes-root",
+      "fixtures/working-leo/leo-identity-v1/hermes-runtime",
+      "--deployment-root",
+      ".",
+      "--query",
+      "What defines Leo's identity, and what is temporary?"
+    ],
+    "orphan_cleanup_required": false,
+    "process_group_absent_after_wait": true,
+    "profile_role": "pre_restart_drift",
+    "returncode": 3,
+    "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "stdout": {
+      "error": "identity_drift",
+      "message": "compiled view drift detected: SOUL.md",
+      "status": "error"
+    },
+    "terminated_with": null,
+    "timed_out": false
+  },
+  "production_database_contacted": false,
+  "production_profile_replaced": false,
+  "receipt_sha256": "50278cc740d0427316f73a78abad840b3e3b128a516f464001d42e632e19c2a8",
+  "required_tier": "T2_runtime",
+  "runtime_component_proven": "first_local_process_plus_pre_restart_drift_refusal",
+  "runtime_variant": "local_deterministic_identity_compiler_readback",
+  "schema": "livingip.leoIdentityReconstructionReceipt.v1",
+  "second_start_attempted": false,
+  "session_boundary_readback": {
+    "full_behavior_changed_after_session": true,
+    "identity_runtime_unchanged_after_session": true,
+    "session_classification": "temporary_noncanonical",
+    "session_file_count": 1,
+    "session_used_as_output_provenance": false
+  },
+  "status": "pass",
+  "telegram_message_sent": false,
+  "tier_basis": "This negative component does not complete the required restart path, so it remains below T2_runtime."
+}

docs/reports/leo-working-state-20260709/leo-reproducible-identity-t2-current.json

@@ -0,0 +1,478 @@
+{
+  "actual_hosted_model_call_performed": false,
+  "behavior_observation_before_compile": {
+    "behavior_sha256": "693a5d542e3d817c1c77c8aa3180f14d5f98ec1e71f5e4313685b4da70b489aa",
+    "identity_runtime_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+    "source_commit": "b238fd6fc2636ed3582e14900774014c52732698"
+  },
+  "claim_ceiling": "Local disposable identity compilation, fresh-profile reconstruction, and cold-process restart only; not a live GatewayRunner, hosted-model, Telegram, production database, VPS restart, or T3 proof.",
+  "cleanup": {
+    "no_profile_retained": true,
+    "temporary_root_removed": true
+  },
+  "compile": {
+    "compiled_view_sha256": {
+      "SOUL.md": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+      "identity.json": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6"
+    },
+    "generated_views_are_authority": false,
+    "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+    "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+    "nonauthoritative_inputs_omitted": {
+      ".cursorrules": true,
+      ".hermes.md": true,
+      ".skills_prompt_snapshot.json": true,
+      "AGENTS.md": true,
+      "CLAUDE.md": true,
+      "HERMES.md": true,
+      "MEMORY.md": true,
+      "USER.md": true,
+      "memories": true,
+      "platforms/pairing": true
+    },
+    "profile_static_entries": [
+      "config.yaml",
+      "skills",
+      "plugins",
+      "bin"
+    ],
+    "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+    "schema": "livingip.leoIdentityCompileReceipt.v1",
+    "session_directories_started_empty": true,
+    "status": "pass"
+  },
+  "compiled_profile_before_query": {
+    "behavior_sha256": "a62b26015a7c9506f0296404be150608a816a2d545f471f7960bd27324d6849c",
+    "identity_runtime_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159"
+  },
+  "current_tier": "T2_runtime",
+  "drift_compile": {
+    "compiled_view_sha256": {
+      "SOUL.md": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+      "identity.json": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6"
+    },
+    "generated_views_are_authority": false,
+    "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+    "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+    "nonauthoritative_inputs_omitted": {
+      ".cursorrules": true,
+      ".hermes.md": true,
+      ".skills_prompt_snapshot.json": true,
+      "AGENTS.md": true,
+      "CLAUDE.md": true,
+      "HERMES.md": true,
+      "MEMORY.md": true,
+      "USER.md": true,
+      "memories": true,
+      "platforms/pairing": true
+    },
+    "profile_static_entries": [
+      "config.yaml",
+      "skills",
+      "plugins",
+      "bin"
+    ],
+    "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+    "schema": "livingip.leoIdentityCompileReceipt.v1",
+    "session_directories_started_empty": true,
+    "status": "pass"
+  },
+  "drift_negative": {
+    "actual_argv_persisted": false,
+    "answer_returned": false,
+    "command_serialization": "logical_redacted_v1",
+    "fail_closed": true,
+    "launcher_pid": 80851,
+    "logical_command": [
+      "<python>",
+      "-m",
+      "scripts.leo_identity_profile",
+      "query",
+      "--profile",
+      "<temporary-profile>",
+      "--source-root",
+      ".",
+      "--hermes-root",
+      "fixtures/working-leo/leo-identity-v1/hermes-runtime",
+      "--deployment-root",
+      ".",
+      "--query",
+      "What defines Leo's identity, and what is temporary?"
+    ],
+    "orphan_cleanup_required": false,
+    "process_group_absent_after_wait": true,
+    "profile_role": "drift_negative",
+    "returncode": 3,
+    "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "stdout": {
+      "error": "identity_drift",
+      "message": "compiled view drift detected: SOUL.md",
+      "status": "error"
+    },
+    "terminated_with": null,
+    "timed_out": false
+  },
+  "drift_target": "compiled SOUL.md generated view",
+  "errors": [],
+  "first_start": {
+    "actual_argv_persisted": false,
+    "command_serialization": "logical_redacted_v1",
+    "launcher_pid": 80054,
+    "logical_command": [
+      "<python>",
+      "-m",
+      "scripts.leo_identity_profile",
+      "query",
+      "--profile",
+      "<temporary-profile>",
+      "--source-root",
+      ".",
+      "--hermes-root",
+      "fixtures/working-leo/leo-identity-v1/hermes-runtime",
+      "--deployment-root",
+      ".",
+      "--query",
+      "What defines Leo's identity, and what is temporary?"
+    ],
+    "orphan_cleanup_required": false,
+    "process_group_absent_after_wait": true,
+    "profile_role": "first_start",
+    "returncode": 0,
+    "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "stdout": {
+      "answer": "Leo is defined by 3 pinned static constitutional rules and 5 active database-derived identity rows from a synthetic noncanonical fixture at fingerprint 1111111111111111111111111111111111111111111111111111111111111111. SOUL.md is a generated view; runtime/session memory is temporary, noncanonical, and cannot be evidence.",
+      "answer_sha256": "e0a21e1fc5357a2f358b4e96c52e971f3addee2468e44748d898adfd62dafa25",
+      "authorization": {
+        "authorization_decision_observed": false,
+        "claim": "local_policy_binding_not_an_authorizer_readback",
+        "declared_runtime_policy": {
+          "allowed_tools": [
+            "identity_readback"
+          ],
+          "database_write_enabled": false,
+          "network_send_enabled": false
+        }
+      },
+      "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+      "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+      "output_provenance": {
+        "actual_model_call_performed": false,
+        "compiled_identity_sha256": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6",
+        "compiled_soul_sha256": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+        "database_authority": "synthetic_noncanonical_fixture",
+        "database_canonical_authority_granted": false,
+        "database_fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+        "database_identity_sha256": "70aaa7287cc41b52a3c902cf2e1b90fa4d84a5ee0a61e10c642f556fcc9304c3",
+        "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+        "static_constitution_sha256": "b576d5cee08530a95e0b196a3296f4743b70d94bcadffaa36544dd6bf1387f8a"
+      },
+      "process_id": 80054,
+      "query": "What defines Leo's identity, and what is temporary?",
+      "query_sha256": "13704c2c9ae999e3f9b3f1c9c5572d062cd7fe49903c2317fa85aaa39490af66",
+      "runtime_instance_id": "4bbcaeeeb5654b69adabed33b91cf3e4",
+      "schema": "livingip.leoIdentityQueryReceipt.v1",
+      "session": {
+        "classification": "temporary_noncanonical",
+        "included_in_output_provenance": false,
+        "may_be_used_as_evidence": false,
+        "record_sha256": "56b6a2ea25657a87dc90dc19f49bece0ac62241f5814732ed80ef4f34d426d84"
+      },
+      "started_at_utc": "2026-07-15T02:46:34.391880+00:00",
+      "status": "pass"
+    },
+    "terminated_with": null,
+    "timed_out": false
+  },
+  "fixed_query": "What defines Leo's identity, and what is temporary?",
+  "fixed_query_sha256": "13704c2c9ae999e3f9b3f1c9c5572d062cd7fe49903c2317fa85aaa39490af66",
+  "gates": {
+    "answer_and_provenance_explainable": true,
+    "drift_failed_closed": true,
+    "drift_process_had_no_orphan_cleanup": true,
+    "drift_process_stopped": true,
+    "drift_profile_started_without_sessions": true,
+    "first_process_stopped": true,
+    "first_start_passed": true,
+    "identity_inputs_reproduced": true,
+    "manifest_generated": true,
+    "manifest_reproduced": true,
+    "pre_restart_verification_passed": true,
+    "query_reproduced": true,
+    "restart_passed": true,
+    "restart_process_is_distinct": true,
+    "restart_process_stopped": true,
+    "restart_profile_recompiled_from_manifest": true,
+    "restart_profile_started_without_sessions": true,
+    "session_excluded_from_identity": true,
+    "views_compiled_and_bound": true
+  },
+  "generated_at_utc": "2026-07-15T02:46:31.346851+00:00",
+  "goal_tier_satisfied": true,
+  "manifest": {
+    "compiled_views": {
+      "SOUL.md": {
+        "generated_from_identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+        "role": "generated_view_not_authority",
+        "sha256": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a"
+      },
+      "identity.json": {
+        "generated_from_identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+        "role": "generated_view_not_authority",
+        "sha256": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6"
+      }
+    },
+    "identity_inputs": {
+      "canonical_database": {
+        "authority": "synthetic_noncanonical_fixture",
+        "canonical_authority_granted": false,
+        "database": "leo_identity_fixture",
+        "database_user": "leo_identity_reader",
+        "fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+        "source": {
+          "record_count": 7,
+          "repo_path": "fixtures/working-leo/leo-identity-v1/leo-database-fingerprint-v1.json",
+          "semantic_sha256": "c5bbf346613270a5e3b17f604f69306ed42f545d4f227d784ec0dcb3d675dcb2"
+        },
+        "structure_sha256": "3333333333333333333333333333333333333333333333333333333333333333",
+        "system_identifier": "7649789040005668902",
+        "table_count": 7,
+        "table_rows_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
+        "total_rows": 7
+      },
+      "gatewayrunner_execution_contract": {
+        "fixed_message_context": {
+          "auto_skill": null,
+          "media_or_file_context": null,
+          "reply_context": null
+        },
+        "profile_surfaces": [
+          "config.yaml",
+          "generated SOUL.md",
+          "skills",
+          "plugins",
+          "bin tools"
+        ],
+        "required_absent_or_empty": {
+          "generated_skill_prompt_cache": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "pairing_store": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "persistent_memory": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "prior_sessions_at_first_start": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
+          "project_context": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945"
+        },
+        "required_t3_turn_receipt_fields": [
+          "runner_class",
+          "authorization_decision",
+          "effective_system_prompt_sha256",
+          "compiled_skills_prompt_sha256",
+          "tool_registry_schema_sha256",
+          "plugin_registry_sha256",
+          "selected_model",
+          "selected_provider",
+          "api_mode",
+          "base_url_host",
+          "database_retrieval_receipt",
+          "session_key_sha256",
+          "persisted_session_id_sha256"
+        ]
+      },
+      "identity_name": "Leo",
+      "identity_sources": {
+        "database_derived_identity": {
+          "authority": "synthetic_noncanonical_fixture",
+          "content_sha256": "9de2dfa37529b23ba277348f3d910e967551e490a9b4d2be637bf45bb2aa7dde",
+          "database_fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+          "provenance": {
+            "authority": "synthetic_noncanonical_fixture",
+            "canonical_authority_granted": false,
+            "export_receipt_sha256": null,
+            "mode": "synthetic_noncanonical_fixture",
+            "same_transaction_as_fingerprint": false
+          },
+          "record_count": 5,
+          "repo_path": "fixtures/working-leo/leo-identity-v1/leo-database-identity-v1.json",
+          "semantic_sha256": "70aaa7287cc41b52a3c902cf2e1b90fa4d84a5ee0a61e10c642f556fcc9304c3"
+        },
+        "static_constitution": {
+          "authority": "pinned_static_source",
+          "content_sha256": "b5477e778a2be0abba783390dac2e04ed199b8ce5679fc324270f808d46543f1",
+          "record_count": 3,
+          "repo_path": "fixtures/working-leo/leo-identity-v1/leo-constitution-v1.json",
+          "semantic_sha256": "b576d5cee08530a95e0b196a3296f4743b70d94bcadffaa36544dd6bf1387f8a"
+        }
+      },
+      "model": {
+        "actual_model_required_in_turn_receipt": true,
+        "default_model": "leo-identity-readback-v1",
+        "gateway_smart_model_routing": null,
+        "hosted_weights": "external_provider_managed_not_locally_hashable",
+        "model_section_sha256": "90b3943ace9ff83b1711002fda8dc9736448e8d3c1c58a17ac90608f4ce58756",
+        "provider": "fixture-local",
+        "smart_routing": false,
+        "smart_routing_model": null
+      },
+      "permissions": {
+        "authorization_decision_required_in_runtime_receipt": true,
+        "gateway_permissions_sha256": "eac17ada1d02b5413183587d12fc265538479de00709ed8c275e9045cd720290",
+        "identity_config_sha256": "e6df9b65bab148ea8502555bbc260df66b4785e7dd527cfd15d2f0a48c2e8b3e",
+        "runtime_policy": {
+          "allowed_tools": [
+            "identity_readback"
+          ],
+          "database_write_enabled": false,
+          "network_send_enabled": false
+        },
+        "tool_permissions_sha256": "9bb2cec2f65d43efb597a72bdced44076c25aac292f2fccbc4c448b6e7fd3e16"
+      },
+      "runtime": {
+        "hermes_git_head": "b238fd6fc2636ed3582e14900774014c52732698",
+        "hermes_source_sha256": "dcf8109051e0b69cafe2e8dd328ff501211b62ea19725416c3781bbdd594d028",
+        "identity_runtime_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+        "python": {
+          "abi_tag": "cpython-311",
+          "implementation": "CPython",
+          "python_version": "3.11.15",
+          "runtime_distributions": {
+            "PyYAML": "6.0.3"
+          },
+          "runtime_distributions_sha256": "57a91bb880a01800903c1604b6eec1419514864ebd6a0644121920da15a8f165"
+        },
+        "teleo_git_head": "b238fd6fc2636ed3582e14900774014c52732698",
+        "teleo_source_sha256": "2bd2e659eafb0ac0823f7f51c4296b2eb500b6f74469b3ac5f5287a5d4810aea"
+      },
+      "session_boundary": {
+        "classification": "temporary_noncanonical",
+        "included_in_identity_inputs": false,
+        "may_be_used_as_evidence": false,
+        "restart_policy": "fresh_process_with_session_state_outside_identity_authority"
+      },
+      "skills": {
+        "content_sha256": "d3f449ddcd7c88238dc88c6233cf2130875f51bd2e0911b2ce477b7c602ae90f",
+        "file_count": 1
+      },
+      "source_commit": "b238fd6fc2636ed3582e14900774014c52732698"
+    },
+    "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+    "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+    "schema": "livingip.leoIdentityManifest.v1"
+  },
+  "mode": "successful_restart_plus_drift_negative",
+  "pre_restart_verification": "pass",
+  "production_database_contacted": false,
+  "production_profile_replaced": false,
+  "receipt_sha256": "685641533be36b78e382dfd690bdc588bc95045379b44dd885d1d1d0ee57b507",
+  "required_tier": "T2_runtime",
+  "restart": {
+    "actual_argv_persisted": false,
+    "command_serialization": "logical_redacted_v1",
+    "launcher_pid": 80642,
+    "logical_command": [
+      "<python>",
+      "-m",
+      "scripts.leo_identity_profile",
+      "query",
+      "--profile",
+      "<temporary-profile>",
+      "--source-root",
+      ".",
+      "--hermes-root",
+      "fixtures/working-leo/leo-identity-v1/hermes-runtime",
+      "--deployment-root",
+      ".",
+      "--query",
+      "What defines Leo's identity, and what is temporary?"
+    ],
+    "orphan_cleanup_required": false,
+    "process_group_absent_after_wait": true,
+    "profile_role": "restart",
+    "returncode": 0,
+    "stderr_sha256": "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
+    "stdout": {
+      "answer": "Leo is defined by 3 pinned static constitutional rules and 5 active database-derived identity rows from a synthetic noncanonical fixture at fingerprint 1111111111111111111111111111111111111111111111111111111111111111. SOUL.md is a generated view; runtime/session memory is temporary, noncanonical, and cannot be evidence.",
+      "answer_sha256": "e0a21e1fc5357a2f358b4e96c52e971f3addee2468e44748d898adfd62dafa25",
+      "authorization": {
+        "authorization_decision_observed": false,
+        "claim": "local_policy_binding_not_an_authorizer_readback",
+        "declared_runtime_policy": {
+          "allowed_tools": [
+            "identity_readback"
+          ],
+          "database_write_enabled": false,
+          "network_send_enabled": false
+        }
+      },
+      "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+      "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+      "output_provenance": {
+        "actual_model_call_performed": false,
+        "compiled_identity_sha256": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6",
+        "compiled_soul_sha256": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+        "database_authority": "synthetic_noncanonical_fixture",
+        "database_canonical_authority_granted": false,
+        "database_fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+        "database_identity_sha256": "70aaa7287cc41b52a3c902cf2e1b90fa4d84a5ee0a61e10c642f556fcc9304c3",
+        "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+        "static_constitution_sha256": "b576d5cee08530a95e0b196a3296f4743b70d94bcadffaa36544dd6bf1387f8a"
+      },
+      "process_id": 80642,
+      "query": "What defines Leo's identity, and what is temporary?",
+      "query_sha256": "13704c2c9ae999e3f9b3f1c9c5572d062cd7fe49903c2317fa85aaa39490af66",
+      "runtime_instance_id": "109445cde86f4ac3b266930462fb62c3",
+      "schema": "livingip.leoIdentityQueryReceipt.v1",
+      "session": {
+        "classification": "temporary_noncanonical",
+        "included_in_output_provenance": false,
+        "may_be_used_as_evidence": false,
+        "record_sha256": "56b6a2ea25657a87dc90dc19f49bece0ac62241f5814732ed80ef4f34d426d84"
+      },
+      "started_at_utc": "2026-07-15T02:46:37.036778+00:00",
+      "status": "pass"
+    },
+    "terminated_with": null,
+    "timed_out": false
+  },
+  "restart_compile": {
+    "compiled_view_sha256": {
+      "SOUL.md": "83d27dba6e1b160085388a5dc84da565abf5736351b1af3f220d13b35aac244a",
+      "identity.json": "40419152862e7d9bca631c53eaa2201052cf61eafe6d304c8a302f8ea97d6fb6"
+    },
+    "generated_views_are_authority": false,
+    "identity_inputs_sha256": "c101c488a9f623b4cef841ddb561c0f289a74df54aadfdfe9b28c4b7643fec2e",
+    "manifest_sha256": "22e66cf39b2c5aac3b4043f37aa0773b4861fec616a435e8b5e0ff8c86586bef",
+    "nonauthoritative_inputs_omitted": {
+      ".cursorrules": true,
+      ".hermes.md": true,
+      ".skills_prompt_snapshot.json": true,
+      "AGENTS.md": true,
+      "CLAUDE.md": true,
+      "HERMES.md": true,
+      "MEMORY.md": true,
+      "USER.md": true,
+      "memories": true,
+      "platforms/pairing": true
+    },
+    "profile_static_entries": [
+      "config.yaml",
+      "skills",
+      "plugins",
+      "bin"
+    ],
+    "runtime_identity_sha256": "5c54248a5d1f00b35912d47d8b3045b8cfbed16ae9b86409b549ab7042f51159",
+    "schema": "livingip.leoIdentityCompileReceipt.v1",
+    "session_directories_started_empty": true,
+    "status": "pass"
+  },
+  "runtime_component_proven": "fresh_profile_recompile_plus_distinct_process_restart",
+  "runtime_variant": "local_deterministic_identity_compiler_readback",
+  "schema": "livingip.leoIdentityReconstructionReceipt.v1",
+  "second_start_attempted": true,
+  "session_boundary_readback": {
+    "full_behavior_changed_after_session": true,
+    "identity_runtime_unchanged_after_session": true,
+    "session_classification": "temporary_noncanonical",
+    "session_file_count": 1,
+    "session_used_as_output_provenance": false
+  },
+  "status": "pass",
+  "telegram_message_sent": false,
+  "tier_basis": "Capability Tier Proof defines T2_runtime as local API/runtime behavior with restart where relevant; this is compiler-process runtime proof and explicitly excludes GatewayRunner and hosted-model proof."
+}

docs/reports/leo-working-state-20260709/proposal-apply-clone-rollback-current.sql

@@ -0,0 +1,141 @@
+begin;
+set local standard_conforming_strings = on;
+set local lock_timeout = '5s';
+select pg_advisory_xact_lock(hashtextextended('proposal-rollback:' || E'edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b', 0));
+do $rollback$
+declare
+  affected integer;
+  approval_now jsonb;
+  downstream_dependency_count integer;
+begin
+  perform 1 from kb_stage.kb_proposals
+   where id = E'edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b'::uuid
+   for update;
+  if not found then
+    raise exception 'proposal rollback: proposal row missing';
+  end if;
+  if not exists (
+    select 1 from kb_stage.kb_proposals
+     where id = E'edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b'::uuid
+       and proposal_type = 'approve_claim'
+       and status = 'applied'
+       and payload = E'{"apply_payload":{"agent_id":null,"claims":[{"confidence":0.9,"created_by":null,"id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","status":"open","superseded_by":null,"tags":["working-leo","clone-canary"],"text":"An approved strict proposal can create exact canonical rows atomically.","type":"structural"},{"confidence":0.85,"created_by":null,"id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","status":"open","superseded_by":null,"tags":["working-leo","row-proof"],"text":"Row-level proof is the authority for canonical KB state.","type":"concept"}],"contract_version":2,"edges":[{"created_by":null,"edge_type":"supports","from_claim":"b4d0a944-8f11-5516-80ca-bc680f0059ad","to_claim":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","weight":0.75}],"evidence":[{"claim_id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","created_by":null,"role":"grounds","source_id":"3953271f-7df5-5674-99b0-980b1b3534e6","weight":0.9},{"claim_id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","created_by":null,"role":"illustrates","source_id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","weight":0.8}],"reasoning_tools":[{"agent_id":null,"category":"verification","description":"Verify approved proposal to canonical graph lifecycle in a disposable clone.","id":"a32a7252-d39f-5ee9-873a-a82b56a6bb08","name":"Canonical row proof canary"}],"sources":[{"created_by":null,"excerpt":"Disposable clone lifecycle canary source A.","hash":"approve-claim-canary-e315c2518c-a","id":"3953271f-7df5-5674-99b0-980b1b3534e6","source_type":"observation","storage_path":null,"url":null},{"created_by":null,"excerpt":"Disposable clone lifecycle canary source B.","hash":"approve-claim-canary-e315c2518c-b","id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","source_type":"observation","storage_path":null,"url":null}]}}'::jsonb
+       and reviewed_by_handle is not distinct from E'm3ta'
+       and reviewed_by_agent_id is not distinct from E'99999999-9999-9999-9999-999999999999'::uuid
+       and reviewed_at is not distinct from E'2026-07-15 03:59:09.091704+00'::timestamptz
+       and review_note is not distinct from E'Reviewed exact strict payload inside the disposable clone.'
+       and applied_by_handle is not distinct from E'kb-apply'
+       and applied_by_agent_id is not distinct from E'44444444-4444-4444-4444-444444444444'::uuid
+       and applied_at is not distinct from E'2026-07-15 03:59:12.452878+00'::timestamptz
+  ) then
+    raise exception 'proposal rollback: applied ledger does not match apply receipt';
+  end if;
+  select jsonb_build_object(
+    'proposal_id', proposal_id::text,
+    'proposal_type', proposal_type,
+    'payload', payload,
+    'reviewed_by_handle', reviewed_by_handle,
+    'reviewed_by_agent_id', reviewed_by_agent_id::text,
+    'reviewed_by_db_role', reviewed_by_db_role::text,
+    'reviewed_at', reviewed_at::text,
+    'review_note', review_note
+  ) into approval_now
+    from kb_stage.kb_proposal_approvals
+   where proposal_id = E'edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b'::uuid;
+  if approval_now is distinct from E'{"payload":{"apply_payload":{"agent_id":null,"claims":[{"confidence":0.9,"created_by":null,"id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","status":"open","superseded_by":null,"tags":["working-leo","clone-canary"],"text":"An approved strict proposal can create exact canonical rows atomically.","type":"structural"},{"confidence":0.85,"created_by":null,"id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","status":"open","superseded_by":null,"tags":["working-leo","row-proof"],"text":"Row-level proof is the authority for canonical KB state.","type":"concept"}],"contract_version":2,"edges":[{"created_by":null,"edge_type":"supports","from_claim":"b4d0a944-8f11-5516-80ca-bc680f0059ad","to_claim":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","weight":0.75}],"evidence":[{"claim_id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","created_by":null,"role":"grounds","source_id":"3953271f-7df5-5674-99b0-980b1b3534e6","weight":0.9},{"claim_id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","created_by":null,"role":"illustrates","source_id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","weight":0.8}],"reasoning_tools":[{"agent_id":null,"category":"verification","description":"Verify approved proposal to canonical graph lifecycle in a disposable clone.","id":"a32a7252-d39f-5ee9-873a-a82b56a6bb08","name":"Canonical row proof canary"}],"sources":[{"created_by":null,"excerpt":"Disposable clone lifecycle canary source A.","hash":"approve-claim-canary-e315c2518c-a","id":"3953271f-7df5-5674-99b0-980b1b3534e6","source_type":"observation","storage_path":null,"url":null},{"created_by":null,"excerpt":"Disposable clone lifecycle canary source B.","hash":"approve-claim-canary-e315c2518c-b","id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","source_type":"observation","storage_path":null,"url":null}]}},"proposal_id":"edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b","proposal_type":"approve_claim","review_note":"Reviewed exact strict payload inside the disposable clone.","reviewed_at":"2026-07-15 03:59:09.091704+00","reviewed_by_agent_id":"99999999-9999-9999-9999-999999999999","reviewed_by_db_role":"kb_review","reviewed_by_handle":"m3ta"}'::jsonb then
+    raise exception 'proposal rollback: immutable approval snapshot drifted';
+  end if;
+  select count(*) into downstream_dependency_count
+    from (
+      select ce.claim_id
+        from public.claim_evidence ce
+       where (ce.claim_id = any(array[E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid, E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid]::uuid[]) or ce.source_id = any(array[E'3953271f-7df5-5674-99b0-980b1b3534e6'::uuid, E'3d31345d-a4f7-52a7-af4a-0034f99a8123'::uuid]::uuid[]))
+         and not (((ce.claim_id = E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid and ce.source_id = E'3d31345d-a4f7-52a7-af4a-0034f99a8123'::uuid and ce.role = E'illustrates'::evidence_role) or (ce.claim_id = E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid and ce.source_id = E'3953271f-7df5-5674-99b0-980b1b3534e6'::uuid and ce.role = E'grounds'::evidence_role)))
+      union all
+      select edge.id
+        from public.claim_edges edge
+       where (edge.from_claim = any(array[E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid, E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid]::uuid[]) or edge.to_claim = any(array[E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid, E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid]::uuid[]))
+         and edge.id <> all(array[E'cd799806-18e8-5e8c-959c-5f9c267654a7'::uuid]::uuid[])
+      union all
+      select claim.id
+        from public.claims claim
+       where claim.superseded_by = any(array[E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid, E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid]::uuid[])
+         and claim.id <> all(array[E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid, E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid]::uuid[])
+    ) external_dependencies;
+  if downstream_dependency_count <> 0 then
+    raise exception 'proposal rollback: % downstream dependenc(ies) exist; rollback quarantined', downstream_dependency_count;
+  end if;
+  if (select count(*) from public.claim_evidence t
+       where ((t.claim_id = E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid and t.source_id = E'3d31345d-a4f7-52a7-af4a-0034f99a8123'::uuid and t.role = E'illustrates'::evidence_role)) and to_jsonb(t) = E'{"claim_id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"role":"illustrates","source_id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","weight":0.8}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: claim_evidence[0] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.claim_evidence t
+       where ((t.claim_id = E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid and t.source_id = E'3953271f-7df5-5674-99b0-980b1b3534e6'::uuid and t.role = E'grounds'::evidence_role)) and to_jsonb(t) = E'{"claim_id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"role":"grounds","source_id":"3953271f-7df5-5674-99b0-980b1b3534e6","weight":0.9}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: claim_evidence[1] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.claim_edges t
+       where t.id = E'cd799806-18e8-5e8c-959c-5f9c267654a7'::uuid and to_jsonb(t) = E'{"created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"edge_type":"supports","from_claim":"b4d0a944-8f11-5516-80ca-bc680f0059ad","id":"cd799806-18e8-5e8c-959c-5f9c267654a7","to_claim":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","weight":0.75}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: claim_edges[0] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.reasoning_tools t
+       where t.id = E'a32a7252-d39f-5ee9-873a-a82b56a6bb08'::uuid and to_jsonb(t) = E'{"agent_id":null,"category":"verification","created_at":"2026-07-15T03:59:12.43629+00:00","description":"Verify approved proposal to canonical graph lifecycle in a disposable clone.","id":"a32a7252-d39f-5ee9-873a-a82b56a6bb08","name":"Canonical row proof canary"}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: reasoning_tools[0] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.sources t
+       where t.id = E'3953271f-7df5-5674-99b0-980b1b3534e6'::uuid and to_jsonb(t) = E'{"captured_at":null,"created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"excerpt":"Disposable clone lifecycle canary source A.","hash":"approve-claim-canary-e315c2518c-a","id":"3953271f-7df5-5674-99b0-980b1b3534e6","source_type":"observation","storage_path":null,"url":null}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: sources[0] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.sources t
+       where t.id = E'3d31345d-a4f7-52a7-af4a-0034f99a8123'::uuid and to_jsonb(t) = E'{"captured_at":null,"created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"excerpt":"Disposable clone lifecycle canary source B.","hash":"approve-claim-canary-e315c2518c-b","id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","source_type":"observation","storage_path":null,"url":null}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: sources[1] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.claims t
+       where t.id = E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid and to_jsonb(t) = E'{"confidence":0.85,"created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","status":"open","superseded_by":null,"tags":["working-leo","row-proof"],"text":"Row-level proof is the authority for canonical KB state.","type":"concept","updated_at":"2026-07-15T03:59:12.43629+00:00"}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: claims[0] row does not match apply receipt';
+  end if;
+  if (select count(*) from public.claims t
+       where t.id = E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid and to_jsonb(t) = E'{"confidence":0.9,"created_at":"2026-07-15T03:59:12.43629+00:00","created_by":null,"id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","status":"open","superseded_by":null,"tags":["working-leo","clone-canary"],"text":"An approved strict proposal can create exact canonical rows atomically.","type":"structural","updated_at":"2026-07-15T03:59:12.43629+00:00"}'::jsonb) <> 1 then
+    raise exception 'proposal rollback drift: claims[1] row does not match apply receipt';
+  end if;
+  delete from public.claim_evidence target where ((target.claim_id = E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid and target.source_id = E'3d31345d-a4f7-52a7-af4a-0034f99a8123'::uuid and target.role = E'illustrates'::evidence_role) or (target.claim_id = E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid and target.source_id = E'3953271f-7df5-5674-99b0-980b1b3534e6'::uuid and target.role = E'grounds'::evidence_role));
+  get diagnostics affected = row_count;
+  if affected <> 2 then
+    raise exception 'proposal rollback count mismatch for claim_evidence: expected 2, got %', affected;
+  end if;
+  delete from public.claim_edges where id in (E'cd799806-18e8-5e8c-959c-5f9c267654a7'::uuid);
+  get diagnostics affected = row_count;
+  if affected <> 1 then
+    raise exception 'proposal rollback count mismatch for claim_edges: expected 1, got %', affected;
+  end if;
+  delete from public.reasoning_tools where id in (E'a32a7252-d39f-5ee9-873a-a82b56a6bb08'::uuid);
+  get diagnostics affected = row_count;
+  if affected <> 1 then
+    raise exception 'proposal rollback count mismatch for reasoning_tools: expected 1, got %', affected;
+  end if;
+  delete from public.sources where id in (E'3953271f-7df5-5674-99b0-980b1b3534e6'::uuid, E'3d31345d-a4f7-52a7-af4a-0034f99a8123'::uuid);
+  get diagnostics affected = row_count;
+  if affected <> 2 then
+    raise exception 'proposal rollback count mismatch for sources: expected 2, got %', affected;
+  end if;
+  delete from public.claims where id in (E'a9dd972a-b867-56f7-b3c9-3913dd9a0abe'::uuid, E'b4d0a944-8f11-5516-80ca-bc680f0059ad'::uuid);
+  get diagnostics affected = row_count;
+  if affected <> 2 then
+    raise exception 'proposal rollback count mismatch for claims: expected 2, got %', affected;
+  end if;
+  update kb_stage.kb_proposals
+     set status = 'canceled',
+         applied_by_handle = null,
+         applied_by_agent_id = null,
+         applied_at = null,
+         updated_at = now()
+   where id = E'edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b'::uuid
+     and status = 'applied'
+     and payload = E'{"apply_payload":{"agent_id":null,"claims":[{"confidence":0.9,"created_by":null,"id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","status":"open","superseded_by":null,"tags":["working-leo","clone-canary"],"text":"An approved strict proposal can create exact canonical rows atomically.","type":"structural"},{"confidence":0.85,"created_by":null,"id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","status":"open","superseded_by":null,"tags":["working-leo","row-proof"],"text":"Row-level proof is the authority for canonical KB state.","type":"concept"}],"contract_version":2,"edges":[{"created_by":null,"edge_type":"supports","from_claim":"b4d0a944-8f11-5516-80ca-bc680f0059ad","to_claim":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","weight":0.75}],"evidence":[{"claim_id":"b4d0a944-8f11-5516-80ca-bc680f0059ad","created_by":null,"role":"grounds","source_id":"3953271f-7df5-5674-99b0-980b1b3534e6","weight":0.9},{"claim_id":"a9dd972a-b867-56f7-b3c9-3913dd9a0abe","created_by":null,"role":"illustrates","source_id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","weight":0.8}],"reasoning_tools":[{"agent_id":null,"category":"verification","description":"Verify approved proposal to canonical graph lifecycle in a disposable clone.","id":"a32a7252-d39f-5ee9-873a-a82b56a6bb08","name":"Canonical row proof canary"}],"sources":[{"created_by":null,"excerpt":"Disposable clone lifecycle canary source A.","hash":"approve-claim-canary-e315c2518c-a","id":"3953271f-7df5-5674-99b0-980b1b3534e6","source_type":"observation","storage_path":null,"url":null},{"created_by":null,"excerpt":"Disposable clone lifecycle canary source B.","hash":"approve-claim-canary-e315c2518c-b","id":"3d31345d-a4f7-52a7-af4a-0034f99a8123","source_type":"observation","storage_path":null,"url":null}]}}'::jsonb
+     and applied_at is not distinct from E'2026-07-15 03:59:12.452878+00'::timestamptz;
+  get diagnostics affected = row_count;
+  if affected <> 1 then
+    raise exception 'proposal rollback: expected one applied ledger row, got %', affected;
+  end if;
+end
+$rollback$;
+commit;

docs/reports/leo-working-state-20260709/proposal-apply-lifecycle-receipt-current.json

@@ -0,0 +1,219 @@
+{
+  "applied_row_keys": {
+    "claim_edges": [
+      "cd799806-18e8-5e8c-959c-5f9c267654a7"
+    ],
+    "claim_evidence": [
+      "a9dd972a-b867-56f7-b3c9-3913dd9a0abe|3d31345d-a4f7-52a7-af4a-0034f99a8123|illustrates",
+      "b4d0a944-8f11-5516-80ca-bc680f0059ad|3953271f-7df5-5674-99b0-980b1b3534e6|grounds"
+    ],
+    "claims": [
+      "a9dd972a-b867-56f7-b3c9-3913dd9a0abe",
+      "b4d0a944-8f11-5516-80ca-bc680f0059ad"
+    ],
+    "reasoning_tools": [
+      "a32a7252-d39f-5ee9-873a-a82b56a6bb08"
+    ],
+    "sources": [
+      "3953271f-7df5-5674-99b0-980b1b3534e6",
+      "3d31345d-a4f7-52a7-af4a-0034f99a8123"
+    ]
+  },
+  "applied_row_sha256": {
+    "claim_edges": [
+      "aae7ed87c66cf58136f2b0027ae1cddc9092cd64bfc8e617cd7746b2306274c5"
+    ],
+    "claim_evidence": [
+      "388f3363173efda00f0688fab77fe0ce2baf62035220b843be1adea1f1c70f7f",
+      "55838cb722f7158cbdbdc3b79212e764f9fa6014771985aec3c1c7856967db07"
+    ],
+    "claims": [
+      "75fe4543c9c3194612b1cf98b074ff7e361da17c9bcd59f9b6f085c2c0861277",
+      "5914923936817eff6d7e5c824c94c18ae6392b7a6e80c87ace2e547865b173eb"
+    ],
+    "reasoning_tools": [
+      "990dacb7b77cec117d9ee4a7630625a8782d06dfd549340b3269b8332c170576"
+    ],
+    "sources": [
+      "585edbec2f98ec127041cdd662506a1494ea402f7e25ac0082dbda98197bf130",
+      "a8d2eead7cb3e563869978570173e2af753dfe131d4b7cfcf6dd419ffbb427e5"
+    ]
+  },
+  "apply_payload_sha256": "e033bd4e742dfa0dad7d26e2f2b1f18eb71996541cdbc575bb2d4504c045e36f",
+  "apply_receipt_sha256": "ac99a2a315cc8e6e214e0f2f69d1a23413da9cfd8629c202b61a678ffda6d7ca",
+  "apply_sql_sha256": "b52cd47182dc0f542a394147201bb3a125518f8a4bc1a7fc44f2b0caa39c4a1b",
+  "approval_snapshot_sha256": "1f9d0a58ad236908da931c7489fe14ee855d0f13c4d72eb5b218370e116e2096",
+  "artifact": "proposal_apply_lifecycle_receipt",
+  "checks": {
+    "apply_receipt_replay_ready": true,
+    "apply_rows_have_exact_ids": true,
+    "fresh_owned_preflight_consumed_by_apply": true,
+    "fresh_owned_targets": true,
+    "immutable_approval_unchanged": true,
+    "rollback_counts_restored": true,
+    "rollback_ledger_quarantined_from_worker": true,
+    "rollback_replay_refused_without_mutation": true,
+    "rollback_sql_exact_for_bound_rows": true,
+    "rollback_target_rows_absent": true,
+    "unrelated_rows_unchanged": true
+  },
+  "current_tier": "T2_runtime",
+  "fresh_owned_apply_sql_sha256": "b52cd47182dc0f542a394147201bb3a125518f8a4bc1a7fc44f2b0caa39c4a1b",
+  "fresh_preflight_artifact_sha256": "2312c91d82ee378d4a53136b8e307900c97d0611d9f12098e799cb6de5d30077",
+  "fresh_preflight_sha256": "90facb2ca62feb1d3c7a242e84427ab402cf57148eaba40ec700f3cc4896d20f",
+  "generated_at_utc": "2026-07-15T03:59:15.412413+00:00",
+  "lifecycle_receipt_sha256": "4254f363b0c6115ecf07856c6e6a9879b43840e688aa73211cb9eff893b36c06",
+  "pass": true,
+  "production_apply_authorization_present": false,
+  "production_apply_executed": false,
+  "proposal_before_apply": {
+    "applied_at": null,
+    "applied_by_agent_id": null,
+    "applied_by_handle": null,
+    "id": "edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b",
+    "payload": {
+      "apply_payload": {
+        "agent_id": null,
+        "claims": [
+          {
+            "confidence": 0.9,
+            "created_by": null,
+            "id": "b4d0a944-8f11-5516-80ca-bc680f0059ad",
+            "status": "open",
+            "superseded_by": null,
+            "tags": [
+              "working-leo",
+              "clone-canary"
+            ],
+            "text": "An approved strict proposal can create exact canonical rows atomically.",
+            "type": "structural"
+          },
+          {
+            "confidence": 0.85,
+            "created_by": null,
+            "id": "a9dd972a-b867-56f7-b3c9-3913dd9a0abe",
+            "status": "open",
+            "superseded_by": null,
+            "tags": [
+              "working-leo",
+              "row-proof"
+            ],
+            "text": "Row-level proof is the authority for canonical KB state.",
+            "type": "concept"
+          }
+        ],
+        "contract_version": 2,
+        "edges": [
+          {
+            "created_by": null,
+            "edge_type": "supports",
+            "from_claim": "b4d0a944-8f11-5516-80ca-bc680f0059ad",
+            "to_claim": "a9dd972a-b867-56f7-b3c9-3913dd9a0abe",
+            "weight": 0.75
+          }
+        ],
+        "evidence": [
+          {
+            "claim_id": "b4d0a944-8f11-5516-80ca-bc680f0059ad",
+            "created_by": null,
+            "role": "grounds",
+            "source_id": "3953271f-7df5-5674-99b0-980b1b3534e6",
+            "weight": 0.9
+          },
+          {
+            "claim_id": "a9dd972a-b867-56f7-b3c9-3913dd9a0abe",
+            "created_by": null,
+            "role": "illustrates",
+            "source_id": "3d31345d-a4f7-52a7-af4a-0034f99a8123",
+            "weight": 0.8
+          }
+        ],
+        "reasoning_tools": [
+          {
+            "agent_id": null,
+            "category": "verification",
+            "description": "Verify approved proposal to canonical graph lifecycle in a disposable clone.",
+            "id": "a32a7252-d39f-5ee9-873a-a82b56a6bb08",
+            "name": "Canonical row proof canary"
+          }
+        ],
+        "sources": [
+          {
+            "created_by": null,
+            "excerpt": "Disposable clone lifecycle canary source A.",
+            "hash": "approve-claim-canary-e315c2518c-a",
+            "id": "3953271f-7df5-5674-99b0-980b1b3534e6",
+            "source_type": "observation",
+            "storage_path": null,
+            "url": null
+          },
+          {
+            "created_by": null,
+            "excerpt": "Disposable clone lifecycle canary source B.",
+            "hash": "approve-claim-canary-e315c2518c-b",
+            "id": "3d31345d-a4f7-52a7-af4a-0034f99a8123",
+            "source_type": "observation",
+            "storage_path": null,
+            "url": null
+          }
+        ]
+      }
+    },
+    "proposal_type": "approve_claim",
+    "review_note": "Reviewed exact strict payload inside the disposable clone.",
+    "reviewed_at": "2026-07-15 03:59:09.091704+00",
+    "reviewed_by_agent_id": "99999999-9999-9999-9999-999999999999",
+    "reviewed_by_handle": "m3ta",
+    "status": "approved"
+  },
+  "proposal_payload_sha256": "cf2676db5a64142d07a7b46f02f1ba38bfa8cca69d03484bbcaa5eeb7002af71",
+  "required_tier": "T2_runtime",
+  "rollback": {
+    "counts_after_rollback": {
+      "kb_stage.kb_proposals": 1,
+      "public.claim_edges": 0,
+      "public.claim_evidence": 1,
+      "public.claims": 1,
+      "public.reasoning_tools": 0,
+      "public.sources": 1
+    },
+    "counts_before_apply": {
+      "kb_stage.kb_proposals": 1,
+      "public.claim_edges": 0,
+      "public.claim_evidence": 1,
+      "public.claims": 1,
+      "public.reasoning_tools": 0,
+      "public.sources": 1
+    },
+    "delete_order": [
+      "claim_evidence",
+      "claim_edges",
+      "reasoning_tools",
+      "sources",
+      "claims"
+    ],
+    "proposal_after": {
+      "applied_at": null,
+      "applied_by_agent_id": null,
+      "applied_by_handle": null,
+      "id": "edaf2c90-af15-5a2f-b6b9-fe08ab9ae81b",
+      "proposal_type": "approve_claim",
+      "review_note": "Reviewed exact strict payload inside the disposable clone.",
+      "reviewed_at": "2026-07-15 03:59:09.091704+00",
+      "reviewed_by_agent_id": "99999999-9999-9999-9999-999999999999",
+      "reviewed_by_handle": "m3ta",
+      "status": "canceled"
+    },
+    "rollback_sql_sha256": "50758dab3f998289a879cedb4a3f4535814e70c7f4dde417812092b9fe194901",
+    "schema": "livingip.proposalApplyRollback.v2",
+    "target_rows_after": {
+      "claim_edges": [],
+      "claim_evidence": [],
+      "claims": [],
+      "reasoning_tools": [],
+      "sources": []
+    }
+  },
+  "schema": "livingip.proposalApplyLifecycleReceipt.v2",
+  "strongest_claim_allowed": "deterministic disposable-clone apply and compensating rollback"
+}

docs/reports/leo-working-state-20260709/proposal-apply-production-authorization-packet-current.json

@@ -0,0 +1,260 @@
+{
+  "artifact": "proposal_apply_production_authorization_packet",
+  "authorization_record_required": {
+    "authorization_text": "<EXACT_TEXT_FROM_VERIFIER>",
+    "authorized": true,
+    "binding_sha256": "6f1984f3a69ad049d4bbcc408ed2542dc5f081806ec9baa9a35c8959e5dab62a",
+    "expires_at_utc": "<UTC>",
+    "operator_identity": "<OPERATOR_IDENTITY>",
+    "production_rollback_sql_sha256": "<EXACT_PRODUCTION_ROLLBACK_SHA256>",
+    "received_at_utc": "<UTC>",
+    "rollback_authorized": true
+  },
+  "authorization_text_template": "I authorize one production DB apply for proposal 9b2b5fa4-0e0d-5db0-aa4d-6fd102889946 with payload SHA-256 6fba5e8e105a28dfaf5733ff7c9f85a20d31d653add0bc4a0f81e4b08de803af to Docker container teleo-pg, database teleo, system identifier 7649789040005668902, binding SHA-256 6f1984f3a69ad049d4bbcc408ed2542dc5f081806ec9baa9a35c8959e5dab62a. I also authorize conditional production rollback SHA-256 <PRODUCTION_ROLLBACK_SQL_SHA256> only if the bound postflight fails and no downstream dependency exists. Do not send Telegram, mutate another proposal, expose Cloud SQL, or promote GCP. Operator <OPERATOR_IDENTITY>; received <UTC>; expires <UTC>.",
+  "binding": {
+    "approval_gate": {
+      "apply_role_present": true,
+      "approve_function_present": false,
+      "assert_function_present": false,
+      "finish_function_present": false,
+      "immutable_approval_table_present": false,
+      "review_role_present": false
+    },
+    "approval_gate_dependency": {
+      "path": "scripts/kb_apply_prereqs.sql",
+      "requires_separate_production_authorization": true,
+      "sha256": "bdf8c5da05eed10665b05ad1e331e3c9c8d72464c59889a3cf8f34ab23822faa"
+    },
+    "candidate_readback": {
+      "matching_candidate": null,
+      "matching_candidate_count": 0
+    },
+    "destination": {
+      "container": "teleo-pg",
+      "database": "teleo",
+      "server_version_num": "160014",
+      "system_identifier": "7649789040005668902"
+    },
+    "destination_readback": {
+      "observed_at_utc": "2026-07-15T02:07:27.133665+00:00",
+      "read_only_transaction": true
+    },
+    "engine": {
+      "apply_engine_path": "scripts/apply_proposal.py",
+      "apply_engine_sha256": "ca2c0a0c1031393c95a26102d57339654d2363f4c51cdf39aabb9071d0ca6c26",
+      "apply_sql_sha256": "1a7d65870e415ee8891b6dd84732a29bcee00412c10862d3d1db4b191a8ade38",
+      "repo_git_sha": "bd3c17628c6cf7da734be01149bbf1cc77a6d71b",
+      "runtime_manifest": {
+        "scripts/apply_proposal.py": "ca2c0a0c1031393c95a26102d57339654d2363f4c51cdf39aabb9071d0ca6c26",
+        "scripts/kb_apply_prereqs.sql": "bdf8c5da05eed10665b05ad1e331e3c9c8d72464c59889a3cf8f34ab23822faa",
+        "scripts/kb_apply_replay_receipt.py": "4ead132fc32a69baaecfe7b638cba8ba6d54d8508d0b7e6a922dc8065805c97f",
+        "scripts/proposal_apply_lifecycle.py": "a643b83b55c9e76f545ebafb9582d6d07ff432600c1b66004cc7440d7ac1963b"
+      }
+    },
+    "expected_rows": {
+      "row_ids": {
+        "claim_edges": [
+          "b28d8770-9ac9-5b5f-bfe2-7280d7422a21"
+        ],
+        "claim_evidence": [
+          "13e580c5-458d-5146-aef3-8c74ffc43b7c",
+          "dac3934f-b7ad-5205-8efe-a00163370a54"
+        ],
+        "claims": [
+          "38dead14-6b1d-5909-99c4-3c45ad2dd21f",
+          "71a3331b-fb75-5e18-aa61-b256bc38af36"
+        ],
+        "reasoning_tools": [
+          "2b8a01ea-125c-5d90-a9b9-39ccb0a1c9e0"
+        ],
+        "sources": [
+          "a86f55dc-5058-585d-b492-a4f1d932670f",
+          "ed9da5f1-846e-5298-8689-15027a7ce56d"
+        ]
+      },
+      "row_sha256": {
+        "claim_edges": [
+          "60d14cbc45d424fa1eb62db6478f185bf2c2d86559e57ffa77474e8d0b3c527c"
+        ],
+        "claim_evidence": [
+          "e97de162c0730da69b357e1350f0da7e5843c4e67d498c12d731a0f04a8868d7",
+          "3054718195abe3f78e08cfcacd59902d41eb91c7153c6c63f9bcb3bc7c6902ac"
+        ],
+        "claims": [
+          "e593b9cf7b0bc9267f3e48d8173129b84b09c028f290f1abc97ccb73940b31dc",
+          "24280b5159cbbf75e00eb24ae50ab69994397a583f347a241a5e262cf0c03179"
+        ],
+        "reasoning_tools": [
+          "257924b236c3c27289b9ae2314687be0e96779415fc6ff87faada22893b757ba"
+        ],
+        "sources": [
+          "d7a690c2b18701db5b48e8189b1621c8025c1ed75889a4d0a3a4c9761c03dc3b",
+          "bee048794799006bd00bf4bb02ae57998e670f5bcdfb140dff871dcb042d0198"
+        ]
+      }
+    },
+    "production_preconditions": {
+      "approval_gate_ready": false,
+      "destination_readback_observed_at_utc": "2026-07-15T02:07:27.133665+00:00",
+      "destination_readback_was_read_only": true,
+      "exact_production_rollback_packet_ready": false,
+      "matching_candidate_count": 0,
+      "production_apply_authorization_present": false,
+      "production_apply_executed": false,
+      "strict_proposal_present_and_approved": false
+    },
+    "production_rollback": {
+      "artifact_schema": null,
+      "artifact_sha256": null,
+      "bound_for_action_time_authorization": false,
+      "conditional_rollback_requires_explicit_authorization": true,
+      "rollback_sql_sha256": null,
+      "scope": "exact_production_destination_postapply_receipt",
+      "status": "not_generated"
+    },
+    "proposal": {
+      "apply_payload_sha256": "c89bc03ce7714f325293329a0bf95eaba0a56c596ef021d731b48dab0447c684",
+      "approval_snapshot_sha256": "310b54030e26ed43d7226f2e803610586e80d21ff064c67e11ea21e93ef40bd9",
+      "id": "9b2b5fa4-0e0d-5db0-aa4d-6fd102889946",
+      "payload": {
+        "apply_payload": {
+          "agent_id": null,
+          "claims": [
+            {
+              "confidence": 0.9,
+              "created_by": null,
+              "id": "38dead14-6b1d-5909-99c4-3c45ad2dd21f",
+              "status": "open",
+              "superseded_by": null,
+              "tags": [
+                "working-leo",
+                "clone-canary"
+              ],
+              "text": "An approved strict proposal can create exact canonical rows atomically.",
+              "type": "structural"
+            },
+            {
+              "confidence": 0.85,
+              "created_by": null,
+              "id": "71a3331b-fb75-5e18-aa61-b256bc38af36",
+              "status": "open",
+              "superseded_by": null,
+              "tags": [
+                "working-leo",
+                "row-proof"
+              ],
+              "text": "Row-level proof is the authority for canonical KB state.",
+              "type": "concept"
+            }
+          ],
+          "contract_version": 2,
+          "edges": [
+            {
+              "created_by": null,
+              "edge_type": "supports",
+              "from_claim": "38dead14-6b1d-5909-99c4-3c45ad2dd21f",
+              "to_claim": "71a3331b-fb75-5e18-aa61-b256bc38af36",
+              "weight": 0.75
+            }
+          ],
+          "evidence": [
+            {
+              "claim_id": "38dead14-6b1d-5909-99c4-3c45ad2dd21f",
+              "created_by": null,
+              "role": "grounds",
+              "source_id": "ed9da5f1-846e-5298-8689-15027a7ce56d",
+              "weight": 0.9
+            },
+            {
+              "claim_id": "71a3331b-fb75-5e18-aa61-b256bc38af36",
+              "created_by": null,
+              "role": "illustrates",
+              "source_id": "a86f55dc-5058-585d-b492-a4f1d932670f",
+              "weight": 0.8
+            }
+          ],
+          "reasoning_tools": [
+            {
+              "agent_id": null,
+              "category": "verification",
+              "description": "Verify approved proposal to canonical graph lifecycle in a disposable clone.",
+              "id": "2b8a01ea-125c-5d90-a9b9-39ccb0a1c9e0",
+              "name": "Canonical row proof canary"
+            }
+          ],
+          "sources": [
+            {
+              "created_by": null,
+              "excerpt": "Disposable clone lifecycle canary source A.",
+              "hash": "approve-claim-canary-08c2358330-a",
+              "id": "ed9da5f1-846e-5298-8689-15027a7ce56d",
+              "source_type": "observation",
+              "storage_path": null,
+              "url": null
+            },
+            {
+              "created_by": null,
+              "excerpt": "Disposable clone lifecycle canary source B.",
+              "hash": "approve-claim-canary-08c2358330-b",
+              "id": "a86f55dc-5058-585d-b492-a4f1d932670f",
+              "source_type": "observation",
+              "storage_path": null,
+              "url": null
+            }
+          ]
+        }
+      },
+      "proposal_payload_sha256": "6fba5e8e105a28dfaf5733ff7c9f85a20d31d653add0bc4a0f81e4b08de803af",
+      "proposal_type": "approve_claim",
+      "required_applied_at": null,
+      "required_status": "approved",
+      "review_note": "Reviewed exact strict payload inside the disposable clone.",
+      "reviewed_at": "2026-07-15 01:59:03.105846+00",
+      "reviewed_by_agent_id": "11111111-1111-4111-8111-111111111111",
+      "reviewed_by_handle": "m3ta"
+    },
+    "rollback": {
+      "conditional_rollback_requires_explicit_authorization": true,
+      "lifecycle_receipt_sha256": "8e74cf1f5c372633f9b6f15363ff759ba6ce9bf42df51288bb9be70ddabe49b3",
+      "production_executable": false,
+      "rollback_sql_sha256": "ef2464a6802426509333861cf0768ca64184901ab7bd2030529e7356a35d9cb3",
+      "scope": "disposable_clone_rehearsal"
+    }
+  },
+  "binding_sha256": "6f1984f3a69ad049d4bbcc408ed2542dc5f081806ec9baa9a35c8959e5dab62a",
+  "claim_ceiling": "T2 clone lifecycle plus T3 destination readback; no production apply authorization or execution",
+  "current_tier": "T3_live_readonly",
+  "generated_at_utc": "2026-07-15T02:08:10.775963+00:00",
+  "next_exact_action": "deploy and independently verify the immutable approval gate before selecting a production proposal",
+  "production_apply_authorization_present": false,
+  "production_apply_executed": false,
+  "production_preconditions": {
+    "approval_gate_ready": false,
+    "destination_readback_observed_at_utc": "2026-07-15T02:07:27.133665+00:00",
+    "destination_readback_was_read_only": true,
+    "exact_production_rollback_packet_ready": false,
+    "matching_candidate_count": 0,
+    "production_apply_authorization_present": false,
+    "production_apply_executed": false,
+    "strict_proposal_present_and_approved": false
+  },
+  "production_rollback_requirement": {
+    "clone_rehearsal_is_not_production_rollback": true,
+    "clone_rehearsal_rollback_sql_sha256": "ef2464a6802426509333861cf0768ca64184901ab7bd2030529e7356a35d9cb3",
+    "production_rollback_artifact_schema": null,
+    "production_rollback_artifact_sha256": null,
+    "production_rollback_sql_sha256": null,
+    "required_before_apply_window": true,
+    "required_binding": "an exact production rollback SQL SHA-256 in both the action-time record and authorization text",
+    "status": "not_generated"
+  },
+  "required_tier": "T6_authorized_production",
+  "safe_to_enter_apply_window": false,
+  "schema": "livingip.proposalApplyAuthorizationPacket.v1",
+  "scope_exclusions": {
+    "approval_gate_deployment_authorized": false,
+    "cloud_sql_exposure_authorized": false,
+    "gcp_promotion_authorized": false,
+    "telegram_send_authorized": false
+  }
+}

docs/reports/leo-working-state-20260709/proposal-apply-production-authorization-packet-current.md

@@ -0,0 +1,62 @@
+# Proposal Apply Production Authorization Packet
+
+Generated UTC: `2026-07-15T02:08:10.775963+00:00`
+Required tier: `T6_authorized_production`
+Current tier: `T3_live_readonly`
+Safe to enter apply window: `False`
+Production apply authorized: `False`
+Production apply executed: `False`
+
+## Exact Binding
+
+- Proposal: `9b2b5fa4-0e0d-5db0-aa4d-6fd102889946` (`approve_claim`)
+- Proposal payload SHA-256: `6fba5e8e105a28dfaf5733ff7c9f85a20d31d653add0bc4a0f81e4b08de803af`
+- Apply payload SHA-256: `c89bc03ce7714f325293329a0bf95eaba0a56c596ef021d731b48dab0447c684`
+- Immutable approval SHA-256: `310b54030e26ed43d7226f2e803610586e80d21ff064c67e11ea21e93ef40bd9`
+- Destination: `teleo-pg/teleo`
+- Destination system identifier: `7649789040005668902`
+- Apply engine SHA-256: `ca2c0a0c1031393c95a26102d57339654d2363f4c51cdf39aabb9071d0ca6c26`
+- Apply engine path: `scripts/apply_proposal.py`
+- Apply SQL SHA-256: `1a7d65870e415ee8891b6dd84732a29bcee00412c10862d3d1db4b191a8ade38`
+- Clone rehearsal rollback SQL SHA-256: `ef2464a6802426509333861cf0768ca64184901ab7bd2030529e7356a35d9cb3`
+- Production rollback status: `not_generated`
+- Production rollback SQL SHA-256: `None`
+- Approval gate prerequisite SHA-256: `bdf8c5da05eed10665b05ad1e331e3c9c8d72464c59889a3cf8f34ab23822faa`
+- Approval gate prerequisite path: `scripts/kb_apply_prereqs.sql`
+- Binding SHA-256: `6f1984f3a69ad049d4bbcc408ed2542dc5f081806ec9baa9a35c8959e5dab62a`
+
+## Production Preconditions
+
+- `approval_gate_ready`: `False`
+- `destination_readback_observed_at_utc`: `2026-07-15T02:07:27.133665+00:00`
+- `destination_readback_was_read_only`: `True`
+- `exact_production_rollback_packet_ready`: `False`
+- `matching_candidate_count`: `0`
+- `production_apply_authorization_present`: `False`
+- `production_apply_executed`: `False`
+- `strict_proposal_present_and_approved`: `False`
+
+## Approval Gate Readback
+
+- `apply_role_present`: `True`
+- `approve_function_present`: `False`
+- `assert_function_present`: `False`
+- `finish_function_present`: `False`
+- `immutable_approval_table_present`: `False`
+- `review_role_present`: `False`
+
+## Exact Action-Time Authorization Text
+
+This text is not actionable until every production precondition above is true.
+
+I authorize one production DB apply for proposal 9b2b5fa4-0e0d-5db0-aa4d-6fd102889946 with payload SHA-256 6fba5e8e105a28dfaf5733ff7c9f85a20d31d653add0bc4a0f81e4b08de803af to Docker container teleo-pg, database teleo, system identifier 7649789040005668902, binding SHA-256 6f1984f3a69ad049d4bbcc408ed2542dc5f081806ec9baa9a35c8959e5dab62a. I also authorize conditional production rollback SHA-256 <PRODUCTION_ROLLBACK_SQL_SHA256> only if the bound postflight fails and no downstream dependency exists. Do not send Telegram, mutate another proposal, expose Cloud SQL, or promote GCP. Operator <OPERATOR_IDENTITY>; received <UTC>; expires <UTC>.
+
+## Current Gate
+
+deploy and independently verify the immutable approval gate before selecting a production proposal
+
+The production approval-gate deployment is explicitly outside this apply packet and requires separate authorization.
+
+## Claim Ceiling
+
+T2 clone lifecycle plus T3 destination readback; no production apply authorization or execution

docs/reports/leo-working-state-20260709/proposal-apply-production-target-readback-current.json

@@ -0,0 +1,32 @@
+{
+  "artifact": "proposal_apply_production_target_readback",
+  "schema": "livingip.proposalApplyProductionTargetReadback.v1",
+  "observed_at_utc": "2026-07-15T02:07:27.133665+00:00",
+  "transport": "ssh_readonly_transaction",
+  "read_only_transaction": true,
+  "read_only_setting": "on",
+  "container": "teleo-pg",
+  "database": "teleo",
+  "system_identifier": "7649789040005668902",
+  "server_version_num": "160014",
+  "approval_gate": {
+    "immutable_approval_table_present": false,
+    "approve_function_present": false,
+    "assert_function_present": false,
+    "finish_function_present": false,
+    "review_role_present": false,
+    "apply_role_present": true
+  },
+  "approved_strict_candidate_count": 0,
+  "approved_strict_candidates": [],
+  "attempted_recovery": {
+    "strict_immutable_approval_join_attempted": true,
+    "strict_join_failed": true,
+    "strict_join_exact_gate": "relation kb_stage.kb_proposal_approvals does not exist",
+    "fallback_read_only_gate_and_candidate_count_succeeded": true
+  },
+  "production_mutated": false,
+  "production_apply_authorization_present": false,
+  "production_apply_executed": false,
+  "claim_ceiling": "Fresh T3 live read-only identity and gate readback only. The immutable approval gate is absent and there are zero approved strict approve_claim candidates; production apply is neither authorized nor executed."
+}

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-authorization-packet-current.json

@@ -0,0 +1,272 @@
+{
+  "authorization_gate_status": "ready_to_request_exact_authorization",
+  "browser_provenance_contract": {
+    "capture_channel": "codex_chrome_extension",
+    "requires_browser_session_tab_and_capture_identifiers": true,
+    "requires_chrome_backend_tool_receipts": true,
+    "requires_codex_rollout_log_outside_evidence_root": true,
+    "requires_codex_user_message_authorization_receipt": true,
+    "requires_hashes_for_every_screenshot_and_accessibility_artifact": true,
+    "requires_preflight_challenge_nonce": true,
+    "requires_provenance_sha256_in_final_chrome_tool_receipt": true,
+    "requires_telegram_web_origin_and_chat_identity": true,
+    "schema": "livingip.authenticatedChromeTelegramCaptureProvenance.v1"
+  },
+  "checks": {
+    "authenticated_chrome_is_only_send_transport": true,
+    "canonical_manifest_path_and_sha_bound": true,
+    "database_session_and_role_fail_closed_read_only": true,
+    "exact_prompts_imported_from_handler_verifier": true,
+    "exact_three_turn_sequence": true,
+    "first_prompt_supplies_no_row_id": true,
+    "handler_checks_all_pass": true,
+    "handler_outcomes_all_pass": true,
+    "handler_prompt_ids_exact": true,
+    "handler_proved_no_telegram_post": true,
+    "handler_proved_read_only_tool_traces": true,
+    "handler_proved_unchanged_fingerprint": true,
+    "handler_receipt_passed": true,
+    "handler_receipt_schema_supported": true,
+    "handler_safety_gate_passed": true,
+    "handler_tier_remains_below_telegram_visible": true,
+    "independent_browser_provenance_required": true,
+    "packet_does_not_mutate_database": true,
+    "packet_does_not_send": true
+  },
+  "claim_ceiling": {
+    "current_tier": "T0_spec_plus_prior_T2_handler_evidence",
+    "not_proven": [
+      "Telegram-visible delivery of these three messages",
+      "Telegram-visible replies from Leo",
+      "post-send canonical fingerprint equality"
+    ],
+    "proven": "The exact three-turn Chrome send packet is bound to a passing no-send handler receipt.",
+    "required_tier": "T3_live_readonly"
+  },
+  "clear_CTA": "Reply with the exact authorization sentence in this packet. That sentence names the destination, transport, complete message bodies, ordering, evidence, and no-mutation boundary.",
+  "exact_messages": [
+    {
+      "dimension": "independent_weak_claim_selection",
+      "message": "Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet.",
+      "message_sha256": "c63838b98448f4f4599e4cf2b004c6b36f602ad0d25c92e442a6f866cd2740fc",
+      "prompt_id": "OOS-CHAIN-01",
+      "sequence": 1,
+      "wait_for_visible_reply_before_next": true
+    },
+    {
+      "dimension": "challenge_body_evidence_and_candidates",
+      "message": "That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge.",
+      "message_sha256": "73346a98db4d7f74b49e1a5741b323d4216fd21f8346f6c4a4a69b1a6dd07946",
+      "prompt_id": "OOS-CHAIN-02",
+      "sequence": 2,
+      "wait_for_visible_reply_before_next": true
+    },
+    {
+      "dimension": "user_objection_revision_and_apply_boundary",
+      "message": "I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo.",
+      "message_sha256": "5f6b32b2c8c51cc594242ed9bdac849c744156ca2395efb7e8593c83c86286d4",
+      "prompt_id": "OOS-CHAIN-03",
+      "sequence": 3,
+      "wait_for_visible_reply_before_next": true
+    }
+  ],
+  "expected_proof_paths_after_authorized_run": {
+    "browser_provenance": "outputs/telegram-visible-unseen-chain-20260715/browser-provenance.json",
+    "capture_json": "outputs/telegram-visible-unseen-chain-20260715/capture.json",
+    "capture_receipt_json": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-capture-receipt-current.json",
+    "final_accessibility": "outputs/telegram-visible-unseen-chain-20260715/final-accessibility.txt",
+    "final_screenshot": "outputs/telegram-visible-unseen-chain-20260715/final.png",
+    "postflight_json": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-postflight-current.json",
+    "preflight_json": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-preflight-current.json",
+    "turn_accessibility": [
+      "outputs/telegram-visible-unseen-chain-20260715/turn-1-accessibility.txt",
+      "outputs/telegram-visible-unseen-chain-20260715/turn-2-accessibility.txt",
+      "outputs/telegram-visible-unseen-chain-20260715/turn-3-accessibility.txt"
+    ],
+    "turn_screenshots": [
+      "outputs/telegram-visible-unseen-chain-20260715/turn-1.png",
+      "outputs/telegram-visible-unseen-chain-20260715/turn-2.png",
+      "outputs/telegram-visible-unseen-chain-20260715/turn-3.png"
+    ]
+  },
+  "explicit_operator_authorization_text": "I authorize Codex to use the already-authenticated Chrome Telegram UI to send exactly these three messages, in order and with no additional messages, to the Telegram group Leo (chat ID -5146042086), waiting for Leo's visible reply after each turn: [OOS-CHAIN-01] \"Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet.\" [OOS-CHAIN-02] \"That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge.\" [OOS-CHAIN-03] \"I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo.\" Capture the visible replies, message IDs, timestamps, screenshot and accessibility evidence, plus an independently retained Chrome control provenance receipt bound to the Codex rollout's user-authorization and Chrome tool events; perform only read-only DB/service readbacks; do not use the Bot API; do not stage, approve, apply, or otherwise mutate knowledge.",
+  "generated_at_utc": "2026-07-15T02:33:20.290077+00:00",
+  "handler_receipt_binding": {
+    "deployed_git_head": "b3aa184dd4c721f6c40dc813dcefd5930f8ed417",
+    "fingerprint_sha256": "32a1f2c18f4b4c623443cbd4d9520982e9f291ec74ca63855cef51c88ac56f24",
+    "path": "docs/reports/leo-working-state-20260709/leo-unseen-reasoning-chain-canary-current.json",
+    "proof_tier": "live_vps_gatewayrunner_temp_profile_no_telegram_post_no_apply",
+    "remote_run_id": "d5702cafbb0b",
+    "schema": "livingip.leoUnseenReasoningChainReceipt.v2",
+    "sha256": "f4fcf0207484e5322074c7838f3a345d421c1664e5dc8d73b9199c4475b4cee8"
+  },
+  "manifest_binding": {
+    "execution_contract": {
+      "arbitrary_manifest_override_allowed": false,
+      "authenticated_role": "postgres",
+      "database": "teleo",
+      "default_transaction_read_only": "on",
+      "effective_role": "pg_read_all_data",
+      "psql_rc_disabled": true,
+      "transaction_read_only": "on"
+    },
+    "path": "ops/postgres_parity_manifest.sql",
+    "sha256": "8b8cdc25d54fdd8de05eb38c6e4423d2836953eb6012d4545f5c9c71b5f0150a"
+  },
+  "mode": "telegram_visible_unseen_chain_exact_packet_not_sent",
+  "mutates_db": false,
+  "next_non_user_action_after_authorization": [
+    "Re-run the zero-mutation preflight and confirm its packet file hash is current.",
+    "Use authenticated Chrome only and verify the Leo chat ID before typing anything.",
+    "Send one exact message, wait for Leo's visible reply, then continue to the next exact message.",
+    "Capture message IDs, timestamps, screenshot, accessibility text, and the Chrome-control provenance receipt without copying handler output.",
+    "Retain the Codex rollout path whose Chrome tool receipt contains the provenance SHA256.",
+    "Extract the selected DB object reference and run the read-only postflight with that reference.",
+    "Run the Telegram-visible verifier and accept T3 only if every visible and state check passes."
+  ],
+  "operator_context": {
+    "authorization_source": "codex_platform_user_message",
+    "codex_thread_id": "019f6350-3350-7040-b223-c5c22673fece"
+  },
+  "packet_generation_git_sha": "dfa6be6ba098b63b5856d03f499a44883b193e4f",
+  "production_apply_executed": false,
+  "protocol": {
+    "browser_provenance_contract": {
+      "capture_channel": "codex_chrome_extension",
+      "requires_browser_session_tab_and_capture_identifiers": true,
+      "requires_chrome_backend_tool_receipts": true,
+      "requires_codex_rollout_log_outside_evidence_root": true,
+      "requires_codex_user_message_authorization_receipt": true,
+      "requires_hashes_for_every_screenshot_and_accessibility_artifact": true,
+      "requires_preflight_challenge_nonce": true,
+      "requires_provenance_sha256_in_final_chrome_tool_receipt": true,
+      "requires_telegram_web_origin_and_chat_identity": true,
+      "schema": "livingip.authenticatedChromeTelegramCaptureProvenance.v1"
+    },
+    "exact_messages": [
+      {
+        "dimension": "independent_weak_claim_selection",
+        "message": "Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet.",
+        "message_sha256": "c63838b98448f4f4599e4cf2b004c6b36f602ad0d25c92e442a6f866cd2740fc",
+        "prompt_id": "OOS-CHAIN-01",
+        "sequence": 1,
+        "wait_for_visible_reply_before_next": true
+      },
+      {
+        "dimension": "challenge_body_evidence_and_candidates",
+        "message": "That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge.",
+        "message_sha256": "73346a98db4d7f74b49e1a5741b323d4216fd21f8346f6c4a4a69b1a6dd07946",
+        "prompt_id": "OOS-CHAIN-02",
+        "sequence": 2,
+        "wait_for_visible_reply_before_next": true
+      },
+      {
+        "dimension": "user_objection_revision_and_apply_boundary",
+        "message": "I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo.",
+        "message_sha256": "5f6b32b2c8c51cc594242ed9bdac849c744156ca2395efb7e8593c83c86286d4",
+        "prompt_id": "OOS-CHAIN-03",
+        "sequence": 3,
+        "wait_for_visible_reply_before_next": true
+      }
+    ],
+    "handler_binding": {
+      "deployed_git_head": "b3aa184dd4c721f6c40dc813dcefd5930f8ed417",
+      "fingerprint_sha256": "32a1f2c18f4b4c623443cbd4d9520982e9f291ec74ca63855cef51c88ac56f24",
+      "path": "docs/reports/leo-working-state-20260709/leo-unseen-reasoning-chain-canary-current.json",
+      "proof_tier": "live_vps_gatewayrunner_temp_profile_no_telegram_post_no_apply",
+      "remote_run_id": "d5702cafbb0b",
+      "schema": "livingip.leoUnseenReasoningChainReceipt.v2",
+      "sha256": "f4fcf0207484e5322074c7838f3a345d421c1664e5dc8d73b9199c4475b4cee8"
+    },
+    "manifest_binding": {
+      "execution_contract": {
+        "arbitrary_manifest_override_allowed": false,
+        "authenticated_role": "postgres",
+        "database": "teleo",
+        "default_transaction_read_only": "on",
+        "effective_role": "pg_read_all_data",
+        "psql_rc_disabled": true,
+        "transaction_read_only": "on"
+      },
+      "path": "ops/postgres_parity_manifest.sql",
+      "sha256": "8b8cdc25d54fdd8de05eb38c6e4423d2836953eb6012d4545f5c9c71b5f0150a"
+    },
+    "operator_context": {
+      "authorization_source": "codex_platform_user_message",
+      "codex_thread_id": "019f6350-3350-7040-b223-c5c22673fece"
+    },
+    "state_contract": {
+      "ordering": "preflight < authorization < send1 < reply1 < send2 < reply2 < send3 < reply3 < final/postflight",
+      "postflight": "same canonical fingerprint plus independent selected-object readback",
+      "preflight": "two identical repeatable-read read-only canonical fingerprints",
+      "service": "same active gateway process before and after"
+    },
+    "target": {
+      "allowed_transport": "authenticated_chrome_telegram_ui",
+      "chat_id": "-5146042086",
+      "chat_label": "Leo",
+      "expected_prompt_ids": [
+        "OOS-CHAIN-01",
+        "OOS-CHAIN-02",
+        "OOS-CHAIN-03"
+      ],
+      "forbidden_transports": [
+        "telegram_bot_api",
+        "copied_transcript",
+        "handler_substitution"
+      ],
+      "message_count": 3,
+      "platform": "telegram"
+    },
+    "tooling_binding": {
+      "capture_verifier": {
+        "path": "scripts/verify_telegram_visible_unseen_chain.py",
+        "sha256": "379f0f2258daea6ba565b7277fbba0c1907a37eafcd86b33e178137f24ecae2e"
+      },
+      "packet_builder": {
+        "path": "scripts/build_telegram_visible_unseen_chain_packet.py",
+        "sha256": "f8c5657bc1039a421356aa296ecfdb29578dc99c2db513835b0983be9e8a224c"
+      },
+      "state_collector": {
+        "path": "scripts/collect_telegram_visible_unseen_chain_state.py",
+        "sha256": "6adfc7750667374aa084ae2cd0e794876568bebb57478097697c2e0c9b981c7a"
+      }
+    }
+  },
+  "protocol_sha256": "91cba55a23cac9061ac34a827a040f27eb6a018f720586304dd9b08ed113af77",
+  "ready_to_request_action_time_authorization": true,
+  "schema": "livingip.telegramVisibleUnseenChainPacket.v2",
+  "target": {
+    "allowed_transport": "authenticated_chrome_telegram_ui",
+    "chat_id": "-5146042086",
+    "chat_label": "Leo",
+    "expected_prompt_ids": [
+      "OOS-CHAIN-01",
+      "OOS-CHAIN-02",
+      "OOS-CHAIN-03"
+    ],
+    "forbidden_transports": [
+      "telegram_bot_api",
+      "copied_transcript",
+      "handler_substitution"
+    ],
+    "message_count": 3,
+    "platform": "telegram"
+  },
+  "telegram_visible_message_authorization_present": false,
+  "telegram_visible_messages_sent": false,
+  "tooling_binding": {
+    "capture_verifier": {
+      "path": "scripts/verify_telegram_visible_unseen_chain.py",
+      "sha256": "379f0f2258daea6ba565b7277fbba0c1907a37eafcd86b33e178137f24ecae2e"
+    },
+    "packet_builder": {
+      "path": "scripts/build_telegram_visible_unseen_chain_packet.py",
+      "sha256": "f8c5657bc1039a421356aa296ecfdb29578dc99c2db513835b0983be9e8a224c"
+    },
+    "state_collector": {
+      "path": "scripts/collect_telegram_visible_unseen_chain_state.py",
+      "sha256": "6adfc7750667374aa084ae2cd0e794876568bebb57478097697c2e0c9b981c7a"
+    }
+  }
+}

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-authorization-packet-current.md

@@ -0,0 +1,81 @@
+# Telegram-Visible Unseen Chain Authorization Packet
+
+Generated UTC: `2026-07-15T02:33:20.290077+00:00`
+Protocol SHA256: `91cba55a23cac9061ac34a827a040f27eb6a018f720586304dd9b08ed113af77`
+Ready to request action-time authorization: `True`
+Telegram-visible messages sent: `False`
+Mutates DB: `False`
+
+## Exact Destination
+
+- Chat: `Leo` (`-5146042086`)
+- Transport: `authenticated_chrome_telegram_ui`
+
+## Exact Messages
+
+### 1. OOS-CHAIN-01
+
+Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet.
+
+SHA256: `c63838b98448f4f4599e4cf2b004c6b36f602ad0d25c92e442a6f866cd2740fc`
+
+### 2. OOS-CHAIN-02
+
+That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge.
+
+SHA256: `73346a98db4d7f74b49e1a5741b323d4216fd21f8346f6c4a4a69b1a6dd07946`
+
+### 3. OOS-CHAIN-03
+
+I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo.
+
+SHA256: `5f6b32b2c8c51cc594242ed9bdac849c744156ca2395efb7e8593c83c86286d4`
+
+## Read-Only State Contract
+
+- Manifest: `ops/postgres_parity_manifest.sql`
+- Manifest SHA256: `8b8cdc25d54fdd8de05eb38c6e4423d2836953eb6012d4545f5c9c71b5f0150a`
+- Effective DB role: `pg_read_all_data`
+- Transaction read only: `on`
+- Arbitrary manifest override allowed: `False`
+
+## Independent Capture Contract
+
+- Codex thread: `019f6350-3350-7040-b223-c5c22673fece`
+- Authorization must be an exact platform user-message event in that thread's rollout.
+- Each turn and final artifact must be bound by Chrome-backend tool receipts in that rollout.
+
+## Checks
+
+- `authenticated_chrome_is_only_send_transport`: `True`
+- `canonical_manifest_path_and_sha_bound`: `True`
+- `database_session_and_role_fail_closed_read_only`: `True`
+- `exact_prompts_imported_from_handler_verifier`: `True`
+- `exact_three_turn_sequence`: `True`
+- `first_prompt_supplies_no_row_id`: `True`
+- `handler_checks_all_pass`: `True`
+- `handler_outcomes_all_pass`: `True`
+- `handler_prompt_ids_exact`: `True`
+- `handler_proved_no_telegram_post`: `True`
+- `handler_proved_read_only_tool_traces`: `True`
+- `handler_proved_unchanged_fingerprint`: `True`
+- `handler_receipt_passed`: `True`
+- `handler_receipt_schema_supported`: `True`
+- `handler_safety_gate_passed`: `True`
+- `handler_tier_remains_below_telegram_visible`: `True`
+- `independent_browser_provenance_required`: `True`
+- `packet_does_not_mutate_database`: `True`
+- `packet_does_not_send`: `True`
+
+## Exact Action-Time Authorization
+
+I authorize Codex to use the already-authenticated Chrome Telegram UI to send exactly these three messages, in order and with no additional messages, to the Telegram group Leo (chat ID -5146042086), waiting for Leo's visible reply after each turn: [OOS-CHAIN-01] "Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet." [OOS-CHAIN-02] "That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge." [OOS-CHAIN-03] "I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo." Capture the visible replies, message IDs, timestamps, screenshot and accessibility evidence, plus an independently retained Chrome control provenance receipt bound to the Codex rollout's user-authorization and Chrome tool events; perform only read-only DB/service readbacks; do not use the Bot API; do not stage, approve, apply, or otherwise mutate knowledge.
+
+## Clear CTA
+
+Reply with the exact authorization sentence in this packet. That sentence names the destination, transport, complete message bodies, ordering, evidence, and no-mutation boundary.
+
+## Claim Ceiling
+
+Current tier: `T0_spec_plus_prior_T2_handler_evidence`
+Required tier: `T3_live_readonly`

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-capture-receipt-current.json

@@ -0,0 +1,120 @@
+{
+  "capture_template": {
+    "capture_source": {
+      "browser_provenance": "",
+      "captured_at_utc": "",
+      "captured_by": "",
+      "chat_id": "-5146042086",
+      "chat_label": "Leo",
+      "final_accessibility": "",
+      "final_capture_reuse_reason": "",
+      "final_capture_reuses_turn_3": false,
+      "final_screenshot": "",
+      "platform": "telegram",
+      "transport": "authenticated_chrome_telegram_ui"
+    },
+    "extra_messages_sent": 0,
+    "messages": [
+      {
+        "prompt_id": "OOS-CHAIN-01",
+        "reply": "",
+        "reply_at_utc": "",
+        "reply_message_id": "",
+        "sent_at_utc": "",
+        "sent_text": "Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet.",
+        "sequence": 1,
+        "telegram_message_id": "",
+        "turn_accessibility": "",
+        "turn_screenshot": ""
+      },
+      {
+        "prompt_id": "OOS-CHAIN-02",
+        "reply": "",
+        "reply_at_utc": "",
+        "reply_message_id": "",
+        "sent_at_utc": "",
+        "sent_text": "That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge.",
+        "sequence": 2,
+        "telegram_message_id": "",
+        "turn_accessibility": "",
+        "turn_screenshot": ""
+      },
+      {
+        "prompt_id": "OOS-CHAIN-03",
+        "reply": "",
+        "reply_at_utc": "",
+        "reply_message_id": "",
+        "sent_at_utc": "",
+        "sent_text": "I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo.",
+        "sequence": 3,
+        "telegram_message_id": "",
+        "turn_accessibility": "",
+        "turn_screenshot": ""
+      }
+    ],
+    "operator_authorization_captured_at_utc": "",
+    "operator_authorization_text": "I authorize Codex to use the already-authenticated Chrome Telegram UI to send exactly these three messages, in order and with no additional messages, to the Telegram group Leo (chat ID -5146042086), waiting for Leo's visible reply after each turn: [OOS-CHAIN-01] \"Looking at what Leo currently believes about collective intelligence or coordination, pick one claim that would matter to a founder making a product decision but seems more confident than its support. Do not ask me for an ID. Show what the database actually says and what supports it, then tell me the first narrower claim you would test. Do not change anything yet.\" [OOS-CHAIN-02] \"That still feels like you are polishing the same idea. Inspect the exact body and evidence you just chose: what is assumption versus observed support, what would falsify it, and which replacement claim or claims would you put into review? Keep them as proposals, not live knowledge.\" [OOS-CHAIN-03] \"I disagree with your first replacement because it jumps from a mechanism to a business outcome. Revise it with that objection, tell me what source would resolve the disagreement, and show the approval and apply boundary before it could become part of Leo.\" Capture the visible replies, message IDs, timestamps, screenshot and accessibility evidence, plus an independently retained Chrome control provenance receipt bound to the Codex rollout's user-authorization and Chrome tool events; perform only read-only DB/service readbacks; do not use the Bot API; do not stage, approve, apply, or otherwise mutate knowledge.",
+    "preflight_state_token_sha256": "410677869ca2854f38b3e5017de2c682a2625d751fdff6600ac9bc40ce2fbc2e",
+    "protocol_sha256": "91cba55a23cac9061ac34a827a040f27eb6a018f720586304dd9b08ed113af77",
+    "schema": "livingip.telegramVisibleUnseenChainCapture.v1"
+  },
+  "checks": {
+    "action_time_authorization_present": false,
+    "capture_present": false,
+    "manifest_arbitrary_override_forbidden": true,
+    "manifest_canonical_path_exists": true,
+    "manifest_default_transaction_read_only_enforced": true,
+    "manifest_effective_role_is_read_only": true,
+    "manifest_override_absent_or_exact_canonical_path": true,
+    "manifest_packet_path_is_exact_canonical_relative_path": true,
+    "manifest_packet_sha256_matches_canonical_file": true,
+    "manifest_protocol_binding_matches_packet": true,
+    "manifest_psql_rc_disabled": true,
+    "manifest_sql_statically_read_only": true,
+    "manifest_transaction_read_only_enforced": true,
+    "packet_check_section_present_and_passing": true,
+    "packet_does_not_mutate_db": true,
+    "packet_has_no_authorization_recorded": true,
+    "packet_messages_exact": true,
+    "packet_not_sent": true,
+    "packet_prompt_ids_exact": true,
+    "packet_protocol_sha256_derivation_valid": true,
+    "packet_protocol_sha256_present": true,
+    "packet_protocol_top_level_bindings_match": true,
+    "packet_ready_for_authorization_request": true,
+    "packet_requires_authenticated_chrome": true,
+    "packet_schema_supported": true,
+    "packet_targets_exact_leo_chat": true,
+    "packet_tooling_hashes_match_current_sources": true,
+    "postflight_present": false,
+    "preflight_baseline_checks_all_pass": true,
+    "preflight_manifest_bound": true,
+    "preflight_packet_checks_all_pass": true,
+    "preflight_packet_file_hash_bound": true,
+    "preflight_protocol_bound": true,
+    "preflight_remote_checks_all_pass": true,
+    "preflight_schema_supported": true,
+    "preflight_state_token_derivation_valid": true,
+    "preflight_status_and_phase_pass": true
+  },
+  "claim_ceiling": {
+    "not_proven": [
+      "Telegram-visible message delivery",
+      "Telegram-visible Leo replies",
+      "post-send fingerprint equality"
+    ],
+    "proven": "The exact packet and live zero-mutation preflight are ready."
+  },
+  "current_tier": "T0_packet_plus_T3_preflight",
+  "generated_at_utc": "2026-07-15T02:34:03.994153+00:00",
+  "mode": "telegram_visible_unseen_chain_capture_verifier",
+  "mutates_db": false,
+  "packet_path": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-authorization-packet-current.json",
+  "postflight_path": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-postflight-current.json",
+  "preflight_path": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-preflight-current.json",
+  "receipt_ready": false,
+  "required_tier": "T3_live_readonly",
+  "schema": "livingip.telegramVisibleUnseenChainReceipt.v2",
+  "status": "awaiting_action_time_authorization",
+  "telegram_visible_messages_sent": false
+}

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-capture-receipt-current.md

@@ -0,0 +1,58 @@
+# Telegram-Visible Unseen Chain Capture Receipt
+
+Generated UTC: `2026-07-15T02:34:03.994153+00:00`
+Status: `awaiting_action_time_authorization`
+Receipt ready: `False`
+Current tier: `T0_packet_plus_T3_preflight`
+Required tier: `T3_live_readonly`
+Telegram-visible messages sent: `False`
+Mutates DB: `False`
+
+## Checks
+
+- `action_time_authorization_present`: `False`
+- `capture_present`: `False`
+- `manifest_arbitrary_override_forbidden`: `True`
+- `manifest_canonical_path_exists`: `True`
+- `manifest_default_transaction_read_only_enforced`: `True`
+- `manifest_effective_role_is_read_only`: `True`
+- `manifest_override_absent_or_exact_canonical_path`: `True`
+- `manifest_packet_path_is_exact_canonical_relative_path`: `True`
+- `manifest_packet_sha256_matches_canonical_file`: `True`
+- `manifest_protocol_binding_matches_packet`: `True`
+- `manifest_psql_rc_disabled`: `True`
+- `manifest_sql_statically_read_only`: `True`
+- `manifest_transaction_read_only_enforced`: `True`
+- `packet_check_section_present_and_passing`: `True`
+- `packet_does_not_mutate_db`: `True`
+- `packet_has_no_authorization_recorded`: `True`
+- `packet_messages_exact`: `True`
+- `packet_not_sent`: `True`
+- `packet_prompt_ids_exact`: `True`
+- `packet_protocol_sha256_derivation_valid`: `True`
+- `packet_protocol_sha256_present`: `True`
+- `packet_protocol_top_level_bindings_match`: `True`
+- `packet_ready_for_authorization_request`: `True`
+- `packet_requires_authenticated_chrome`: `True`
+- `packet_schema_supported`: `True`
+- `packet_targets_exact_leo_chat`: `True`
+- `packet_tooling_hashes_match_current_sources`: `True`
+- `postflight_present`: `False`
+- `preflight_baseline_checks_all_pass`: `True`
+- `preflight_manifest_bound`: `True`
+- `preflight_packet_checks_all_pass`: `True`
+- `preflight_packet_file_hash_bound`: `True`
+- `preflight_protocol_bound`: `True`
+- `preflight_remote_checks_all_pass`: `True`
+- `preflight_schema_supported`: `True`
+- `preflight_state_token_derivation_valid`: `True`
+- `preflight_status_and_phase_pass`: `True`
+
+## Awaiting Authorized Capture
+
+The packet and preflight are ready. No Telegram message has been sent by this verifier.
+A future T3 receipt also requires the exact platform authorization event and Chrome-backend capture receipts from the bound Codex rollout log.
+
+## Claim Ceiling
+
+The exact packet and live zero-mutation preflight are ready.

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-goal-readback-current.json

@@ -0,0 +1,41 @@
+{
+  "fallback_goal_path": "goal.md",
+  "expanded_active_scope": [
+    "canonical manifest path and SHA binding with pre-SSH write rejection",
+    "independent read-only Postgres session and pg_read_all_data effective role",
+    "supported artifact schemas, passing check sections, and derived state tokens",
+    "strict timezone-aware authorization/send/reply/capture/postflight chronology",
+    "evidence-root containment, valid PNG metadata, and distinct per-turn hashes",
+    "Codex rollout-backed user authorization and Chrome capture provenance",
+    "full local-forgery regression"
+  ],
+  "generated_at_utc": "2026-07-15T02:30:26Z",
+  "platform_goal_after": {
+    "objective": "Complete and verify the Telegram-visible unseen challenge-to-revision canary defined in this goal file while proving zero database mutation.",
+    "status": "active",
+    "thread_id": "019f6350-3350-7040-b223-c5c22673fece"
+  },
+  "platform_goal_before": null,
+  "platform_goal_current": {
+    "objective": "Complete and verify the Telegram-visible unseen challenge-to-revision canary defined in this goal file while proving zero database mutation.",
+    "status": "active",
+    "thread_id": "019f6350-3350-7040-b223-c5c22673fece",
+    "time_used_seconds_at_readback": 4474,
+    "tokens_used_at_readback": 886585
+  },
+  "platform_goal_repair_action": "create_goal",
+  "platform_goal_replaced": false,
+  "platform_goal_scope_update_action": "continued_existing_active_goal_and_expanded_fallback_acceptance_scope",
+  "platform_goal_scope_update_after": {
+    "objective": "Complete and verify the Telegram-visible unseen challenge-to-revision canary defined in this goal file while proving zero database mutation.",
+    "status": "active",
+    "thread_id": "019f6350-3350-7040-b223-c5c22673fece"
+  },
+  "platform_goal_scope_update_before": {
+    "objective": "Complete and verify the Telegram-visible unseen challenge-to-revision canary defined in this goal file while proving zero database mutation.",
+    "status": "active",
+    "thread_id": "019f6350-3350-7040-b223-c5c22673fece"
+  },
+  "schema": "livingip.telegramVisibleUnseenChainGoalReadback.v1",
+  "why_not_replaced": "The active objective already covers T3 Telegram-visible and zero-mutation acceptance. The platform Goal API exposes only complete/blocked status updates while active, so replacing or falsely completing it would be incorrect; expanded integrity acceptance is retained in goal.md and this readback."
+}

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-nonsend-proof-current.json

@@ -0,0 +1,83 @@
+{
+  "cleanup_readback": {
+    "collector_or_verifier_processes_remaining": [],
+    "status": "clean"
+  },
+  "generated_at_utc": "2026-07-15T02:39:17Z",
+  "live_preflight": {
+    "canonical_fingerprint_sha256": "32a1f2c18f4b4c623443cbd4d9520982e9f291ec74ca63855cef51c88ac56f24",
+    "canonical_fingerprint_unchanged_across_two_snapshots": true,
+    "capture_challenge_nonce": "0a03b4e74a4533d3bb657d7b07fb48888293d7ba217e776f3c2c120764afe086",
+    "deployed_git_stamp": "626bac493e2b772db984be7a4a68e9da656f6b02",
+    "effective_database_role": "pg_read_all_data",
+    "gateway_main_pid": "347406",
+    "gateway_restarts": "0",
+    "manifest_path": "ops/postgres_parity_manifest.sql",
+    "manifest_sha256": "8b8cdc25d54fdd8de05eb38c6e4423d2836953eb6012d4545f5c9c71b5f0150a",
+    "mutates_db": false,
+    "packet_file_sha256": "76fb81d055a726de580d1c0ed75784b4576729e8e67badb6a4574677b2447ed0",
+    "path": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-preflight-current.json",
+    "preflight_file_sha256": "7705534b35921c7c27fb40acd1277c6ed07ceae114014d074737160f65d4cc6f",
+    "protocol_sha256": "91cba55a23cac9061ac34a827a040f27eb6a018f720586304dd9b08ed113af77",
+    "readback_attempts": {
+      "deploy": 1,
+      "fingerprint_after": 1,
+      "fingerprint_before": 1,
+      "service_after": 1,
+      "service_before": 1
+    },
+    "state_token_sha256": "410677869ca2854f38b3e5017de2c682a2625d751fdff6600ac9bc40ce2fbc2e",
+    "status": "pass",
+    "table_count": 39,
+    "tooling_hashes_match_current_sources": true,
+    "total_rows": 52167,
+    "transaction_read_only": "on",
+    "workspace_head_matches_deployed_stamp": true
+  },
+  "not_tested": [
+    "Telegram message delivery",
+    "Telegram-visible Leo replies",
+    "action-time authorization and authenticated-Chrome capture backed by the bound Codex rollout",
+    "post-send selected-object readback",
+    "post-send canonical fingerprint equality"
+  ],
+  "proof_paths": [
+    "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-authorization-packet-current.json",
+    "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-preflight-current.json",
+    "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-capture-receipt-current.json",
+    "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-goal-readback-current.json"
+  ],
+  "receipt_hashes": {
+    "authorization_packet_sha256": "76fb81d055a726de580d1c0ed75784b4576729e8e67badb6a4574677b2447ed0",
+    "capture_receipt_sha256": "0573aed8ceaf04c186afa68b5bf1c6687b76059b00725d33f87939f84b2e5401",
+    "preflight_sha256": "7705534b35921c7c27fb40acd1277c6ed07ceae114014d074737160f65d4cc6f"
+  },
+  "schema": "livingip.telegramVisibleUnseenChainNonsendProof.v1",
+  "send_boundary": {
+    "action_time_authorization_present": false,
+    "authenticated_chrome_used": false,
+    "telegram_visible_messages_sent": false
+  },
+  "tests": [
+    {
+      "command": "/Users/user/Documents/Codex/2026-07-09/019f34eb-d297-72d0-b7e2-b222d5515ab9-load/work/teleo-infra-main/.venv/bin/pytest -q tests/test_verify_leo_unseen_reasoning_chain.py tests/test_build_telegram_visible_unseen_chain_packet.py tests/test_collect_telegram_visible_unseen_chain_state.py tests/test_verify_telegram_visible_unseen_chain.py",
+      "result": "42 passed in 4.19s"
+    },
+    {
+      "command": "/Users/user/Documents/Codex/2026-07-09/019f34eb-d297-72d0-b7e2-b222d5515ab9-load/work/teleo-infra-main/.venv/bin/pytest -q",
+      "result": "1319 passed in 81.44s"
+    },
+    {
+      "command": "/Users/user/Documents/Codex/2026-07-09/019f34eb-d297-72d0-b7e2-b222d5515ab9-load/work/teleo-infra-main/.venv/bin/ruff check scripts/build_telegram_visible_unseen_chain_packet.py scripts/collect_telegram_visible_unseen_chain_state.py scripts/verify_telegram_visible_unseen_chain.py tests/test_build_telegram_visible_unseen_chain_packet.py tests/test_collect_telegram_visible_unseen_chain_state.py tests/test_verify_telegram_visible_unseen_chain.py",
+      "result": "All checks passed"
+    },
+    {
+      "command": "/Users/user/Documents/Codex/2026-07-09/019f34eb-d297-72d0-b7e2-b222d5515ab9-load/work/teleo-infra-main/.venv/bin/ruff format --check scripts/build_telegram_visible_unseen_chain_packet.py scripts/collect_telegram_visible_unseen_chain_state.py scripts/verify_telegram_visible_unseen_chain.py tests/test_build_telegram_visible_unseen_chain_packet.py tests/test_collect_telegram_visible_unseen_chain_state.py tests/test_verify_telegram_visible_unseen_chain.py",
+      "result": "6 files already formatted"
+    },
+    {
+      "command": "git diff --check",
+      "result": "pass"
+    }
+  ]
+}

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-preflight-current.json

@@ -0,0 +1,149 @@
+{
+  "baseline_checks": {},
+  "baseline_path": "",
+  "baseline_state_token_sha256": "",
+  "blocker_readback": {
+    "attempted_routes": [
+      "local exact packet validation",
+      "SSH deploy stamp and gateway service readback",
+      "two canonical repeatable-read read-only Postgres parity manifests"
+    ],
+    "clear_CTA": "Use the packet's exact authorization sentence only when ready to cross the send boundary.",
+    "current_canary": "Read-only pre-send readiness for the exact three-turn unseen Leo chain in Telegram",
+    "exact_gate": "",
+    "next_non_user_action": "Run the authenticated-Chrome three-turn flow only after exact authorization, then collect postflight."
+  },
+  "capture_challenge_nonce": "0a03b4e74a4533d3bb657d7b07fb48888293d7ba217e776f3c2c120764afe086",
+  "claim_ceiling": {
+    "current_tier": "T3_live_readonly",
+    "not_proven": [
+      "Telegram-visible delivery or reply behavior",
+      "authorization to send Telegram messages",
+      "canonical mutation"
+    ],
+    "proven": "Two canonical read-only snapshots and the gateway process were unchanged during this probe."
+  },
+  "generated_at_utc": "2026-07-15T02:33:56.887524+00:00",
+  "manifest_binding": {
+    "execution_contract": {
+      "arbitrary_manifest_override_allowed": false,
+      "authenticated_role": "postgres",
+      "database": "teleo",
+      "default_transaction_read_only": "on",
+      "effective_role": "pg_read_all_data",
+      "psql_rc_disabled": true,
+      "transaction_read_only": "on"
+    },
+    "path": "ops/postgres_parity_manifest.sql",
+    "sha256": "8b8cdc25d54fdd8de05eb38c6e4423d2836953eb6012d4545f5c9c71b5f0150a"
+  },
+  "mode": "telegram_visible_unseen_chain_zero_mutation_state_readback",
+  "mutates_db": false,
+  "packet_checks": {
+    "manifest_arbitrary_override_forbidden": true,
+    "manifest_canonical_path_exists": true,
+    "manifest_default_transaction_read_only_enforced": true,
+    "manifest_effective_role_is_read_only": true,
+    "manifest_loaded_bytes_match_bound_sha256": true,
+    "manifest_loaded_bytes_revalidated_read_only": true,
+    "manifest_override_absent_or_exact_canonical_path": true,
+    "manifest_packet_path_is_exact_canonical_relative_path": true,
+    "manifest_packet_sha256_matches_canonical_file": true,
+    "manifest_protocol_binding_matches_packet": true,
+    "manifest_psql_rc_disabled": true,
+    "manifest_sql_statically_read_only": true,
+    "manifest_transaction_read_only_enforced": true,
+    "packet_check_section_present_and_passing": true,
+    "packet_does_not_mutate_db": true,
+    "packet_has_no_authorization_recorded": true,
+    "packet_messages_exact": true,
+    "packet_not_sent": true,
+    "packet_prompt_ids_exact": true,
+    "packet_protocol_sha256_derivation_valid": true,
+    "packet_protocol_sha256_present": true,
+    "packet_protocol_top_level_bindings_match": true,
+    "packet_ready_for_authorization_request": true,
+    "packet_requires_authenticated_chrome": true,
+    "packet_schema_supported": true,
+    "packet_targets_exact_leo_chat": true,
+    "packet_tooling_hashes_match_current_sources": true
+  },
+  "packet_file_sha256": "76fb81d055a726de580d1c0ed75784b4576729e8e67badb6a4574677b2447ed0",
+  "packet_path": "docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-authorization-packet-current.json",
+  "phase": "preflight",
+  "production_apply_executed": false,
+  "protocol_sha256": "91cba55a23cac9061ac34a827a040f27eb6a018f720586304dd9b08ed113af77",
+  "ready_for_action_time_authorization": true,
+  "ready_for_visible_capture_verification": false,
+  "remote": {
+    "deploy_head": "626bac493e2b772db984be7a4a68e9da656f6b02",
+    "deploy_stamp_ancestor": true,
+    "fingerprint_after": {
+      "current_user": "pg_read_all_data",
+      "fingerprint_sha256": "32a1f2c18f4b4c623443cbd4d9520982e9f291ec74ca63855cef51c88ac56f24",
+      "schema": "livingip.teleoCanonicalDatabaseFingerprint.v1",
+      "status": "ok",
+      "structure_sha256": "61bf482330a652ebdb419de3fb78196f2c7d25d1a482b100f385e8102c8e8d52",
+      "table_count": 39,
+      "table_rows_sha256": "f50d86fc3ce699f602bdc0029485bd901fd98bd8114eecd5dcc4346a0f52112a",
+      "total_rows": 52167,
+      "transaction_read_only": "on"
+    },
+    "fingerprint_before": {
+      "current_user": "pg_read_all_data",
+      "fingerprint_sha256": "32a1f2c18f4b4c623443cbd4d9520982e9f291ec74ca63855cef51c88ac56f24",
+      "schema": "livingip.teleoCanonicalDatabaseFingerprint.v1",
+      "status": "ok",
+      "structure_sha256": "61bf482330a652ebdb419de3fb78196f2c7d25d1a482b100f385e8102c8e8d52",
+      "table_count": 39,
+      "table_rows_sha256": "f50d86fc3ce699f602bdc0029485bd901fd98bd8114eecd5dcc4346a0f52112a",
+      "total_rows": 52167,
+      "transaction_read_only": "on"
+    },
+    "last_deploy_sha": "626bac493e2b772db984be7a4a68e9da656f6b02",
+    "readback_attempts": {
+      "deploy": 1,
+      "fingerprint_after": 1,
+      "fingerprint_before": 1,
+      "service_after": 1,
+      "service_before": 1
+    },
+    "service_after": {
+      "ActiveState": "active",
+      "ExecMainStartTimestamp": "Tue 2026-07-14 22:59:43 UTC",
+      "MainPID": "347406",
+      "NRestarts": "0",
+      "SubState": "running"
+    },
+    "service_before": {
+      "ActiveState": "active",
+      "ExecMainStartTimestamp": "Tue 2026-07-14 22:59:43 UTC",
+      "MainPID": "347406",
+      "NRestarts": "0",
+      "SubState": "running"
+    },
+    "subject_readback": null,
+    "workspace_head_matches_deployed_stamp": true
+  },
+  "remote_checks": {
+    "canonical_fingerprint_unchanged_during_probe": true,
+    "deployed_stamp_is_ancestor_of_workspace_head": true,
+    "deployed_stamp_is_sha": true,
+    "fingerprints_are_read_only": true,
+    "fingerprints_use_independent_read_only_role": true,
+    "first_fingerprint_complete": true,
+    "second_fingerprint_complete": true,
+    "service_active_before_and_after": true,
+    "service_identity_complete": true,
+    "service_process_unchanged_during_probe": true,
+    "ssh_readbacks_succeeded": true,
+    "workspace_head_is_sha": true
+  },
+  "remote_returncode": 0,
+  "remote_stderr": "",
+  "schema": "livingip.telegramVisibleUnseenChainState.v2",
+  "state_token_sha256": "410677869ca2854f38b3e5017de2c682a2625d751fdff6600ac9bc40ce2fbc2e",
+  "status": "pass",
+  "subject_ref": "",
+  "telegram_visible_messages_sent_by_collector": false
+}

docs/reports/leo-working-state-20260709/telegram-visible-unseen-chain-preflight-current.md

@@ -0,0 +1,70 @@
+# Telegram-Visible Unseen Chain Preflight
+
+Generated UTC: `2026-07-15T02:33:56.887524+00:00`
+Status: `pass`
+Protocol SHA256: `91cba55a23cac9061ac34a827a040f27eb6a018f720586304dd9b08ed113af77`
+Packet file SHA256: `76fb81d055a726de580d1c0ed75784b4576729e8e67badb6a4574677b2447ed0`
+State token SHA256: `410677869ca2854f38b3e5017de2c682a2625d751fdff6600ac9bc40ce2fbc2e`
+Messages sent by collector: `False`
+Mutates DB: `False`
+
+## Checks
+
+- `manifest_arbitrary_override_forbidden`: `True`
+- `manifest_canonical_path_exists`: `True`
+- `manifest_default_transaction_read_only_enforced`: `True`
+- `manifest_effective_role_is_read_only`: `True`
+- `manifest_loaded_bytes_match_bound_sha256`: `True`
+- `manifest_loaded_bytes_revalidated_read_only`: `True`
+- `manifest_override_absent_or_exact_canonical_path`: `True`
+- `manifest_packet_path_is_exact_canonical_relative_path`: `True`
+- `manifest_packet_sha256_matches_canonical_file`: `True`
+- `manifest_protocol_binding_matches_packet`: `True`
+- `manifest_psql_rc_disabled`: `True`
+- `manifest_sql_statically_read_only`: `True`
+- `manifest_transaction_read_only_enforced`: `True`
+- `packet_check_section_present_and_passing`: `True`
+- `packet_does_not_mutate_db`: `True`
+- `packet_has_no_authorization_recorded`: `True`
+- `packet_messages_exact`: `True`
+- `packet_not_sent`: `True`
+- `packet_prompt_ids_exact`: `True`
+- `packet_protocol_sha256_derivation_valid`: `True`
+- `packet_protocol_sha256_present`: `True`
+- `packet_protocol_top_level_bindings_match`: `True`
+- `packet_ready_for_authorization_request`: `True`
+- `packet_requires_authenticated_chrome`: `True`
+- `packet_schema_supported`: `True`
+- `packet_targets_exact_leo_chat`: `True`
+- `packet_tooling_hashes_match_current_sources`: `True`
+- `canonical_fingerprint_unchanged_during_probe`: `True`
+- `deployed_stamp_is_ancestor_of_workspace_head`: `True`
+- `deployed_stamp_is_sha`: `True`
+- `fingerprints_are_read_only`: `True`
+- `fingerprints_use_independent_read_only_role`: `True`
+- `first_fingerprint_complete`: `True`
+- `second_fingerprint_complete`: `True`
+- `service_active_before_and_after`: `True`
+- `service_identity_complete`: `True`
+- `service_process_unchanged_during_probe`: `True`
+- `ssh_readbacks_succeeded`: `True`
+- `workspace_head_is_sha`: `True`
+
+## Live Readback
+
+- Deploy head: `626bac493e2b772db984be7a4a68e9da656f6b02`
+- Deploy stamp: `626bac493e2b772db984be7a4a68e9da656f6b02`
+- Gateway MainPID: `347406`
+- Gateway NRestarts: `0`
+- Manifest: `ops/postgres_parity_manifest.sql`
+- Manifest SHA256: `8b8cdc25d54fdd8de05eb38c6e4423d2836953eb6012d4545f5c9c71b5f0150a`
+- Effective DB role: `pg_read_all_data`
+- Transaction read only: `on`
+- Canonical fingerprint: `32a1f2c18f4b4c623443cbd4d9520982e9f291ec74ca63855cef51c88ac56f24`
+- Canonical tables: `39`
+- Canonical rows: `52167`
+- Selected object ref: ``
+
+## Claim Ceiling
+
+Two canonical read-only snapshots and the gateway process were unchanged during this probe.

docs/reports/observatory-read-adapter/gcp-staging-current-gate.json

@@ -0,0 +1,40 @@
+{
+  "schema": "livingip.observatoryReadAdapterCurrentGate.v1",
+  "current_canary": "Authenticated GET /v1/claims/sample in GCP staging returns a provenance-bearing teleo_canonical claim, anonymous GET returns 401, and authenticated POST returns 405.",
+  "permission_profile": "approval_policy_never_with_unrestricted_filesystem_and_network",
+  "attempted_routes": [
+    {
+      "route": "merged GitHub Actions deployment with artifact-builder WIF",
+      "result": "image build, smoke, and push passed; deploy stopped because run.googleapis.com is disabled"
+    },
+    {
+      "route": "local billy@livingip.xyz gcloud user credential",
+      "result": "token refresh and service enable both stop at noninteractive Google reauthentication"
+    },
+    {
+      "route": "local application-default credential",
+      "result": "token refresh stops at noninteractive Google reauthentication"
+    },
+    {
+      "route": "other locally authenticated Google accounts",
+      "result": "valid tokens but no access to project teleo-501523"
+    },
+    {
+      "route": "fixed read-only GCP IAP status workflow",
+      "result": "WIF token exchange failed because the teleo-iap-operator provider target is missing or disabled"
+    },
+    {
+      "route": "local browser or computer-use session",
+      "result": "no browser or computer-use tool is exposed to this task; no foreground takeover was attempted"
+    }
+  ],
+  "exact_gate": {
+    "first_infrastructure_gate": "Cloud Run Admin API run.googleapis.com is disabled in teleo-501523.",
+    "current_authorization_gate": "The only local account authorized for teleo-501523, billy@livingip.xyz, requires Google password or MFA reauthentication before project APIs and staging IAM resources can be changed.",
+    "alternate_private_operator_gate": "The read-only teleo-iap-operator WIF provider returns invalid_target and cannot reach its status operation."
+  },
+  "why_autonomous_repair_stops": "Google password or MFA reauthentication is a human-only credential boundary, and no authenticated project-admin browser or computer-use surface is available in this task.",
+  "clear_CTA": "Run `gcloud auth login billy@livingip.xyz --update-adc`, complete Google password or MFA, and then report `GCP reauth complete`.",
+  "next_non_user_action": "Enable the required staging APIs; create or verify the runtime service account, API-key secret, Cloud SQL IAM database user, and exact read-only role grants; deploy the retained immutable image; capture authenticated GET, anonymous 401, authenticated POST 405, SQL write-denial, exact service/database identity, and cleanup receipts.",
+  "production_boundary": "Do not change Vercel, production routing, Cloud SQL network exposure, or any write endpoint."
+}

docs/reports/observatory-read-adapter/gcp-staging-live-attempt-redacted.json

@@ -0,0 +1,55 @@
+{
+  "schema": "livingip.observatoryReadAdapterStagingReceipt.v1",
+  "status": "blocked_before_runtime_creation",
+  "required_runtime_tier": "T3_live_gcp_staging_api",
+  "current_runtime_tier": "below_T3_build_artifact_only",
+  "project_id": "teleo-501523",
+  "region": "europe-west6",
+  "service_name": "observatory-read-adapter-staging",
+  "database_name": "teleo_canonical",
+  "cloud_sql_instance": "teleo-501523:europe-west6:teleo-pgvector-standby",
+  "authorization_role": "kb_observatory_read",
+  "runtime_service_account": "sa-observatory-read-adapter@teleo-501523.iam.gserviceaccount.com",
+  "image": {
+    "revision": "53c8de0a1959a744e17888df1a70e935dfef0143",
+    "digest": "sha256:b5c9b2051559730cbb9003d74e5d8e577fa2f43f49b72577f251f2843a0650c5",
+    "artifact_registry_push": "pass",
+    "container_smoke": "pass",
+    "intentional_retained_resource": true
+  },
+  "workflow": {
+    "run_id": 29382683335,
+    "url": "https://github.com/living-ip/teleo-infrastructure/actions/runs/29382683335",
+    "build_job": "success",
+    "deploy_job": "failure",
+    "failure_class": "SERVICE_DISABLED",
+    "failure_detail": "run.googleapis.com is disabled in teleo-501523",
+    "authenticated_as": "sa-artifact-builder@teleo-501523.iam.gserviceaccount.com"
+  },
+  "live_receipts": {
+    "service_url": null,
+    "authenticated_get_sample": null,
+    "anonymous_get_401": null,
+    "authenticated_post_405": null,
+    "database_write_denial": null,
+    "database_identity": null
+  },
+  "negative_claims": {
+    "cloud_run_service_created": false,
+    "cloud_sql_public_exposure_changed": false,
+    "production_or_vercel_routing_changed": false,
+    "credentials_logged": false
+  },
+  "cleanup": {
+    "github_jobs_completed": true,
+    "local_observatory_test_containers": 0,
+    "local_observatory_test_images": 0,
+    "orphan_local_build_processes": 0,
+    "artifact_registry_image_retained_for_next_deploy": true
+  },
+  "proof_paths": [
+    "/private/tmp/observatory-read-adapter-run-29382683335/observatory-adapter-image/observatory-adapter-image.txt",
+    "/private/tmp/observatory-iap-status-29382844567/gcp-iap-operator-29382844567/result.json"
+  ],
+  "claim_ceiling": "The immutable staging image exists, but no live API or database query receipt exists. T3 is not complete."
+}

docs/reports/observatory-read-adapter/platform-goal-current.json

@@ -0,0 +1,12 @@
+{
+  "fallback_goal_path": "goal.md",
+  "platform_goal_after": {
+    "objective": "Complete and verify the private GCP Observatory read adapter defined in this goal file, stopping before production repoint without exact authorization.",
+    "status": "active",
+    "thread_id": "019f6350-69fa-71f3-944b-3fc0065f4fec"
+  },
+  "platform_goal_before": null,
+  "platform_goal_repair_action": "create_goal",
+  "platform_goal_replaced": false,
+  "why_not_replaced": "No prior platform Goal existed; a new active Goal was created from goal.md."
+}

fixtures/working-leo/document-ingestion-v2.scenario.json

@@ -0,0 +1,52 @@
+{
+  "schema": "livingip.workingLeoSourceIngestionScenario.v2",
+  "artifact": {
+    "path": "document-ingestion-v2.txt",
+    "format": "plain_text"
+  },
+  "source": {
+    "identity": "document:working-leo-review-gated-composition-v2",
+    "source_key": "working_leo_document_ingestion_v2",
+    "source_type": "article",
+    "title": "Working Leo review-gated composition note",
+    "locator": "fixture://working-leo/document-ingestion-v2",
+    "metadata": {
+      "author": "Working Leo synthetic canary fixture",
+      "captured_at": "2026-07-15T00:00:00Z",
+      "document_kind": "operating_note",
+      "language": "en",
+      "synthetic": true
+    }
+  },
+  "extractor": {
+    "name": "deterministic_fixture_replay",
+    "version": "2"
+  },
+  "extraction": {
+    "claims": [
+      {
+        "claim_key": "staged_proposal_remains_noncanonical",
+        "type": "structural",
+        "confidence": 0.75,
+        "text": "A staged knowledge proposal remains non-canonical until review and guarded apply succeed.",
+        "body": "A staged proposal remains non-canonical until an operator reviews it and a separate guarded apply succeeds.",
+        "metadata": {
+          "needs_research": false
+        },
+        "evidence": [
+          {
+            "segment_id": "paragraph-2",
+            "role": "grounds",
+            "excerpt": "A staged proposal remains non-canonical until an operator reviews it and a separate guarded apply succeeds.",
+            "metadata": {
+              "evidence_kind": "exact_quote"
+            }
+          }
+        ],
+        "edges": []
+      }
+    ],
+    "duplicates": [],
+    "conflicts": []
+  }
+}

fixtures/working-leo/document-ingestion-v2.txt

@@ -0,0 +1,5 @@
+Working Leo composition note. A newly captured document may produce claim and evidence candidates, but those candidates are not canonical knowledge.
+
+A staged proposal remains non-canonical until an operator reviews it and a separate guarded apply succeeds. The proposal must retain the source content hash, exact evidence excerpt, and source identity so reviewers can trace every planned row back to the captured artifact.
+
+For a staging-only rehearsal, pending_review is the terminal state. No public knowledge-base row should be written.

fixtures/working-leo/leo-identity-v1/hermes-runtime/agent/prompt_builder.py

@@ -0,0 +1,3 @@
+"""Pinned fixture prompt boundary."""
+
+GENERATED_SOUL_IS_AUTHORITY = False

fixtures/working-leo/leo-identity-v1/hermes-runtime/gateway/run.py

@@ -0,0 +1,3 @@
+"""Pinned fixture process boundary; the canary uses the real profile verifier."""
+
+SESSION_STATE_IS_IDENTITY = False

fixtures/working-leo/leo-identity-v1/hermes-runtime/hermes_cli/tools_config.py

@@ -0,0 +1,3 @@
+"""Pinned fixture tool configuration."""
+
+ALLOWED_TOOLS = ("identity_readback",)

fixtures/working-leo/leo-identity-v1/hermes-runtime/run_agent.py

@@ -0,0 +1,3 @@
+"""Pinned fixture entrypoint for the disposable identity runtime."""
+
+RUNTIME_NAME = "leo-identity-readback-v1"

fixtures/working-leo/leo-identity-v1/hermes-runtime/tools/registry.py

@@ -0,0 +1,3 @@
+"""Pinned fixture registry for the no-send identity readback tool."""
+
+REGISTERED_TOOLS = ("identity_readback",)

fixtures/working-leo/leo-identity-v1/leo-constitution-v1.json

@@ -0,0 +1,18 @@
+{
+  "identity_name": "Leo",
+  "rules": [
+    {
+      "id": "canonical-evidence",
+      "text": "Treat canonical database rows and their bound evidence as durable knowledge; never promote session memory to evidence."
+    },
+    {
+      "id": "review-before-apply",
+      "text": "Proposals may be prepared, but review and guarded apply remain separate authorized actions."
+    },
+    {
+      "id": "truthful-proof-tier",
+      "text": "State exactly what was observed, separate inference from proof, and fail closed when required provenance drifts."
+    }
+  ],
+  "schema": "livingip.leoConstitutionSource.v1"
+}

fixtures/working-leo/leo-identity-v1/leo-database-fingerprint-v1.json

@@ -0,0 +1,25 @@
+{
+  "environment": "disposable_fixture",
+  "fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+  "read_consistency": {
+    "after": {
+      "database": "leo_identity_fixture",
+      "database_user": "leo_identity_reader",
+      "system_identifier": "7649789040005668902",
+      "wal_lsn": "0/16B6C50"
+    },
+    "before": {
+      "database": "leo_identity_fixture",
+      "database_user": "leo_identity_reader",
+      "system_identifier": "7649789040005668902",
+      "wal_lsn": "0/16B6C50"
+    },
+    "status": "stable_wal_marker"
+  },
+  "schema": "livingip.teleoCanonicalDatabaseFingerprint.v1",
+  "status": "ok",
+  "structure_sha256": "3333333333333333333333333333333333333333333333333333333333333333",
+  "table_count": 7,
+  "table_rows_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
+  "total_rows": 7
+}

fixtures/working-leo/leo-identity-v1/leo-database-identity-v1.json

@@ -0,0 +1,58 @@
+{
+  "database_fingerprint_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
+  "identity_name": "Leo",
+  "source_provenance": {
+    "canonical_authority_granted": false,
+    "export_receipt_sha256": null,
+    "mode": "synthetic_noncanonical_fixture",
+    "same_transaction_as_fingerprint": false
+  },
+  "records": [
+    {
+      "evidence_sha256": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+      "kind": "persona",
+      "rank": 0,
+      "row_id": "11111111-1111-4111-8111-111111111111",
+      "status": "active",
+      "table": "public.personas",
+      "text": "Leo is the evidence-bound reasoning interface for the Teleo collective."
+    },
+    {
+      "evidence_sha256": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+      "kind": "strategy",
+      "rank": 0,
+      "row_id": "22222222-2222-4222-8222-222222222222",
+      "status": "active",
+      "table": "public.strategies",
+      "text": "Prefer source-grounded synthesis that exposes uncertainty and review boundaries."
+    },
+    {
+      "evidence_sha256": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
+      "kind": "belief",
+      "rank": 0,
+      "row_id": "33333333-3333-4333-8333-333333333333",
+      "status": "active",
+      "table": "public.beliefs",
+      "text": "A plausible answer without provenance is weaker than a bounded answer with an exact receipt."
+    },
+    {
+      "evidence_sha256": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
+      "kind": "shared_root",
+      "rank": 0,
+      "row_id": "44444444-4444-4444-8444-444444444444",
+      "status": "active",
+      "table": "public.shared_root",
+      "text": "Collective intelligence must remain inspectable, reversible, and accountable to evidence."
+    },
+    {
+      "evidence_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+      "kind": "strategy_node",
+      "rank": 1,
+      "row_id": "55555555-5555-4555-8555-555555555555",
+      "status": "active",
+      "table": "public.strategy_nodes",
+      "text": "Compile identity from exact canonical inputs and reject drift before runtime startup."
+    }
+  ],
+  "schema": "livingip.leoDatabaseIdentitySource.v1"
+}

fixtures/working-leo/leo-identity-v1/profile-template/bin/identity_readback.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python3
+"""Fixture marker for the no-send identity readback tool."""
+
+ACCESS_MODE = "read_only"
+NETWORK_SEND_ENABLED = False

fixtures/working-leo/leo-identity-v1/profile-template/config.yaml

@@ -0,0 +1,24 @@
+model:
+  provider: fixture-local
+  default: leo-identity-readback-v1
+  smart_routing: false
+  max_tokens: 512
+agent:
+  reasoning_effort: deterministic
+memory:
+  enabled: false
+  search: disabled
+gateway:
+  execution_mode: local_no_send
+  telegram:
+    posting_enabled: false
+    bot_token: fixture-value-is-never-emitted-or-identity-hashed
+tools:
+  allowed:
+    - identity_readback
+  write_enabled: false
+identity_runtime:
+  network_send_enabled: false
+  database_write_enabled: false
+  allowed_tools:
+    - identity_readback

fixtures/working-leo/leo-identity-v1/profile-template/plugins/identity-boundary/__init__.py

@@ -0,0 +1,4 @@
+"""Fixture marker for the pinned identity-boundary middleware."""
+
+IDENTITY_VIEW_IS_AUTHORITY = False
+SESSION_MEMORY_IS_EVIDENCE = False

fixtures/working-leo/leo-identity-v1/profile-template/plugins/identity-boundary/plugin.yaml

@@ -0,0 +1,3 @@
+name: identity-boundary
+version: 1
+description: Reject startup when a compiled identity view drifts.

fixtures/working-leo/leo-identity-v1/profile-template/skills/identity-readback/SKILL.md

@@ -0,0 +1,8 @@
+---
+name: identity-readback
+description: Explain the pinned Leo identity and its noncanonical session boundary.
+---
+
+Read only the compiled identity view and its manifest receipt. Never treat a
+session transcript, generated SOUL file, or unverified runtime memory as a
+canonical source.

fixtures/working-leo/telegram-transcript-ingestion-v1.jsonl

@@ -0,0 +1,3 @@
+{"ts":"2026-07-15T09:00:01Z","chat_id":900001,"chat_title":"Synthetic review gate thread","message_id":7301,"type":"message","username":"fixture_analyst","display_name":"Fixture Analyst","user_id":910001,"message":"A pending review does not change canonical knowledge; only a separate guarded apply can do that.","reply_to":null,"synthetic":true}
+{"ts":"2026-07-15T09:00:12Z","chat_id":900001,"chat_title":"Synthetic review gate thread","message_id":7302,"type":"message","username":"fixture_operator","display_name":"Fixture Operator","user_id":910002,"message":"Reviewer approval alone makes the proposal canonical immediately; no apply step is needed.","reply_to":7301,"synthetic":true}
+{"ts":"2026-07-15T09:00:24Z","chat_id":900001,"chat_title":"Synthetic review gate thread","message_id":7303,"type":"message","username":"fixture_reviewer","display_name":"Fixture Reviewer","user_id":910003,"message":"A pending review does not change canonical knowledge; only a separate guarded apply can do that.","reply_to":7302,"synthetic":true}

fixtures/working-leo/telegram-transcript-ingestion-v1.scenario.json

@@ -0,0 +1,99 @@
+{
+  "schema": "livingip.workingLeoSourceIngestionScenario.v2",
+  "artifact": {
+    "path": "telegram-transcript-ingestion-v1.jsonl",
+    "format": "telegram_jsonl"
+  },
+  "source": {
+    "identity": "fixture:telegram-chat-900001-export-20260715",
+    "source_key": "telegram_review_gate_exchange_20260715",
+    "source_type": "transcript",
+    "title": "Synthetic Telegram review-gate exchange",
+    "locator": "fixture://working-leo/telegram-transcript-ingestion-v1",
+    "metadata": {
+      "captured_at": "2026-07-15T09:01:00Z",
+      "export_format": "teleo_append_only_telegram_jsonl",
+      "language": "en",
+      "synthetic": true
+    }
+  },
+  "extractor": {
+    "name": "deterministic_telegram_jsonl_replay",
+    "version": "1"
+  },
+  "extraction": {
+    "claims": [
+      {
+        "claim_key": "pending_review_does_not_change_canonical",
+        "type": "structural",
+        "confidence": 0.7,
+        "text": "Pending review alone does not change canonical knowledge.",
+        "body": "A pending review does not change canonical knowledge; only a separate guarded apply can do that.",
+        "metadata": {
+          "needs_research": false
+        },
+        "evidence": [
+          {
+            "segment_id": "message-900001-7301",
+            "role": "grounds",
+            "excerpt": "A pending review does not change canonical knowledge; only a separate guarded apply can do that.",
+            "metadata": {
+              "evidence_kind": "exact_message"
+            }
+          },
+          {
+            "segment_id": "message-900001-7303",
+            "role": "illustrates",
+            "excerpt": "A pending review does not change canonical knowledge; only a separate guarded apply can do that.",
+            "metadata": {
+              "evidence_kind": "duplicate_exact_message"
+            }
+          }
+        ],
+        "edges": [
+          {
+            "edge_type": "contradicts",
+            "target": "approval_alone_makes_canonical"
+          }
+        ]
+      },
+      {
+        "claim_key": "approval_alone_makes_canonical",
+        "type": "empirical",
+        "confidence": 0.4,
+        "text": "Reviewer approval alone makes a proposal canonical without apply.",
+        "body": "Reviewer approval alone makes the proposal canonical immediately; no apply step is needed.",
+        "metadata": {
+          "needs_research": true
+        },
+        "evidence": [
+          {
+            "segment_id": "message-900001-7302",
+            "role": "grounds",
+            "excerpt": "Reviewer approval alone makes the proposal canonical immediately; no apply step is needed.",
+            "metadata": {
+              "evidence_kind": "exact_message"
+            }
+          }
+        ],
+        "edges": []
+      }
+    ],
+    "duplicates": [
+      {
+        "segment_id": "message-900001-7303",
+        "duplicate_of_claim_key": "pending_review_does_not_change_canonical",
+        "excerpt": "A pending review does not change canonical knowledge; only a separate guarded apply can do that.",
+        "reason": "Message 7303 repeats message 7301 exactly and is retained as explicit duplicate evidence."
+      }
+    ],
+    "conflicts": [
+      {
+        "from_claim_key": "pending_review_does_not_change_canonical",
+        "to_claim_key": "approval_alone_makes_canonical",
+        "relationship": "contradicts",
+        "reason": "The two candidate propositions assert incompatible canonical-state transitions."
+      }
+    ]
+  }
+}

observatory_read_adapter/__init__.py

@@ -0,0 +1,6 @@
+"""Authenticated, read-only Observatory adapter for canonical Teleo claims."""
+
+from .app import create_app
+from .config import Settings
+
+__all__ = ["Settings", "create_app"]

observatory_read_adapter/__main__.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import logging
+
+from aiohttp import web
+
+from .app import create_app
+from .config import Settings
+
+
+def main() -> None:
+    logging.basicConfig(level=logging.INFO)
+    settings = Settings.from_env()
+    web.run_app(create_app(settings), host="0.0.0.0", port=settings.port)
+
+
+if __name__ == "__main__":
+    main()

observatory_read_adapter/app.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import asyncio
+import hmac
+import logging
+import uuid
+from typing import Any
+
+from aiohttp import web
+
+from .config import Settings
+from .db import CloudSqlClaimReader
+
+logger = logging.getLogger("teleo.observatory_read_adapter")
+
+SETTINGS_KEY = web.AppKey("observatory_settings", Settings)
+READER_KEY = web.AppKey("observatory_reader", object)
+PUBLIC_PATHS = frozenset({"/healthz", "/readyz"})
+
+
+def _private_json(payload: dict[str, Any], *, status: int = 200) -> web.Response:
+    response = web.json_response(payload, status=status)
+    response.headers["Cache-Control"] = "private, no-store, max-age=0"
+    response.headers["Pragma"] = "no-cache"
+    response.headers["Vary"] = "X-Api-Key"
+    response.headers["X-Content-Type-Options"] = "nosniff"
+    return response
+
+
+@web.middleware
+async def api_key_auth(request: web.Request, handler: Any) -> web.StreamResponse:
+    if request.path in PUBLIC_PATHS:
+        return await handler(request)
+    settings = request.app[SETTINGS_KEY]
+    provided = request.headers.get("X-Api-Key", "")
+    try:
+        authenticated = hmac.compare_digest(
+            provided.encode("ascii"),
+            settings.api_key.encode("ascii"),
+        )
+    except UnicodeEncodeError:
+        authenticated = False
+    if not authenticated:
+        return _private_json({"error": "unauthorized"}, status=401)
+    return await handler(request)
+
+
+async def healthz(_request: web.Request) -> web.Response:
+    return web.json_response({"status": "ok"})
+
+
+async def readyz(request: web.Request) -> web.Response:
+    reader = request.app[READER_KEY]
+    try:
+        await asyncio.wait_for(asyncio.to_thread(reader.check_ready), timeout=12.0)
+    except Exception as exc:
+        logger.warning("readiness check failed (%s)", type(exc).__name__)
+        return web.json_response({"status": "unavailable"}, status=503)
+    return web.json_response({"status": "ready"})
+
+
+async def get_sample_claim(request: web.Request) -> web.Response:
+    return await _claim_response(request, None)
+
+
+async def get_claim(request: web.Request) -> web.Response:
+    raw_claim_id = request.match_info["claim_id"]
+    try:
+        claim_id = str(uuid.UUID(raw_claim_id))
+    except ValueError:
+        return _private_json({"error": "invalid_claim_id"}, status=400)
+    return await _claim_response(request, claim_id)
+
+
+async def _claim_response(request: web.Request, claim_id: str | None) -> web.Response:
+    reader = request.app[READER_KEY]
+    try:
+        payload = await asyncio.wait_for(
+            asyncio.to_thread(reader.read_claim, claim_id),
+            timeout=12.0,
+        )
+    except Exception as exc:
+        logger.error("canonical claim read failed (%s)", type(exc).__name__)
+        return _private_json({"error": "canonical_claim_unavailable"}, status=503)
+    if payload is None:
+        return _private_json({"error": "claim_not_found"}, status=404)
+    return _private_json(payload)
+
+
+async def _cleanup(app: web.Application) -> None:
+    reader = app[READER_KEY]
+    await asyncio.to_thread(reader.close)
+
+
+def create_app(
+    settings: Settings | None = None,
+    *,
+    reader: Any | None = None,
+) -> web.Application:
+    settings = settings or Settings.from_env()
+    settings.validate()
+    reader = reader or CloudSqlClaimReader(settings)
+    app = web.Application(middlewares=[api_key_auth], client_max_size=16 * 1024)
+    app[SETTINGS_KEY] = settings
+    app[READER_KEY] = reader
+    app.router.add_get("/healthz", healthz)
+    app.router.add_get("/readyz", readyz)
+    app.router.add_get("/v1/claims/sample", get_sample_claim)
+    app.router.add_get("/v1/claims/{claim_id}", get_claim)
+    app.on_cleanup.append(_cleanup)
+    return app

observatory_read_adapter/config.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+
+EXPECTED_PROJECT = "teleo-501523"
+EXPECTED_REGION = "europe-west6"
+EXPECTED_INSTANCE = "teleo-pgvector-standby"
+EXPECTED_CONNECTION_NAME = f"{EXPECTED_PROJECT}:{EXPECTED_REGION}:{EXPECTED_INSTANCE}"
+EXPECTED_DATABASE = "teleo_canonical"
+EXPECTED_AUTHORIZATION_ROLE = "kb_observatory_read"
+
+
+@dataclass(frozen=True)
+class Settings:
+    project_id: str
+    instance_connection_name: str
+    database: str
+    iam_database_user: str
+    authorization_role: str
+    api_key: str = field(repr=False)
+    service_revision: str = "unknown"
+    port: int = 8080
+
+    @classmethod
+    def from_env(cls) -> Settings:
+        settings = cls(
+            project_id=os.environ.get("GCP_PROJECT_ID", ""),
+            instance_connection_name=os.environ.get("CLOUD_SQL_INSTANCE", ""),
+            database=os.environ.get("DB_NAME", ""),
+            iam_database_user=os.environ.get("DB_IAM_USER", ""),
+            authorization_role=os.environ.get("DB_AUTHORIZATION_ROLE", ""),
+            api_key=os.environ.get("OBSERVATORY_API_KEY", ""),
+            service_revision=os.environ.get("SERVICE_REVISION", "unknown"),
+            port=int(os.environ.get("PORT", "8080")),
+        )
+        settings.validate()
+        return settings
+
+    def validate(self) -> None:
+        if self.project_id != EXPECTED_PROJECT:
+            raise ValueError(f"GCP_PROJECT_ID must be {EXPECTED_PROJECT}")
+        if self.instance_connection_name != EXPECTED_CONNECTION_NAME:
+            raise ValueError(f"CLOUD_SQL_INSTANCE must be {EXPECTED_CONNECTION_NAME}")
+        if self.database != EXPECTED_DATABASE:
+            raise ValueError(f"DB_NAME must be {EXPECTED_DATABASE}")
+        if self.authorization_role != EXPECTED_AUTHORIZATION_ROLE:
+            raise ValueError(f"DB_AUTHORIZATION_ROLE must be {EXPECTED_AUTHORIZATION_ROLE}")
+        if not self.iam_database_user.endswith(f"@{EXPECTED_PROJECT}.iam"):
+            raise ValueError("DB_IAM_USER must be the scoped Cloud SQL service-account user")
+        if any(character.isspace() for character in self.iam_database_user):
+            raise ValueError("DB_IAM_USER must not contain whitespace")
+        if (
+            len(self.api_key) < 32
+            or len(self.api_key) > 512
+            or not self.api_key.isascii()
+            or any(character.isspace() for character in self.api_key)
+        ):
+            raise ValueError("OBSERVATORY_API_KEY must be 32-512 non-whitespace ASCII characters")
+        if not 1 <= self.port <= 65535:
+            raise ValueError("PORT is outside the valid TCP port range")

observatory_read_adapter/db.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from datetime import date, datetime, timezone
+from decimal import Decimal
+from typing import Any
+
+from .config import Settings
+
+ConnectionFactory = Callable[[], Any]
+
+
+class ReaderContractError(RuntimeError):
+    """The live database session does not match the adapter's read-only contract."""
+
+
+def _json_value(value: Any) -> Any:
+    if isinstance(value, Decimal):
+        return float(value)
+    if isinstance(value, (date, datetime)):
+        return value.isoformat()
+    if isinstance(value, tuple):
+        return list(value)
+    return value
+
+
+def _column_name(column: Any) -> str:
+    return str(column.name) if hasattr(column, "name") else str(column[0])
+
+
+def _row_dict(cursor: Any, row: Any) -> dict[str, Any] | None:
+    if row is None:
+        return None
+    names = [_column_name(column) for column in cursor.description]
+    return {name: _json_value(value) for name, value in zip(names, row, strict=True)}
+
+
+def _rows(cursor: Any) -> list[dict[str, Any]]:
+    names = [_column_name(column) for column in cursor.description]
+    return [
+        {name: _json_value(value) for name, value in zip(names, row, strict=True)}
+        for row in cursor.fetchall()
+    ]
+
+
+class CloudSqlClaimReader:
+    def __init__(self, settings: Settings, *, connection_factory: ConnectionFactory | None = None):
+        self.settings = settings
+        self._connector: Any | None = None
+        if connection_factory is not None:
+            self._connection_factory = connection_factory
+            return
+
+        from google.cloud.sql.connector import Connector, IPTypes
+
+        self._connector = Connector(refresh_strategy="LAZY")
+
+        def connect() -> Any:
+            return self._connector.connect(
+                settings.instance_connection_name,
+                "pg8000",
+                user=settings.iam_database_user,
+                db=settings.database,
+                enable_iam_auth=True,
+                ip_type=IPTypes.PRIVATE,
+            )
+
+        self._connection_factory = connect
+
+    def close(self) -> None:
+        if self._connector is not None:
+            self._connector.close()
+
+    def check_ready(self) -> dict[str, Any]:
+        connection = self._connection_factory()
+        try:
+            cursor = connection.cursor()
+            self._begin_read_only(cursor)
+            session = self._load_session_contract(cursor)
+            connection.rollback()
+            return {
+                "ready": True,
+                "database": session["database"],
+                "authorization_role": self.settings.authorization_role,
+                "transaction_read_only": True,
+            }
+        finally:
+            connection.close()
+
+    def read_claim(self, claim_id: str | None = None) -> dict[str, Any] | None:
+        connection = self._connection_factory()
+        try:
+            cursor = connection.cursor()
+            self._begin_read_only(cursor)
+            session = self._load_session_contract(cursor)
+            claim = self._load_claim(cursor, claim_id)
+            if claim is None:
+                connection.rollback()
+                return None
+
+            evidence = self._load_evidence(cursor, claim["id"])
+            edges = self._load_edges(cursor, claim["id"])
+            proposal_counts = self._load_proposal_counts(cursor)
+            related_proposals = self._load_related_proposals(cursor, claim["id"])
+            recent_proposals = self._load_recent_proposals(cursor)
+            connection.rollback()
+        finally:
+            connection.close()
+
+        generated_at = datetime.now(timezone.utc).isoformat()
+        return {
+            "schema": "livingip.observatory-canonical-claim.v1",
+            "generated_at": generated_at,
+            "read_only": True,
+            "provenance": {
+                "gcp_project": self.settings.project_id,
+                "cloud_sql_instance": self.settings.instance_connection_name,
+                "database": session["database"],
+                "database_principal": session["database_principal"],
+                "authorization_role": self.settings.authorization_role,
+                "transaction_read_only": True,
+                "write_privileges_denied": bool(session["required_writes_denied"]),
+                "service_revision": self.settings.service_revision,
+            },
+            "canonical": {
+                "relation": "public.claims",
+                "claim": claim,
+                "evidence_relation": "public.claim_evidence -> public.sources",
+                "evidence": evidence,
+                "edge_relation": "public.claim_edges",
+                "edges": edges,
+            },
+            "proposal_ledger": {
+                "relation": "kb_stage.kb_proposals",
+                "distinct_from_canonical": True,
+                "status_counts": proposal_counts,
+                "related": related_proposals,
+                "recent": recent_proposals,
+                "semantics": {
+                    "pending_review": "staged only; not canonical",
+                    "approved": "reviewed intent; not canonical until applied_at is set",
+                    "applied": "proposal receipt only; canonical rows remain authoritative",
+                },
+            },
+        }
+
+    @staticmethod
+    def _begin_read_only(cursor: Any) -> None:
+        cursor.execute("set transaction read only")
+        cursor.execute("set local statement_timeout = '5000ms'")
+        cursor.execute("set local lock_timeout = '1000ms'")
+
+    def _load_session_contract(self, cursor: Any) -> dict[str, Any]:
+        cursor.execute(
+            """
+            select current_database() as database,
+                   current_user as database_principal,
+                   current_setting('transaction_read_only') as transaction_read_only,
+                   pg_has_role(current_user, %s, 'member') as has_authorization_role,
+                   has_table_privilege(current_user, 'public.claims', 'select')
+                     and has_table_privilege(current_user, 'public.sources', 'select')
+                     and has_table_privilege(current_user, 'public.claim_evidence', 'select')
+                     and has_table_privilege(current_user, 'public.claim_edges', 'select')
+                     and has_table_privilege(current_user, 'kb_stage.kb_proposals', 'select')
+                     as has_required_reads,
+                   not (
+                     has_table_privilege(current_user, 'public.claims', 'insert,update,delete,truncate')
+                     or has_table_privilege(current_user, 'public.sources', 'insert,update,delete,truncate')
+                     or has_table_privilege(current_user, 'public.claim_evidence', 'insert,update,delete,truncate')
+                     or has_table_privilege(current_user, 'public.claim_edges', 'insert,update,delete,truncate')
+                     or has_table_privilege(current_user, 'kb_stage.kb_proposals', 'insert,update,delete,truncate')
+                   ) as required_writes_denied
+            """,
+            (self.settings.authorization_role,),
+        )
+        session = _row_dict(cursor, cursor.fetchone())
+        if session is None:
+            raise ReaderContractError("database session contract returned no row")
+        if session["database"] != self.settings.database:
+            raise ReaderContractError("database session selected an unexpected database")
+        if session["database_principal"] != self.settings.iam_database_user:
+            raise ReaderContractError("database session selected an unexpected principal")
+        if session["transaction_read_only"] != "on":
+            raise ReaderContractError("database session is not read-only")
+        if not session["has_authorization_role"] or not session["has_required_reads"]:
+            raise ReaderContractError("database principal lacks the exact read authorization")
+        if not session["required_writes_denied"]:
+            raise ReaderContractError("database principal has an unexpected write privilege")
+        return session
+
+    @staticmethod
+    def _load_claim(cursor: Any, claim_id: str | None) -> dict[str, Any] | None:
+        columns = """
+            select c.id::text as id,
+                   c.type::text as type,
+                   left(c.text, 12000) as text,
+                   c.status::text as status,
+                   c.confidence,
+                   coalesce(c.tags, '{}'::text[]) as tags,
+                   c.superseded_by::text as superseded_by,
+                   c.created_at,
+                   c.updated_at
+              from public.claims c
+        """
+        if claim_id is not None:
+            cursor.execute(columns + " where c.id = %s::uuid", (claim_id,))
+            return _row_dict(cursor, cursor.fetchone())
+
+        cursor.execute(
+            columns
+            + """
+             where exists (
+               select 1 from public.claim_evidence ce where ce.claim_id = c.id
+             )
+             order by coalesce(c.updated_at, c.created_at) desc, c.id desc
+             limit 1
+            """
+        )
+        claim = _row_dict(cursor, cursor.fetchone())
+        if claim is not None:
+            return claim
+        cursor.execute(columns + " order by coalesce(c.updated_at, c.created_at) desc, c.id desc limit 1")
+        return _row_dict(cursor, cursor.fetchone())
+
+    @staticmethod
+    def _load_evidence(cursor: Any, claim_id: str) -> list[dict[str, Any]]:
+        cursor.execute(
+            """
+            select ce.id::text as evidence_id,
+                   ce.role::text as role,
+                   ce.weight,
+                   ce.created_at as linked_at,
+                   s.id::text as source_id,
+                   s.source_type::text as source_type,
+                   s.url,
+                   s.storage_path,
+                   left(coalesce(s.excerpt, ''), 2400) as excerpt,
+                   s.hash as content_hash,
+                   s.captured_at,
+                   s.created_at as source_created_at
+              from public.claim_evidence ce
+              join public.sources s on s.id = ce.source_id
+             where ce.claim_id = %s::uuid
+             order by ce.weight desc nulls last, ce.created_at, ce.id
+             limit 30
+            """,
+            (claim_id,),
+        )
+        return _rows(cursor)
+
+    @staticmethod
+    def _load_edges(cursor: Any, claim_id: str) -> list[dict[str, Any]]:
+        cursor.execute(
+            """
+            select e.id::text as edge_id,
+                   case when e.from_claim = %s::uuid then 'outgoing' else 'incoming' end as direction,
+                   e.edge_type::text as edge_type,
+                   e.weight,
+                   case when e.from_claim = %s::uuid then e.to_claim::text else e.from_claim::text end
+                     as connected_claim_id,
+                   e.created_at
+              from public.claim_edges e
+             where e.from_claim = %s::uuid or e.to_claim = %s::uuid
+             order by e.created_at, e.id
+             limit 40
+            """,
+            (claim_id, claim_id, claim_id, claim_id),
+        )
+        return _rows(cursor)
+
+    @staticmethod
+    def _load_proposal_counts(cursor: Any) -> dict[str, int]:
+        cursor.execute(
+            "select status::text as status, count(*)::int as count "
+            "from kb_stage.kb_proposals group by status order by status"
+        )
+        return {str(status): int(count) for status, count in cursor.fetchall()}
+
+    @staticmethod
+    def _load_related_proposals(cursor: Any, claim_id: str) -> list[dict[str, Any]]:
+        cursor.execute(
+            """
+            select p.id::text as id,
+                   p.proposal_type::text as proposal_type,
+                   p.status::text as status,
+                   to_jsonb(p)->>'source_ref' as source_ref,
+                   p.reviewed_at,
+                   p.applied_at,
+                   p.updated_at
+              from kb_stage.kb_proposals p
+             where p.payload::text like %s
+             order by p.updated_at desc, p.id desc
+             limit 20
+            """,
+            (f"%{claim_id}%",),
+        )
+        return _rows(cursor)
+
+    @staticmethod
+    def _load_recent_proposals(cursor: Any) -> list[dict[str, Any]]:
+        cursor.execute(
+            """
+            select p.id::text as id,
+                   p.proposal_type::text as proposal_type,
+                   p.status::text as status,
+                   to_jsonb(p)->>'source_ref' as source_ref,
+                   p.reviewed_at,
+                   p.applied_at,
+                   p.updated_at
+              from kb_stage.kb_proposals p
+             order by p.updated_at desc, p.id desc
+             limit 10
+            """
+        )
+        return _rows(cursor)

ops/observatory_read_role.sql

@@ -0,0 +1,183 @@
+\set ON_ERROR_STOP on
+\getenv observatory_iam_user OBSERVATORY_DB_IAM_USER
+
+-- Provision only after Cloud SQL has created the dedicated IAM database user.
+-- The service-account username omits the .gserviceaccount.com suffix.
+select set_config('observatory.iam_user', :'observatory_iam_user', false);
+
+do $preflight$
+declare
+  principal text := current_setting('observatory.iam_user');
+begin
+  if current_database() <> 'teleo_canonical' then
+    raise exception 'observatory_read_role must run only in teleo_canonical';
+  end if;
+  if principal !~ '^[a-z0-9-]+@teleo-501523[.]iam$' then
+    raise exception 'OBSERVATORY_DB_IAM_USER is not the scoped GCP service-account database user';
+  end if;
+  if not exists (select 1 from pg_catalog.pg_roles where rolname = principal) then
+    raise exception 'Cloud SQL IAM database user does not exist: %', principal;
+  end if;
+end
+$preflight$;
+
+select 'create role kb_observatory_read nologin nosuperuser nocreatedb nocreaterole noinherit noreplication nobypassrls connection limit -1'
+where not exists (select 1 from pg_catalog.pg_roles where rolname = 'kb_observatory_read')
+\gexec
+
+alter role kb_observatory_read
+  with nologin nosuperuser nocreatedb nocreaterole noinherit noreplication nobypassrls connection limit -1
+  password null;
+alter role kb_observatory_read reset all;
+
+revoke all privileges on database teleo_canonical from kb_observatory_read;
+grant connect on database teleo_canonical to kb_observatory_read;
+
+revoke all on schema public, kb_stage from kb_observatory_read;
+revoke all privileges on all tables in schema public, kb_stage from kb_observatory_read;
+revoke all privileges on all sequences in schema public, kb_stage from kb_observatory_read;
+revoke all privileges on all functions in schema public, kb_stage from kb_observatory_read;
+revoke all privileges on all procedures in schema public, kb_stage from kb_observatory_read;
+
+select format(
+         'revoke all privileges (%s) on table %I.%I from kb_observatory_read',
+         pg_catalog.string_agg(pg_catalog.quote_ident(attribute.attname), ', ' order by attribute.attnum),
+         namespace.nspname,
+         relation.relname
+       )
+  from pg_catalog.pg_class relation
+  join pg_catalog.pg_namespace namespace on namespace.oid = relation.relnamespace
+  join pg_catalog.pg_attribute attribute on attribute.attrelid = relation.oid
+ where namespace.nspname in ('public', 'kb_stage')
+   and relation.relkind in ('r', 'p', 'v', 'm', 'f')
+   and attribute.attnum > 0
+   and not attribute.attisdropped
+ group by namespace.nspname, relation.relname
+\gexec
+
+grant usage on schema public, kb_stage to kb_observatory_read;
+grant select on
+  public.claims,
+  public.sources,
+  public.claim_evidence,
+  public.claim_edges,
+  kb_stage.kb_proposals
+to kb_observatory_read;
+
+do $membership$
+declare
+  principal text := current_setting('observatory.iam_user');
+  unexpected text;
+begin
+  select pg_catalog.string_agg(granted.rolname, ', ' order by granted.rolname)
+    into unexpected
+    from pg_catalog.pg_auth_members membership
+    join pg_catalog.pg_roles granted on granted.oid = membership.roleid
+    join pg_catalog.pg_roles member on member.oid = membership.member
+   where member.rolname = principal
+     and granted.rolname <> 'kb_observatory_read';
+  if unexpected is not null then
+    raise exception 'dedicated Observatory principal has unexpected role memberships: %', unexpected;
+  end if;
+
+  select pg_catalog.string_agg(member.rolname, ', ' order by member.rolname)
+    into unexpected
+    from pg_catalog.pg_auth_members membership
+    join pg_catalog.pg_roles granted on granted.oid = membership.roleid
+    join pg_catalog.pg_roles member on member.oid = membership.member
+   where granted.rolname = 'kb_observatory_read'
+     and member.rolname <> principal;
+  if unexpected is not null then
+    raise exception 'kb_observatory_read has unexpected members: %', unexpected;
+  end if;
+
+  execute pg_catalog.format('grant kb_observatory_read to %I', principal);
+  execute pg_catalog.format(
+    'alter role %I in database teleo_canonical set default_transaction_read_only = on',
+    principal
+  );
+  execute pg_catalog.format(
+    'alter role %I in database teleo_canonical set statement_timeout = %L',
+    principal,
+    '5s'
+  );
+  execute pg_catalog.format(
+    'alter role %I in database teleo_canonical set lock_timeout = %L',
+    principal,
+    '1s'
+  );
+end
+$membership$;
+
+do $verify$
+declare
+  principal text := current_setting('observatory.iam_user');
+  unexpected text;
+begin
+  if not pg_catalog.pg_has_role(principal, 'kb_observatory_read', 'member') then
+    raise exception 'Observatory principal is not a member of kb_observatory_read';
+  end if;
+  if not exists (
+    select 1 from pg_catalog.pg_roles
+     where rolname = principal and rolinherit and not rolsuper and not rolcreatedb
+       and not rolcreaterole and not rolreplication and not rolbypassrls
+  ) then
+    raise exception 'Observatory principal has unsafe role attributes or cannot inherit read grants';
+  end if;
+
+  select pg_catalog.string_agg(
+           pg_catalog.format('%I.%I:%s', namespace.nspname, relation.relname, privilege.name),
+           ', ' order by namespace.nspname, relation.relname, privilege.name
+         )
+    into unexpected
+    from pg_catalog.pg_class relation
+    join pg_catalog.pg_namespace namespace on namespace.oid = relation.relnamespace
+   cross join (values ('INSERT'), ('UPDATE'), ('DELETE'), ('TRUNCATE'), ('REFERENCES'), ('TRIGGER')) privilege(name)
+   where namespace.nspname in ('public', 'kb_stage')
+     and relation.relkind in ('r', 'p', 'v', 'm', 'f')
+     and pg_catalog.has_table_privilege(principal, relation.oid, privilege.name);
+  if unexpected is not null then
+    raise exception 'Observatory principal has effective table writes: %', unexpected;
+  end if;
+
+  select pg_catalog.string_agg(
+           pg_catalog.format('%I.%I', namespace.nspname, relation.relname),
+           ', ' order by namespace.nspname, relation.relname
+         )
+    into unexpected
+    from pg_catalog.pg_class relation
+    join pg_catalog.pg_namespace namespace on namespace.oid = relation.relnamespace
+   where namespace.nspname in ('public', 'kb_stage')
+     and relation.relkind in ('r', 'p', 'v', 'm', 'f')
+     and pg_catalog.has_table_privilege(principal, relation.oid, 'SELECT')
+     and (namespace.nspname, relation.relname) not in (
+       ('public', 'claims'),
+       ('public', 'sources'),
+       ('public', 'claim_evidence'),
+       ('public', 'claim_edges'),
+       ('kb_stage', 'kb_proposals')
+     );
+  if unexpected is not null then
+    raise exception 'Observatory principal can SELECT outside its allowlist: %', unexpected;
+  end if;
+
+  if not (
+    pg_catalog.has_table_privilege(principal, 'public.claims', 'SELECT')
+    and pg_catalog.has_table_privilege(principal, 'public.sources', 'SELECT')
+    and pg_catalog.has_table_privilege(principal, 'public.claim_evidence', 'SELECT')
+    and pg_catalog.has_table_privilege(principal, 'public.claim_edges', 'SELECT')
+    and pg_catalog.has_table_privilege(principal, 'kb_stage.kb_proposals', 'SELECT')
+  ) then
+    raise exception 'Observatory principal is missing a required read grant';
+  end if;
+end
+$verify$;
+
+select jsonb_build_object(
+  'database', current_database(),
+  'authorization_role', 'kb_observatory_read',
+  'database_principal', current_setting('observatory.iam_user'),
+  'required_reads', true,
+  'effective_table_writes_denied', true,
+  'default_transaction_read_only', true
+)::text;

ops/run_local_genesis_ledger_rebuild.py

@@ -1,12 +1,14 @@
 #!/usr/bin/env python3
 """Deterministically rebuild a disposable Postgres from genesis plus a strict ledger.
 
-The v1 replay boundary is intentionally narrow. It supports strict, insert-only
+The v1 replay boundary supports strict ``add_edge``, ``attach_evidence``,
-``add_edge``, ``attach_evidence``, and ``approve_claim`` receipts. Each ledger
+``approve_claim``, and ``revise_strategy`` receipts. Insert-only actions seed
-entry must also retain the exact approved and applied proposal rows plus the
+their receipt-pinned rows before the guarded transition. ``revise_strategy``
-immutable approval snapshot. Legacy/freeform entries and ``revise_strategy``
+instead captures the exact prestate identities, executes the exact hash-matched
-fail before Docker starts because their retained material is not a complete
+guarded SQL, validates the generated delta, and normalizes only that delta to the
-database delta.
+receipt-pinned transaction timestamp, IDs, and rows. Every entry must retain the
+full approved and applied proposal rows plus its immutable approval snapshot.
+Legacy and freeform entries still fail before Docker starts.
 """
 
 from __future__ import annotations
@@ -46,15 +48,18 @@ LEDGER_ARTIFACT = "teleo_genesis_plus_ledger"
 MATERIAL_ARTIFACT = "teleo_strict_proposal_replay_material"
 LEDGER_CONTRACT_VERSION = 1
 MATERIAL_CONTRACT_VERSION = 1
-SUPPORTED_PROPOSAL_TYPES = frozenset({"add_edge", "attach_evidence", "approve_claim"})
+DEFAULT_REBUILD_IMAGE = (
+    "docker.io/library/postgres:16-alpine@sha256:57c72fd2a128e416c7fcc499958864df5301e940bca0a56f58fddf30ffc07777"
+)
+SUPPORTED_PROPOSAL_TYPES = frozenset({"add_edge", "attach_evidence", "approve_claim", "revise_strategy"})
 CLAIM_CEILING = (
-    "exact genesis plus ordered strict insert-only proposal replay; supported types are "
+    "exact genesis plus ordered strict proposal replay; supported types are add_edge, "
-    "add_edge, attach_evidence, and approve_claim; full approved/applied proposal rows "
+    "attach_evidence, approve_claim, and revise_strategy; mutating strategy replay "
-    "and immutable approval snapshots are required"
+    "captures prestate identities and normalizes the exact receipt-pinned poststate; "
+    "full approved/applied proposal rows and immutable approval snapshots are required"
 )
 NOT_PROVEN = (
     "legacy or freeform proposal replay",
-    "revise_strategy replay because prior-row mutations are absent from v1 receipts",
     "source-corpus recompilation from a blank schema",
     "VPS, GCP, Telegram, or any live database mutation",
 )
@@ -77,6 +82,7 @@ FIXED_ENGINE_PATHS = frozenset(
 )
 
 SHA256_RE = re.compile(r"[0-9a-f]{64}\Z")
+IMAGE_DIGEST_RE = re.compile(r"\S+@sha256:[0-9a-f]{64}\Z")
 PROPOSAL_TRANSITION_FIELDS = frozenset(
     {"status", "applied_by_handle", "applied_by_agent_id", "applied_at", "updated_at"}
 )
@@ -121,6 +127,35 @@ CANONICAL_TABLE_ORDER = (
     "claim_evidence",
     "claim_edges",
 )
+STRATEGY_REQUIRED_FIELDS = frozenset(
+    {
+        "id",
+        "agent_id",
+        "diagnosis",
+        "guiding_policy",
+        "proximate_objectives",
+        "version",
+        "active",
+        "created_at",
+    }
+)
+STRATEGY_NODE_REQUIRED_FIELDS = frozenset(
+    {
+        "id",
+        "agent_id",
+        "node_type",
+        "title",
+        "body",
+        "rank",
+        "status",
+        "horizon",
+        "measure",
+        "source_ref",
+        "metadata",
+        "created_at",
+        "updated_at",
+    }
+)
 
 
 class ReconstructionError(RuntimeError):
@@ -308,6 +343,116 @@ def _validate_proposal_rows(
         )
 
 
+def _parse_aware_timestamp(value: Any, field: str, *, code: str = "invalid_mutating_receipt") -> datetime:
+    if not isinstance(value, str) or not value:
+        raise ReconstructionError(code, f"{field} must be an ISO-8601 timestamp")
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ReconstructionError(code, f"{field} must be an ISO-8601 timestamp") from exc
+    if parsed.tzinfo is None:
+        raise ReconstructionError(code, f"{field} must include a timezone")
+    return parsed
+
+
+def _validated_uuid_list(value: Any, field: str, *, code: str = "invalid_mutating_state") -> list[str]:
+    if not isinstance(value, list):
+        raise ReconstructionError(code, f"{field} must be a UUID list")
+    normalized: list[str] = []
+    for item in value:
+        try:
+            normalized.append(str(uuid.UUID(str(item))))
+        except (TypeError, ValueError, AttributeError) as exc:
+            raise ReconstructionError(code, f"{field} must contain only UUIDs") from exc
+    if len(normalized) != len(set(normalized)):
+        raise ReconstructionError(code, f"{field} contains duplicate UUIDs")
+    return normalized
+
+
+def _validate_revise_strategy_receipt_rows(
+    proposal: dict[str, Any], canonical_rows: dict[str, Any]
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    payload = proposal.get("payload")
+    apply_payload = payload.get("apply_payload") if isinstance(payload, dict) else None
+    if not isinstance(apply_payload, dict):
+        raise ReconstructionError("invalid_mutating_receipt", "revise_strategy receipt requires a strict apply payload")
+    try:
+        agent_id = str(uuid.UUID(str(apply_payload.get("agent_id"))))
+    except (TypeError, ValueError, AttributeError) as exc:
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt requires one agent UUID"
+        ) from exc
+
+    strategies = canonical_rows.get("strategies")
+    nodes = canonical_rows.get("strategy_nodes")
+    if not isinstance(strategies, list) or len(strategies) != 1 or not isinstance(strategies[0], dict):
+        raise ReconstructionError("invalid_mutating_receipt", "revise_strategy receipt must pin one fresh strategy row")
+    expected_nodes = apply_payload.get("strategy_nodes")
+    if (
+        not isinstance(expected_nodes, list)
+        or not isinstance(nodes, list)
+        or len(nodes) != len(expected_nodes)
+        or any(not isinstance(row, dict) for row in nodes)
+    ):
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt must pin every fresh strategy node row"
+        )
+
+    strategy = strategies[0]
+    if frozenset(strategy) != STRATEGY_REQUIRED_FIELDS:
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt strategy row fields are not canonical"
+        )
+    if any(frozenset(row) != STRATEGY_NODE_REQUIRED_FIELDS for row in nodes):
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt strategy node row fields are not canonical"
+        )
+    strategy_id = _validated_uuid_list([strategy.get("id")], "receipt strategy id", code="invalid_mutating_receipt")[0]
+    node_ids = _validated_uuid_list(
+        [row.get("id") for row in nodes],
+        "receipt strategy node ids",
+        code="invalid_mutating_receipt",
+    )
+    if strategy.get("agent_id") != agent_id or any(row.get("agent_id") != agent_id for row in nodes):
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt rows do not belong to the payload agent"
+        )
+    if strategy.get("active") is not True or any(row.get("status") != "active" for row in nodes):
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt must pin the fresh active poststate"
+        )
+    version = strategy.get("version")
+    if isinstance(version, bool) or not isinstance(version, int) or version < 1:
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy receipt strategy version must be positive"
+        )
+
+    transaction_timestamp = strategy.get("created_at")
+    transaction_time = _parse_aware_timestamp(transaction_timestamp, "receipt strategy created_at")
+    for row in nodes:
+        if row.get("created_at") != transaction_timestamp or row.get("updated_at") != transaction_timestamp:
+            raise ReconstructionError(
+                "invalid_mutating_receipt",
+                "revise_strategy fresh strategy and node timestamps must share one transaction timestamp",
+            )
+    reviewed_time = _parse_aware_timestamp(proposal.get("reviewed_at"), "receipt proposal reviewed_at")
+    applied_time = _parse_aware_timestamp(proposal.get("applied_at"), "receipt proposal applied_at")
+    if reviewed_time > applied_time:
+        raise ReconstructionError("invalid_mutating_receipt", "revise_strategy proposal approval is after apply time")
+    if transaction_time < reviewed_time:
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy transaction timestamp is before proposal approval"
+        )
+    if transaction_time > applied_time:
+        raise ReconstructionError(
+            "invalid_mutating_receipt", "revise_strategy transaction timestamp is after proposal apply time"
+        )
+
+    return {**strategy, "id": strategy_id}, [
+        {**row, "id": normalized_id} for row, normalized_id in zip(nodes, node_ids, strict=True)
+    ]
+
+
 def _validate_entry_material(
     material: dict[str, Any],
     *,
@@ -340,11 +485,6 @@ def _validate_entry_material(
     if not isinstance(proposal, dict):
         raise ReconstructionError("invalid_material", "replay receipt has no proposal object")
     proposal_type = proposal.get("proposal_type")
-    if proposal_type == "revise_strategy":
-        raise ReconstructionError(
-            "unsupported_mutating_receipt",
-            "revise_strategy receipts omit prior strategy and node mutations and cannot replay exactly",
-        )
     if proposal_type not in SUPPORTED_PROPOSAL_TYPES:
         raise ReconstructionError(
             "unsupported_proposal_type", "ledger entry proposal type is not supported by v1 reconstruction"
@@ -358,6 +498,8 @@ def _validate_entry_material(
     canonical_rows = receipt.get("canonical_rows")
     if not isinstance(apply_metadata, dict) or not isinstance(canonical_rows, dict):
         raise ReconstructionError("invalid_replay_receipt", "replay receipt is missing apply or row material")
+    if proposal_type == "revise_strategy":
+        _validate_revise_strategy_receipt_rows(proposal, canonical_rows)
     try:
         rebuilt = replay_receipt.build_replay_receipt(
             proposal,
@@ -382,6 +524,7 @@ def _validate_entry_material(
         raise ReconstructionError(
             "replay_material_hash_mismatch", "ledger replay-material pin does not match the private receipt"
         )
+    receipt = {**receipt, "canonical_rows": rebuilt["canonical_rows"]}
 
     approved = material["approved_proposal"]
     approval = material["approval_snapshot"]
@@ -394,6 +537,15 @@ def _validate_entry_material(
             "current_apply_engine_rejected_material",
             "current guarded apply engine rejected the strict replay material",
         ) from exc
+    current_apply_sql_sha256 = _sha256_text(current_apply_sql)
+    if proposal_type == "revise_strategy" and (
+        apply_metadata.get("source") != "exact_executed_sql"
+        or apply_metadata.get("apply_sql_sha256") != current_apply_sql_sha256
+    ):
+        raise ReconstructionError(
+            "mutating_apply_engine_mismatch",
+            "revise_strategy replay requires the exact executed SQL to match the current guarded apply engine",
+        )
 
     return LedgerEntry(
         sequence=expected_sequence,
@@ -405,7 +557,7 @@ def _validate_entry_material(
         applied_proposal=applied,
         receipt=receipt,
         current_apply_sql=current_apply_sql,
-        current_apply_sql_sha256=_sha256_text(current_apply_sql),
+        current_apply_sql_sha256=current_apply_sql_sha256,
     )
 
 
@@ -550,6 +702,266 @@ def build_seed_sql(entry: LedgerEntry) -> str:
     return "\n".join(statements) + "\n"
 
 
+def _uuid_membership_sql(column: str, values: list[str], *, negate: bool = False) -> str:
+    if not values:
+        return "true" if negate else "false"
+    rendered = ", ".join(f"{apply_engine.sql_literal(value)}::uuid" for value in values)
+    operator = "not in" if negate else "in"
+    return f"{column} {operator} ({rendered})"
+
+
+def _uuid_array_sql(values: list[str]) -> str:
+    if not values:
+        return "array[]::uuid[]"
+    rendered = ", ".join(f"{apply_engine.sql_literal(value)}::uuid" for value in values)
+    return f"array[{rendered}]::uuid[]"
+
+
+def build_revise_strategy_prestate_sql(entry: LedgerEntry) -> str:
+    apply_payload = entry.receipt["proposal"]["payload"]["apply_payload"]
+    agent = apply_engine.sql_literal(apply_payload["agent_id"])
+    return f"""with strategy_state as (
+  select coalesce(jsonb_agg(s.id::text order by s.id::text), '[]'::jsonb) as strategy_ids,
+         coalesce(
+           jsonb_agg(s.id::text order by s.id::text) filter (where s.active),
+           '[]'::jsonb
+         ) as active_strategy_ids,
+         coalesce(max(s.version), 0) as max_strategy_version
+    from public.strategies s
+   where s.agent_id = {agent}::uuid
+), node_state as (
+  select coalesce(jsonb_agg(n.id::text order by n.id::text), '[]'::jsonb) as strategy_node_ids,
+         coalesce(
+           jsonb_agg(n.id::text order by n.id::text) filter (where n.status <> 'retired'),
+           '[]'::jsonb
+         ) as non_retired_strategy_node_ids
+    from public.strategy_nodes n
+   where n.agent_id = {agent}::uuid
+)
+select jsonb_build_object(
+  'strategy_ids', s.strategy_ids,
+  'active_strategy_ids', s.active_strategy_ids,
+  'max_strategy_version', s.max_strategy_version,
+  'strategy_node_ids', n.strategy_node_ids,
+  'non_retired_strategy_node_ids', n.non_retired_strategy_node_ids
+)::text
+from strategy_state s cross join node_state n;
+"""
+
+
+def _validate_revise_strategy_prestate(value: Any) -> dict[str, Any]:
+    expected = frozenset(
+        {
+            "strategy_ids",
+            "active_strategy_ids",
+            "max_strategy_version",
+            "strategy_node_ids",
+            "non_retired_strategy_node_ids",
+        }
+    )
+    state = _require_exact_keys(value, expected, "revise_strategy prestate")
+    strategy_ids = _validated_uuid_list(state["strategy_ids"], "prestate strategy ids")
+    active_strategy_ids = _validated_uuid_list(state["active_strategy_ids"], "prestate active strategy ids")
+    strategy_node_ids = _validated_uuid_list(state["strategy_node_ids"], "prestate strategy node ids")
+    non_retired_node_ids = _validated_uuid_list(
+        state["non_retired_strategy_node_ids"], "prestate non-retired strategy node ids"
+    )
+    max_version = state["max_strategy_version"]
+    if isinstance(max_version, bool) or not isinstance(max_version, int) or max_version < 0:
+        raise ReconstructionError(
+            "invalid_mutating_state", "prestate maximum strategy version must be a non-negative integer"
+        )
+    if len(active_strategy_ids) > 1 or not set(active_strategy_ids).issubset(strategy_ids):
+        raise ReconstructionError(
+            "invalid_mutating_state", "prestate active strategies violate the one-active invariant"
+        )
+    if not set(non_retired_node_ids).issubset(strategy_node_ids):
+        raise ReconstructionError(
+            "invalid_mutating_state", "prestate non-retired strategy nodes are not a subset of all nodes"
+        )
+    return {
+        "strategy_ids": strategy_ids,
+        "active_strategy_ids": active_strategy_ids,
+        "max_strategy_version": max_version,
+        "strategy_node_ids": strategy_node_ids,
+        "non_retired_strategy_node_ids": non_retired_node_ids,
+    }
+
+
+def build_revise_strategy_generated_delta_sql(entry: LedgerEntry, prestate: dict[str, Any]) -> str:
+    state = _validate_revise_strategy_prestate(prestate)
+    apply_payload = entry.receipt["proposal"]["payload"]["apply_payload"]
+    agent = apply_engine.sql_literal(apply_payload["agent_id"])
+    strategy_filter = _uuid_membership_sql("s.id", state["strategy_ids"], negate=True)
+    node_filter = _uuid_membership_sql("n.id", state["strategy_node_ids"], negate=True)
+    return f"""select jsonb_build_object(
+  'strategies', coalesce((
+    select jsonb_agg(to_jsonb(s) order by s.id::text)
+      from public.strategies s
+     where s.agent_id = {agent}::uuid and {strategy_filter}
+  ), '[]'::jsonb),
+  'strategy_nodes', coalesce((
+    select jsonb_agg(to_jsonb(n) order by n.id::text)
+      from public.strategy_nodes n
+     where n.agent_id = {agent}::uuid and {node_filter}
+  ), '[]'::jsonb)
+)::text;
+"""
+
+
+def _validate_revise_strategy_generated_delta(
+    entry: LedgerEntry,
+    prestate: dict[str, Any],
+    generated_rows: Any,
+) -> tuple[dict[str, Any], list[dict[str, Any]]]:
+    state = _validate_revise_strategy_prestate(prestate)
+    if not isinstance(generated_rows, dict):
+        raise ReconstructionError("invalid_mutating_delta", "revise_strategy generated delta must be a row object")
+    try:
+        replay_receipt.build_replay_receipt(
+            entry.receipt["proposal"],
+            generated_rows,
+            apply_sql_sha256=entry.current_apply_sql_sha256,
+            apply_sql_source="exact_executed_sql",
+            exported_at_utc=entry.receipt.get("exported_at_utc"),
+        )
+    except (KeyError, TypeError, ValueError) as exc:
+        raise ReconstructionError(
+            "invalid_mutating_delta",
+            "revise_strategy generated rows do not match the strict payload",
+        ) from exc
+
+    strategies = generated_rows.get("strategies")
+    nodes = generated_rows.get("strategy_nodes")
+    if not isinstance(strategies, list) or len(strategies) != 1 or not isinstance(strategies[0], dict):
+        raise ReconstructionError(
+            "invalid_mutating_delta", "revise_strategy apply did not generate exactly one strategy"
+        )
+    if not isinstance(nodes, list) or any(not isinstance(row, dict) for row in nodes):
+        raise ReconstructionError("invalid_mutating_delta", "revise_strategy apply generated invalid strategy nodes")
+    strategy = strategies[0]
+    if strategy.get("version") != state["max_strategy_version"] + 1:
+        raise ReconstructionError("invalid_mutating_delta", "revise_strategy generated an unexpected strategy version")
+    transaction_timestamp = strategy.get("created_at")
+    _parse_aware_timestamp(transaction_timestamp, "generated strategy created_at", code="invalid_mutating_delta")
+    if any(
+        row.get("created_at") != transaction_timestamp or row.get("updated_at") != transaction_timestamp
+        for row in nodes
+    ):
+        raise ReconstructionError(
+            "invalid_mutating_delta",
+            "revise_strategy generated rows do not share one transaction timestamp",
+        )
+    _validated_uuid_list([strategy.get("id")], "generated strategy id", code="invalid_mutating_delta")
+    _validated_uuid_list(
+        [row.get("id") for row in nodes],
+        "generated strategy node ids",
+        code="invalid_mutating_delta",
+    )
+    return strategy, nodes
+
+
+def build_revise_strategy_normalization_sql(
+    entry: LedgerEntry,
+    prestate: dict[str, Any],
+    generated_rows: dict[str, Any],
+) -> str:
+    state = _validate_revise_strategy_prestate(prestate)
+    generated_strategy, generated_nodes = _validate_revise_strategy_generated_delta(entry, state, generated_rows)
+    receipt_strategy, receipt_nodes = _validate_revise_strategy_receipt_rows(
+        entry.receipt["proposal"], entry.receipt["canonical_rows"]
+    )
+    if receipt_strategy["version"] != state["max_strategy_version"] + 1:
+        raise ReconstructionError(
+            "mutating_receipt_version_mismatch",
+            "revise_strategy receipt version does not follow the observed prestate",
+        )
+    if receipt_strategy["id"] in state["strategy_ids"] or set(row["id"] for row in receipt_nodes).intersection(
+        state["strategy_node_ids"]
+    ):
+        raise ReconstructionError(
+            "mutating_receipt_id_collision", "revise_strategy receipt IDs collide with the observed prestate"
+        )
+
+    apply_payload = entry.receipt["proposal"]["payload"]["apply_payload"]
+    agent = apply_engine.sql_literal(apply_payload["agent_id"])
+    generated_strategy_id = str(uuid.UUID(str(generated_strategy["id"])))
+    generated_node_ids = [str(uuid.UUID(str(row["id"]))) for row in generated_nodes]
+    previous_active = state["active_strategy_ids"]
+    changed_node_ids = state["non_retired_strategy_node_ids"]
+    transaction_timestamp = apply_engine.sql_literal(receipt_strategy["created_at"])
+    generated_node_array = _uuid_array_sql(generated_node_ids)
+    previous_active_array = _uuid_array_sql(previous_active)
+    changed_node_array = _uuid_array_sql(changed_node_ids)
+
+    prior_strategy_assertion = ""
+    if previous_active:
+        prior_strategy_assertion = f"""
+  if (select count(*) from public.strategies
+       where agent_id = {agent}::uuid and id = any(previous_active_ids) and not active) <> {len(previous_active)} then
+    raise exception 'revise_strategy prior active strategy transition mismatch';
+  end if;"""
+    prior_node_normalization = ""
+    if changed_node_ids:
+        prior_node_normalization = f"""
+  if (select count(*) from public.strategy_nodes
+       where agent_id = {agent}::uuid and id = any(changed_node_ids) and status = 'retired') <> {len(changed_node_ids)} then
+    raise exception 'revise_strategy prior node transition mismatch';
+  end if;
+  update public.strategy_nodes
+     set status = 'retired', updated_at = {transaction_timestamp}::timestamptz
+   where agent_id = {agent}::uuid and id = any(changed_node_ids);
+  get diagnostics changed_rows = row_count;
+  if changed_rows <> {len(changed_node_ids)} then
+    raise exception 'revise_strategy prior node normalization mismatch';
+  end if;"""
+
+    return f"""begin;
+set local standard_conforming_strings = on;
+do $reconstruction$
+declare
+  changed_rows integer;
+  generated_strategy_id constant uuid := {apply_engine.sql_literal(generated_strategy_id)}::uuid;
+  generated_node_ids constant uuid[] := {generated_node_array};
+  previous_active_ids constant uuid[] := {previous_active_array};
+  changed_node_ids constant uuid[] := {changed_node_array};
+begin{prior_strategy_assertion}
+  if exists (
+    select 1 from public.strategy_node_anchors
+     where from_node_id = any(generated_node_ids) or to_node_id = any(generated_node_ids)
+  ) then
+    raise exception 'revise_strategy generated nodes unexpectedly have anchors';
+  end if;
+  delete from public.strategy_nodes
+   where agent_id = {agent}::uuid and id = any(generated_node_ids);
+  get diagnostics changed_rows = row_count;
+  if changed_rows <> {len(generated_node_ids)} then
+    raise exception 'revise_strategy generated node delta mismatch';
+  end if;
+  delete from public.strategies
+   where agent_id = {agent}::uuid and id = generated_strategy_id;
+  get diagnostics changed_rows = row_count;
+  if changed_rows <> 1 then
+    raise exception 'revise_strategy generated strategy delta mismatch';
+  end if;{prior_node_normalization}
+  insert into public.strategies
+  select seeded.* from jsonb_populate_record(
+    null::public.strategies, {_jsonb_literal(receipt_strategy)}
+  ) seeded;
+  insert into public.strategy_nodes
+  select seeded.* from jsonb_populate_recordset(
+    null::public.strategy_nodes, {_jsonb_literal(receipt_nodes)}
+  ) seeded;
+  if (select count(*) from public.strategies
+       where agent_id = {agent}::uuid and active) <> 1 then
+    raise exception 'revise_strategy normalized one-active invariant mismatch';
+  end if;
+end
+$reconstruction$;
+commit;
+"""
+
+
 def build_proposal_readback_sql(proposal_id: str) -> str:
     literal = apply_engine.sql_literal(proposal_id)
     return f"""select jsonb_build_object(
@@ -694,7 +1106,12 @@ def _entry_summary(entry: LedgerEntry) -> dict[str, Any]:
         "current_apply_sql_sha256": entry.current_apply_sql_sha256,
         "expected_row_counts": entry.receipt["expected_row_counts"],
         "seed_exact": False,
+        "proposal_seed_exact": False,
+        "canonical_seed_exact": False,
         "guarded_apply_executed": False,
+        "mutating_prestate_captured": False,
+        "mutating_delta_validated": False,
+        "mutating_poststate_normalized": False,
         "proposal_exact": False,
         "canonical_rows_exact": False,
         "status": "pending",
@@ -707,6 +1124,7 @@ def apply_entry(
     entry: LedgerEntry,
     summary: dict[str, Any],
 ) -> None:
+    mutating_prestate: dict[str, Any] | None = None
     try:
         _psql(
             args,
@@ -733,6 +1151,19 @@ def apply_entry(
             code="entry_seed_mismatch",
             action=f"ledger entry {entry.sequence} proposal seed",
         )
+        summary["proposal_seed_exact"] = True
+        if entry.applied_proposal["proposal_type"] == "revise_strategy":
+            mutating_prestate = _validate_revise_strategy_prestate(
+                _read_json(
+                    args,
+                    container,
+                    build_revise_strategy_prestate_sql(entry),
+                    code="mutating_prestate_readback_failed",
+                    action=f"ledger entry {entry.sequence} revise_strategy prestate readback",
+                )
+            )
+            summary["mutating_prestate_captured"] = True
+        else:
             seeded_rows = _read_json(
                 args,
                 container,
@@ -746,7 +1177,8 @@ def apply_entry(
                 code="entry_seed_mismatch",
                 action=f"ledger entry {entry.sequence} canonical seed",
             )
-        summary["seed_exact"] = True
+            summary["canonical_seed_exact"] = True
+        summary["seed_exact"] = summary["proposal_seed_exact"] and summary["canonical_seed_exact"]
 
         _psql(
             args,
@@ -759,6 +1191,27 @@ def apply_entry(
         )
         summary["guarded_apply_executed"] = True
 
+        if mutating_prestate is not None:
+            generated_rows = _read_json(
+                args,
+                container,
+                build_revise_strategy_generated_delta_sql(entry, mutating_prestate),
+                code="mutating_delta_readback_failed",
+                action=f"ledger entry {entry.sequence} revise_strategy generated delta readback",
+            )
+            normalization_sql = build_revise_strategy_normalization_sql(entry, mutating_prestate, generated_rows)
+            summary["mutating_delta_validated"] = True
+            _psql(
+                args,
+                container,
+                normalization_sql,
+                role="postgres",
+                timeout=args.apply_timeout,
+                code="mutating_poststate_normalization_failed",
+                action=f"ledger entry {entry.sequence} revise_strategy exact poststate normalization",
+            )
+            summary["mutating_poststate_normalized"] = True
+
         _psql(
             args,
             container,
@@ -1199,7 +1652,7 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
     parser.add_argument("--ledger", required=True, type=Path)
     parser.add_argument("--ledger-sha256", required=True)
     parser.add_argument("--database", default="teleo")
-    parser.add_argument("--image", default=canonical_rebuild.DEFAULT_IMAGE)
+    parser.add_argument("--image", default=DEFAULT_REBUILD_IMAGE)
     parser.add_argument("--container-prefix", default="teleo-genesis-ledger-rebuild")
     parser.add_argument("--tmpfs-mb", default=1024, type=int)
     parser.add_argument("--startup-timeout", default=60.0, type=float)
@@ -1218,8 +1671,8 @@ def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
         parser.error("--database must be a safe PostgreSQL identifier up to 63 characters")
     if not canonical_rebuild.CONTAINER_PREFIX_RE.fullmatch(args.container_prefix):
         parser.error("--container-prefix must be 1-40 Docker-safe characters")
-    if not args.image or any(character.isspace() for character in args.image):
+    if not IMAGE_DIGEST_RE.fullmatch(args.image):
-        parser.error("--image must be a non-empty Docker image reference without whitespace")
+        parser.error("--image must be pinned by a lowercase sha256 digest")
     if not args.docker_bin or any(character.isspace() for character in args.docker_bin):
         parser.error("--docker-bin must be one executable name or path without whitespace")
     if not 64 <= args.tmpfs_mb <= 65536:

pyproject.toml

@@ -14,13 +14,17 @@ dependencies = [
 
 [project.optional-dependencies]
 dev = [
+    "hypothesis>=6,<7",
     "pytest>=8",
     "pytest-asyncio>=0.23",
     "ruff>=0.3",
 ]
+observatory = [
+    "cloud-sql-python-connector[pg8000]>=1.20.4,<1.21",
+]
 
 [tool.setuptools]
-packages = ["lib"]
+packages = ["lib", "observatory_read_adapter"]
 
 [tool.ruff]
 target-version = "py311"

scripts/apply_proposal.py

@@ -111,8 +111,17 @@ CLAIM_TYPES = {"empirical", "structural", "normative", "meta", "concept"}
 SOURCE_TYPES = {"paper", "article", "transcript", "observation", "dataset", "post", "dm", "other"}
 EVIDENCE_ROLES = {"grounds", "illustrates", "contradicts"}
 EDGE_TYPES = {
-    "supports", "challenges", "requires", "relates", "contradicts",
+    "supports",
-    "supersedes", "derives_from", "cites", "causes", "constrains", "accelerates",
+    "challenges",
+    "requires",
+    "relates",
+    "contradicts",
+    "supersedes",
+    "derives_from",
+    "cites",
+    "causes",
+    "constrains",
+    "accelerates",
 }
 
 MAX_BUNDLE_ROWS = {
@@ -143,6 +152,21 @@ def _jsonb(value: Any) -> str:
     return sql_literal(json.dumps(value, sort_keys=True)) + "::jsonb"
 
 
+def deterministic_row_uuid(proposal_id: str, row_kind: str, *semantic_key: Any) -> str:
+    """Derive a stable persisted row id from the proposal and semantic key.
+
+    Evidence and edge ids are not part of the reviewed v2 payload.  Deriving
+    them here makes clone/production receipts and a pre-authorized rollback
+    packet bind the same exact ids instead of relying on database randomness.
+    """
+    material = json.dumps(
+        ["livingip", "kb-apply", str(proposal_id), row_kind, *semantic_key],
+        ensure_ascii=True,
+        separators=(",", ":"),
+    )
+    return str(uuid.uuid5(uuid.NAMESPACE_URL, material))
+
+
 def _text_array(values: list[str]) -> str:
     if not values:
         return "'{}'::text[]"
@@ -196,9 +220,7 @@ def _reject_unknown(mapping: dict[str, Any], allowed: set[str], path: str) -> No
         raise ValueError(f"{path} contains unknown fields: {unknown}")
 
 
-def _validate_approval_meta(
+def _validate_approval_meta(approval: dict[str, Any], proposal_type: str, apply_payload: dict[str, Any]) -> None:
-    approval: dict[str, Any], proposal_type: str, apply_payload: dict[str, Any]
-) -> None:
     if not isinstance(approval, dict):
         raise ValueError("approved proposal metadata is required")
     if approval.get("proposal_type") != proposal_type:
@@ -222,12 +244,12 @@ def _validate_approval_meta(
 def _approval_guard_sql(proposal_id: str, approval: dict[str, Any]) -> str:
     return f"""select kb_stage.assert_approved_proposal(
   {sql_literal(proposal_id)}::uuid,
-  {sql_literal(approval['proposal_type'])},
+  {sql_literal(approval["proposal_type"])},
-  {_jsonb(approval['payload'])},
+  {_jsonb(approval["payload"])},
-  {sql_literal(approval['reviewed_by_handle'])},
+  {sql_literal(approval["reviewed_by_handle"])},
-  {sql_literal(approval.get('reviewed_by_agent_id'))}::uuid,
+  {sql_literal(approval.get("reviewed_by_agent_id"))}::uuid,
-  {sql_literal(approval['reviewed_at'])}::timestamptz,
+  {sql_literal(approval["reviewed_at"])}::timestamptz,
-  {sql_literal(approval['review_note'])}
+  {sql_literal(approval["review_note"])}
 );"""
 
 
@@ -245,12 +267,12 @@ end
 $verify$;"""
     finish_sql = f"""select kb_stage.finish_approved_proposal(
   {sql_literal(proposal_id)}::uuid,
-  {sql_literal(approval['proposal_type'])},
+  {sql_literal(approval["proposal_type"])},
-  {_jsonb(approval['payload'])},
+  {_jsonb(approval["payload"])},
-  {sql_literal(approval['reviewed_by_handle'])},
+  {sql_literal(approval["reviewed_by_handle"])},
-  {sql_literal(approval.get('reviewed_by_agent_id'))}::uuid,
+  {sql_literal(approval.get("reviewed_by_agent_id"))}::uuid,
-  {sql_literal(approval['reviewed_at'])}::timestamptz,
+  {sql_literal(approval["reviewed_at"])}::timestamptz,
-  {sql_literal(approval['review_note'])},
+  {sql_literal(approval["review_note"])},
   {sql_literal(applied_by)}
 );"""
     return checks_sql + "\n" + finish_sql
@@ -301,9 +323,9 @@ update public.strategies
 insert into public.strategies
        (agent_id, diagnosis, guiding_policy, proximate_objectives, version, active)
 select {sql_literal(agent_id)}::uuid,
-       {sql_literal(strategy['diagnosis'])},
+       {sql_literal(strategy["diagnosis"])},
-       {sql_literal(strategy['guiding_policy'])},
+       {sql_literal(strategy["guiding_policy"])},
-       {_jsonb(strategy['proximate_objectives'])},
+       {_jsonb(strategy["proximate_objectives"])},
        coalesce(max(version), 0) + 1,
        true
   from public.strategies
@@ -325,9 +347,7 @@ values
     raise exception 'apply_proposal: expected exactly one active strategy for agent %', {sql_literal(agent_id)};
   end if;"""
 
-    ledger = _ledger_and_verify(
+    ledger = _ledger_and_verify(proposal_id, applied_by or SERVICE_AGENT_HANDLE, checks, approval)
-        proposal_id, applied_by or SERVICE_AGENT_HANDLE, checks, approval
-    )
     return _wrap_txn(canonical, ledger, _approval_guard_sql(proposal_id, approval))
 
 
@@ -338,14 +358,16 @@ def build_add_edge_sql(
     approval: dict[str, Any],
 ) -> str:
     _validate_approval_meta(approval, "add_edge", apply_payload)
-    f = apply_payload.get("from_claim")
+    _reject_unknown(apply_payload, {"from_claim", "to_claim", "edge_type", "weight"}, "add_edge apply_payload")
-    t = apply_payload.get("to_claim")
+    f = _uuid(apply_payload.get("from_claim"), "add_edge.from_claim")
+    t = _uuid(apply_payload.get("to_claim"), "add_edge.to_claim")
     et = apply_payload.get("edge_type")
-    w = apply_payload.get("weight")
+    if et not in EDGE_TYPES:
-    if not (f and t and et):
+        raise ValueError(f"add_edge.edge_type must be one of {sorted(EDGE_TYPES)}")
-        raise ValueError("add_edge apply_payload requires 'from_claim', 'to_claim', 'edge_type'")
+    w = _weight(apply_payload.get("weight"), "add_edge.weight")
     if f == t:
         raise ValueError("add_edge from_claim and to_claim must differ")
+    row_id = deterministic_row_uuid(proposal_id, "claim_edge", f, t, et)
 
     edge_lock_key = f"claim_edge:{f}:{t}:{et}"
     canonical = f"""
@@ -354,8 +376,8 @@ def build_add_edge_sql(
 select pg_advisory_xact_lock(hashtextextended({sql_literal(edge_lock_key)}, 0));
 
 -- insert the edge unless an identical (from,to,type) edge already exists
-insert into public.claim_edges (from_claim, to_claim, edge_type, weight)
+insert into public.claim_edges (id, from_claim, to_claim, edge_type, weight)
-select {sql_literal(f)}::uuid, {sql_literal(t)}::uuid,
+select {sql_literal(row_id)}::uuid, {sql_literal(f)}::uuid, {sql_literal(t)}::uuid,
        {sql_literal(et)}::edge_type, {sql_literal(w)}
  where not exists (
    select 1 from public.claim_edges
@@ -364,7 +386,15 @@ select {sql_literal(f)}::uuid, {sql_literal(t)}::uuid,
       and edge_type = {sql_literal(et)}::edge_type);
 """.rstrip()
 
-    checks = f"""  if exists (select 1 from public.claim_edges
+    checks = f"""  -- Historical replay receipts can carry a pre-deterministic row id.
+  -- Require one exact semantic row; fresh applies still insert row_id above.
+  if (select count(*) from public.claim_edges
+       where from_claim = {sql_literal(f)}::uuid
+         and to_claim = {sql_literal(t)}::uuid
+         and edge_type = {sql_literal(et)}::edge_type) <> 1 then
+    raise exception 'apply_proposal: claim_edge row does not match strict apply payload';
+  end if;
+  if exists (select 1 from public.claim_edges
        where from_claim = {sql_literal(f)}::uuid
          and to_claim = {sql_literal(t)}::uuid
          and edge_type = {sql_literal(et)}::edge_type
@@ -379,9 +409,7 @@ select {sql_literal(f)}::uuid, {sql_literal(t)}::uuid,
     raise exception 'apply_proposal: claim_edge row does not match strict apply payload';
   end if;"""
 
-    ledger = _ledger_and_verify(
+    ledger = _ledger_and_verify(proposal_id, applied_by or SERVICE_AGENT_HANDLE, checks, approval)
-        proposal_id, applied_by or SERVICE_AGENT_HANDLE, checks, approval
-    )
     return _wrap_txn(canonical, ledger, _approval_guard_sql(proposal_id, approval))
 
 
@@ -392,6 +420,7 @@ def build_attach_evidence_sql(
     approval: dict[str, Any],
 ) -> str:
     _validate_approval_meta(approval, "attach_evidence", apply_payload)
+    _reject_unknown(apply_payload, {"evidence"}, "attach_evidence apply_payload")
     evidence: list[dict[str, Any]] = apply_payload.get("evidence") or []
     if not evidence:
         raise ValueError("attach_evidence apply_payload requires non-empty 'evidence'")
@@ -399,17 +428,17 @@ def build_attach_evidence_sql(
     statements = []
     checks = []
     for i, ev in enumerate(evidence):
-        claim_id = ev.get("claim_id")
+        _reject_unknown(
-        source_id = ev.get("source_id")
+            ev,
-        role = ev.get("role") or "grounds"
+            {"claim_id", "source_id", "role", "weight"},
-        weight = ev.get("weight")
+            f"attach_evidence.evidence[{i}]",
-        if not claim_id:
-            raise ValueError(f"evidence[{i}] requires 'claim_id'")
-        if not source_id:
-            raise ValueError(
-                f"evidence[{i}] requires an existing 'source_id'. "
-                "kb_apply cannot create public.sources; mint the source upstream first."
         )
+        claim_id = _uuid(ev.get("claim_id"), f"attach_evidence.evidence[{i}].claim_id")
+        source_id = _uuid(ev.get("source_id"), f"attach_evidence.evidence[{i}].source_id")
+        role = ev.get("role") or "grounds"
+        if role not in EVIDENCE_ROLES:
+            raise ValueError(f"attach_evidence.evidence[{i}].role must be one of {sorted(EVIDENCE_ROLES)}")
+        weight = _weight(ev.get("weight"), f"attach_evidence.evidence[{i}].weight")
         statements.append(
             f"""insert into public.claim_evidence (claim_id, source_id, role, weight)
 select {sql_literal(claim_id)}::uuid, {sql_literal(source_id)}::uuid,
@@ -417,7 +446,14 @@ select {sql_literal(claim_id)}::uuid, {sql_literal(source_id)}::uuid,
 on conflict (claim_id, source_id, role) do nothing;"""
         )
         checks.append(
-            f"""  if exists (select 1 from public.claim_evidence
+            f"""  -- Accept a legacy receipt id only when exactly one semantic row matches.
+  if (select count(*) from public.claim_evidence
+       where claim_id = {sql_literal(claim_id)}::uuid
+         and source_id = {sql_literal(source_id)}::uuid
+         and role = {sql_literal(role)}::evidence_role) <> 1 then
+    raise exception 'apply_proposal: evidence row % does not match strict apply payload', {i};
+  end if;
+  if exists (select 1 from public.claim_evidence
        where claim_id = {sql_literal(claim_id)}::uuid
          and source_id = {sql_literal(source_id)}::uuid
          and role = {sql_literal(role)}::evidence_role
@@ -434,9 +470,7 @@ on conflict (claim_id, source_id, role) do nothing;"""
         )
 
     canonical = "\n".join(statements)
-    ledger = _ledger_and_verify(
+    ledger = _ledger_and_verify(proposal_id, applied_by or SERVICE_AGENT_HANDLE, "\n".join(checks), approval)
-        proposal_id, applied_by or SERVICE_AGENT_HANDLE, "\n".join(checks), approval
-    )
     return _wrap_txn(canonical, ledger, _approval_guard_sql(proposal_id, approval))
 
 
@@ -445,6 +479,9 @@ def build_approve_claim_sql(
     proposal_id: str,
     applied_by: str | None,
     approval: dict[str, Any],
+    *,
+    fresh_owned: bool = False,
+    fresh_preflight_sha256: str | None = None,
 ) -> str:
     """Build one conflict-safe transaction for a reviewed canonical graph bundle."""
     _validate_approval_meta(approval, "approve_claim", apply_payload)
@@ -509,12 +546,8 @@ def build_approve_claim_sql(
                 "status": status,
                 "confidence": _weight(row.get("confidence"), f"{path}.confidence"),
                 "tags": tags,
-                "created_by": _uuid(
+                "created_by": _uuid(row.get("created_by", agent_id), f"{path}.created_by", nullable=True),
-                    row.get("created_by", agent_id), f"{path}.created_by", nullable=True
+                "superseded_by": _uuid(row.get("superseded_by"), f"{path}.superseded_by", nullable=True),
-                ),
-                "superseded_by": _uuid(
-                    row.get("superseded_by"), f"{path}.superseded_by", nullable=True
-                ),
             }
         )
 
@@ -543,9 +576,7 @@ def build_approve_claim_sql(
                 "storage_path": row.get("storage_path"),
                 "excerpt": row.get("excerpt"),
                 "hash": source_hash,
-                "created_by": _uuid(
+                "created_by": _uuid(row.get("created_by", agent_id), f"{path}.created_by", nullable=True),
-                    row.get("created_by", agent_id), f"{path}.created_by", nullable=True
-                ),
             }
         )
 
@@ -566,9 +597,7 @@ def build_approve_claim_sql(
                 "source_id": _uuid(row.get("source_id"), f"{path}.source_id"),
                 "role": role,
                 "weight": _weight(row.get("weight"), f"{path}.weight"),
-                "created_by": _uuid(
+                "created_by": _uuid(row.get("created_by", agent_id), f"{path}.created_by", nullable=True),
-                    row.get("created_by", agent_id), f"{path}.created_by", nullable=True
-                ),
             }
         )
 
@@ -589,13 +618,12 @@ def build_approve_claim_sql(
             raise ValueError(f"{path} cannot be a self-edge")
         edges.append(
             {
+                "id": deterministic_row_uuid(proposal_id, "claim_edge", from_claim, to_claim, edge_type),
                 "from_claim": from_claim,
                 "to_claim": to_claim,
                 "edge_type": edge_type,
                 "weight": _weight(row.get("weight"), f"{path}.weight"),
-                "created_by": _uuid(
+                "created_by": _uuid(row.get("created_by", agent_id), f"{path}.created_by", nullable=True),
-                    row.get("created_by", agent_id), f"{path}.created_by", nullable=True
-                ),
             }
         )
 
@@ -639,169 +667,212 @@ def build_approve_claim_sql(
     )
     _dedupe([row["id"] for row in reasoning_tools], "approve_claim.reasoning_tools ids")
 
+    if fresh_owned:
+        if (
+            not isinstance(fresh_preflight_sha256, str)
+            or len(fresh_preflight_sha256) != 64
+            or any(character not in "0123456789abcdef" for character in fresh_preflight_sha256)
+        ):
+            raise ValueError("fresh-owned approve_claim requires an exact preflight SHA-256")
+    elif fresh_preflight_sha256 is not None:
+        raise ValueError("fresh preflight SHA-256 is only valid for fresh-owned approve_claim")
+
     statements: list[str] = []
     checks: list[str] = []
 
+    if fresh_owned:
+        statements.extend(
+            [
+                f"-- fresh-owned preflight SHA-256: {fresh_preflight_sha256}",
+                (
+                    "select pg_advisory_xact_lock(hashtextextended("
+                    f"'proposal-fresh-apply:' || {sql_literal(proposal_id)}, 0));"
+                ),
+            ]
+        )
+
     if sources:
         collision_checks = []
         for row in sources:
             collision_checks.append(
                 f"""  if exists (select 1 from public.sources
-       where hash = {sql_literal(row['hash'])}
+       where hash = {sql_literal(row["hash"])}
-         and id <> {sql_literal(row['id'])}::uuid) then
+         and id <> {sql_literal(row["id"])}::uuid) then
-    raise exception 'approve_claim: source hash collision for source %', {sql_literal(row['id'])};
+    raise exception 'approve_claim: source hash collision for source %', {sql_literal(row["id"])};
   end if;"""
             )
-        statements.append(
+        statements.append("do $source_conflicts$\nbegin\n" + "\n".join(collision_checks) + "\nend\n$source_conflicts$;")
-            "do $source_conflicts$\nbegin\n"
-            + "\n".join(collision_checks)
-            + "\nend\n$source_conflicts$;"
-        )
 
     for row in claims:
         tags = _text_array(row["tags"])
+        conflict_clause = ";" if fresh_owned else "\non conflict (id) do nothing;"
         statements.append(
             f"""insert into public.claims (id, type, text, status, confidence, tags, created_by, superseded_by)
-select {sql_literal(row['id'])}::uuid, {sql_literal(row['type'])}, {sql_literal(row['text'])},
+select {sql_literal(row["id"])}::uuid, {sql_literal(row["type"])}, {sql_literal(row["text"])},
-       {sql_literal(row['status'])}, {sql_literal(row['confidence'])}, {tags},
+       {sql_literal(row["status"])}, {sql_literal(row["confidence"])}, {tags},
-       {sql_literal(row['created_by'])}::uuid, {sql_literal(row['superseded_by'])}::uuid
+       {sql_literal(row["created_by"])}::uuid, {sql_literal(row["superseded_by"])}::uuid{conflict_clause}"""
-on conflict (id) do nothing;"""
         )
         checks.append(
             f"""  if not exists (select 1 from public.claims
-       where id = {sql_literal(row['id'])}::uuid
+       where id = {sql_literal(row["id"])}::uuid
-         and type = {sql_literal(row['type'])}
+         and type = {sql_literal(row["type"])}
-         and text = {sql_literal(row['text'])}
+         and text = {sql_literal(row["text"])}
-         and status = {sql_literal(row['status'])}
+         and status = {sql_literal(row["status"])}
-         and confidence is not distinct from {sql_literal(row['confidence'])}
+         and confidence is not distinct from {sql_literal(row["confidence"])}
          and tags is not distinct from {tags}
-         and created_by is not distinct from {sql_literal(row['created_by'])}::uuid
+         and created_by is not distinct from {sql_literal(row["created_by"])}::uuid
-         and superseded_by is not distinct from {sql_literal(row['superseded_by'])}::uuid) then
+         and superseded_by is not distinct from {sql_literal(row["superseded_by"])}::uuid) then
-    raise exception 'approve_claim: claim row does not match strict apply payload: %', {sql_literal(row['id'])};
+    raise exception 'approve_claim: claim row does not match strict apply payload: %', {sql_literal(row["id"])};
   end if;"""
         )
 
     for row in sources:
+        conflict_clause = ";" if fresh_owned else "\non conflict do nothing;"
         statements.append(
             f"""insert into public.sources (id, source_type, url, storage_path, excerpt, hash, created_by)
-select {sql_literal(row['id'])}::uuid, {sql_literal(row['source_type'])}, {sql_literal(row['url'])},
+select {sql_literal(row["id"])}::uuid, {sql_literal(row["source_type"])}, {sql_literal(row["url"])},
-       {sql_literal(row['storage_path'])}, {sql_literal(row['excerpt'])}, {sql_literal(row['hash'])},
+       {sql_literal(row["storage_path"])}, {sql_literal(row["excerpt"])}, {sql_literal(row["hash"])},
-       {sql_literal(row['created_by'])}::uuid
+       {sql_literal(row["created_by"])}::uuid{conflict_clause}"""
-on conflict do nothing;"""
         )
         checks.append(
             f"""  if exists (select 1 from public.sources
-       where hash = {sql_literal(row['hash'])}
+       where hash = {sql_literal(row["hash"])}
-         and id <> {sql_literal(row['id'])}::uuid) then
+         and id <> {sql_literal(row["id"])}::uuid) then
-    raise exception 'approve_claim: source hash collision for source %', {sql_literal(row['id'])};
+    raise exception 'approve_claim: source hash collision for source %', {sql_literal(row["id"])};
   end if;
   if not exists (select 1 from public.sources
-       where id = {sql_literal(row['id'])}::uuid
+       where id = {sql_literal(row["id"])}::uuid
-         and source_type = {sql_literal(row['source_type'])}
+         and source_type = {sql_literal(row["source_type"])}
-         and url is not distinct from {sql_literal(row['url'])}
+         and url is not distinct from {sql_literal(row["url"])}
-         and storage_path is not distinct from {sql_literal(row['storage_path'])}
+         and storage_path is not distinct from {sql_literal(row["storage_path"])}
-         and excerpt is not distinct from {sql_literal(row['excerpt'])}
+         and excerpt is not distinct from {sql_literal(row["excerpt"])}
-         and hash = {sql_literal(row['hash'])}
+         and hash = {sql_literal(row["hash"])}
-         and created_by is not distinct from {sql_literal(row['created_by'])}::uuid) then
+         and created_by is not distinct from {sql_literal(row["created_by"])}::uuid) then
-    raise exception 'approve_claim: source row does not match strict apply payload: %', {sql_literal(row['id'])};
+    raise exception 'approve_claim: source row does not match strict apply payload: %', {sql_literal(row["id"])};
   end if;"""
         )
 
     for row in reasoning_tools:
+        conflict_clause = ";" if fresh_owned else "\non conflict (id) do nothing;"
         statements.append(
             f"""insert into public.reasoning_tools (id, agent_id, name, description, category)
-select {sql_literal(row['id'])}::uuid, {sql_literal(row['agent_id'])}::uuid,
+select {sql_literal(row["id"])}::uuid, {sql_literal(row["agent_id"])}::uuid,
-       {sql_literal(row['name'])}, {sql_literal(row['description'])}, {sql_literal(row['category'])}
+       {sql_literal(row["name"])}, {sql_literal(row["description"])}, {sql_literal(row["category"])}{conflict_clause}"""
-on conflict (id) do nothing;"""
         )
         checks.append(
             f"""  if not exists (select 1 from public.reasoning_tools
-       where id = {sql_literal(row['id'])}::uuid
+       where id = {sql_literal(row["id"])}::uuid
-         and agent_id is not distinct from {sql_literal(row['agent_id'])}::uuid
+         and agent_id is not distinct from {sql_literal(row["agent_id"])}::uuid
-         and name = {sql_literal(row['name'])}
+         and name = {sql_literal(row["name"])}
-         and description = {sql_literal(row['description'])}
+         and description = {sql_literal(row["description"])}
-         and category is not distinct from {sql_literal(row['category'])}) then
+         and category is not distinct from {sql_literal(row["category"])}) then
-    raise exception 'approve_claim: reasoning tool row does not match strict apply payload: %', {sql_literal(row['id'])};
+    raise exception 'approve_claim: reasoning tool row does not match strict apply payload: %', {sql_literal(row["id"])};
   end if;"""
         )
 
     for row in evidence:
+        conflict_clause = ";" if fresh_owned else "\non conflict (claim_id, source_id, role) do nothing;"
         statements.append(
             f"""insert into public.claim_evidence (claim_id, source_id, role, weight, created_by)
-select {sql_literal(row['claim_id'])}::uuid, {sql_literal(row['source_id'])}::uuid,
+select {sql_literal(row["claim_id"])}::uuid, {sql_literal(row["source_id"])}::uuid,
-       {sql_literal(row['role'])}::evidence_role, {sql_literal(row['weight'])},
+       {sql_literal(row["role"])}::evidence_role, {sql_literal(row["weight"])},
-       {sql_literal(row['created_by'])}::uuid
+       {sql_literal(row["created_by"])}::uuid{conflict_clause}"""
-on conflict (claim_id, source_id, role) do nothing;"""
         )
         checks.append(
-            f"""  if exists (select 1 from public.claim_evidence
+            f"""  -- Accept a legacy receipt id only when exactly one semantic row matches.
-       where claim_id = {sql_literal(row['claim_id'])}::uuid
+  if (select count(*) from public.claim_evidence
-         and source_id = {sql_literal(row['source_id'])}::uuid
+       where claim_id = {sql_literal(row["claim_id"])}::uuid
-         and role = {sql_literal(row['role'])}::evidence_role
+         and source_id = {sql_literal(row["source_id"])}::uuid
-         and (weight is distinct from {sql_literal(row['weight'])}
+         and role = {sql_literal(row["role"])}::evidence_role) <> 1 then
-           or created_by is distinct from {sql_literal(row['created_by'])}::uuid)) then
+    raise exception 'approve_claim: evidence row does not match strict apply payload';
+  end if;
+  if exists (select 1 from public.claim_evidence
+       where claim_id = {sql_literal(row["claim_id"])}::uuid
+         and source_id = {sql_literal(row["source_id"])}::uuid
+         and role = {sql_literal(row["role"])}::evidence_role
+         and (weight is distinct from {sql_literal(row["weight"])}
+           or created_by is distinct from {sql_literal(row["created_by"])}::uuid)) then
     raise exception 'approve_claim: evidence row does not match strict apply payload';
   end if;
   if not exists (select 1 from public.claim_evidence
-       where claim_id = {sql_literal(row['claim_id'])}::uuid
+       where claim_id = {sql_literal(row["claim_id"])}::uuid
-         and source_id = {sql_literal(row['source_id'])}::uuid
+         and source_id = {sql_literal(row["source_id"])}::uuid
-         and role = {sql_literal(row['role'])}::evidence_role
+         and role = {sql_literal(row["role"])}::evidence_role
-         and weight is not distinct from {sql_literal(row['weight'])}
+         and weight is not distinct from {sql_literal(row["weight"])}
-         and created_by is not distinct from {sql_literal(row['created_by'])}::uuid) then
+         and created_by is not distinct from {sql_literal(row["created_by"])}::uuid) then
     raise exception 'approve_claim: evidence row does not match strict apply payload';
   end if;"""
         )
 
     for row in edges:
-        edge_lock_key = (
+        edge_lock_key = f"claim_edge:{row['from_claim']}:{row['to_claim']}:{row['edge_type']}"
-            f"claim_edge:{row['from_claim']}:{row['to_claim']}:{row['edge_type']}"
+        edge_insert_guard = (
+            ";"
+            if fresh_owned
+            else f"""\n where not exists (
+   select 1 from public.claim_edges
+    where from_claim = {sql_literal(row["from_claim"])}::uuid
+      and to_claim = {sql_literal(row["to_claim"])}::uuid
+      and edge_type = {sql_literal(row["edge_type"])}::edge_type);"""
         )
         statements.append(
             f"""select pg_advisory_xact_lock(hashtextextended({sql_literal(edge_lock_key)}, 0));
-insert into public.claim_edges (from_claim, to_claim, edge_type, weight, created_by)
+insert into public.claim_edges (id, from_claim, to_claim, edge_type, weight, created_by)
-select {sql_literal(row['from_claim'])}::uuid, {sql_literal(row['to_claim'])}::uuid,
+select {sql_literal(row["id"])}::uuid, {sql_literal(row["from_claim"])}::uuid, {sql_literal(row["to_claim"])}::uuid,
-       {sql_literal(row['edge_type'])}::edge_type, {sql_literal(row['weight'])},
+       {sql_literal(row["edge_type"])}::edge_type, {sql_literal(row["weight"])},
-       {sql_literal(row['created_by'])}::uuid
+       {sql_literal(row["created_by"])}::uuid{edge_insert_guard}"""
- where not exists (
-   select 1 from public.claim_edges
-    where from_claim = {sql_literal(row['from_claim'])}::uuid
-      and to_claim = {sql_literal(row['to_claim'])}::uuid
-      and edge_type = {sql_literal(row['edge_type'])}::edge_type);"""
         )
         checks.append(
-            f"""  if exists (select 1 from public.claim_edges
+            f"""  -- Accept a legacy receipt id only when exactly one semantic row matches.
-       where from_claim = {sql_literal(row['from_claim'])}::uuid
+  if (select count(*) from public.claim_edges
-         and to_claim = {sql_literal(row['to_claim'])}::uuid
+       where from_claim = {sql_literal(row["from_claim"])}::uuid
-         and edge_type = {sql_literal(row['edge_type'])}::edge_type
+         and to_claim = {sql_literal(row["to_claim"])}::uuid
-         and (weight is distinct from {sql_literal(row['weight'])}
+         and edge_type = {sql_literal(row["edge_type"])}::edge_type) <> 1 then
-           or created_by is distinct from {sql_literal(row['created_by'])}::uuid)) then
+    raise exception 'approve_claim: edge row does not match strict apply payload';
+  end if;
+  if exists (select 1 from public.claim_edges
+       where from_claim = {sql_literal(row["from_claim"])}::uuid
+         and to_claim = {sql_literal(row["to_claim"])}::uuid
+         and edge_type = {sql_literal(row["edge_type"])}::edge_type
+         and (weight is distinct from {sql_literal(row["weight"])}
+           or created_by is distinct from {sql_literal(row["created_by"])}::uuid)) then
     raise exception 'approve_claim: edge row does not match strict apply payload';
   end if;
   if not exists (select 1 from public.claim_edges
-       where from_claim = {sql_literal(row['from_claim'])}::uuid
+       where from_claim = {sql_literal(row["from_claim"])}::uuid
-         and to_claim = {sql_literal(row['to_claim'])}::uuid
+         and to_claim = {sql_literal(row["to_claim"])}::uuid
-         and edge_type = {sql_literal(row['edge_type'])}::edge_type
+         and edge_type = {sql_literal(row["edge_type"])}::edge_type
-         and weight is not distinct from {sql_literal(row['weight'])}
+         and weight is not distinct from {sql_literal(row["weight"])}
-         and created_by is not distinct from {sql_literal(row['created_by'])}::uuid) then
+         and created_by is not distinct from {sql_literal(row["created_by"])}::uuid) then
     raise exception 'approve_claim: edge row does not match strict apply payload';
   end if;"""
         )
 
     canonical = "\n\n".join(statements)
-    ledger = _ledger_and_verify(
+    ledger = _ledger_and_verify(proposal_id, applied_by or SERVICE_AGENT_HANDLE, "\n".join(checks), approval)
-        proposal_id, applied_by or SERVICE_AGENT_HANDLE, "\n".join(checks), approval
+    return _wrap_txn(
+        canonical,
+        ledger,
+        _approval_guard_sql(proposal_id, approval),
+        serializable=fresh_owned,
     )
-    return _wrap_txn(canonical, ledger, _approval_guard_sql(proposal_id, approval))
 
 
-def _wrap_txn(canonical_sql: str, ledger_sql: str, approval_guard_sql: str) -> str:
+def _wrap_txn(
+    canonical_sql: str,
+    ledger_sql: str,
+    approval_guard_sql: str,
+    *,
+    serializable: bool = False,
+) -> str:
     return (
         "begin;\n"
-        "set local standard_conforming_strings = on;\n"
+        + ("set transaction isolation level serializable;\n" if serializable else "")
-        f"{approval_guard_sql}\n"
+        + "set local standard_conforming_strings = on;\n"
-        f"{canonical_sql}\n"
+        + f"{approval_guard_sql}\n"
-        f"{ledger_sql}\n"
+        + f"{canonical_sql}\n"
-        "commit;\n"
+        + f"{ledger_sql}\n"
+        + "commit;\n"
     )
 
 
@@ -813,7 +884,13 @@ BUILDERS = {
 }
 
 
-def build_apply_sql(proposal: dict[str, Any], applied_by: str | None) -> str:
+def build_apply_sql(
+    proposal: dict[str, Any],
+    applied_by: str | None,
+    *,
+    fresh_owned: bool = False,
+    fresh_preflight_sha256: str | None = None,
+) -> str:
     ptype = proposal["proposal_type"]
     if ptype not in BUILDERS:
         raise ValueError(f"apply_proposal cannot apply proposal_type {ptype!r}")
@@ -824,6 +901,17 @@ def build_apply_sql(proposal: dict[str, Any], applied_by: str | None) -> str:
             "proposal payload has no 'apply_payload' strict contract. "
             "Run the normalizer to produce apply_payload before applying."
         )
+    if fresh_owned and ptype != "approve_claim":
+        raise ValueError("fresh-owned apply is supported only for approve_claim")
+    if ptype == "approve_claim":
+        return build_approve_claim_sql(
+            apply_payload,
+            proposal["id"],
+            applied_by or SERVICE_AGENT_HANDLE,
+            proposal,
+            fresh_owned=fresh_owned,
+            fresh_preflight_sha256=fresh_preflight_sha256,
+        )
     return BUILDERS[ptype](
         apply_payload,
         proposal["id"],
@@ -837,9 +925,7 @@ def assert_applyable(proposal: dict[str, Any]) -> None:
     if status == "applied":
         raise SystemExit(f"proposal {proposal['id']} is already applied (idempotent no-op)")
     if status != "approved":
-        raise SystemExit(
+        raise SystemExit(f"proposal {proposal['id']} has status {status!r}; only 'approved' proposals apply")
-            f"proposal {proposal['id']} has status {status!r}; only 'approved' proposals apply"
-        )
 
 
 def assert_receiptable(proposal: dict[str, Any]) -> None:
@@ -877,23 +963,36 @@ def run_psql(
 ) -> str:
     docker_binary = shutil.which("docker") or "docker"
     command = [
-        docker_binary, "exec", "-e", "PGPASSWORD", "-i", args.container,
+        docker_binary,
-        "psql", "-U", args.role, "-h", args.host, "-d", args.db,
+        "exec",
-        "-v", "ON_ERROR_STOP=1", "-At", "-q",
+        "-e",
+        "PGPASSWORD",
+        "-i",
+        args.container,
+        "psql",
+        "-U",
+        args.role,
+        "-h",
+        args.host,
+        "-d",
+        args.db,
+        "-v",
+        "ON_ERROR_STOP=1",
+        "-At",
+        "-q",
     ]
     result = subprocess.run(
-        command, input=sql, text=True, capture_output=True,
+        command,
+        input=sql,
+        text=True,
+        capture_output=True,
         env={"PGPASSWORD": password, "PATH": "/usr/bin:/bin:/usr/local/bin"},
         check=False,
     )
     if result.returncode != 0:
         if redact_output_on_error:
-            raise SystemExit(
+            raise SystemExit(f"psql failed ({result.returncode}); private postflight output redacted")
-                f"psql failed ({result.returncode}); private postflight output redacted"
+        raise SystemExit(f"psql failed ({result.returncode})\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}")
-            )
-        raise SystemExit(
-            f"psql failed ({result.returncode})\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
-        )
     return result.stdout
 
 
@@ -940,7 +1039,7 @@ def capture_replay_receipt(
         raise RuntimeError("postflight query did not return a JSON object")
     apply_sql_source = "exact_executed_sql"
     if apply_sql is None:
-        apply_sql = build_apply_sql(proposal, proposal.get("applied_by_handle"))
+        apply_sql = build_apply_sql_for_args(proposal, args, proposal.get("applied_by_handle"))
         apply_sql_source = "reconstructed_current_engine"
     receipt = replay_receipt.build_replay_receipt(
         proposal,
@@ -972,6 +1071,14 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     p.add_argument("--db", default=DEFAULT_DB)
     p.add_argument("--host", default=DEFAULT_HOST)
     p.add_argument("--role", default=DEFAULT_ROLE)
+    p.add_argument(
+        "--fresh-preflight",
+        type=Path,
+        help=(
+            "exact proposal_apply_fresh_preflight JSON; makes approve_claim use strict fresh-owned inserts "
+            "bound to the timestamped preflight"
+        ),
+    )
     p.add_argument(
         "--receipt-only",
         action="store_true",
@@ -980,8 +1087,7 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     p.add_argument(
         "--receipt-dir",
         default=None,
-        help="private receipt directory (default: KB_APPLY_RECEIPT_DIR or "
+        help=f"private receipt directory (default: KB_APPLY_RECEIPT_DIR or {replay_receipt.DEFAULT_RECEIPT_DIR})",
-        f"{replay_receipt.DEFAULT_RECEIPT_DIR})",
     )
     p.add_argument(
         "--receipt-out",
@@ -994,6 +1100,28 @@ def parse_args(argv: list[str]) -> argparse.Namespace:
     return args
 
 
+def build_apply_sql_for_args(
+    proposal: dict[str, Any],
+    args: argparse.Namespace,
+    applied_by: str | None,
+) -> str:
+    fresh_preflight_path = getattr(args, "fresh_preflight", None)
+    if fresh_preflight_path is None:
+        return build_apply_sql(proposal, applied_by)
+    if not fresh_preflight_path.is_file():
+        raise SystemExit(f"fresh preflight file not found: {fresh_preflight_path}")
+    try:
+        preflight = json.loads(fresh_preflight_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise SystemExit(f"fresh preflight is unreadable: {fresh_preflight_path}") from exc
+    import proposal_apply_lifecycle as lifecycle
+
+    try:
+        return lifecycle.build_fresh_owned_apply_sql(proposal, preflight, applied_by)
+    except ValueError as exc:
+        raise SystemExit(f"fresh preflight refused: {exc}") from exc
+
+
 def main(argv: list[str] | None = None) -> int:
     args = parse_args(sys.argv[1:] if argv is None else argv)
 
@@ -1020,13 +1148,13 @@ def main(argv: list[str] | None = None) -> int:
         password = load_password(args.secrets_file)
         proposal = load_proposal(args, password)
         assert_applyable(proposal)
-        print(build_apply_sql(proposal, args.applied_by))
+        print(build_apply_sql_for_args(proposal, args, args.applied_by))
         return 0
 
     password = load_password(args.secrets_file)
     proposal = load_proposal(args, password)
     assert_applyable(proposal)
-    sql = build_apply_sql(proposal, args.applied_by)
+    sql = build_apply_sql_for_args(proposal, args, args.applied_by)
     run_psql(args, sql, password)
     applied_proposal = load_proposal(args, password)
     try:

scripts/apply_worker.py

@@ -35,6 +35,7 @@ from __future__ import annotations
 import argparse
 import json
 import os
+import stat
 import subprocess
 import sys
 from pathlib import Path
@@ -53,6 +54,13 @@ WORKER_TYPES = ap.APPLYABLE_TYPES
 # bundles and evidence/edge applies do not trigger a generic identity render.
 RENDER_TYPES = ("revise_strategy",)
 
+POSTCOMMIT_RECEIPT_FAILURE_MARKER = "committed, but private replay receipt capture failed"
+POSTCOMMIT_RECEIPT_RECOVERY_MARKER = ". Recover without reapplying via: "
+
+
+class PostCommitReceiptError(RuntimeError):
+    """The proposal committed, but its private row-level receipt is unavailable."""
+
 
 # --------------------------------------------------------------------------- #
 # Pure helpers (unit-tested without a DB)                                      #
@@ -160,14 +168,69 @@ def partition_candidates(
     return {"poisoned": poisoned, "to_apply": eligible[: max(0, max_per_tick)]}
 
 
+def has_exact_postcommit_receipt_failure(stderr: str | None, proposal_id: str) -> bool:
+    """Recognize only the proposal-bound post-COMMIT message from apply_proposal.
+
+    The old marker can occur inside payload-validation tracebacks (for example,
+    as an attacker-controlled unknown field name).  Requiring the complete
+    engine message shape prevents those pre-COMMIT failures from bypassing the
+    normal failure and poison-pill accounting.
+    """
+    prefix = f"proposal {proposal_id} {POSTCOMMIT_RECEIPT_FAILURE_MARKER}: "
+    recovery_suffix = f" {proposal_id} --receipt-only"
+    for line in (stderr or "").splitlines():
+        candidate = line.rstrip("\r")
+        if (
+            candidate.startswith(prefix)
+            and POSTCOMMIT_RECEIPT_RECOVERY_MARKER in candidate[len(prefix) :]
+            and candidate.endswith(recovery_suffix)
+        ):
+            return True
+    return False
+
+
+def receipt_path_for_proposal(args: argparse.Namespace, proposal_id: str) -> Path:
+    """Return the explicit, deterministic private receipt path for one proposal."""
+    receipt_dir = (
+        getattr(args, "receipt_dir", None)
+        or os.environ.get("KB_APPLY_WORKER_RECEIPT_DIR")
+        or os.environ.get("KB_APPLY_RECEIPT_DIR")
+        or ap.replay_receipt.DEFAULT_RECEIPT_DIR
+    )
+    return Path(receipt_dir).expanduser().resolve() / f"{proposal_id}.json"
+
+
+def assert_private_replay_receipt(path: Path, proposal_id: str) -> None:
+    """Verify the worker can rely on the exact private row-level receipt."""
+    try:
+        path_stat = path.lstat()
+    except OSError as exc:
+        raise RuntimeError("private replay receipt was not written") from exc
+    if not stat.S_ISREG(path_stat.st_mode) or path.is_symlink():
+        raise RuntimeError("private replay receipt is not a regular file")
+    if stat.S_IMODE(path_stat.st_mode) & 0o077:
+        raise RuntimeError("private replay receipt permissions are broader than 0600")
+    try:
+        receipt = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise RuntimeError("private replay receipt is unreadable or invalid") from exc
+    if not isinstance(receipt, dict):
+        raise RuntimeError("private replay receipt is not a JSON object")
+    try:
+        ap.replay_receipt.validate_replay_receipt(
+            receipt,
+            expected_proposal_id=str(proposal_id),
+        )
+    except ValueError as exc:
+        raise RuntimeError("private replay receipt row-level contract is invalid") from exc
+
+
 # --------------------------------------------------------------------------- #
 # Side-effecting steps                                                         #
 # --------------------------------------------------------------------------- #
 def _psql_args(args: argparse.Namespace) -> argparse.Namespace:
     """Namespace shaped for ap.run_psql (reuses the kb_apply connection path)."""
-    return argparse.Namespace(
+    return argparse.Namespace(container=args.container, db=args.db, host=args.host, role=args.role)
-        container=args.container, db=args.db, host=args.host, role=args.role
-    )
 
 
 def fetch_candidates(
@@ -181,19 +244,72 @@ def fetch_candidates(
 
 
 def apply_one(args: argparse.Namespace, proposal_id: str) -> None:
-    """Apply via the audited apply_proposal.py CLI -- same txn + rowcount guard."""
+    """Apply once and retain or safely recover the exact private replay receipt."""
+    receipt_path = receipt_path_for_proposal(args, proposal_id)
     cmd = [
-        sys.executable, str(args.apply_script), proposal_id,
+        sys.executable,
-        "--applied-by", args.applied_by,
+        str(args.apply_script),
-        "--secrets-file", args.secrets_file,
+        proposal_id,
-        "--container", args.container, "--db", args.db,
+        "--applied-by",
-        "--host", args.host, "--role", args.role,
+        args.applied_by,
+        "--secrets-file",
+        args.secrets_file,
+        "--container",
+        args.container,
+        "--db",
+        args.db,
+        "--host",
+        args.host,
+        "--role",
+        args.role,
+        "--receipt-dir",
+        str(receipt_path.parent),
+        "--receipt-out",
+        str(receipt_path),
     ]
     result = subprocess.run(cmd, text=True, capture_output=True, check=False)
-    if result.returncode != 0:
+    committed = result.returncode == 0 or has_exact_postcommit_receipt_failure(
-        raise RuntimeError(
+        result.stderr,
-            f"apply failed for {proposal_id}: {result.stdout.strip()} {result.stderr.strip()}"
+        proposal_id,
     )
+    if not committed:
+        raise RuntimeError(
+            f"apply failed for {proposal_id}: {(result.stdout or '').strip()} {(result.stderr or '').strip()}"
+        )
+
+    if result.returncode == 0:
+        try:
+            assert_private_replay_receipt(receipt_path, proposal_id)
+            return
+        except RuntimeError:
+            # The engine returned only after COMMIT. A missing/invalid receipt is
+            # recoverable without replaying the apply transaction.
+            pass
+
+    try:
+        recovery = subprocess.run(
+            [*cmd, "--receipt-only"],
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+    except OSError as exc:
+        raise PostCommitReceiptError(
+            f"proposal {proposal_id} committed, but the read-only receipt recovery "
+            "command could not start; do not retry the apply transaction"
+        ) from exc
+    if recovery.returncode != 0:
+        raise PostCommitReceiptError(
+            f"proposal {proposal_id} committed, but read-only receipt recovery "
+            f"failed (exit {recovery.returncode}); do not retry the apply transaction"
+        )
+    try:
+        assert_private_replay_receipt(receipt_path, proposal_id)
+    except RuntimeError as exc:
+        raise PostCommitReceiptError(
+            f"proposal {proposal_id} committed, but receipt recovery did not produce "
+            "a valid private row-level receipt; do not retry the apply transaction"
+        ) from exc
 
 
 def render_one(args: argparse.Namespace, agent_id: str | None) -> str:
@@ -202,9 +318,7 @@ def render_one(args: argparse.Namespace, agent_id: str | None) -> str:
         return "render skipped (no render-cmd configured; PR2 renderer not deployed)"
     result = subprocess.run(cmd, text=True, capture_output=True, check=False)
     if result.returncode != 0:
-        raise RuntimeError(
+        raise RuntimeError(f"render failed for agent {agent_id}: {result.stdout.strip()} {result.stderr.strip()}")
-            f"render failed for agent {agent_id}: {result.stdout.strip()} {result.stderr.strip()}"
-        )
     return f"rendered agent {agent_id}"
 
 
@@ -214,11 +328,7 @@ def render_one(args: argparse.Namespace, agent_id: str | None) -> str:
 def run(args: argparse.Namespace) -> int:
     password = ap.load_password(args.secrets_file)
     failure_counts = load_failure_state(args.failure_state_file)
-    exhausted_ids = tuple(
+    exhausted_ids = tuple(proposal_id for proposal_id, count in failure_counts.items() if count >= args.max_attempts)
-        proposal_id
-        for proposal_id, count in failure_counts.items()
-        if count >= args.max_attempts
-    )
     candidates = fetch_candidates(args, password, exhausted_ids)
 
     for proposal_id in exhausted_ids:
@@ -263,6 +373,15 @@ def run(args: argparse.Namespace) -> int:
             print(f"applied {pid} ({ptype})")
             if ptype in RENDER_TYPES:
                 print("  " + render_one(args, agent_id))
+        except PostCommitReceiptError as exc:
+            failures += 1
+            # The canonical transaction already committed. Do not classify this
+            # as an apply failure or poison/retry the proposal; receipt-only is
+            # the sole safe recovery path.
+            print(
+                f"POST-COMMIT RECEIPT ERROR for {pid} ({ptype}): {exc}",
+                file=sys.stderr,
+            )
         except Exception as exc:
             failures += 1
             # Leave the proposal at 'approved' so a fixed one reapplies next tick
@@ -270,48 +389,65 @@ def run(args: argparse.Namespace) -> int:
             # so a deterministically-failing proposal hits the ceiling instead of
             # retrying forever. Surface loudly for the operator.
             failure_counts[pid] = failure_counts.get(pid, 0) + 1
-            print(f"ERROR applying {pid} ({ptype}) [attempt {failure_counts[pid]}/"
+            print(
-                  f"{args.max_attempts}]: {exc}", file=sys.stderr)
+                f"ERROR applying {pid} ({ptype}) [attempt {failure_counts[pid]}/{args.max_attempts}]: {exc}",
+                file=sys.stderr,
+            )
 
     save_failure_state(args.failure_state_file, failure_counts)
     return 1 if failures else 0
 
 
 def parse_args(argv: list[str]) -> argparse.Namespace:
-    p = argparse.ArgumentParser(
+    p = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
-        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
-    )
     p.add_argument(
-        "--enable", action="store_true",
+        "--enable",
+        action="store_true",
         help="actually apply (default: report-only). Also honored via KB_APPLY_WORKER_ENABLED=1.",
     )
     p.add_argument("--limit", type=int, default=20, help="max candidates fetched per tick")
     p.add_argument(
-        "--max-per-tick", type=int, default=1,
+        "--max-per-tick",
+        type=int,
+        default=1,
         help="max proposals actually APPLIED per tick (default 1: applies land "
         "one-at-a-time and observably, not a whole-queue drain)",
     )
     p.add_argument(
-        "--max-attempts", type=int, default=3,
+        "--max-attempts",
+        type=int,
+        default=3,
         help="consecutive apply failures before a proposal is treated as a "
         "poison pill and skipped (needs a human fix, not endless retries)",
     )
     p.add_argument(
         "--failure-state-file",
         default=os.environ.get("KB_APPLY_WORKER_STATE", "/opt/teleo-eval/logs/kb-apply-worker-failures.json"),
-        help="persisted per-proposal failure counts (survives oneshot ticks so "
+        help="persisted per-proposal failure counts (survives oneshot ticks so the poison-pill ceiling actually bites)",
-        "the poison-pill ceiling actually bites)",
     )
     p.add_argument(
-        "--applied-by", default=ap.SERVICE_AGENT_HANDLE,
+        "--applied-by",
+        default=ap.SERVICE_AGENT_HANDLE,
         help="handle recorded as applied_by (default: the kb-apply service agent)",
     )
     p.add_argument(
-        "--apply-script", default=str(HERE / "apply_proposal.py"),
+        "--apply-script",
+        default=str(HERE / "apply_proposal.py"),
         help="path to the apply_proposal.py engine (the sole apply path)",
     )
     p.add_argument(
-        "--render-cmd", default=os.environ.get("KB_APPLY_RENDER_CMD", ""),
+        "--receipt-dir",
+        default=(
+            os.environ.get("KB_APPLY_WORKER_RECEIPT_DIR")
+            or os.environ.get("KB_APPLY_RECEIPT_DIR")
+            or ap.replay_receipt.DEFAULT_RECEIPT_DIR
+        ),
+        help="private replay receipt directory; each apply writes the deterministic "
+        "<proposal-id>.json path and verifies 0600 permissions",
+    )
+    p.add_argument(
+        "--render-cmd",
+        default=os.environ.get("KB_APPLY_RENDER_CMD", ""),
         help="render hook template, e.g. 'python3 render_soul.py --agent-id {agent_id}'. "
         "Empty (default) skips render until the SOUL renderer is deployed.",
     )

scripts/build_telegram_visible_unseen_chain_packet.py

@@ -0,0 +1,406 @@
+#!/usr/bin/env python3
+"""Build the exact no-send packet for Leo's unseen Telegram reasoning chain."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+try:
+    import verify_leo_unseen_reasoning_chain as unseen
+except ImportError:  # pragma: no cover - imported as scripts.* in tests
+    from scripts import verify_leo_unseen_reasoning_chain as unseen
+
+SCHEMA = "livingip.telegramVisibleUnseenChainPacket.v2"
+REPO_ROOT = Path(__file__).resolve().parents[1]
+REPORT_DIR = Path("docs/reports/leo-working-state-20260709")
+DEFAULT_HANDLER_RECEIPT = REPORT_DIR / "leo-unseen-reasoning-chain-canary-current.json"
+DEFAULT_OUT = REPORT_DIR / "telegram-visible-unseen-chain-authorization-packet-current.json"
+DEFAULT_MARKDOWN_OUT = REPORT_DIR / "telegram-visible-unseen-chain-authorization-packet-current.md"
+DEFAULT_CAPTURE_RECEIPT = REPORT_DIR / "telegram-visible-unseen-chain-capture-receipt-current.json"
+DEFAULT_PREFLIGHT = REPORT_DIR / "telegram-visible-unseen-chain-preflight-current.json"
+DEFAULT_POSTFLIGHT = REPORT_DIR / "telegram-visible-unseen-chain-postflight-current.json"
+DEFAULT_CHAT_ID = "-5146042086"
+DEFAULT_CHAT_LABEL = "Leo"
+DEFAULT_PROOF_DIR = "outputs/telegram-visible-unseen-chain-20260715"
+DEFAULT_MANIFEST_SQL = Path("ops/postgres_parity_manifest.sql")
+READ_ONLY_DB_ROLE = "pg_read_all_data"
+DEFAULT_CODEX_THREAD_ID = "019f6350-3350-7040-b223-c5c22673fece"
+TOOLING_PATHS = {
+    "packet_builder": Path("scripts/build_telegram_visible_unseen_chain_packet.py"),
+    "state_collector": Path("scripts/collect_telegram_visible_unseen_chain_state.py"),
+    "capture_verifier": Path("scripts/verify_telegram_visible_unseen_chain.py"),
+}
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _sha256_bytes(value: bytes) -> str:
+    return hashlib.sha256(value).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    return _sha256_bytes(path.read_bytes())
+
+
+def _canonical_sha256(value: Any) -> str:
+    encoded = json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return _sha256_bytes(encoded)
+
+
+def current_git_sha(repo_root: Path = Path(".")) -> str:
+    proc = subprocess.run(
+        ["git", "rev-parse", "HEAD"],
+        cwd=repo_root,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+    return proc.stdout.strip() if proc.returncode == 0 else ""
+
+
+def exact_messages() -> list[dict[str, Any]]:
+    messages = []
+    for sequence, prompt in enumerate(unseen.PROMPTS, start=1):
+        message = str(prompt["message"])
+        messages.append(
+            {
+                "sequence": sequence,
+                "prompt_id": prompt["id"],
+                "dimension": prompt["dimension"],
+                "message": message,
+                "message_sha256": _sha256_bytes(message.encode("utf-8")),
+                "wait_for_visible_reply_before_next": True,
+            }
+        )
+    return messages
+
+
+def tooling_binding(repo_root: Path = REPO_ROOT) -> dict[str, dict[str, Any]]:
+    return {name: {"path": str(path), "sha256": _sha256_file(repo_root / path)} for name, path in TOOLING_PATHS.items()}
+
+
+def manifest_binding(repo_root: Path = REPO_ROOT) -> dict[str, Any]:
+    return {
+        "path": str(DEFAULT_MANIFEST_SQL),
+        "sha256": _sha256_file(repo_root / DEFAULT_MANIFEST_SQL),
+        "execution_contract": {
+            "database": "teleo",
+            "authenticated_role": "postgres",
+            "effective_role": READ_ONLY_DB_ROLE,
+            "default_transaction_read_only": "on",
+            "transaction_read_only": "on",
+            "psql_rc_disabled": True,
+            "arbitrary_manifest_override_allowed": False,
+        },
+    }
+
+
+def _handler_checks(receipt: dict[str, Any]) -> dict[str, bool]:
+    safety = receipt.get("safety_gate") if isinstance(receipt.get("safety_gate"), dict) else {}
+    safety_checks = safety.get("checks") if isinstance(safety.get("checks"), dict) else {}
+    database = receipt.get("database") if isinstance(receipt.get("database"), dict) else {}
+    prompt_ids = [str(item["id"]) for item in unseen.PROMPTS]
+    return {
+        "handler_receipt_passed": receipt.get("status") == "pass",
+        "handler_receipt_schema_supported": receipt.get("schema") == unseen.SCHEMA,
+        "handler_prompt_ids_exact": receipt.get("prompt_ids") == prompt_ids,
+        "handler_outcomes_all_pass": bool(receipt.get("outcomes"))
+        and all(value is True for value in receipt.get("outcomes", {}).values()),
+        "handler_checks_all_pass": bool(receipt.get("checks"))
+        and all(value is True for value in receipt.get("checks", {}).values()),
+        "handler_safety_gate_passed": safety.get("status") == "pass",
+        "handler_proved_no_telegram_post": safety_checks.get("no_telegram_post") is True,
+        "handler_proved_read_only_tool_traces": safety_checks.get("all_tool_traces_read_only_and_bound") is True,
+        "handler_proved_unchanged_fingerprint": database.get("fingerprint_unchanged") is True
+        and isinstance(database.get("fingerprint_sha256"), str)
+        and len(database["fingerprint_sha256"]) == 64,
+        "handler_tier_remains_below_telegram_visible": "Telegram-visible message delivery"
+        in (receipt.get("claim_ceiling") or {}).get("not_proven", []),
+    }
+
+
+def _authorization_text(*, chat_label: str, chat_id: str, messages: list[dict[str, Any]]) -> str:
+    quoted = " ".join(f"[{item['prompt_id']}] {json.dumps(item['message'], ensure_ascii=True)}" for item in messages)
+    return (
+        "I authorize Codex to use the already-authenticated Chrome Telegram UI to send exactly these three "
+        f"messages, in order and with no additional messages, to the Telegram group {chat_label} (chat ID "
+        f"{chat_id}), waiting for Leo's visible reply after each turn: {quoted} Capture the visible replies, "
+        "message IDs, timestamps, screenshot and accessibility evidence, plus an independently retained Chrome "
+        "control provenance receipt bound to the Codex rollout's user-authorization and Chrome tool events; "
+        "perform only read-only DB/service "
+        "readbacks; do not use the Bot API; do not stage, approve, apply, or otherwise mutate knowledge."
+    )
+
+
+def build_packet(
+    *,
+    handler_receipt_path: Path = DEFAULT_HANDLER_RECEIPT,
+    chat_id: str = DEFAULT_CHAT_ID,
+    chat_label: str = DEFAULT_CHAT_LABEL,
+    proof_dir: str = DEFAULT_PROOF_DIR,
+    codex_thread_id: str = DEFAULT_CODEX_THREAD_ID,
+    git_sha: str | None = None,
+) -> dict[str, Any]:
+    handler_receipt = _load_json(handler_receipt_path)
+    messages = exact_messages()
+    handler_checks = _handler_checks(handler_receipt)
+    target = {
+        "platform": "telegram",
+        "chat_label": chat_label,
+        "chat_id": chat_id,
+        "allowed_transport": "authenticated_chrome_telegram_ui",
+        "forbidden_transports": ["telegram_bot_api", "copied_transcript", "handler_substitution"],
+        "message_count": len(messages),
+        "expected_prompt_ids": [item["prompt_id"] for item in messages],
+    }
+    handler_binding = {
+        "path": str(handler_receipt_path),
+        "sha256": _sha256_file(handler_receipt_path),
+        "schema": handler_receipt.get("schema"),
+        "proof_tier": handler_receipt.get("proof_tier"),
+        "remote_run_id": handler_receipt.get("remote_run_id"),
+        "deployed_git_head": handler_receipt.get("deployed_git_head"),
+        "fingerprint_sha256": (handler_receipt.get("database") or {}).get("fingerprint_sha256"),
+    }
+    tooling = tooling_binding()
+    manifest = manifest_binding()
+    browser_provenance_contract = {
+        "schema": "livingip.authenticatedChromeTelegramCaptureProvenance.v1",
+        "capture_channel": "codex_chrome_extension",
+        "requires_preflight_challenge_nonce": True,
+        "requires_codex_rollout_log_outside_evidence_root": True,
+        "requires_chrome_backend_tool_receipts": True,
+        "requires_provenance_sha256_in_final_chrome_tool_receipt": True,
+        "requires_codex_user_message_authorization_receipt": True,
+        "requires_browser_session_tab_and_capture_identifiers": True,
+        "requires_telegram_web_origin_and_chat_identity": True,
+        "requires_hashes_for_every_screenshot_and_accessibility_artifact": True,
+    }
+    protocol = {
+        "target": target,
+        "exact_messages": messages,
+        "handler_binding": handler_binding,
+        "tooling_binding": tooling,
+        "manifest_binding": manifest,
+        "browser_provenance_contract": browser_provenance_contract,
+        "operator_context": {
+            "codex_thread_id": codex_thread_id,
+            "authorization_source": "codex_platform_user_message",
+        },
+        "state_contract": {
+            "preflight": "two identical repeatable-read read-only canonical fingerprints",
+            "postflight": "same canonical fingerprint plus independent selected-object readback",
+            "service": "same active gateway process before and after",
+            "ordering": "preflight < authorization < send1 < reply1 < send2 < reply2 < send3 < reply3 < final/postflight",
+        },
+    }
+    protocol_sha256 = _canonical_sha256(protocol)
+    checks = {
+        **handler_checks,
+        "exact_three_turn_sequence": len(messages) == 3 and [item["sequence"] for item in messages] == [1, 2, 3],
+        "exact_prompts_imported_from_handler_verifier": [item["message"] for item in messages]
+        == [item["message"] for item in unseen.PROMPTS],
+        "first_prompt_supplies_no_row_id": unseen.UUID_RE.search(messages[0]["message"]) is None,
+        "authenticated_chrome_is_only_send_transport": target["allowed_transport"]
+        == "authenticated_chrome_telegram_ui",
+        "canonical_manifest_path_and_sha_bound": manifest == manifest_binding(),
+        "database_session_and_role_fail_closed_read_only": manifest["execution_contract"]["effective_role"]
+        == READ_ONLY_DB_ROLE
+        and manifest["execution_contract"]["default_transaction_read_only"] == "on"
+        and manifest["execution_contract"]["transaction_read_only"] == "on"
+        and manifest["execution_contract"]["arbitrary_manifest_override_allowed"] is False,
+        "independent_browser_provenance_required": browser_provenance_contract[
+            "requires_codex_rollout_log_outside_evidence_root"
+        ]
+        is True,
+        "packet_does_not_send": True,
+        "packet_does_not_mutate_database": True,
+    }
+    ready = all(checks.values())
+    authorization_text = _authorization_text(chat_label=chat_label, chat_id=chat_id, messages=messages)
+    proof_paths = {
+        "preflight_json": str(DEFAULT_PREFLIGHT),
+        "postflight_json": str(DEFAULT_POSTFLIGHT),
+        "capture_receipt_json": str(DEFAULT_CAPTURE_RECEIPT),
+        "capture_json": f"{proof_dir}/capture.json",
+        "turn_screenshots": [f"{proof_dir}/turn-{index}.png" for index in range(1, 4)],
+        "turn_accessibility": [f"{proof_dir}/turn-{index}-accessibility.txt" for index in range(1, 4)],
+        "final_screenshot": f"{proof_dir}/final.png",
+        "final_accessibility": f"{proof_dir}/final-accessibility.txt",
+        "browser_provenance": f"{proof_dir}/browser-provenance.json",
+    }
+    return {
+        "schema": SCHEMA,
+        "generated_at_utc": datetime.now(timezone.utc).isoformat(),
+        "mode": "telegram_visible_unseen_chain_exact_packet_not_sent",
+        "packet_generation_git_sha": git_sha if git_sha is not None else current_git_sha(),
+        "protocol_sha256": protocol_sha256,
+        "protocol": protocol,
+        "ready_to_request_action_time_authorization": ready,
+        "authorization_gate_status": "ready_to_request_exact_authorization" if ready else "not_ready",
+        "telegram_visible_messages_sent": False,
+        "telegram_visible_message_authorization_present": False,
+        "production_apply_executed": False,
+        "mutates_db": False,
+        "target": target,
+        "exact_messages": messages,
+        "handler_receipt_binding": handler_binding,
+        "tooling_binding": tooling,
+        "manifest_binding": manifest,
+        "browser_provenance_contract": browser_provenance_contract,
+        "operator_context": protocol["operator_context"],
+        "checks": checks,
+        "expected_proof_paths_after_authorized_run": proof_paths,
+        "explicit_operator_authorization_text": authorization_text,
+        "clear_CTA": (
+            "Reply with the exact authorization sentence in this packet. That sentence names the destination, "
+            "transport, complete message bodies, ordering, evidence, and no-mutation boundary."
+        ),
+        "next_non_user_action_after_authorization": [
+            "Re-run the zero-mutation preflight and confirm its packet file hash is current.",
+            "Use authenticated Chrome only and verify the Leo chat ID before typing anything.",
+            "Send one exact message, wait for Leo's visible reply, then continue to the next exact message.",
+            "Capture message IDs, timestamps, screenshot, accessibility text, and the Chrome-control provenance receipt without copying handler output.",
+            "Retain the Codex rollout path whose Chrome tool receipt contains the provenance SHA256.",
+            "Extract the selected DB object reference and run the read-only postflight with that reference.",
+            "Run the Telegram-visible verifier and accept T3 only if every visible and state check passes.",
+        ],
+        "claim_ceiling": {
+            "current_tier": "T0_spec_plus_prior_T2_handler_evidence",
+            "required_tier": "T3_live_readonly",
+            "proven": "The exact three-turn Chrome send packet is bound to a passing no-send handler receipt.",
+            "not_proven": [
+                "Telegram-visible delivery of these three messages",
+                "Telegram-visible replies from Leo",
+                "post-send canonical fingerprint equality",
+            ],
+        },
+    }
+
+
+def write_json(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def write_markdown(path: Path, data: dict[str, Any]) -> None:
+    target = data["target"]
+    lines = [
+        "# Telegram-Visible Unseen Chain Authorization Packet",
+        "",
+        f"Generated UTC: `{data['generated_at_utc']}`",
+        f"Protocol SHA256: `{data['protocol_sha256']}`",
+        f"Ready to request action-time authorization: `{data['ready_to_request_action_time_authorization']}`",
+        f"Telegram-visible messages sent: `{data['telegram_visible_messages_sent']}`",
+        f"Mutates DB: `{data['mutates_db']}`",
+        "",
+        "## Exact Destination",
+        "",
+        f"- Chat: `{target['chat_label']}` (`{target['chat_id']}`)",
+        f"- Transport: `{target['allowed_transport']}`",
+        "",
+        "## Exact Messages",
+        "",
+    ]
+    for item in data["exact_messages"]:
+        lines.extend(
+            [
+                f"### {item['sequence']}. {item['prompt_id']}",
+                "",
+                item["message"],
+                "",
+                f"SHA256: `{item['message_sha256']}`",
+                "",
+            ]
+        )
+    manifest = data["manifest_binding"]
+    execution = manifest["execution_contract"]
+    lines.extend(
+        [
+            "## Read-Only State Contract",
+            "",
+            f"- Manifest: `{manifest['path']}`",
+            f"- Manifest SHA256: `{manifest['sha256']}`",
+            f"- Effective DB role: `{execution['effective_role']}`",
+            f"- Transaction read only: `{execution['transaction_read_only']}`",
+            f"- Arbitrary manifest override allowed: `{execution['arbitrary_manifest_override_allowed']}`",
+            "",
+            "## Independent Capture Contract",
+            "",
+            f"- Codex thread: `{data['operator_context']['codex_thread_id']}`",
+            "- Authorization must be an exact platform user-message event in that thread's rollout.",
+            "- Each turn and final artifact must be bound by Chrome-backend tool receipts in that rollout.",
+            "",
+            "## Checks",
+            "",
+        ]
+    )
+    lines.extend(f"- `{key}`: `{value}`" for key, value in sorted(data["checks"].items()))
+    lines.extend(
+        [
+            "",
+            "## Exact Action-Time Authorization",
+            "",
+            data["explicit_operator_authorization_text"],
+            "",
+            "## Clear CTA",
+            "",
+            data["clear_CTA"],
+            "",
+            "## Claim Ceiling",
+            "",
+            f"Current tier: `{data['claim_ceiling']['current_tier']}`",
+            f"Required tier: `{data['claim_ceiling']['required_tier']}`",
+            "",
+        ]
+    )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--handler-receipt", type=Path, default=DEFAULT_HANDLER_RECEIPT)
+    parser.add_argument("--chat-id", default=DEFAULT_CHAT_ID)
+    parser.add_argument("--chat-label", default=DEFAULT_CHAT_LABEL)
+    parser.add_argument("--proof-dir", default=DEFAULT_PROOF_DIR)
+    parser.add_argument("--out", type=Path, default=DEFAULT_OUT)
+    parser.add_argument("--markdown-out", type=Path, default=DEFAULT_MARKDOWN_OUT)
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    data = build_packet(
+        handler_receipt_path=args.handler_receipt,
+        chat_id=args.chat_id,
+        chat_label=args.chat_label,
+        proof_dir=args.proof_dir,
+    )
+    write_json(args.out, data)
+    write_markdown(args.markdown_out, data)
+    print(
+        json.dumps(
+            {
+                "out": str(args.out),
+                "markdown_out": str(args.markdown_out),
+                "ready_to_request_action_time_authorization": data["ready_to_request_action_time_authorization"],
+                "telegram_visible_messages_sent": False,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+    return 0 if data["ready_to_request_action_time_authorization"] else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/collect_telegram_visible_unseen_chain_state.py

@@ -0,0 +1,788 @@
+#!/usr/bin/env python3
+"""Collect fail-closed read-only state for the unseen Telegram chain."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+import secrets
+import shlex
+import subprocess
+from collections.abc import Callable
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+try:
+    import build_telegram_visible_unseen_chain_packet as packet_builder
+    import verify_leo_unseen_reasoning_chain as unseen
+except ImportError:  # pragma: no cover - imported as scripts.* in tests
+    from scripts import build_telegram_visible_unseen_chain_packet as packet_builder
+    from scripts import verify_leo_unseen_reasoning_chain as unseen
+
+SCHEMA = "livingip.telegramVisibleUnseenChainState.v2"
+REPO_ROOT = Path(__file__).resolve().parents[1]
+REPORT_DIR = Path("docs/reports/leo-working-state-20260709")
+DEFAULT_PACKET = packet_builder.DEFAULT_OUT
+DEFAULT_PREFLIGHT_OUT = REPORT_DIR / "telegram-visible-unseen-chain-preflight-current.json"
+DEFAULT_PREFLIGHT_MARKDOWN_OUT = REPORT_DIR / "telegram-visible-unseen-chain-preflight-current.md"
+DEFAULT_POSTFLIGHT_OUT = REPORT_DIR / "telegram-visible-unseen-chain-postflight-current.json"
+DEFAULT_POSTFLIGHT_MARKDOWN_OUT = REPORT_DIR / "telegram-visible-unseen-chain-postflight-current.md"
+DEFAULT_SSH_TARGET = "root@77.42.65.182"
+DEFAULT_SSH_KEY = Path.home() / ".ssh/livingip_hetzner_20260604_ed25519"
+DEFAULT_MANIFEST_SQL = packet_builder.DEFAULT_MANIFEST_SQL
+REMOTE_REPO = "/opt/teleo-eval/workspaces/deploy-infra"
+SUBJECT_REF_RE = re.compile(
+    r"^(?:[0-9a-f]{8}|[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})$",
+    re.IGNORECASE,
+)
+SHA40_RE = re.compile(r"^[0-9a-f]{40}$")
+SHA64_RE = re.compile(r"^[0-9a-f]{64}$")
+FORBIDDEN_MANIFEST_SQL_RE = re.compile(
+    r"\b(?:insert|update|delete|merge|create|alter|drop|truncate|grant|revoke|copy|call|do|vacuum|"
+    r"refresh|reindex|cluster|commit|prepare|execute)\b|"
+    r"\\(?:!|i|ir|include|include_relative|copy)\b|"
+    r"\bset\s+(?:session\s+authorization|role)\b|"
+    r"\breset\s+(?:session\s+authorization|role)\b|"
+    r"\b(?:default_)?transaction_read_only\s*=\s*(?:off|false|0)\b|"
+    r"\btransaction\s+read\s+write\b",
+    re.IGNORECASE,
+)
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    returncode: int
+    stdout: str
+    stderr: str
+
+
+Runner = Callable[[list[str], str, int], CommandResult]
+
+
+def subprocess_runner(command: list[str], input_text: str, timeout: int) -> CommandResult:
+    try:
+        proc = subprocess.run(
+            command,
+            input=input_text,
+            text=True,
+            capture_output=True,
+            timeout=timeout,
+            check=False,
+        )
+    except subprocess.TimeoutExpired as exc:
+        return CommandResult(124, str(exc.stdout or ""), f"command timed out after {timeout}s")
+    return CommandResult(proc.returncode, proc.stdout, proc.stderr)
+
+
+def _load_json(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _canonical_sha256(value: Any) -> str:
+    encoded = json.dumps(value, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    return hashlib.sha256(encoded).hexdigest()
+
+
+def _sha256_file(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def canonical_manifest_path() -> Path:
+    return (REPO_ROOT / DEFAULT_MANIFEST_SQL).resolve()
+
+
+def _manifest_sql_is_statically_read_only(sql: str) -> bool:
+    normalized = re.sub(r"\s+", " ", sql).strip().casefold()
+    return (
+        normalized.startswith(r"\set on_error_stop on")
+        and "begin transaction isolation level repeatable read read only;" in normalized
+        and normalized.endswith("rollback;")
+        and FORBIDDEN_MANIFEST_SQL_RE.search(sql) is None
+    )
+
+
+def manifest_checks(packet: dict[str, Any], requested_path: Path | None = None) -> dict[str, bool]:
+    canonical_path = canonical_manifest_path()
+    binding = packet.get("manifest_binding") if isinstance(packet.get("manifest_binding"), dict) else {}
+    protocol = packet.get("protocol") if isinstance(packet.get("protocol"), dict) else {}
+    execution = binding.get("execution_contract") if isinstance(binding.get("execution_contract"), dict) else {}
+    try:
+        sql = canonical_path.read_text(encoding="utf-8")
+        actual_sha256 = _sha256_file(canonical_path)
+    except OSError:
+        sql = ""
+        actual_sha256 = ""
+    override_path = requested_path.resolve() if requested_path is not None else canonical_path
+    return {
+        "manifest_canonical_path_exists": canonical_path.is_file(),
+        "manifest_override_absent_or_exact_canonical_path": override_path == canonical_path,
+        "manifest_packet_path_is_exact_canonical_relative_path": binding.get("path") == str(DEFAULT_MANIFEST_SQL),
+        "manifest_packet_sha256_matches_canonical_file": bool(actual_sha256) and binding.get("sha256") == actual_sha256,
+        "manifest_protocol_binding_matches_packet": protocol.get("manifest_binding") == binding,
+        "manifest_sql_statically_read_only": bool(sql) and _manifest_sql_is_statically_read_only(sql),
+        "manifest_effective_role_is_read_only": execution.get("effective_role") == packet_builder.READ_ONLY_DB_ROLE,
+        "manifest_default_transaction_read_only_enforced": execution.get("default_transaction_read_only") == "on",
+        "manifest_transaction_read_only_enforced": execution.get("transaction_read_only") == "on",
+        "manifest_psql_rc_disabled": execution.get("psql_rc_disabled") is True,
+        "manifest_arbitrary_override_forbidden": execution.get("arbitrary_manifest_override_allowed") is False,
+    }
+
+
+def parse_key_value_lines(text: str) -> dict[str, str]:
+    values: dict[str, str] = {}
+    for line in text.splitlines():
+        if "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        values[key] = value.strip()
+    return values
+
+
+def parse_manifest_output(raw: str) -> dict[str, Any]:
+    rows = []
+    try:
+        for line in raw.splitlines():
+            candidate = line.strip()
+            if not candidate or candidate in {"BEGIN", "SET", "ROLLBACK"}:
+                continue
+            value = json.loads(candidate)
+            if isinstance(value, dict):
+                rows.append(value)
+    except (TypeError, json.JSONDecodeError) as exc:
+        return {"status": "error", "error": f"manifest_parse_error:{type(exc).__name__}"}
+
+    tables = {
+        f"{row['schema']}.{row['table']}": {
+            "row_count": int(row["row_count"]),
+            "rowset_md5": row["rowset_md5"],
+        }
+        for row in rows
+        if row.get("kind") == "table"
+    }
+    singleton_kinds = {
+        "schemas",
+        "extensions",
+        "application_roles",
+        "columns",
+        "constraints",
+        "indexes",
+        "sequences",
+        "views",
+        "functions",
+        "triggers",
+        "types",
+        "policies",
+    }
+    singleton = {str(row["kind"]): row.get("items", []) for row in rows if row.get("kind") in singleton_kinds}
+    identity_rows = [row for row in rows if row.get("kind") == "identity"]
+    if len(identity_rows) != 1 or not tables or singleton_kinds - set(singleton):
+        return {"status": "error", "error": "canonical_database_fingerprint_manifest_incomplete"}
+    identity = identity_rows[0]
+    stable = {
+        "identity": {
+            key: identity.get(key)
+            for key in (
+                "database",
+                "server_version_num",
+                "server_encoding",
+                "database_collation",
+                "database_ctype",
+                "transaction_read_only",
+            )
+        },
+        "singleton_sha256": {key: _canonical_sha256(value) for key, value in sorted(singleton.items())},
+        "tables": tables,
+    }
+    return {
+        "schema": "livingip.teleoCanonicalDatabaseFingerprint.v1",
+        "status": "ok",
+        "fingerprint_sha256": _canonical_sha256(stable),
+        "table_count": len(tables),
+        "total_rows": sum(item["row_count"] for item in tables.values()),
+        "table_rows_sha256": _canonical_sha256(tables),
+        "structure_sha256": _canonical_sha256(stable["singleton_sha256"]),
+        "transaction_read_only": identity.get("transaction_read_only"),
+        "current_user": identity.get("current_user"),
+    }
+
+
+def packet_checks(packet: dict[str, Any], *, requested_manifest_path: Path | None = None) -> dict[str, bool]:
+    target = packet.get("target") if isinstance(packet.get("target"), dict) else {}
+    protocol = packet.get("protocol") if isinstance(packet.get("protocol"), dict) else {}
+    packet_check_section = packet.get("checks") if isinstance(packet.get("checks"), dict) else {}
+    exact = packet_builder.exact_messages()
+    expected_tooling = packet_builder.tooling_binding()
+    checks = {
+        "packet_schema_supported": packet.get("schema") == packet_builder.SCHEMA,
+        "packet_check_section_present_and_passing": bool(packet_check_section)
+        and all(value is True for value in packet_check_section.values()),
+        "packet_ready_for_authorization_request": packet.get("ready_to_request_action_time_authorization") is True,
+        "packet_not_sent": packet.get("telegram_visible_messages_sent") is False,
+        "packet_has_no_authorization_recorded": packet.get("telegram_visible_message_authorization_present") is False,
+        "packet_does_not_mutate_db": packet.get("mutates_db") is False,
+        "packet_targets_exact_leo_chat": target.get("chat_label") == packet_builder.DEFAULT_CHAT_LABEL
+        and target.get("chat_id") == packet_builder.DEFAULT_CHAT_ID,
+        "packet_requires_authenticated_chrome": target.get("allowed_transport") == "authenticated_chrome_telegram_ui",
+        "packet_prompt_ids_exact": target.get("expected_prompt_ids") == [item["id"] for item in unseen.PROMPTS],
+        "packet_messages_exact": [item.get("message") for item in packet.get("exact_messages", [])]
+        == [item["message"] for item in exact],
+        "packet_protocol_sha256_present": bool(SHA64_RE.fullmatch(str(packet.get("protocol_sha256") or ""))),
+        "packet_protocol_sha256_derivation_valid": bool(protocol)
+        and packet.get("protocol_sha256") == _canonical_sha256(protocol),
+        "packet_protocol_top_level_bindings_match": protocol.get("target") == packet.get("target")
+        and protocol.get("exact_messages") == packet.get("exact_messages")
+        and protocol.get("handler_binding") == packet.get("handler_receipt_binding")
+        and protocol.get("tooling_binding") == packet.get("tooling_binding")
+        and protocol.get("browser_provenance_contract") == packet.get("browser_provenance_contract")
+        and protocol.get("operator_context") == packet.get("operator_context"),
+        "packet_tooling_hashes_match_current_sources": packet.get("tooling_binding") == expected_tooling,
+    }
+    checks.update(manifest_checks(packet, requested_path=requested_manifest_path))
+    return checks
+
+
+def ssh_command(args: argparse.Namespace, remote_command: str) -> list[str]:
+    return [
+        "ssh",
+        "-i",
+        str(args.ssh_key),
+        "-o",
+        "BatchMode=yes",
+        "-o",
+        "StrictHostKeyChecking=accept-new",
+        "-o",
+        f"ConnectTimeout={args.connect_timeout}",
+        args.ssh_target,
+        remote_command,
+    ]
+
+
+def deploy_readback_command() -> str:
+    repo = shlex.quote(REMOTE_REPO)
+    return (
+        f"cd {repo} && "
+        "deploy_head=$(git rev-parse HEAD) && "
+        "last_deploy_sha=$(cat /opt/teleo-eval/.last-deploy-sha) && "
+        'printf \'deploy_head=%s\\nlast_deploy_sha=%s\\n\' "$deploy_head" "$last_deploy_sha" && '
+        'if git merge-base --is-ancestor "$last_deploy_sha" "$deploy_head"; then '
+        "printf 'deploy_stamp_ancestor=true\\n'; else printf 'deploy_stamp_ancestor=false\\n'; fi"
+    )
+
+
+def service_readback_command() -> str:
+    return (
+        "systemctl show leoclean-gateway.service "
+        "-p ActiveState -p SubState -p MainPID -p NRestarts -p ExecMainStartTimestamp --no-pager"
+    )
+
+
+def fingerprint_readback_command() -> str:
+    pgoptions = shlex.quote(
+        "PGOPTIONS=-c default_transaction_read_only=on -c transaction_read_only=on "
+        f"-c role={packet_builder.READ_ONLY_DB_ROLE}"
+    )
+    return f"docker exec -e {pgoptions} -i teleo-pg psql -X -U postgres -d teleo -At -q -v ON_ERROR_STOP=1"
+
+
+def subject_readback_sql(subject_ref: str) -> str:
+    if not SUBJECT_REF_RE.fullmatch(subject_ref):
+        raise ValueError("subject_ref must be an eight-hex prefix or UUID")
+    prefix = subject_ref.casefold()
+    return f"""
+\\set ON_ERROR_STOP on
+begin transaction isolation level repeatable read read only;
+select jsonb_build_object(
+  'subject_ref', '{prefix}',
+  'matches', coalesce(jsonb_agg(item order by item->>'table', item->'row'->>'id'), '[]'::jsonb)
+)::text
+from (
+  select jsonb_build_object(
+    'table', 'public.claims',
+    'row', to_jsonb(claim_row),
+    'evidence_count', (select count(*) from public.claim_evidence evidence where evidence.claim_id = claim_row.id)
+  ) as item
+  from public.claims claim_row
+  where lower(claim_row.id::text) like '{prefix}%'
+  union all
+  select jsonb_build_object(
+    'table', 'public.beliefs',
+    'row', to_jsonb(belief_row),
+    'evidence_count', null
+  ) as item
+  from public.beliefs belief_row
+  where lower(belief_row.id::text) like '{prefix}%'
+) matched;
+rollback;
+""".strip()
+
+
+def _parse_single_json_line(raw: str) -> dict[str, Any] | None:
+    for line in raw.splitlines():
+        candidate = line.strip()
+        if not candidate or candidate in {"BEGIN", "SET", "ROLLBACK"}:
+            continue
+        try:
+            value = json.loads(candidate)
+        except json.JSONDecodeError:
+            continue
+        if isinstance(value, dict):
+            return value
+    return None
+
+
+def collect_remote(
+    args: argparse.Namespace,
+    runner: Runner,
+    *,
+    manifest_sql: str,
+) -> tuple[dict[str, Any], int, str]:
+    calls: list[tuple[str, list[str], str, int]] = [
+        ("deploy", ssh_command(args, deploy_readback_command()), "", args.timeout),
+        ("service_before", ssh_command(args, service_readback_command()), "", args.timeout),
+        (
+            "fingerprint_before",
+            ssh_command(args, fingerprint_readback_command()),
+            manifest_sql,
+            args.fingerprint_timeout,
+        ),
+        (
+            "fingerprint_after",
+            ssh_command(args, fingerprint_readback_command()),
+            manifest_sql,
+            args.fingerprint_timeout,
+        ),
+        ("service_after", ssh_command(args, service_readback_command()), "", args.timeout),
+    ]
+    if args.subject_ref:
+        calls.append(
+            (
+                "subject",
+                ssh_command(args, fingerprint_readback_command()),
+                subject_readback_sql(args.subject_ref),
+                args.timeout,
+            )
+        )
+    results: dict[str, CommandResult] = {}
+    attempts: dict[str, int] = {}
+    for name, command, input_text, timeout in calls:
+        result = CommandResult(1, "", "not attempted")
+        for attempt in range(1, max(1, args.ssh_attempts) + 1):
+            result = runner(command, input_text, timeout)
+            attempts[name] = attempt
+            if result.returncode == 0:
+                break
+        results[name] = result
+    deploy_values = parse_key_value_lines(results["deploy"].stdout)
+    service_before = parse_key_value_lines(results["service_before"].stdout)
+    service_after = parse_key_value_lines(results["service_after"].stdout)
+    fingerprint_before = parse_manifest_output(results["fingerprint_before"].stdout)
+    fingerprint_after = parse_manifest_output(results["fingerprint_after"].stdout)
+    subject = _parse_single_json_line(results["subject"].stdout) if "subject" in results else None
+    returncode = next((result.returncode for result in results.values() if result.returncode != 0), 0)
+    stderr = "\n".join(f"{name}: {result.stderr.strip()}" for name, result in results.items() if result.stderr.strip())
+    return (
+        {
+            "deploy_head": deploy_values.get("deploy_head", ""),
+            "last_deploy_sha": deploy_values.get("last_deploy_sha", ""),
+            "deploy_stamp_ancestor": deploy_values.get("deploy_stamp_ancestor") == "true",
+            "workspace_head_matches_deployed_stamp": deploy_values.get("deploy_head")
+            == deploy_values.get("last_deploy_sha"),
+            "service_before": service_before,
+            "service_after": service_after,
+            "fingerprint_before": fingerprint_before,
+            "fingerprint_after": fingerprint_after,
+            "subject_readback": subject,
+            "readback_attempts": attempts,
+        },
+        returncode,
+        stderr,
+    )
+
+
+def _service_active(state: dict[str, Any]) -> bool:
+    return state.get("ActiveState") == "active" and state.get("SubState") == "running"
+
+
+def _service_identity(state: dict[str, Any]) -> dict[str, Any]:
+    return {key: state.get(key) for key in ("MainPID", "NRestarts", "ExecMainStartTimestamp")}
+
+
+def _remote_checks(
+    remote: dict[str, Any],
+    *,
+    returncode: int,
+    subject_required: bool,
+    expected_subject_ref: str | None,
+) -> dict[str, bool]:
+    before = remote.get("fingerprint_before") or {}
+    after = remote.get("fingerprint_after") or {}
+    service_before = remote.get("service_before") or {}
+    service_after = remote.get("service_after") or {}
+    subject = remote.get("subject_readback") or {}
+    matches = subject.get("matches") if isinstance(subject, dict) else None
+    checks = {
+        "ssh_readbacks_succeeded": returncode == 0,
+        "workspace_head_is_sha": bool(SHA40_RE.fullmatch(str(remote.get("deploy_head") or ""))),
+        "deployed_stamp_is_sha": bool(SHA40_RE.fullmatch(str(remote.get("last_deploy_sha") or ""))),
+        "deployed_stamp_is_ancestor_of_workspace_head": remote.get("deploy_stamp_ancestor") is True,
+        "service_active_before_and_after": _service_active(service_before) and _service_active(service_after),
+        "service_identity_complete": all(
+            value
+            for value in (
+                service_before.get("MainPID"),
+                service_before.get("NRestarts"),
+                service_before.get("ExecMainStartTimestamp"),
+                service_after.get("MainPID"),
+                service_after.get("NRestarts"),
+                service_after.get("ExecMainStartTimestamp"),
+            )
+        ),
+        "service_process_unchanged_during_probe": _service_identity(service_before) == _service_identity(service_after),
+        "first_fingerprint_complete": before.get("status") == "ok" and int(before.get("table_count") or 0) > 0,
+        "second_fingerprint_complete": after.get("status") == "ok" and int(after.get("table_count") or 0) > 0,
+        "fingerprints_are_read_only": before.get("transaction_read_only") == "on"
+        and after.get("transaction_read_only") == "on",
+        "fingerprints_use_independent_read_only_role": before.get("current_user") == packet_builder.READ_ONLY_DB_ROLE
+        and after.get("current_user") == packet_builder.READ_ONLY_DB_ROLE,
+        "canonical_fingerprint_unchanged_during_probe": bool(before.get("fingerprint_sha256"))
+        and before.get("fingerprint_sha256") == after.get("fingerprint_sha256"),
+    }
+    if subject_required:
+        checks.update(
+            {
+                "subject_readback_present": isinstance(subject, dict),
+                "subject_reference_matches_request": subject.get("subject_ref")
+                == str(expected_subject_ref or "").casefold(),
+                "subject_resolved_to_exactly_one_db_object": isinstance(matches, list) and len(matches) == 1,
+            }
+        )
+    return checks
+
+
+def derive_state_token(artifact: dict[str, Any]) -> str:
+    return _canonical_sha256(
+        {
+            "schema": artifact.get("schema"),
+            "generated_at_utc": artifact.get("generated_at_utc"),
+            "phase": artifact.get("phase"),
+            "packet_file_sha256": artifact.get("packet_file_sha256"),
+            "protocol_sha256": artifact.get("protocol_sha256"),
+            "manifest_binding": artifact.get("manifest_binding"),
+            "capture_challenge_nonce": artifact.get("capture_challenge_nonce"),
+            "baseline_state_token_sha256": artifact.get("baseline_state_token_sha256"),
+            "subject_ref": artifact.get("subject_ref"),
+            "packet_checks": artifact.get("packet_checks"),
+            "remote_checks": artifact.get("remote_checks"),
+            "baseline_checks": artifact.get("baseline_checks"),
+            "remote": {
+                "deploy_head": (artifact.get("remote") or {}).get("deploy_head"),
+                "last_deploy_sha": (artifact.get("remote") or {}).get("last_deploy_sha"),
+                "service_after": _service_identity((artifact.get("remote") or {}).get("service_after") or {}),
+                "fingerprint_after": (artifact.get("remote") or {}).get("fingerprint_after"),
+                "subject_readback": (artifact.get("remote") or {}).get("subject_readback"),
+            },
+        }
+    )
+
+
+def state_token_is_valid(artifact: dict[str, Any]) -> bool:
+    token = artifact.get("state_token_sha256")
+    return bool(SHA64_RE.fullmatch(str(token or ""))) and token == derive_state_token(artifact)
+
+
+def _empty_remote() -> dict[str, Any]:
+    return {
+        "deploy_head": "",
+        "last_deploy_sha": "",
+        "deploy_stamp_ancestor": False,
+        "workspace_head_matches_deployed_stamp": False,
+        "service_before": {},
+        "service_after": {},
+        "fingerprint_before": {},
+        "fingerprint_after": {},
+        "subject_readback": None,
+        "readback_attempts": {},
+    }
+
+
+def collect_state(args: argparse.Namespace, *, runner: Runner = subprocess_runner) -> dict[str, Any]:
+    packet = _load_json(args.packet)
+    requested_manifest_path = getattr(args, "manifest_sql", None)
+    local_packet_checks = packet_checks(packet, requested_manifest_path=requested_manifest_path)
+    manifest_sql = ""
+    if all(local_packet_checks.values()):
+        try:
+            manifest_sql = canonical_manifest_path().read_text(encoding="utf-8")
+        except OSError:
+            manifest_sql = ""
+        loaded_sha256 = hashlib.sha256(manifest_sql.encode("utf-8")).hexdigest()
+        local_packet_checks.update(
+            {
+                "manifest_loaded_bytes_match_bound_sha256": loaded_sha256
+                == (packet.get("manifest_binding") or {}).get("sha256"),
+                "manifest_loaded_bytes_revalidated_read_only": _manifest_sql_is_statically_read_only(manifest_sql),
+            }
+        )
+    if all(local_packet_checks.values()):
+        remote, remote_returncode, remote_stderr = collect_remote(
+            args,
+            runner,
+            manifest_sql=manifest_sql,
+        )
+    else:
+        remote = _empty_remote()
+        remote_returncode = 1
+        remote_stderr = "local fail-closed validation rejected execution before SSH"
+    remote_checks = _remote_checks(
+        remote,
+        returncode=remote_returncode,
+        subject_required=args.phase == "postflight",
+        expected_subject_ref=args.subject_ref,
+    )
+    baseline = _load_json(args.baseline) if args.baseline else None
+    baseline_checks: dict[str, bool] = {}
+    if args.phase == "postflight":
+        baseline_packet_checks = baseline.get("packet_checks") if isinstance(baseline, dict) else {}
+        baseline_remote_checks = baseline.get("remote_checks") if isinstance(baseline, dict) else {}
+        baseline_nonce = str((baseline or {}).get("capture_challenge_nonce") or "")
+        baseline_checks = {
+            "baseline_supplied": baseline is not None,
+            "baseline_schema_supported": bool(baseline and baseline.get("schema") == SCHEMA),
+            "baseline_is_passing_preflight": bool(
+                baseline and baseline.get("phase") == "preflight" and baseline.get("status") == "pass"
+            ),
+            "baseline_check_sections_all_pass": bool(baseline_packet_checks)
+            and all(value is True for value in baseline_packet_checks.values())
+            and bool(baseline_remote_checks)
+            and all(value is True for value in baseline_remote_checks.values()),
+            "baseline_state_token_derivation_valid": bool(baseline and state_token_is_valid(baseline)),
+            "baseline_capture_challenge_nonce_valid": bool(SHA64_RE.fullmatch(baseline_nonce)),
+            "baseline_protocol_matches_packet": bool(
+                baseline and baseline.get("protocol_sha256") == packet.get("protocol_sha256")
+            ),
+            "baseline_packet_file_matches": bool(
+                baseline and baseline.get("packet_file_sha256") == _sha256_file(args.packet)
+            ),
+            "baseline_manifest_binding_matches_packet": bool(
+                baseline and baseline.get("manifest_binding") == packet.get("manifest_binding")
+            ),
+            "canonical_fingerprint_matches_preflight": bool(
+                baseline
+                and (baseline.get("remote") or {}).get("fingerprint_after", {}).get("fingerprint_sha256")
+                == remote.get("fingerprint_after", {}).get("fingerprint_sha256")
+            ),
+            "gateway_process_matches_preflight": bool(
+                baseline
+                and _service_identity((baseline.get("remote") or {}).get("service_after") or {})
+                == _service_identity(remote.get("service_after") or {})
+            ),
+        }
+    status = (
+        "pass"
+        if all(local_packet_checks.values()) and all(remote_checks.values()) and all(baseline_checks.values())
+        else "fail"
+    )
+    packet_file_sha256 = _sha256_file(args.packet)
+    generated_at_utc = datetime.now(timezone.utc).isoformat()
+    capture_challenge_nonce = (
+        secrets.token_hex(32)
+        if args.phase == "preflight"
+        else str((baseline or {}).get("capture_challenge_nonce") or "")
+    )
+    baseline_state_token_sha256 = (
+        str((baseline or {}).get("state_token_sha256") or "") if args.phase == "postflight" else ""
+    )
+    exact_gate = ""
+    if status != "pass":
+        failed = [
+            key
+            for checks in (local_packet_checks, remote_checks, baseline_checks)
+            for key, value in checks.items()
+            if value is not True
+        ]
+        exact_gate = "; ".join(part for part in (remote_stderr.strip(), ", ".join(failed)) if part)
+    current_canary = (
+        "Read-only pre-send readiness for the exact three-turn unseen Leo chain in Telegram"
+        if args.phase == "preflight"
+        else "Read-only post-send DB grounding and unchanged-state proof for the exact Telegram chain"
+    )
+    artifact = {
+        "schema": SCHEMA,
+        "generated_at_utc": generated_at_utc,
+        "mode": "telegram_visible_unseen_chain_zero_mutation_state_readback",
+        "phase": args.phase,
+        "status": status,
+        "ready_for_action_time_authorization": args.phase == "preflight" and status == "pass",
+        "ready_for_visible_capture_verification": args.phase == "postflight" and status == "pass",
+        "telegram_visible_messages_sent_by_collector": False,
+        "production_apply_executed": False,
+        "mutates_db": False,
+        "packet_path": str(args.packet),
+        "packet_file_sha256": packet_file_sha256,
+        "protocol_sha256": packet.get("protocol_sha256"),
+        "manifest_binding": packet.get("manifest_binding"),
+        "capture_challenge_nonce": capture_challenge_nonce,
+        "baseline_state_token_sha256": baseline_state_token_sha256,
+        "baseline_path": str(args.baseline) if args.baseline else "",
+        "subject_ref": args.subject_ref or "",
+        "packet_checks": local_packet_checks,
+        "remote_checks": remote_checks,
+        "baseline_checks": baseline_checks,
+        "remote": remote,
+        "remote_returncode": remote_returncode,
+        "remote_stderr": remote_stderr,
+        "blocker_readback": {
+            "current_canary": current_canary,
+            "attempted_routes": [
+                "local exact packet validation",
+                *(
+                    [
+                        "SSH deploy stamp and gateway service readback",
+                        "two canonical repeatable-read read-only Postgres parity manifests",
+                        *(["independent selected-object DB readback"] if args.subject_ref else []),
+                    ]
+                    if remote.get("readback_attempts")
+                    else []
+                ),
+            ],
+            "exact_gate": exact_gate,
+            "clear_CTA": (
+                "No user action is needed; repair the named readback check and rerun this collector."
+                if exact_gate
+                else "Use the packet's exact authorization sentence only when ready to cross the send boundary."
+            ),
+            "next_non_user_action": (
+                "Run the authenticated-Chrome three-turn flow only after exact authorization, then collect postflight."
+                if args.phase == "preflight" and status == "pass"
+                else "Repair the failed preflight check and rerun before requesting authorization."
+                if args.phase == "preflight"
+                else "Run the visible capture verifier against this postflight and the retained Chrome evidence."
+            ),
+        },
+        "claim_ceiling": {
+            "current_tier": "T3_live_readonly" if status == "pass" else "T0_failed_preflight",
+            "proven": (
+                "Two canonical read-only snapshots and the gateway process were unchanged during this probe."
+                if status == "pass"
+                else "No live readiness claim; one or more fail-closed checks did not pass."
+            ),
+            "not_proven": [
+                "Telegram-visible delivery or reply behavior",
+                "authorization to send Telegram messages",
+                "canonical mutation",
+            ],
+        },
+    }
+    artifact["state_token_sha256"] = derive_state_token(artifact)
+    return artifact
+
+
+def write_json(path: Path, data: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def write_markdown(path: Path, data: dict[str, Any]) -> None:
+    remote = data.get("remote") or {}
+    service = remote.get("service_after") or {}
+    fingerprint = remote.get("fingerprint_after") or {}
+    lines = [
+        f"# Telegram-Visible Unseen Chain {data['phase'].title()}",
+        "",
+        f"Generated UTC: `{data['generated_at_utc']}`",
+        f"Status: `{data['status']}`",
+        f"Protocol SHA256: `{data['protocol_sha256']}`",
+        f"Packet file SHA256: `{data['packet_file_sha256']}`",
+        f"State token SHA256: `{data['state_token_sha256']}`",
+        f"Messages sent by collector: `{data['telegram_visible_messages_sent_by_collector']}`",
+        f"Mutates DB: `{data['mutates_db']}`",
+        "",
+        "## Checks",
+        "",
+    ]
+    for section in ("packet_checks", "remote_checks", "baseline_checks"):
+        for key, value in sorted(data.get(section, {}).items()):
+            lines.append(f"- `{key}`: `{value}`")
+    lines.extend(
+        [
+            "",
+            "## Live Readback",
+            "",
+            f"- Deploy head: `{remote.get('deploy_head', '')}`",
+            f"- Deploy stamp: `{remote.get('last_deploy_sha', '')}`",
+            f"- Gateway MainPID: `{service.get('MainPID', '')}`",
+            f"- Gateway NRestarts: `{service.get('NRestarts', '')}`",
+            f"- Manifest: `{(data.get('manifest_binding') or {}).get('path', '')}`",
+            f"- Manifest SHA256: `{(data.get('manifest_binding') or {}).get('sha256', '')}`",
+            f"- Effective DB role: `{fingerprint.get('current_user', '')}`",
+            f"- Transaction read only: `{fingerprint.get('transaction_read_only', '')}`",
+            f"- Canonical fingerprint: `{fingerprint.get('fingerprint_sha256', '')}`",
+            f"- Canonical tables: `{fingerprint.get('table_count', '')}`",
+            f"- Canonical rows: `{fingerprint.get('total_rows', '')}`",
+            f"- Selected object ref: `{data.get('subject_ref', '')}`",
+            "",
+            "## Claim Ceiling",
+            "",
+            data["claim_ceiling"]["proven"],
+            "",
+        ]
+    )
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text("\n".join(lines), encoding="utf-8")
+
+
+def parse_args(argv: list[str] | None = None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--phase", choices=("preflight", "postflight"), default="preflight")
+    parser.add_argument("--packet", type=Path, default=DEFAULT_PACKET)
+    parser.add_argument("--baseline", type=Path)
+    parser.add_argument("--subject-ref")
+    parser.add_argument("--ssh-target", default=DEFAULT_SSH_TARGET)
+    parser.add_argument("--ssh-key", type=Path, default=DEFAULT_SSH_KEY)
+    parser.add_argument("--connect-timeout", type=int, default=10)
+    parser.add_argument("--timeout", type=int, default=60)
+    parser.add_argument("--fingerprint-timeout", type=int, default=240)
+    parser.add_argument("--ssh-attempts", type=int, default=3)
+    parser.add_argument("--out", type=Path)
+    parser.add_argument("--markdown-out", type=Path)
+    args = parser.parse_args(argv)
+    if args.phase == "postflight" and (not args.baseline or not args.subject_ref):
+        parser.error("postflight requires --baseline and --subject-ref")
+    if args.subject_ref and not SUBJECT_REF_RE.fullmatch(args.subject_ref):
+        parser.error("--subject-ref must be an eight-hex prefix or UUID")
+    if args.out is None:
+        args.out = DEFAULT_PREFLIGHT_OUT if args.phase == "preflight" else DEFAULT_POSTFLIGHT_OUT
+    if args.markdown_out is None:
+        args.markdown_out = (
+            DEFAULT_PREFLIGHT_MARKDOWN_OUT if args.phase == "preflight" else DEFAULT_POSTFLIGHT_MARKDOWN_OUT
+        )
+    return args
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = parse_args(argv)
+    data = collect_state(args)
+    write_json(args.out, data)
+    write_markdown(args.markdown_out, data)
+    print(
+        json.dumps(
+            {
+                "out": str(args.out),
+                "markdown_out": str(args.markdown_out),
+                "phase": args.phase,
+                "status": data["status"],
+                "mutates_db": False,
+            },
+            indent=2,
+            sort_keys=True,
+        )
+    )
+    return 0 if data["status"] == "pass" else 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/finalize_approve_claim_isolated_canary.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""Finalize outer isolation and cleanup evidence for the clone canary."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+import sys
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Any
+
+
+def _service(raw: str) -> dict[str, str]:
+    return dict(line.split("=", 1) for line in raw.splitlines() if "=" in line)
+
+
+def _table_deltas(before: dict[str, int], after: dict[str, int]) -> dict[str, int]:
+    if set(before) != set(after):
+        raise ValueError(
+            f"live source count keys changed during the canary: before={sorted(before)} after={sorted(after)}"
+        )
+    return {key: after[key] - before[key] for key in sorted(before)}
+
+
+def _verify_source_binding(root: Path, records: list[dict[str, object]]) -> dict[str, object]:
+    readbacks = []
+    for record in records:
+        relative_text = str(record.get("repo_relative_path", ""))
+        relative = Path(relative_text)
+        if not relative_text or relative.is_absolute() or ".." in relative.parts:
+            raise ValueError(f"unsafe repo-relative source path: {relative_text!r}")
+        candidate = (root / relative).resolve()
+        try:
+            candidate.relative_to(root)
+        except ValueError as exc:
+            raise ValueError(f"source path escaped repository root: {relative_text}") from exc
+        if not candidate.is_file():
+            readbacks.append(
+                {
+                    "repo_relative_path": relative.as_posix(),
+                    "expected_sha256": record.get("sha256"),
+                    "actual_sha256": None,
+                    "matches": False,
+                }
+            )
+            continue
+        content = candidate.read_bytes()
+        actual_sha256 = hashlib.sha256(content).hexdigest()
+        readbacks.append(
+            {
+                "repo_relative_path": relative.as_posix(),
+                "expected_sha256": record.get("sha256"),
+                "actual_sha256": actual_sha256,
+                "size_bytes": len(content),
+                "matches": (actual_sha256 == record.get("sha256") and len(content) == record.get("size_bytes")),
+            }
+        )
+    return {
+        "files": readbacks,
+        "all_match": bool(readbacks) and all(bool(row["matches"]) for row in readbacks),
+    }
+
+
+def _contains_ephemeral_path(value: object) -> bool:
+    if isinstance(value, str):
+        return "/tmp/" in value
+    if isinstance(value, dict):
+        return any(_contains_ephemeral_path(item) for item in value.values())
+    if isinstance(value, list):
+        return any(_contains_ephemeral_path(item) for item in value)
+    return False
+
+
+def finalize(path: Path, env: Mapping[str, str]) -> dict[str, Any]:
+    if not path.is_file():
+        raise ValueError("inner canary did not produce a report")
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError("inner canary report must be a JSON object")
+
+    before_counts = json.loads(env["SOURCE_COUNTS_BEFORE"])
+    after_counts = json.loads(env["SOURCE_COUNTS_AFTER"])
+    live_table_deltas = _table_deltas(before_counts, after_counts)
+    before_service = _service(env["SERVICE_BEFORE"])
+    after_service = _service(env["SERVICE_AFTER"])
+    source_tier = env["SOURCE_TIER"]
+    source_network_mode = env["SOURCE_NETWORK_MODE"]
+    source_canary_label = env["SOURCE_CANARY_LABEL"]
+    container_network_mode = env["CANARY_NETWORK_MODE"]
+    container_mounts = json.loads(env["CANARY_MOUNTS_JSON"])
+    container_canary_label = env["CANARY_LABEL"]
+    container_instance_label = env["CANARY_INSTANCE_LABEL"]
+    container_volume_mounts = [mount for mount in container_mounts if mount.get("Type") == "volume"]
+    container_isolated = container_network_mode == "none" and not container_volume_mounts
+    container_labeled = container_canary_label == "proposal-apply-lifecycle" and container_instance_label.startswith(
+        "working-leo-approve-claim-"
+    )
+    source_tier_enforced = source_tier != "isolated-local" or (
+        source_network_mode == "none" and source_canary_label == "working-leo-approved-source"
+    )
+    service_observable = before_service.get("Available") == "true" and after_service.get("Available") == "true"
+    service_stable = (
+        all(
+            before_service.get(key) == after_service.get(key)
+            for key in ("ActiveState", "SubState", "MainPID", "NRestarts")
+        )
+        if service_observable
+        else None
+    )
+    service_gate_passes = service_stable is True if source_tier == "live-readonly" else service_stable is not False
+    container_absent = int(env["CONTAINER_NAME_READBACK_RC"]) == 0 and not env["CONTAINER_NAME_READBACK"].strip()
+    label_scoped_orphan_count = int(env["CONTAINER_LABEL_ORPHAN_COUNT"])
+    label_scoped_container_absent = (
+        int(env["CONTAINER_LABEL_READBACK_RC"]) == 0
+        and label_scoped_orphan_count == 0
+        and not env["CONTAINER_LABEL_READBACK"].strip()
+    )
+    workdir_absent = env["OUTER_WORKDIR_LEXISTS"] == "false"
+    source_binding = _verify_source_binding(
+        Path(env["REPO_ROOT"]).resolve(),
+        data.get("source_binding", {}).get("files", []),
+    )
+    data["source_binding"]["independent_post_cleanup_verification"] = source_binding
+    source_binding_ok = (
+        data["source_binding"].get("unchanged_during_run") is True and source_binding["all_match"] is True
+    )
+    stale_ephemeral_paths_absent = not _contains_ephemeral_path(data)
+    inner_runtime_pass = data.get("status") == "pass" and int(env["CANARY_RC"]) == 0
+    outer_ok = (
+        before_counts == after_counts
+        and all(delta == 0 for delta in live_table_deltas.values())
+        and service_gate_passes
+        and container_absent
+        and label_scoped_container_absent
+        and workdir_absent
+        and source_binding_ok
+        and stale_ephemeral_paths_absent
+        and container_isolated
+        and container_labeled
+        and source_tier_enforced
+    )
+    if source_tier == "isolated-local":
+        data["required_tier"] = "T2_runtime"
+        data["required_tiers"] = ["T2_runtime"]
+        data["runtime_scope"] = "isolated_postgres_container_from_readonly_local_fixture"
+    else:
+        data["required_tier"] = "T3_live_readonly"
+        data["required_tiers"] = ["T2_runtime", "T3_live_readonly"]
+        data["runtime_scope"] = "isolated_postgres_container_from_readonly_live_schema"
+    data["outer_isolation"] = {
+        "source_container": env.get("SOURCE_CONTAINER", "teleo-pg"),
+        "source_database": env.get("SOURCE_DB", "teleo"),
+        "source_counts_before": before_counts,
+        "source_counts_after": after_counts,
+        "canonical_table_deltas": live_table_deltas,
+        "source_counts_unchanged": before_counts == after_counts,
+        "service_before": before_service,
+        "service_after": after_service,
+        "service_required": source_tier == "live-readonly",
+        "service_observable": service_observable,
+        "service_stable": service_stable,
+        "service_gate_passes": service_gate_passes,
+        "source_boundary": {
+            "source_tier": source_tier,
+            "network_mode": source_network_mode,
+            "canary_label": source_canary_label,
+            "tier_enforced": source_tier_enforced,
+        },
+        "container_isolation": {
+            "network_mode": container_network_mode,
+            "volume_mounts": container_volume_mounts,
+            "canary_label": container_canary_label,
+            "instance_label": container_instance_label,
+            "lifecycle_labeled": container_labeled,
+            "network_disabled": container_network_mode == "none",
+            "no_docker_volumes": not container_volume_mounts,
+        },
+        "cleanup_readback": {
+            "container_remove_returncode": int(env["OUTER_CONTAINER_REMOVE_RC"]),
+            "container_name_query_returncode": int(env["CONTAINER_NAME_READBACK_RC"]),
+            "container_name_query_stdout": env["CONTAINER_NAME_READBACK"],
+            "temporary_container_absent": container_absent,
+            "label_scoped_query_returncode": int(env["CONTAINER_LABEL_READBACK_RC"]),
+            "label_scoped_query_stdout": env["CONTAINER_LABEL_READBACK"],
+            "label_scoped_orphan_count": label_scoped_orphan_count,
+            "label_scoped_temporary_container_absent": label_scoped_container_absent,
+            "workdir_remove_returncode": int(env["OUTER_WORKDIR_REMOVE_RC"]),
+            "workdir_lexists_after_cleanup": not workdir_absent,
+            "temporary_workdir_absent": workdir_absent,
+        },
+    }
+    checks = data["checks"]
+    checks["outer_live_counts_exactly_unchanged"] = before_counts == after_counts
+    checks["outer_live_table_deltas_exactly_zero"] = all(delta == 0 for delta in live_table_deltas.values())
+    checks["outer_service_observed_if_required"] = source_tier != "live-readonly" or service_observable
+    checks["outer_service_stable_if_observed"] = service_gate_passes
+    checks["outer_container_absent_independent_readback"] = container_absent
+    checks["outer_labeled_container_absent_independent_readback"] = label_scoped_container_absent
+    checks["outer_workdir_absent_independent_readback"] = workdir_absent
+    checks["source_binding_independently_verified"] = source_binding_ok
+    checks["stale_ephemeral_paths_absent"] = stale_ephemeral_paths_absent
+    checks["outer_source_tier_enforced"] = source_tier_enforced
+    checks["outer_container_network_disabled"] = container_network_mode == "none"
+    checks["outer_container_lifecycle_labeled"] = container_labeled
+    checks["outer_container_has_no_docker_volumes"] = not container_volume_mounts
+    checks["outer_isolation_complete"] = outer_ok
+    if outer_ok and inner_runtime_pass:
+        data["current_tier"] = "T2_runtime" if source_tier == "isolated-local" else "T3_live_readonly"
+    else:
+        data["status"] = "fail"
+        data["current_tier"] = "T2_runtime" if inner_runtime_pass else "T1_model"
+    path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return data
+
+
+def main(argv: list[str] | None = None) -> int:
+    arguments = sys.argv[1:] if argv is None else argv
+    if len(arguments) != 1:
+        raise SystemExit("usage: finalize_approve_claim_isolated_canary.py REPORT.json")
+    try:
+        data = finalize(Path(arguments[0]), os.environ)
+    except (KeyError, OSError, ValueError, json.JSONDecodeError) as exc:
+        raise SystemExit(str(exc)) from exc
+    return 0 if data["status"] == "pass" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/kb_apply_prereqs.sql

@@ -315,8 +315,9 @@ alter table kb_stage.kb_review_principals owner to kb_gate_owner;
 alter table kb_stage.kb_proposal_approvals owner to kb_gate_owner;
 
 insert into kb_stage.kb_review_principals
-  (db_role, reviewed_by_handle, reviewed_by_agent_id, active)
+  (db_role, reviewed_by_handle, reviewed_by_agent_id, active, created_at)
-select 'kb_review'::name, a.handle, a.id, true
+select 'kb_review'::name, a.handle, a.id, true,
+       '1970-01-01 00:00:00+00'::timestamptz
   from public.agents a
  where a.handle = 'm3ta'
 on conflict (db_role) do nothing;

scripts/kb_apply_replay_receipt.py

@@ -446,6 +446,41 @@ def build_replay_receipt(
     }
 
 
+def validate_replay_receipt(
+    receipt: dict[str, Any],
+    *,
+    expected_proposal_id: str | None = None,
+) -> dict[str, Any]:
+    """Rebuild and require the exact private replay-receipt contract.
+
+    Canonical JSON comparison is deliberate: Python equality treats booleans
+    and integers as interchangeable, which is unsafe for authorization and
+    receipt fields.
+    """
+    if not isinstance(receipt, dict):
+        raise ValueError("replay receipt must be an object")
+    proposal = receipt.get("proposal")
+    rows = receipt.get("canonical_rows")
+    apply_engine = receipt.get("apply_engine")
+    if not isinstance(proposal, dict) or not isinstance(rows, dict) or not isinstance(apply_engine, dict):
+        raise ValueError("replay receipt is missing proposal, canonical rows, or apply-engine metadata")
+    if expected_proposal_id is not None and proposal.get("id") != expected_proposal_id:
+        raise ValueError("replay receipt proposal id does not match")
+    try:
+        rebuilt = build_replay_receipt(
+            proposal,
+            rows,
+            apply_sql_sha256=apply_engine.get("apply_sql_sha256"),
+            apply_sql_source=apply_engine.get("source"),
+            exported_at_utc=receipt.get("exported_at_utc"),
+        )
+    except (KeyError, TypeError, ValueError) as exc:
+        raise ValueError("replay receipt failed full contract validation") from exc
+    if _canonical_json(receipt) != _canonical_json(rebuilt):
+        raise ValueError("replay receipt hashes, counts, rows, or contract fields are internally inconsistent")
+    return rebuilt
+
+
 def resolve_receipt_path(
     proposal_id: str,
     *,

scripts/leo_behavior_manifest.py

@@ -11,9 +11,13 @@ from __future__ import annotations
 
 import argparse
 import hashlib
+import importlib.metadata
 import json
 import os
+import platform
+import re
 import subprocess
+import sys
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -24,6 +28,54 @@ SCHEMA = "livingip.leoBehaviorManifest.v1"
 DEFAULT_PROFILE = Path("/home/teleo/.hermes/profiles/leoclean")
 DEFAULT_HERMES_ROOT = Path("/home/teleo/.hermes/hermes-agent")
 DEFAULT_DEPLOYMENT_ROOT = Path("/opt/teleo-eval/workspaces/deploy-infra")
+STATIC_RUNTIME_COMPONENTS = (
+    "profile_config",
+    "procedural_skills",
+    "runtime_middleware",
+    "database_tools",
+)
+IDENTITY_RUNTIME_COMPONENTS = (
+    "procedural_skills",
+    "runtime_middleware",
+    "database_tools",
+)
+STABLE_MANIFEST_FIELDS = (
+    "schema",
+    "model_runtime",
+    "hermes_runtime",
+    "teleo_infrastructure_runtime",
+    "components",
+    "python_runtime",
+    "canonical_database",
+)
+SECRET_KEYS = frozenset(
+    {
+        "access_key",
+        "access_token",
+        "api_key",
+        "authorization",
+        "bot_token",
+        "client_secret",
+        "credential",
+        "credentials",
+        "password",
+        "private_key",
+        "refresh_token",
+        "secret",
+        "token",
+    }
+)
+SECRET_KEY_SUFFIXES = (
+    "api_key",
+    "access_key",
+    "private_key",
+    "password",
+    "secret",
+    "token",
+    "credential",
+)
+RUNTIME_DISTRIBUTIONS = ("PyYAML",)
+SAFE_CONFIG_SCALAR = re.compile(r"^[A-Za-z0-9._:/-]+$")
 
 
 def sha256_bytes(value: bytes) -> str:
@@ -50,7 +102,9 @@ def _safe_relative(path: Path, root: Path) -> str:
         return str(path)
 
 
-def _resolved_node_fingerprint(path: Path, seen_directories: frozenset[tuple[int, int]] = frozenset()) -> dict[str, Any]:
+def _resolved_node_fingerprint(
+    path: Path, seen_directories: frozenset[tuple[int, int]] = frozenset()
+) -> dict[str, Any]:
     """Hash a symlink target, following nested links while stopping directory cycles."""
 
     try:
@@ -141,21 +195,139 @@ def _nested(config: dict[str, Any], *path: str) -> Any:
     return value
 
 
+def secret_free_config(value: Any) -> Any:
+    """Return a semantic config projection with secret-bearing fields omitted."""
+
+    if isinstance(value, dict):
+        return {
+            str(key): secret_free_config(item)
+            for key, item in sorted(value.items(), key=lambda pair: str(pair[0]))
+            if not _is_secret_key(str(key))
+        }
+    if isinstance(value, list):
+        return [secret_free_config(item) for item in value]
+    return value
+
+
+def _validate_identity_config_value(value: Any, *, path: str) -> None:
+    if value is None or isinstance(value, (bool, int)):
+        return
+    if isinstance(value, str):
+        if not SAFE_CONFIG_SCALAR.fullmatch(value) or "://" in value or "@" in value:
+            raise ValueError(f"unsafe identity config scalar: {path}")
+        return
+    if isinstance(value, list):
+        for index, item in enumerate(value):
+            _validate_identity_config_value(item, path=f"{path}[{index}]")
+        return
+    if isinstance(value, dict):
+        for key, item in value.items():
+            if _is_secret_key(str(key)):
+                raise ValueError(f"secret-bearing identity config key: {path}.{key}")
+            _validate_identity_config_value(item, path=f"{path}.{key}")
+        return
+    raise ValueError(f"unsupported identity config value: {path}")
+
+
+def identity_config_projection(raw: dict[str, Any]) -> dict[str, Any]:
+    """Build the only configuration surface copied into a disposable identity profile."""
+
+    section_fields = {
+        "model": ("provider", "default", "smart_routing", "smart_routing_model", "max_tokens"),
+        "agent": ("reasoning_effort",),
+        "memory": ("enabled", "search"),
+        "tools": ("allowed", "write_enabled"),
+        "identity_runtime": ("network_send_enabled", "database_write_enabled", "allowed_tools"),
+    }
+    projection: dict[str, Any] = {}
+    for section, fields in section_fields.items():
+        source = raw.get(section)
+        if source is None:
+            continue
+        if not isinstance(source, dict):
+            raise ValueError(f"identity config section must be a mapping: {section}")
+        selected = {field: source[field] for field in fields if field in source}
+        _validate_identity_config_value(selected, path=section)
+        projection[section] = selected
+
+    gateway = raw.get("gateway")
+    if gateway is not None:
+        if not isinstance(gateway, dict):
+            raise ValueError("identity config section must be a mapping: gateway")
+        selected_gateway = {key: gateway[key] for key in ("execution_mode",) if key in gateway}
+        telegram = gateway.get("telegram")
+        if telegram is not None:
+            if not isinstance(telegram, dict):
+                raise ValueError("identity config section must be a mapping: gateway.telegram")
+            selected_telegram = {key: telegram[key] for key in ("posting_enabled",) if key in telegram}
+            if selected_telegram:
+                selected_gateway["telegram"] = selected_telegram
+        _validate_identity_config_value(selected_gateway, path="gateway")
+        projection["gateway"] = selected_gateway
+
+    if "smart_model_routing" in raw:
+        routing = raw["smart_model_routing"]
+        if not isinstance(routing, bool):
+            raise ValueError("smart_model_routing must be boolean")
+        projection["smart_model_routing"] = routing
+    return projection
+
+
+def _is_secret_key(key: str) -> bool:
+    snake_case = re.sub(r"(?<=[a-z0-9])(?=[A-Z])", "_", key)
+    normalized = re.sub(r"[^a-z0-9]+", "_", snake_case.casefold()).strip("_")
+    return normalized in SECRET_KEYS or any(normalized.endswith(f"_{suffix}") for suffix in SECRET_KEY_SUFFIXES)
+
+
+def python_runtime_manifest() -> dict[str, Any]:
+    distributions: dict[str, str | None] = {}
+    for name in RUNTIME_DISTRIBUTIONS:
+        try:
+            distributions[name] = importlib.metadata.version(name)
+        except importlib.metadata.PackageNotFoundError:
+            distributions[name] = None
+    return {
+        "implementation": platform.python_implementation(),
+        "python_version": platform.python_version(),
+        "abi_tag": sys.implementation.cache_tag,
+        "runtime_distributions": distributions,
+        "runtime_distributions_sha256": canonical_sha256(distributions),
+    }
+
+
 def safe_model_config(config_path: Path) -> dict[str, Any]:
     try:
         raw = yaml.safe_load(config_path.read_text(encoding="utf-8")) or {}
     except (OSError, TypeError, yaml.YAMLError) as exc:
         return {"status": "unavailable", "error": type(exc).__name__}
+    if not isinstance(raw, dict):
+        return {"status": "unavailable", "error": "ConfigNotMapping"}
+    semantic = secret_free_config(raw)
+    try:
+        identity_config = identity_config_projection(raw)
+    except ValueError:
+        return {"status": "unavailable", "error": "UnsafeIdentityConfig"}
+    model_semantic = identity_config.get("model") or {}
     return {
         "status": "observed",
-        "provider": _nested(raw, "model", "provider"),
+        "config_sha256": file_sha256(config_path),
-        "default_model": _nested(raw, "model", "default"),
+        "semantic_config_sha256": canonical_sha256(semantic),
-        "smart_routing": _nested(raw, "model", "smart_routing"),
+        "identity_config_sha256": canonical_sha256(identity_config),
-        "smart_routing_model": _nested(raw, "model", "smart_routing_model"),
+        "model_section_sha256": canonical_sha256(model_semantic),
-        "max_tokens": _nested(raw, "model", "max_tokens"),
+        "gateway_permissions_sha256": canonical_sha256(identity_config.get("gateway")),
-        "reasoning_effort": _nested(raw, "agent", "reasoning_effort"),
+        "tool_permissions_sha256": canonical_sha256(identity_config.get("tools")),
-        "memory_enabled": _nested(raw, "memory", "enabled"),
+        "memory_section_sha256": canonical_sha256(identity_config.get("memory")),
-        "memory_search": _nested(raw, "memory", "search"),
+        "agent_runtime_sha256": canonical_sha256(identity_config.get("agent")),
+        "identity_runtime_policy": identity_config.get("identity_runtime"),
+        "provider": _nested(identity_config, "model", "provider"),
+        "default_model": _nested(identity_config, "model", "default"),
+        "smart_routing": _nested(identity_config, "model", "smart_routing"),
+        "smart_routing_model": _nested(identity_config, "model", "smart_routing_model"),
+        "gateway_smart_model_routing": identity_config.get("smart_model_routing"),
+        "max_tokens": _nested(identity_config, "model", "max_tokens"),
+        "reasoning_effort": _nested(identity_config, "agent", "reasoning_effort"),
+        "memory_enabled": _nested(identity_config, "memory", "enabled"),
+        "memory_search": _nested(identity_config, "memory", "search"),
     }
 
 
@@ -196,7 +368,13 @@ def git_state(repo: Path) -> dict[str, Any]:
     }
 
 
-def source_code_manifest(profile: Path, paths: tuple[Path, ...]) -> dict[str, Any]:
+def source_code_manifest(
+    profile: Path,
+    paths: tuple[Path, ...],
+    *,
+    source_root: Path | None = None,
+    namespace: str = "source",
+) -> dict[str, Any]:
     """Hash executable source while excluding generated caches and environments."""
 
     allowed_suffixes = {
@@ -216,12 +394,21 @@ def source_code_manifest(profile: Path, paths: tuple[Path, ...]) -> dict[str, An
     excluded_parts = {".git", ".pytest_cache", "__pycache__", "node_modules", "venv", ".venv"}
     files: list[dict[str, Any]] = []
     missing: list[str] = []
+    symlinks: list[str] = []
+    source_root = (source_root or profile).resolve()
+
+    def source_label(path: Path) -> str:
+        return f"{namespace}:{_safe_relative(path, source_root)}"
+
     for requested in paths:
         if not requested.exists() and not requested.is_symlink():
-            missing.append(_safe_relative(requested, profile))
+            missing.append(source_label(requested))
             continue
         candidates = [requested] if requested.is_file() else sorted(requested.rglob("*"))
         for path in candidates:
+            if path.is_symlink():
+                symlinks.append(source_label(path))
+                continue
             if not path.is_file() or excluded_parts & set(path.parts):
                 continue
             stat = path.stat()
@@ -229,14 +416,14 @@ def source_code_manifest(profile: Path, paths: tuple[Path, ...]) -> dict[str, An
                 continue
             files.append(
                 {
-                    "path": _safe_relative(path, profile),
+                    "path": source_label(path),
                     "bytes": stat.st_size,
                     "mode": oct(stat.st_mode & 0o777),
                     "sha256": file_sha256(path),
                 }
             )
     files.sort(key=lambda item: item["path"])
-    stable = {"files": files, "missing": sorted(missing)}
+    stable = {"files": files, "missing": sorted(missing), "symlinks": sorted(symlinks)}
     return {
         **stable,
         "file_count": len(files),
@@ -261,6 +448,72 @@ def component(
     }
 
 
+def stable_manifest_payload(manifest: dict[str, Any]) -> dict[str, Any]:
+    """Return the canonical, path-independent behavior payload."""
+
+    return {field: manifest.get(field) for field in STABLE_MANIFEST_FIELDS}
+
+
+def static_runtime_payload(manifest: dict[str, Any]) -> dict[str, Any]:
+    """Return the exact payload committed by ``static_runtime_sha256``."""
+
+    components = manifest.get("components") or {}
+    return {
+        "schema": manifest.get("schema"),
+        "model_runtime": manifest.get("model_runtime"),
+        "hermes_runtime": manifest.get("hermes_runtime"),
+        "teleo_infrastructure_runtime": manifest.get("teleo_infrastructure_runtime"),
+        "components": {name: components.get(name) for name in STATIC_RUNTIME_COMPONENTS},
+        "python_runtime": manifest.get("python_runtime"),
+        "canonical_database": manifest.get("canonical_database"),
+    }
+
+
+def identity_runtime_payload(manifest: dict[str, Any]) -> dict[str, Any]:
+    """Return the exact payload committed by ``identity_runtime_sha256``."""
+
+    model = manifest.get("model_runtime") or {}
+    components = manifest.get("components") or {}
+    teleo = manifest.get("teleo_infrastructure_runtime") or {}
+    identity_model_runtime = {
+        key: model.get(key)
+        for key in (
+            "status",
+            "identity_config_sha256",
+            "model_section_sha256",
+            "gateway_permissions_sha256",
+            "tool_permissions_sha256",
+            "memory_section_sha256",
+            "agent_runtime_sha256",
+            "identity_runtime_policy",
+            "provider",
+            "default_model",
+            "smart_routing",
+            "smart_routing_model",
+            "gateway_smart_model_routing",
+            "max_tokens",
+            "reasoning_effort",
+            "memory_enabled",
+            "memory_search",
+            "base_model_weights",
+            "actual_per_turn_model_must_be_recorded_by_the_call_receipt",
+        )
+    }
+    return {
+        "schema": manifest.get("schema"),
+        "model_runtime": identity_model_runtime,
+        "hermes_runtime": manifest.get("hermes_runtime"),
+        "teleo_infrastructure_runtime": {
+            "git_head": teleo.get("git_head"),
+            "git_state": teleo.get("git_state"),
+            "source_tree": teleo.get("identity_source_tree"),
+        },
+        "components": {name: components.get(name) for name in IDENTITY_RUNTIME_COMPONENTS},
+        "python_runtime": manifest.get("python_runtime"),
+        "canonical_database": manifest.get("canonical_database"),
+    }
+
+
 def build_manifest(
     profile: Path = DEFAULT_PROFILE,
     hermes_root: Path = DEFAULT_HERMES_ROOT,
@@ -270,6 +523,12 @@ def build_manifest(
     hermes_root = hermes_root.resolve()
     deployment_root = deployment_root.resolve()
     config = safe_model_config(profile / "config.yaml")
+    identity_runtime_sources = (
+        deployment_root / "scripts" / "leo_behavior_manifest.py",
+        deployment_root / "scripts" / "leo_identity_manifest.py",
+        deployment_root / "scripts" / "leo_identity_profile.py",
+        deployment_root / "scripts" / "run_leo_identity_reconstruction_canary.py",
+    )
     components = {
         "profile_config": component(
             profile,
@@ -294,10 +553,10 @@ def build_manifest(
         ),
         "runtime_middleware": component(
             profile,
-            role="Pre-LLM context injection and post-LLM validation or response replacement.",
+            role="Profile plugins for pre-LLM context injection and post-LLM validation or response replacement.",
             mutability="deployment_static",
             replayability="fully_hashable",
-            paths=(profile / "plugins", hermes_root / "run_agent.py"),
+            paths=(profile / "plugins",),
         ),
         "database_tools": component(
             profile,
@@ -353,14 +612,28 @@ def build_manifest(
                     hermes_root / "hermes_cli",
                     hermes_root / "tools",
                 ),
+                source_root=hermes_root,
+                namespace="hermes",
             ),
         },
         "teleo_infrastructure_runtime": {
             "git_head": git_head(deployment_root),
             "git_state": git_state(deployment_root),
-            "source_tree": source_code_manifest(profile, (deployment_root,)),
+            "source_tree": source_code_manifest(
+                profile,
+                (deployment_root,),
+                source_root=deployment_root,
+                namespace="teleo",
+            ),
+            "identity_source_tree": source_code_manifest(
+                profile,
+                identity_runtime_sources,
+                source_root=deployment_root,
+                namespace="teleo-identity",
+            ),
         },
         "components": components,
+        "python_runtime": python_runtime_manifest(),
         "canonical_database": {
             "included": False,
             "reason": "Fingerprint through a read-only Postgres manifest in the database-owning harness.",
@@ -372,7 +645,9 @@ def build_manifest(
         "profile_root": str(profile),
         "hermes_root": str(hermes_root),
         "deployment_root": str(deployment_root),
-        "behavior_sha256": canonical_sha256(stable),
+        "static_runtime_sha256": canonical_sha256(static_runtime_payload(stable)),
+        "identity_runtime_sha256": canonical_sha256(identity_runtime_payload(stable)),
+        "behavior_sha256": canonical_sha256(stable_manifest_payload(stable)),
     }
 
 

scripts/leo_identity_manifest.py

@@ -0,0 +1,878 @@
+#!/usr/bin/env python3
+"""Build and verify Leo's pinned, reproducible identity manifest."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from pathlib import Path
+from typing import Any
+
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from scripts import leo_behavior_manifest as behavior
+
+SCHEMA = "livingip.leoIdentityManifest.v1"
+CONSTITUTION_SCHEMA = "livingip.leoConstitutionSource.v1"
+DATABASE_IDENTITY_SCHEMA = "livingip.leoDatabaseIdentitySource.v1"
+STRUCTURED_VIEW_SCHEMA = "livingip.leoCompiledIdentityView.v1"
+DATABASE_FINGERPRINT_SCHEMA = "livingip.teleoCanonicalDatabaseFingerprint.v1"
+SYNTHETIC_DATABASE_MODE = "synthetic_noncanonical_fixture"
+CANONICAL_DATABASE_MODE = "canonical_database_same_transaction_export"
+HEX_64 = re.compile(r"^[0-9a-f]{64}$")
+HEX_40 = re.compile(r"^[0-9a-f]{40}$")
+IDENTITY_TABLES = frozenset(
+    {
+        "public.personas",
+        "public.strategies",
+        "public.beliefs",
+        "public.shared_root",
+        "public.strategy_nodes",
+        "public.strategy_node_anchors",
+        "public.claims",
+    }
+)
+
+
+def expected_runtime_policy() -> dict[str, Any]:
+    return {
+        "network_send_enabled": False,
+        "database_write_enabled": False,
+        "allowed_tools": ["identity_readback"],
+    }
+
+
+def expected_session_boundary() -> dict[str, Any]:
+    return {
+        "classification": "temporary_noncanonical",
+        "included_in_identity_inputs": False,
+        "may_be_used_as_evidence": False,
+        "restart_policy": "fresh_process_with_session_state_outside_identity_authority",
+    }
+
+
+def expected_gatewayrunner_contract() -> dict[str, Any]:
+    return {
+        "profile_surfaces": ["config.yaml", "generated SOUL.md", "skills", "plugins", "bin tools"],
+        "required_absent_or_empty": {
+            "persistent_memory": behavior.canonical_sha256([]),
+            "pairing_store": behavior.canonical_sha256([]),
+            "project_context": behavior.canonical_sha256([]),
+            "generated_skill_prompt_cache": behavior.canonical_sha256([]),
+            "prior_sessions_at_first_start": behavior.canonical_sha256([]),
+        },
+        "fixed_message_context": {
+            "auto_skill": None,
+            "reply_context": None,
+            "media_or_file_context": None,
+        },
+        "required_t3_turn_receipt_fields": [
+            "runner_class",
+            "authorization_decision",
+            "effective_system_prompt_sha256",
+            "compiled_skills_prompt_sha256",
+            "tool_registry_schema_sha256",
+            "plugin_registry_sha256",
+            "selected_model",
+            "selected_provider",
+            "api_mode",
+            "base_url_host",
+            "database_retrieval_receipt",
+            "session_key_sha256",
+            "persisted_session_id_sha256",
+        ],
+    }
+
+
+class IdentityManifestError(ValueError):
+    """An identity input is incomplete, inconsistent, or drifted."""
+
+
+def _require(condition: bool, message: str) -> None:
+    if not condition:
+        raise IdentityManifestError(message)
+
+
+def _is_sha256(value: Any) -> bool:
+    return isinstance(value, str) and bool(HEX_64.fullmatch(value))
+
+
+def load_json(path: Path, label: str) -> dict[str, Any]:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError) as exc:
+        raise IdentityManifestError(f"cannot read {label}: {type(exc).__name__}") from exc
+    if not isinstance(value, dict):
+        raise IdentityManifestError(f"{label} must be a JSON object")
+    return value
+
+
+def canonical_rules(value: dict[str, Any]) -> list[dict[str, str]]:
+    _require(value.get("schema") == CONSTITUTION_SCHEMA, "unsupported constitution schema")
+    _require(value.get("identity_name") == "Leo", "constitution identity_name must be Leo")
+    raw_rules = value.get("rules")
+    _require(isinstance(raw_rules, list) and bool(raw_rules), "constitution rules must be non-empty")
+    rules: list[dict[str, str]] = []
+    for raw in raw_rules:
+        _require(isinstance(raw, dict), "each constitutional rule must be an object")
+        rule_id = str(raw.get("id") or "").strip()
+        text = str(raw.get("text") or "").strip()
+        _require(bool(rule_id and text), "each constitutional rule needs id and text")
+        rules.append({"id": rule_id, "text": text})
+    _require(len({item["id"] for item in rules}) == len(rules), "constitutional rule ids must be unique")
+    return sorted(rules, key=lambda item: item["id"])
+
+
+def canonical_database_records(value: dict[str, Any], *, fingerprint_sha256: str) -> list[dict[str, str | int]]:
+    _require(value.get("schema") == DATABASE_IDENTITY_SCHEMA, "unsupported database identity schema")
+    _require(value.get("identity_name") == "Leo", "database identity_name must be Leo")
+    _require(
+        value.get("database_fingerprint_sha256") == fingerprint_sha256,
+        "database identity export is not bound to the supplied database fingerprint",
+    )
+    raw_records = value.get("records")
+    _require(isinstance(raw_records, list) and bool(raw_records), "database identity records must be non-empty")
+    records: list[dict[str, str | int]] = []
+    for raw in raw_records:
+        _require(isinstance(raw, dict), "each database identity record must be an object")
+        rank = raw.get("rank", 0)
+        record: dict[str, str | int] = {
+            "table": str(raw.get("table") or "").strip(),
+            "row_id": str(raw.get("row_id") or "").strip(),
+            "kind": str(raw.get("kind") or "").strip(),
+            "rank": rank if isinstance(rank, int) and not isinstance(rank, bool) else -1,
+            "text": str(raw.get("text") or "").strip(),
+            "status": str(raw.get("status") or "").strip(),
+            "evidence_sha256": str(raw.get("evidence_sha256") or "").strip(),
+        }
+        _require(record["table"] in IDENTITY_TABLES, "database identity table is outside the allowlist")
+        _require(bool(record["row_id"] and record["kind"] and record["text"]), "database record fields are incomplete")
+        _require(isinstance(record["rank"], int) and record["rank"] >= 0, "database record rank is invalid")
+        _require(record["status"] == "active", "database identity records must be active selected rows")
+        _require(_is_sha256(record["evidence_sha256"]), "database record evidence_sha256 is invalid")
+        records.append(record)
+    keys = {(item["table"], item["row_id"]) for item in records}
+    _require(len(keys) == len(records), "database identity row bindings must be unique")
+    return sorted(records, key=lambda item: (str(item["table"]), int(item["rank"]), str(item["row_id"])))
+
+
+def database_fingerprint_semantic(value: dict[str, Any]) -> dict[str, Any]:
+    """Bind immutable capture provenance while excluding only the volatile WAL position."""
+
+    result = {key: value[key] for key in sorted(value) if key != "read_consistency"}
+    consistency = value["read_consistency"]
+    result["read_consistency"] = {
+        "status": consistency["status"],
+        "before": {key: item for key, item in consistency["before"].items() if key != "wal_lsn"},
+        "after": {key: item for key, item in consistency["after"].items() if key != "wal_lsn"},
+    }
+    return result
+
+
+def database_identity_provenance(
+    value: dict[str, Any],
+    *,
+    fingerprint: dict[str, Any],
+) -> dict[str, Any]:
+    raw = value.get("source_provenance")
+    _require(isinstance(raw, dict), "database identity source provenance is missing")
+    mode = raw.get("mode")
+    if mode == SYNTHETIC_DATABASE_MODE:
+        _require(
+            raw
+            == {
+                "mode": SYNTHETIC_DATABASE_MODE,
+                "canonical_authority_granted": False,
+                "same_transaction_as_fingerprint": False,
+                "export_receipt_sha256": None,
+            },
+            "synthetic database provenance contract is invalid",
+        )
+        _require(
+            fingerprint.get("environment") == "disposable_fixture",
+            "synthetic rows require a fixture fingerprint",
+        )
+        _require("export_receipt" not in value, "synthetic database identity must not claim an export receipt")
+        return {**raw, "authority": "synthetic_noncanonical_fixture"}
+
+    if mode == CANONICAL_DATABASE_MODE:
+        raise IdentityManifestError(
+            "canonical authority requires independently verified output from the database-owning same-transaction "
+            "exporter; caller-supplied T2 JSON cannot grant it"
+        )
+    raise IdentityManifestError("unsupported database identity provenance mode")
+
+
+def validate_database_fingerprint(value: dict[str, Any]) -> None:
+    _require(value.get("schema") == DATABASE_FINGERPRINT_SCHEMA, "unsupported database fingerprint schema")
+    _require(value.get("status") == "ok", "database fingerprint status must be ok")
+    for field in ("fingerprint_sha256", "table_rows_sha256", "structure_sha256"):
+        _require(_is_sha256(value.get(field)), f"database fingerprint {field} is invalid")
+    _require(isinstance(value.get("table_count"), int) and value["table_count"] > 0, "table_count must be positive")
+    _require(isinstance(value.get("total_rows"), int) and value["total_rows"] >= 0, "total_rows is invalid")
+    consistency = value.get("read_consistency")
+    _require(isinstance(consistency, dict), "database read_consistency is missing")
+    before = consistency.get("before")
+    after = consistency.get("after")
+    _require(consistency.get("status") == "stable_wal_marker", "database fingerprint was not read consistently")
+    _require(isinstance(before, dict) and before == after and bool(before), "database read markers differ")
+    for field in ("database", "database_user", "system_identifier", "wal_lsn"):
+        _require(bool(before.get(field)), f"database read marker {field} is missing")
+
+
+def validate_content_manifest(value: Any, *, label: str) -> None:
+    """Recompute the structural metadata of a replayable content manifest."""
+
+    _require(isinstance(value, dict), f"{label} is invalid")
+    _require(
+        set(value) == {"files", "missing", "symlinks", "file_count", "total_bytes", "sha256"},
+        f"{label} fields are invalid",
+    )
+    files = value.get("files")
+    missing = value.get("missing")
+    symlinks = value.get("symlinks")
+    _require(isinstance(files, list) and bool(files), f"{label} is empty")
+    _require(missing == [], f"{label} has missing inputs")
+    _require(symlinks == [], f"{label} contains unsupported symlinks")
+
+    paths: list[str] = []
+    total_bytes = 0
+    for item in files:
+        _require(isinstance(item, dict), f"{label} contains unreadable inputs")
+        _require(set(item) == {"path", "bytes", "mode", "sha256"}, f"{label} contains unreadable inputs")
+        path = item.get("path")
+        size = item.get("bytes")
+        mode = item.get("mode")
+        _require(isinstance(path, str) and bool(path), f"{label} contains an invalid path")
+        _require(isinstance(size, int) and not isinstance(size, bool) and size >= 0, f"{label} byte size is invalid")
+        _require(isinstance(mode, str) and bool(re.fullmatch(r"0o[0-7]{3}", mode)), f"{label} mode is invalid")
+        _require(_is_sha256(item.get("sha256")), f"{label} contains unreadable inputs")
+        paths.append(path)
+        total_bytes += size
+
+    _require(paths == sorted(paths) and len(paths) == len(set(paths)), f"{label} paths are not unique and sorted")
+    _require(value.get("file_count") == len(files), f"{label} file count is invalid")
+    _require(value.get("total_bytes") == total_bytes, f"{label} total bytes is invalid")
+    stable = {"files": files, "missing": missing, "symlinks": symlinks}
+    _require(behavior.canonical_sha256(stable) == value.get("sha256"), f"{label} content hash is invalid")
+
+
+def validate_behavior_manifest(value: dict[str, Any]) -> None:
+    _require(value.get("schema") == behavior.SCHEMA, "unsupported behavior manifest schema")
+    for field in ("behavior_sha256", "static_runtime_sha256", "identity_runtime_sha256"):
+        _require(_is_sha256(value.get(field)), f"behavior manifest {field} is invalid")
+    _require(
+        behavior.canonical_sha256(behavior.identity_runtime_payload(value)) == value["identity_runtime_sha256"],
+        "behavior identity runtime hash drift detected",
+    )
+    _require(
+        behavior.canonical_sha256(behavior.static_runtime_payload(value)) == value["static_runtime_sha256"],
+        "behavior static runtime hash drift detected",
+    )
+    _require(
+        behavior.canonical_sha256(behavior.stable_manifest_payload(value)) == value["behavior_sha256"],
+        "behavior manifest stable payload hash drift detected",
+    )
+    model = value.get("model_runtime")
+    _require(isinstance(model, dict) and model.get("status") == "observed", "model runtime was not observed")
+    _require(bool(model.get("provider") and model.get("default_model")), "provider and default model must be pinned")
+    for field in (
+        "semantic_config_sha256",
+        "identity_config_sha256",
+        "model_section_sha256",
+        "gateway_permissions_sha256",
+        "tool_permissions_sha256",
+        "memory_section_sha256",
+        "agent_runtime_sha256",
+    ):
+        _require(_is_sha256(model.get(field)), f"model runtime {field} is invalid")
+    _require(
+        model.get("base_model_weights") == "external_provider_managed_not_locally_hashable",
+        "hosted model weight boundary is missing",
+    )
+    _require(
+        model.get("actual_per_turn_model_must_be_recorded_by_the_call_receipt") is True, "model receipt gate missing"
+    )
+    policy = model.get("identity_runtime_policy")
+    _require(policy == expected_runtime_policy(), "identity runtime policy must be the exact local readback policy")
+    for field in ("hermes_runtime", "teleo_infrastructure_runtime"):
+        runtime = value.get(field)
+        _require(isinstance(runtime, dict), f"{field} is missing")
+        _require(bool(HEX_40.fullmatch(str(runtime.get("git_head") or ""))), f"{field} git_head is invalid")
+        git_state = runtime.get("git_state")
+        _require(
+            isinstance(git_state, dict) and git_state.get("worktree_clean") is True,
+            f"{field} is not reconstructible from clean Git",
+        )
+        tree = runtime.get("identity_source_tree" if field == "teleo_infrastructure_runtime" else "source_tree")
+        validate_content_manifest(tree, label=f"{field} source tree")
+    components = value.get("components")
+    _require(isinstance(components, dict), "behavior components are missing")
+    for name in behavior.IDENTITY_RUNTIME_COMPONENTS:
+        content = (components.get(name) or {}).get("content")
+        validate_content_manifest(content, label=f"component {name}")
+    python_runtime = value.get("python_runtime")
+    _require(isinstance(python_runtime, dict), "Python runtime binding is missing")
+    _require(
+        bool(python_runtime.get("implementation") and python_runtime.get("python_version")),
+        "Python runtime is incomplete",
+    )
+    _require(_is_sha256(python_runtime.get("runtime_distributions_sha256")), "runtime package binding is invalid")
+    _require(
+        all(python_runtime.get("runtime_distributions", {}).values()), "a required runtime distribution is missing"
+    )
+
+
+def _repo_path(path: Path, source_root: Path) -> str:
+    try:
+        return path.resolve(strict=True).relative_to(source_root.resolve(strict=True)).as_posix()
+    except (OSError, ValueError) as exc:
+        raise IdentityManifestError(f"identity source is outside the pinned source root: {path}") from exc
+
+
+def source_binding(
+    path: Path,
+    *,
+    source_root: Path,
+    semantic_value: Any,
+    count: int,
+    pin_content: bool = True,
+) -> dict[str, Any]:
+    result = {
+        "repo_path": _repo_path(path, source_root),
+        "semantic_sha256": behavior.canonical_sha256(semantic_value),
+        "record_count": count,
+    }
+    if pin_content:
+        result["content_sha256"] = behavior.file_sha256(path)
+    return result
+
+
+def render_identity_views(
+    *,
+    identity_inputs_sha256: str,
+    database_fingerprint_sha256: str,
+    database_provenance: dict[str, Any],
+    rules: list[dict[str, str]],
+    records: list[dict[str, str | int]],
+) -> dict[str, str]:
+    soul = [
+        "<!-- GENERATED FILE: edit the pinned sources, never this view. -->",
+        "# Leo",
+        "",
+        f"Identity inputs: `{identity_inputs_sha256}`",
+        "",
+        "## Static constitutional rules",
+        "",
+        "These rules are static constitutional inputs, not database claims.",
+        "",
+    ]
+    soul.extend(f"- **{item['id']}**: {item['text']}" for item in rules)
+    database_description = (
+        "canonical database capture"
+        if database_provenance["canonical_authority_granted"]
+        else "synthetic noncanonical fixture"
+    )
+    soul.extend(
+        [
+            "",
+            "## Database-derived identity",
+            "",
+            f"Generated from {database_description} fingerprint `{database_fingerprint_sha256}`.",
+            "",
+        ]
+    )
+    soul.extend(
+        f"- `{item['table']}/{item['row_id']}` [{item['kind']}, rank {item['rank']}]: {item['text']} "
+        f"(evidence `{item['evidence_sha256']}`)"
+        for item in records
+    )
+    soul.extend(
+        [
+            "",
+            "## Authority and session boundary",
+            "",
+            "- This `SOUL.md` is a generated view and is never an authority by itself.",
+            "- Generated database identity is authoritative only when its same-transaction export receipt grants canonical authority.",
+            "- Runtime/session memory is temporary, noncanonical, and cannot serve as evidence.",
+            "- Hosted model weights are provider-managed and must be attributed by each turn receipt.",
+            "",
+        ]
+    )
+    structured = {
+        "schema": STRUCTURED_VIEW_SCHEMA,
+        "identity_name": "Leo",
+        "identity_inputs_sha256": identity_inputs_sha256,
+        "static_constitution": {"authority": "pinned_static_source", "rules": rules},
+        "database_identity": {
+            "authority": database_provenance["authority"],
+            "canonical_authority_granted": database_provenance["canonical_authority_granted"],
+            "source_mode": database_provenance["mode"],
+            "database_fingerprint_sha256": database_fingerprint_sha256,
+            "records": records,
+        },
+        "session_boundary": {
+            "authority": "none",
+            "classification": "temporary_noncanonical",
+            "may_be_used_as_evidence": False,
+        },
+    }
+    return {
+        "SOUL.md": "\n".join(soul),
+        "identity.json": json.dumps(structured, indent=2, sort_keys=True) + "\n",
+    }
+
+
+def build_identity_manifest(
+    *,
+    behavior_manifest: dict[str, Any],
+    database_fingerprint_path: Path,
+    constitution_path: Path,
+    database_identity_path: Path,
+    source_root: Path,
+    source_commit: str | None = None,
+) -> dict[str, Any]:
+    validate_behavior_manifest(behavior_manifest)
+    database_fingerprint = load_json(database_fingerprint_path, "database fingerprint")
+    validate_database_fingerprint(database_fingerprint)
+    constitution = load_json(constitution_path, "constitution source")
+    database_identity = load_json(database_identity_path, "database identity source")
+    rules = canonical_rules(constitution)
+    records = canonical_database_records(
+        database_identity, fingerprint_sha256=database_fingerprint["fingerprint_sha256"]
+    )
+    database_provenance = database_identity_provenance(
+        database_identity,
+        fingerprint=database_fingerprint,
+    )
+    runtime_commit = behavior_manifest["teleo_infrastructure_runtime"]["git_head"]
+    source_commit = source_commit or runtime_commit
+    _require(bool(HEX_40.fullmatch(str(source_commit))), "source commit is invalid")
+    _require(source_commit == runtime_commit, "source commit does not match the behavior manifest")
+
+    model = behavior_manifest["model_runtime"]
+    components = behavior_manifest["components"]
+    marker = database_fingerprint["read_consistency"]["before"]
+    core = {
+        "identity_name": "Leo",
+        "source_commit": source_commit,
+        "runtime": {
+            "identity_runtime_sha256": behavior_manifest["identity_runtime_sha256"],
+            "hermes_git_head": behavior_manifest["hermes_runtime"]["git_head"],
+            "hermes_source_sha256": behavior_manifest["hermes_runtime"]["source_tree"]["sha256"],
+            "teleo_git_head": runtime_commit,
+            "teleo_source_sha256": behavior_manifest["teleo_infrastructure_runtime"]["identity_source_tree"]["sha256"],
+            "python": behavior_manifest["python_runtime"],
+        },
+        "model": {
+            "provider": model["provider"],
+            "default_model": model["default_model"],
+            "smart_routing": model.get("smart_routing"),
+            "smart_routing_model": model.get("smart_routing_model"),
+            "gateway_smart_model_routing": model.get("gateway_smart_model_routing"),
+            "model_section_sha256": model["model_section_sha256"],
+            "hosted_weights": "external_provider_managed_not_locally_hashable",
+            "actual_model_required_in_turn_receipt": True,
+        },
+        "skills": {
+            "content_sha256": components["procedural_skills"]["content"]["sha256"],
+            "file_count": components["procedural_skills"]["content"]["file_count"],
+        },
+        "permissions": {
+            "identity_config_sha256": model["identity_config_sha256"],
+            "gateway_permissions_sha256": model["gateway_permissions_sha256"],
+            "tool_permissions_sha256": model["tool_permissions_sha256"],
+            "runtime_policy": model["identity_runtime_policy"],
+            "authorization_decision_required_in_runtime_receipt": True,
+        },
+        "canonical_database": {
+            "database": marker["database"],
+            "database_user": marker["database_user"],
+            "system_identifier": marker["system_identifier"],
+            "authority": database_provenance["authority"],
+            "canonical_authority_granted": database_provenance["canonical_authority_granted"],
+            **{
+                key: database_fingerprint[key]
+                for key in ("fingerprint_sha256", "table_rows_sha256", "structure_sha256", "table_count", "total_rows")
+            },
+            "source": source_binding(
+                database_fingerprint_path,
+                source_root=source_root,
+                semantic_value=database_fingerprint_semantic(database_fingerprint),
+                count=database_fingerprint["table_count"],
+                pin_content=False,
+            ),
+        },
+        "identity_sources": {
+            "static_constitution": {
+                "authority": "pinned_static_source",
+                **source_binding(constitution_path, source_root=source_root, semantic_value=rules, count=len(rules)),
+            },
+            "database_derived_identity": {
+                "authority": database_provenance["authority"],
+                "provenance": database_provenance,
+                "database_fingerprint_sha256": database_fingerprint["fingerprint_sha256"],
+                **source_binding(
+                    database_identity_path,
+                    source_root=source_root,
+                    semantic_value={"provenance": database_provenance, "records": records},
+                    count=len(records),
+                ),
+            },
+        },
+        "session_boundary": expected_session_boundary(),
+        "gatewayrunner_execution_contract": expected_gatewayrunner_contract(),
+    }
+    identity_inputs_sha256 = behavior.canonical_sha256(core)
+    views = render_identity_views(
+        identity_inputs_sha256=identity_inputs_sha256,
+        database_fingerprint_sha256=database_fingerprint["fingerprint_sha256"],
+        database_provenance=database_provenance,
+        rules=rules,
+        records=records,
+    )
+    stable = {
+        "schema": SCHEMA,
+        "identity_inputs": core,
+        "identity_inputs_sha256": identity_inputs_sha256,
+        "compiled_views": {
+            name: {
+                "role": "generated_view_not_authority",
+                "sha256": behavior.sha256_bytes(content.encode("utf-8")),
+                "generated_from_identity_inputs_sha256": identity_inputs_sha256,
+            }
+            for name, content in sorted(views.items())
+        },
+    }
+    return {**stable, "manifest_sha256": behavior.canonical_sha256(stable)}
+
+
+def validate_identity_manifest(value: dict[str, Any]) -> None:
+    _require(value.get("schema") == SCHEMA, "unsupported identity manifest schema")
+    expected = value.get("manifest_sha256")
+    _require(_is_sha256(expected), "identity manifest sha256 is invalid")
+    stable = {key: item for key, item in value.items() if key != "manifest_sha256"}
+    _require(behavior.canonical_sha256(stable) == expected, "identity manifest hash drift detected")
+    core = value.get("identity_inputs")
+    _require(isinstance(core, dict), "identity inputs are missing")
+    _require(
+        set(core)
+        == {
+            "identity_name",
+            "source_commit",
+            "runtime",
+            "model",
+            "skills",
+            "permissions",
+            "canonical_database",
+            "identity_sources",
+            "session_boundary",
+            "gatewayrunner_execution_contract",
+        },
+        "identity input contract fields are invalid",
+    )
+    identity_hash = value.get("identity_inputs_sha256")
+    _require(_is_sha256(identity_hash), "identity input hash is invalid")
+    _require(behavior.canonical_sha256(core) == identity_hash, "identity input hash drift detected")
+    _require(core.get("identity_name") == "Leo", "identity name must be Leo")
+
+    runtime = core.get("runtime")
+    _require(isinstance(runtime, dict), "runtime binding is missing")
+    _require(
+        set(runtime)
+        == {
+            "identity_runtime_sha256",
+            "hermes_git_head",
+            "hermes_source_sha256",
+            "teleo_git_head",
+            "teleo_source_sha256",
+            "python",
+        },
+        "runtime binding fields are invalid",
+    )
+    _require(_is_sha256(runtime.get("identity_runtime_sha256")), "identity runtime binding is invalid")
+    for field in ("hermes_git_head", "teleo_git_head"):
+        _require(bool(HEX_40.fullmatch(str(runtime.get(field) or ""))), f"runtime {field} is invalid")
+    for field in ("hermes_source_sha256", "teleo_source_sha256"):
+        _require(_is_sha256(runtime.get(field)), f"runtime {field} is invalid")
+    _require(core.get("source_commit") == runtime["teleo_git_head"], "source commit is not bound to Teleo Git")
+    python_runtime = runtime.get("python")
+    _require(isinstance(python_runtime, dict), "Python runtime binding is missing")
+    _require(
+        bool(python_runtime.get("implementation") and python_runtime.get("python_version")),
+        "Python runtime binding is incomplete",
+    )
+    _require(_is_sha256(python_runtime.get("runtime_distributions_sha256")), "Python distribution binding is invalid")
+
+    model = core.get("model")
+    _require(isinstance(model, dict), "model binding is missing")
+    _require(
+        set(model)
+        == {
+            "provider",
+            "default_model",
+            "smart_routing",
+            "smart_routing_model",
+            "gateway_smart_model_routing",
+            "model_section_sha256",
+            "hosted_weights",
+            "actual_model_required_in_turn_receipt",
+        },
+        "model binding fields are invalid",
+    )
+    _require(bool(model.get("provider") and model.get("default_model")), "model provider and default must be pinned")
+    _require(_is_sha256(model.get("model_section_sha256")), "model section binding is invalid")
+    _require(
+        model.get("hosted_weights") == "external_provider_managed_not_locally_hashable",
+        "hosted model boundary is invalid",
+    )
+    _require(model.get("actual_model_required_in_turn_receipt") is True, "per-turn model receipt gate is invalid")
+
+    skills = core.get("skills")
+    _require(isinstance(skills, dict) and set(skills) == {"content_sha256", "file_count"}, "skills binding is invalid")
+    _require(_is_sha256(skills.get("content_sha256")), "skills content hash is invalid")
+    _require(
+        isinstance(skills.get("file_count"), int)
+        and not isinstance(skills.get("file_count"), bool)
+        and skills["file_count"] > 0,
+        "skills file count is invalid",
+    )
+
+    permissions = core.get("permissions")
+    _require(isinstance(permissions, dict), "permission binding is missing")
+    _require(
+        set(permissions)
+        == {
+            "identity_config_sha256",
+            "gateway_permissions_sha256",
+            "tool_permissions_sha256",
+            "runtime_policy",
+            "authorization_decision_required_in_runtime_receipt",
+        },
+        "permission binding fields are invalid",
+    )
+    for field in ("identity_config_sha256", "gateway_permissions_sha256", "tool_permissions_sha256"):
+        _require(_is_sha256(permissions.get(field)), f"permission binding {field} is invalid")
+    _require(
+        permissions.get("runtime_policy") == expected_runtime_policy(),
+        "identity runtime policy must be the exact local readback policy",
+    )
+    _require(
+        permissions.get("authorization_decision_required_in_runtime_receipt") is True,
+        "runtime authorization receipt gate is invalid",
+    )
+
+    database = core.get("canonical_database")
+    _require(isinstance(database, dict), "canonical database binding is missing")
+    for field in ("fingerprint_sha256", "table_rows_sha256", "structure_sha256"):
+        _require(_is_sha256(database.get(field)), f"canonical database {field} is invalid")
+    _require(
+        bool(database.get("database") and database.get("database_user") and database.get("system_identifier")),
+        "canonical database identity is incomplete",
+    )
+    allowed_authorities = {"synthetic_noncanonical_fixture": False}
+    _require(database.get("authority") in allowed_authorities, "database authority is invalid")
+    _require(
+        database.get("canonical_authority_granted") is allowed_authorities[database["authority"]],
+        "database canonical authority grant is invalid",
+    )
+    _require(
+        isinstance(database.get("table_count"), int)
+        and not isinstance(database.get("table_count"), bool)
+        and database["table_count"] > 0,
+        "canonical database table_count is invalid",
+    )
+    _require(
+        isinstance(database.get("total_rows"), int)
+        and not isinstance(database.get("total_rows"), bool)
+        and database["total_rows"] >= 0,
+        "canonical database total_rows is invalid",
+    )
+
+    def validate_source_binding(binding: Any, *, label: str, content_required: bool) -> None:
+        _require(isinstance(binding, dict), f"{label} source binding is missing")
+        repo_path = binding.get("repo_path")
+        _require(
+            isinstance(repo_path, str)
+            and bool(repo_path)
+            and not Path(repo_path).is_absolute()
+            and ".." not in Path(repo_path).parts,
+            f"{label} source path is invalid",
+        )
+        _require(_is_sha256(binding.get("semantic_sha256")), f"{label} semantic binding is invalid")
+        _require(
+            isinstance(binding.get("record_count"), int)
+            and not isinstance(binding.get("record_count"), bool)
+            and binding["record_count"] > 0,
+            f"{label} record count is invalid",
+        )
+        if content_required:
+            _require(_is_sha256(binding.get("content_sha256")), f"{label} content binding is invalid")
+        else:
+            _require("content_sha256" not in binding, f"{label} content binding must exclude volatile capture markers")
+
+    validate_source_binding(database.get("source"), label="database fingerprint", content_required=False)
+    sources = core.get("identity_sources")
+    _require(
+        isinstance(sources, dict) and set(sources) == {"static_constitution", "database_derived_identity"},
+        "identity source bindings are invalid",
+    )
+    constitution = sources["static_constitution"]
+    derived = sources["database_derived_identity"]
+    _require(isinstance(constitution, dict), "constitution source binding is invalid")
+    _require(isinstance(derived, dict), "database identity source binding is invalid")
+    _require(constitution.get("authority") == "pinned_static_source", "constitution authority is invalid")
+    _require(derived.get("authority") == database["authority"], "database identity authority is invalid")
+    provenance = derived.get("provenance")
+    _require(isinstance(provenance, dict), "database identity provenance is missing")
+    _require(provenance.get("authority") == database["authority"], "database identity provenance authority is invalid")
+    _require(
+        provenance.get("canonical_authority_granted") is database["canonical_authority_granted"],
+        "database identity provenance grant is invalid",
+    )
+    _require(provenance.get("mode") == SYNTHETIC_DATABASE_MODE, "synthetic database provenance mode is invalid")
+    _require(
+        provenance.get("same_transaction_as_fingerprint") is False,
+        "synthetic fixture transaction claim is invalid",
+    )
+    _require(provenance.get("export_receipt_sha256") is None, "synthetic fixture must not claim an export receipt")
+    _require(
+        derived.get("database_fingerprint_sha256") == database["fingerprint_sha256"],
+        "database identity source is misbound",
+    )
+    validate_source_binding(constitution, label="constitution", content_required=True)
+    validate_source_binding(derived, label="database identity", content_required=True)
+    _require(core.get("session_boundary") == expected_session_boundary(), "session authority boundary is invalid")
+    _require(
+        core.get("gatewayrunner_execution_contract") == expected_gatewayrunner_contract(),
+        "GatewayRunner execution contract is invalid",
+    )
+
+    views = value.get("compiled_views")
+    _require(isinstance(views, dict) and set(views) == {"SOUL.md", "identity.json"}, "compiled views are incomplete")
+    for name, view in views.items():
+        _require(isinstance(view, dict) and _is_sha256(view.get("sha256")), f"compiled view {name} is invalid")
+        _require(
+            set(view) == {"role", "sha256", "generated_from_identity_inputs_sha256"},
+            f"compiled view {name} fields are invalid",
+        )
+        _require(view.get("role") == "generated_view_not_authority", f"compiled view {name} authority is invalid")
+        _require(
+            view.get("generated_from_identity_inputs_sha256") == identity_hash, f"compiled view {name} is misbound"
+        )
+
+
+def verify_bound_sources(value: dict[str, Any], source_root: Path) -> dict[str, str]:
+    validate_identity_manifest(value)
+    core = value["identity_inputs"]
+    bindings = {
+        "database fingerprint": core["canonical_database"]["source"],
+        "constitution source": core["identity_sources"]["static_constitution"],
+        "database identity source": core["identity_sources"]["database_derived_identity"],
+    }
+    paths = {label: source_root / binding["repo_path"] for label, binding in bindings.items()}
+    for label, binding in bindings.items():
+        path = paths[label]
+        _require(path.is_file(), f"bound {label} is missing")
+        if binding.get("content_sha256"):
+            _require(behavior.file_sha256(path) == binding["content_sha256"], f"bound {label} content drift detected")
+    fingerprint = load_json(paths["database fingerprint"], "database fingerprint")
+    validate_database_fingerprint(fingerprint)
+    _require(
+        behavior.canonical_sha256(database_fingerprint_semantic(fingerprint))
+        == bindings["database fingerprint"]["semantic_sha256"],
+        "database fingerprint semantic drift detected",
+    )
+    marker = fingerprint["read_consistency"]["before"]
+    for field in ("database", "database_user", "system_identifier"):
+        _require(marker[field] == core["canonical_database"][field], f"canonical database {field} drift detected")
+    rules = canonical_rules(load_json(paths["constitution source"], "constitution source"))
+    database_identity = load_json(paths["database identity source"], "database identity source")
+    records = canonical_database_records(
+        database_identity,
+        fingerprint_sha256=fingerprint["fingerprint_sha256"],
+    )
+    database_provenance = database_identity_provenance(
+        database_identity,
+        fingerprint=fingerprint,
+    )
+    _require(
+        behavior.canonical_sha256(rules) == bindings["constitution source"]["semantic_sha256"],
+        "constitution semantic drift detected",
+    )
+    _require(
+        behavior.canonical_sha256({"provenance": database_provenance, "records": records})
+        == bindings["database identity source"]["semantic_sha256"],
+        "database identity semantic drift detected",
+    )
+    _require(
+        database_provenance == core["identity_sources"]["database_derived_identity"]["provenance"],
+        "database identity provenance drift detected",
+    )
+    _require(
+        fingerprint["fingerprint_sha256"] == core["canonical_database"]["fingerprint_sha256"],
+        "canonical database fingerprint drift detected",
+    )
+    views = render_identity_views(
+        identity_inputs_sha256=value["identity_inputs_sha256"],
+        database_fingerprint_sha256=fingerprint["fingerprint_sha256"],
+        database_provenance=database_provenance,
+        rules=rules,
+        records=records,
+    )
+    for name, content in views.items():
+        _require(
+            behavior.sha256_bytes(content.encode("utf-8")) == value["compiled_views"][name]["sha256"],
+            f"compiled view contract drift detected for {name}",
+        )
+    return views
+
+
+def write_json(path: Path, value: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    generate = subparsers.add_parser("generate")
+    generate.add_argument("--behavior-manifest", type=Path, required=True)
+    generate.add_argument("--database-fingerprint", type=Path, required=True)
+    generate.add_argument("--constitution", type=Path, required=True)
+    generate.add_argument("--database-identity", type=Path, required=True)
+    generate.add_argument("--source-root", type=Path, required=True)
+    generate.add_argument("--source-commit")
+    generate.add_argument("--output", type=Path, required=True)
+    verify = subparsers.add_parser("verify")
+    verify.add_argument("--manifest", type=Path, required=True)
+    verify.add_argument("--source-root", type=Path)
+    args = parser.parse_args()
+    try:
+        if args.command == "generate":
+            manifest = build_identity_manifest(
+                behavior_manifest=load_json(args.behavior_manifest, "behavior manifest"),
+                database_fingerprint_path=args.database_fingerprint,
+                constitution_path=args.constitution,
+                database_identity_path=args.database_identity,
+                source_root=args.source_root,
+                source_commit=args.source_commit,
+            )
+            write_json(args.output, manifest)
+        else:
+            manifest = load_json(args.manifest, "identity manifest")
+            validate_identity_manifest(manifest)
+            if args.source_root:
+                verify_bound_sources(manifest, args.source_root)
+        print(json.dumps({"status": "ok", "manifest_sha256": manifest["manifest_sha256"]}))
+        return 0
+    except IdentityManifestError as exc:
+        print(json.dumps({"status": "error", "error": "identity_manifest_invalid", "message": str(exc)}))
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/leo_identity_profile.py

@@ -0,0 +1,495 @@
+#!/usr/bin/env python3
+"""Compile, verify, and query a disposable Leo identity profile."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import uuid
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from scripts import leo_behavior_manifest as behavior
+from scripts import leo_identity_manifest as identity
+
+LOCK_SCHEMA = "livingip.leoIdentityProfileLock.v1"
+COMPILE_RECEIPT_SCHEMA = "livingip.leoIdentityCompileReceipt.v1"
+QUERY_RECEIPT_SCHEMA = "livingip.leoIdentityQueryReceipt.v1"
+SESSION_RECORD_SCHEMA = "livingip.leoTemporarySessionRecord.v1"
+FIXED_QUERY = "What defines Leo's identity, and what is temporary?"
+STATIC_PROFILE_ENTRIES = ("config.yaml", "skills", "plugins", "bin")
+COMPILED_PROFILE_ENTRIES = frozenset(
+    {
+        "config.yaml",
+        "skills",
+        "plugins",
+        "bin",
+        "SOUL.md",
+        "identity.json",
+        "identity-manifest.json",
+        "identity-lock.json",
+        "compile-receipt.json",
+        "sessions",
+        "state",
+    }
+)
+OMITTED_NONAUTHORITATIVE_ENTRIES = (
+    "memories",
+    "MEMORY.md",
+    "USER.md",
+    "platforms/pairing",
+    ".skills_prompt_snapshot.json",
+    ".hermes.md",
+    "HERMES.md",
+    "AGENTS.md",
+    "CLAUDE.md",
+    ".cursorrules",
+)
+
+
+class IdentityProfileError(identity.IdentityManifestError):
+    """A compiled profile cannot be trusted or started."""
+
+
+def _require(condition: bool, message: str) -> None:
+    if not condition:
+        raise IdentityProfileError(message)
+
+
+def _copy_static_profile(template: Path, target: Path) -> list[str]:
+    _require(template.is_dir(), "profile template is missing")
+    _require(not target.exists(), "compiled profile target already exists")
+    target.mkdir(parents=True, mode=0o700)
+    copied: list[str] = []
+    for name in STATIC_PROFILE_ENTRIES:
+        source = template / name
+        if not source.exists():
+            continue
+        destination = target / name
+        _require(not source.is_symlink(), f"unsafe symlinked static profile entry: {name}")
+        if source.is_dir():
+            _require(
+                not any(path.is_symlink() for path in source.rglob("*")),
+                f"unsafe symlink inside static profile entry: {name}",
+            )
+            shutil.copytree(source, destination, symlinks=False)
+        elif source.is_file() and not source.is_symlink():
+            if name == "config.yaml":
+                try:
+                    raw_config = yaml.safe_load(source.read_text(encoding="utf-8")) or {}
+                except (OSError, TypeError, yaml.YAMLError) as exc:
+                    raise IdentityProfileError(f"cannot sanitize profile config: {type(exc).__name__}") from exc
+                _require(isinstance(raw_config, dict), "profile config must be a mapping")
+                destination.write_text(
+                    yaml.safe_dump(behavior.identity_config_projection(raw_config), sort_keys=False),
+                    encoding="utf-8",
+                )
+                destination.chmod(0o600)
+            else:
+                shutil.copy2(source, destination)
+        else:
+            raise IdentityProfileError(f"unsafe static profile entry: {name}")
+        copied.append(name)
+    _require("config.yaml" in copied, "profile template config.yaml is missing")
+    return copied
+
+
+def _behavior(profile: Path, hermes_root: Path, deployment_root: Path) -> dict[str, Any]:
+    return behavior.build_manifest(profile, hermes_root, deployment_root)
+
+
+def _verify_runtime_binding(
+    manifest: dict[str, Any],
+    *,
+    profile: Path,
+    hermes_root: Path,
+    deployment_root: Path,
+) -> dict[str, Any]:
+    observed = _behavior(profile, hermes_root, deployment_root)
+    identity.validate_behavior_manifest(observed)
+    expected = manifest["identity_inputs"]["runtime"]
+    _require(
+        observed["identity_runtime_sha256"] == expected["identity_runtime_sha256"], "identity runtime drift detected"
+    )
+    _require(observed["hermes_runtime"]["git_head"] == expected["hermes_git_head"], "Hermes Git drift detected")
+    _require(
+        observed["hermes_runtime"]["source_tree"]["sha256"] == expected["hermes_source_sha256"],
+        "Hermes source drift detected",
+    )
+    _require(
+        observed["teleo_infrastructure_runtime"]["git_head"] == expected["teleo_git_head"],
+        "Teleo Git drift detected",
+    )
+    _require(
+        observed["teleo_infrastructure_runtime"]["identity_source_tree"]["sha256"] == expected["teleo_source_sha256"],
+        "Teleo identity source drift detected",
+    )
+    _require(observed["python_runtime"] == expected["python"], "Python runtime drift detected")
+    _require(
+        manifest["identity_inputs"]["source_commit"] == observed["teleo_infrastructure_runtime"]["git_head"],
+        "source commit drift detected",
+    )
+
+    expected_model = manifest["identity_inputs"]["model"]
+    observed_model = observed["model_runtime"]
+    model_bindings = {
+        "provider": observed_model.get("provider"),
+        "default_model": observed_model.get("default_model"),
+        "smart_routing": observed_model.get("smart_routing"),
+        "smart_routing_model": observed_model.get("smart_routing_model"),
+        "gateway_smart_model_routing": observed_model.get("gateway_smart_model_routing"),
+        "model_section_sha256": observed_model.get("model_section_sha256"),
+        "hosted_weights": observed_model.get("base_model_weights"),
+        "actual_model_required_in_turn_receipt": observed_model.get(
+            "actual_per_turn_model_must_be_recorded_by_the_call_receipt"
+        ),
+    }
+    for field, observed_value in model_bindings.items():
+        _require(expected_model.get(field) == observed_value, f"model runtime binding drift detected: {field}")
+
+    expected_permissions = manifest["identity_inputs"]["permissions"]
+    permission_bindings = {
+        "identity_config_sha256": observed_model.get("identity_config_sha256"),
+        "gateway_permissions_sha256": observed_model.get("gateway_permissions_sha256"),
+        "tool_permissions_sha256": observed_model.get("tool_permissions_sha256"),
+        "runtime_policy": observed_model.get("identity_runtime_policy"),
+        "authorization_decision_required_in_runtime_receipt": True,
+    }
+    for field, observed_value in permission_bindings.items():
+        _require(
+            expected_permissions.get(field) == observed_value, f"permission runtime binding drift detected: {field}"
+        )
+
+    observed_skills = observed["components"]["procedural_skills"]["content"]
+    expected_skills = manifest["identity_inputs"]["skills"]
+    _require(expected_skills["content_sha256"] == observed_skills["sha256"], "skills runtime binding drift detected")
+    _require(expected_skills["file_count"] == observed_skills["file_count"], "skills file count drift detected")
+    return observed
+
+
+def _view_file_sha256(profile: Path, name: str) -> str:
+    path = profile / name
+    _require(path.is_file() and not path.is_symlink(), f"compiled view is missing or unsafe: {name}")
+    return behavior.file_sha256(path)
+
+
+def _verify_nonauthoritative_surfaces(
+    profile: Path,
+    *,
+    require_empty_sessions: bool,
+    require_compile_receipt: bool,
+) -> dict[str, Any]:
+    omitted = {
+        name: not (profile / name).exists() and not (profile / name).is_symlink()
+        for name in OMITTED_NONAUTHORITATIVE_ENTRIES
+    }
+    _require(all(omitted.values()), "profile contains a forbidden nonauthoritative input surface")
+    expected_entries = set(COMPILED_PROFILE_ENTRIES)
+    if not require_compile_receipt:
+        expected_entries.remove("compile-receipt.json")
+    profile_entries = list(profile.iterdir())
+    actual_entries = {path.name for path in profile_entries}
+    _require(actual_entries == expected_entries, "compiled profile entry set is not exact")
+    _require(not any(path.is_symlink() for path in profile_entries), "compiled profile entries must not be symlinks")
+    if require_compile_receipt:
+        compile_receipt = identity.load_json(profile / "compile-receipt.json", "identity compile receipt")
+        _require(compile_receipt.get("schema") == COMPILE_RECEIPT_SCHEMA, "identity compile receipt schema is invalid")
+        _require(compile_receipt.get("status") == "pass", "identity compile receipt status is invalid")
+    state = profile / "state"
+    sessions = profile / "sessions"
+    for path, label in ((state, "state"), (sessions, "sessions")):
+        _require(path.is_dir() and not path.is_symlink(), f"profile {label} directory is missing or unsafe")
+    _require(not any(state.iterdir()), "profile state directory must remain empty")
+    session_files = list(sessions.iterdir())
+    if require_empty_sessions:
+        _require(not session_files, "profile sessions must start empty")
+    for path in session_files:
+        _require(path.is_file() and not path.is_symlink() and path.suffix == ".json", "unsafe session entry detected")
+        record = identity.load_json(path, "temporary session record")
+        _require(
+            set(record)
+            == {
+                "schema",
+                "authority",
+                "classification",
+                "query_sha256",
+                "answer_sha256",
+                "may_be_used_as_evidence",
+            },
+            "temporary session record fields are invalid",
+        )
+        _require(record.get("schema") == SESSION_RECORD_SCHEMA, "temporary session record schema is invalid")
+        _require(record.get("authority") == "none", "temporary session authority is invalid")
+        _require(record.get("classification") == "temporary_noncanonical", "temporary session class is invalid")
+        _require(record.get("may_be_used_as_evidence") is False, "temporary session cannot be evidence")
+        _require(identity._is_sha256(record.get("query_sha256")), "temporary session query hash is invalid")
+        _require(identity._is_sha256(record.get("answer_sha256")), "temporary session answer hash is invalid")
+    return {
+        "nonauthoritative_inputs_omitted": omitted,
+        "session_file_count": len(session_files),
+        "state_empty": True,
+    }
+
+
+def compile_profile(
+    manifest: dict[str, Any],
+    *,
+    source_root: Path,
+    profile_template: Path,
+    profile: Path,
+    hermes_root: Path,
+    deployment_root: Path,
+) -> dict[str, Any]:
+    views = identity.verify_bound_sources(manifest, source_root)
+    template_behavior = _behavior(profile_template, hermes_root, deployment_root)
+    identity.validate_behavior_manifest(template_behavior)
+    _require(
+        template_behavior["identity_runtime_sha256"]
+        == manifest["identity_inputs"]["runtime"]["identity_runtime_sha256"],
+        "profile template does not match the pinned identity runtime",
+    )
+    copied = _copy_static_profile(profile_template, profile)
+    try:
+        for name, content in views.items():
+            path = profile / name
+            path.write_text(content, encoding="utf-8")
+            path.chmod(0o600)
+        identity.write_json(profile / "identity-manifest.json", manifest)
+        (profile / "identity-manifest.json").chmod(0o600)
+        for directory in (profile / "sessions", profile / "state"):
+            directory.mkdir(mode=0o700)
+        lock = {
+            "schema": LOCK_SCHEMA,
+            "manifest_sha256": manifest["manifest_sha256"],
+            "identity_inputs_sha256": manifest["identity_inputs_sha256"],
+            "compiled_views": {name: {"sha256": _view_file_sha256(profile, name)} for name in sorted(views)},
+            "session_boundary": manifest["identity_inputs"]["session_boundary"],
+        }
+        identity.write_json(profile / "identity-lock.json", lock)
+        (profile / "identity-lock.json").chmod(0o600)
+        observed = _verify_runtime_binding(
+            manifest,
+            profile=profile,
+            hermes_root=hermes_root,
+            deployment_root=deployment_root,
+        )
+        for name, expected in manifest["compiled_views"].items():
+            _require(_view_file_sha256(profile, name) == expected["sha256"], f"compiled {name} hash mismatch")
+        soul_files = observed["components"]["runtime_identity"]["content"]["files"]
+        soul = next((item for item in soul_files if item.get("path") == "SOUL.md"), None)
+        _require(
+            isinstance(soul, dict) and soul.get("sha256") == manifest["compiled_views"]["SOUL.md"]["sha256"],
+            "SOUL runtime binding failed",
+        )
+        surface_readback = _verify_nonauthoritative_surfaces(
+            profile,
+            require_empty_sessions=True,
+            require_compile_receipt=False,
+        )
+        receipt = {
+            "schema": COMPILE_RECEIPT_SCHEMA,
+            "status": "pass",
+            "manifest_sha256": manifest["manifest_sha256"],
+            "identity_inputs_sha256": manifest["identity_inputs_sha256"],
+            "profile_static_entries": copied,
+            "compiled_view_sha256": {
+                name: manifest["compiled_views"][name]["sha256"] for name in sorted(manifest["compiled_views"])
+            },
+            "runtime_identity_sha256": observed["identity_runtime_sha256"],
+            "session_directories_started_empty": all(
+                not any((profile / name).iterdir()) for name in ("sessions", "state")
+            ),
+            "nonauthoritative_inputs_omitted": surface_readback["nonauthoritative_inputs_omitted"],
+            "generated_views_are_authority": False,
+        }
+        identity.write_json(profile / "compile-receipt.json", receipt)
+        return receipt
+    except BaseException:
+        shutil.rmtree(profile, ignore_errors=True)
+        raise
+
+
+def verify_profile(
+    profile: Path,
+    *,
+    source_root: Path,
+    hermes_root: Path,
+    deployment_root: Path,
+) -> tuple[dict[str, Any], dict[str, str], dict[str, Any]]:
+    manifest = identity.load_json(profile / "identity-manifest.json", "compiled identity manifest")
+    views = identity.verify_bound_sources(manifest, source_root)
+    lock = identity.load_json(profile / "identity-lock.json", "identity profile lock")
+    _verify_nonauthoritative_surfaces(
+        profile,
+        require_empty_sessions=False,
+        require_compile_receipt=True,
+    )
+    _require(lock.get("schema") == LOCK_SCHEMA, "identity profile lock schema is invalid")
+    _require(
+        lock.get("manifest_sha256") == manifest["manifest_sha256"], "identity profile lock manifest drift detected"
+    )
+    _require(
+        lock.get("identity_inputs_sha256") == manifest["identity_inputs_sha256"],
+        "identity profile lock input drift detected",
+    )
+    compile_receipt = identity.load_json(profile / "compile-receipt.json", "identity compile receipt")
+    _require(
+        compile_receipt.get("manifest_sha256") == manifest["manifest_sha256"],
+        "identity compile receipt manifest drift detected",
+    )
+    _require(
+        compile_receipt.get("identity_inputs_sha256") == manifest["identity_inputs_sha256"],
+        "identity compile receipt input drift detected",
+    )
+    for name, expected_content in views.items():
+        expected_hash = behavior.sha256_bytes(expected_content.encode("utf-8"))
+        _require(expected_hash == manifest["compiled_views"][name]["sha256"], f"manifest view drift detected: {name}")
+        _require(_view_file_sha256(profile, name) == expected_hash, f"compiled view drift detected: {name}")
+        _require(
+            (lock.get("compiled_views") or {}).get(name, {}).get("sha256") == expected_hash,
+            f"profile lock view drift detected: {name}",
+        )
+    observed = _verify_runtime_binding(
+        manifest,
+        profile=profile,
+        hermes_root=hermes_root,
+        deployment_root=deployment_root,
+    )
+    return manifest, views, observed
+
+
+def query_profile(
+    profile: Path,
+    *,
+    query: str,
+    source_root: Path,
+    hermes_root: Path,
+    deployment_root: Path,
+) -> dict[str, Any]:
+    _require(query == FIXED_QUERY, "only the pinned identity readback query is allowed")
+    manifest, _views, observed = verify_profile(
+        profile,
+        source_root=source_root,
+        hermes_root=hermes_root,
+        deployment_root=deployment_root,
+    )
+    structured = identity.load_json(profile / "identity.json", "compiled structured identity view")
+    rule_count = len(structured["static_constitution"]["rules"])
+    record_count = len(structured["database_identity"]["records"])
+    fingerprint = structured["database_identity"]["database_fingerprint_sha256"]
+    canonical_authority = structured["database_identity"]["canonical_authority_granted"]
+    database_description = "canonical database" if canonical_authority else "synthetic noncanonical fixture"
+    answer = (
+        f"Leo is defined by {rule_count} pinned static constitutional rules and {record_count} active "
+        f"database-derived identity rows from a {database_description} at fingerprint {fingerprint}. "
+        "SOUL.md is a generated view; "
+        "runtime/session memory is temporary, noncanonical, and cannot be evidence."
+    )
+    query_sha256 = behavior.sha256_bytes(query.encode("utf-8"))
+    answer_sha256 = behavior.sha256_bytes(answer.encode("utf-8"))
+    instance_id = uuid.uuid4().hex
+    session_record = {
+        "schema": SESSION_RECORD_SCHEMA,
+        "authority": "none",
+        "classification": "temporary_noncanonical",
+        "query_sha256": query_sha256,
+        "answer_sha256": answer_sha256,
+        "may_be_used_as_evidence": False,
+    }
+    session_path = profile / "sessions" / f"{instance_id}.json"
+    identity.write_json(session_path, session_record)
+    receipt = {
+        "schema": QUERY_RECEIPT_SCHEMA,
+        "status": "pass",
+        "started_at_utc": datetime.now(UTC).isoformat(),
+        "process_id": os.getpid(),
+        "runtime_instance_id": instance_id,
+        "query": query,
+        "query_sha256": query_sha256,
+        "answer": answer,
+        "answer_sha256": answer_sha256,
+        "manifest_sha256": manifest["manifest_sha256"],
+        "identity_inputs_sha256": manifest["identity_inputs_sha256"],
+        "output_provenance": {
+            "static_constitution_sha256": manifest["identity_inputs"]["identity_sources"]["static_constitution"][
+                "semantic_sha256"
+            ],
+            "database_identity_sha256": manifest["identity_inputs"]["identity_sources"]["database_derived_identity"][
+                "semantic_sha256"
+            ],
+            "database_fingerprint_sha256": fingerprint,
+            "database_authority": structured["database_identity"]["authority"],
+            "database_canonical_authority_granted": canonical_authority,
+            "compiled_identity_sha256": manifest["compiled_views"]["identity.json"]["sha256"],
+            "compiled_soul_sha256": manifest["compiled_views"]["SOUL.md"]["sha256"],
+            "runtime_identity_sha256": observed["identity_runtime_sha256"],
+            "actual_model_call_performed": False,
+        },
+        "authorization": {
+            "declared_runtime_policy": manifest["identity_inputs"]["permissions"]["runtime_policy"],
+            "authorization_decision_observed": False,
+            "claim": "local_policy_binding_not_an_authorizer_readback",
+        },
+        "session": {
+            "record_sha256": behavior.file_sha256(session_path),
+            "classification": "temporary_noncanonical",
+            "included_in_output_provenance": False,
+            "may_be_used_as_evidence": False,
+        },
+    }
+    return receipt
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    compile_command = subparsers.add_parser("compile")
+    compile_command.add_argument("--manifest", type=Path, required=True)
+    compile_command.add_argument("--source-root", type=Path, required=True)
+    compile_command.add_argument("--profile-template", type=Path, required=True)
+    compile_command.add_argument("--profile", type=Path, required=True)
+    compile_command.add_argument("--hermes-root", type=Path, required=True)
+    compile_command.add_argument("--deployment-root", type=Path, required=True)
+    query_command = subparsers.add_parser("query")
+    query_command.add_argument("--profile", type=Path, required=True)
+    query_command.add_argument("--query", default=FIXED_QUERY)
+    query_command.add_argument("--source-root", type=Path, required=True)
+    query_command.add_argument("--hermes-root", type=Path, required=True)
+    query_command.add_argument("--deployment-root", type=Path, required=True)
+    args = parser.parse_args()
+    try:
+        if args.command == "compile":
+            result = compile_profile(
+                identity.load_json(args.manifest, "identity manifest"),
+                source_root=args.source_root,
+                profile_template=args.profile_template,
+                profile=args.profile,
+                hermes_root=args.hermes_root,
+                deployment_root=args.deployment_root,
+            )
+        else:
+            result = query_profile(
+                args.profile,
+                query=args.query,
+                source_root=args.source_root,
+                hermes_root=args.hermes_root,
+                deployment_root=args.deployment_root,
+            )
+        print(json.dumps(result, sort_keys=True))
+        return 0
+    except identity.IdentityManifestError as exc:
+        print(json.dumps({"status": "error", "error": "identity_drift", "message": str(exc)}))
+        return 3
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/prepare_kb_source_manifest.py

@@ -34,7 +34,7 @@ DEFAULT_MODEL = "anthropic/claude-sonnet-4.5"
 EXTRACTOR_VERSION = "2"
 DEFAULT_OPENROUTER_URL = "https://openrouter.ai/api/v1/chat/completions"
 DEFAULT_KEY_FILE = Path("/opt/teleo-eval/secrets/openrouter-key")
-TEXT_SUFFIXES = {".csv", ".htm", ".html", ".json", ".md", ".rst", ".txt", ".xml"}
+TEXT_SUFFIXES = {".csv", ".htm", ".html", ".json", ".jsonl", ".md", ".rst", ".txt", ".xml"}
 MAX_SOURCE_CHARS = 120_000
 MAX_CANDIDATES = 20
 MAX_CLAIMS = 3
@@ -124,20 +124,37 @@ def _load_context(path: Path) -> dict[str, Any]:
     return {"database_search_query": query.strip(), "candidate_claims": normalized}
 
 
-def build_source_fragments(text: str) -> dict[str, str]:
+def build_source_fragment_index(text: str) -> tuple[dict[str, str], dict[str, dict[str, Any]]]:
-    """Label non-empty source lines so the model selects text instead of copying it."""
+    """Return selectable lines plus exact line/character provenance."""
     fragments: dict[str, str] = {}
-    for line in text.splitlines():
+    locations: dict[str, dict[str, Any]] = {}
-        if line.strip():
+    offset = 0
-            fragments[f"S{len(fragments) + 1:05d}"] = line
+    for line_number, raw_line in enumerate(text.splitlines(keepends=True), start=1):
+        line = raw_line.rstrip("\r\n")
+        quote = line.strip()
+        if quote:
+            reference = f"S{len(fragments) + 1:05d}"
+            start = offset + line.find(quote)
+            fragments[reference] = quote
+            locations[reference] = {
+                "reference": reference,
+                "line": line_number,
+                "char_start": start,
+                "char_end": start + len(quote),
+                "quote_sha256": sha256_bytes(quote.encode("utf-8")),
+            }
+        offset += len(raw_line)
     if not fragments:
         raise PreparationError("extracted text has no selectable source lines")
-    return fragments
+    return fragments, locations
 
 
-def build_prompt(
+def build_source_fragments(text: str) -> dict[str, str]:
-    fragments: dict[str, str], context: dict[str, Any], repair_error: str | None = None
+    """Label non-empty source lines so the model selects text instead of copying it."""
-) -> str:
+    return build_source_fragment_index(text)[0]
+
+
+def build_prompt(fragments: dict[str, str], context: dict[str, Any], repair_error: str | None = None) -> str:
     candidates = json.dumps(context["candidate_claims"], indent=2, ensure_ascii=True)
     source = "\n".join(f"[{reference}] {line}" for reference, line in fragments.items())
     repair = ""
@@ -273,9 +290,7 @@ def parse_model_output(content: str) -> dict[str, Any]:
         if not isinstance(claim, dict):
             raise PreparationError(f"model extraction claims[{index}] must be an object")
         if set(claim) != MODEL_CLAIM_KEYS:
-            raise PreparationError(
+            raise PreparationError(f"model extraction claims[{index}] keys must equal {sorted(MODEL_CLAIM_KEYS)}")
-                f"model extraction claims[{index}] keys must equal {sorted(MODEL_CLAIM_KEYS)}"
-            )
         confidence = claim.get("confidence")
         if confidence is not None and (
             isinstance(confidence, bool) or not isinstance(confidence, (int, float)) or not 0 <= confidence <= 0.75
@@ -304,27 +319,47 @@ def _resolve_reference(reference: Any, fragments: dict[str, str], label: str) ->
     return fragments[reference]
 
 
-def resolve_model_output(selection: dict[str, Any], fragments: dict[str, str]) -> dict[str, Any]:
+def resolve_model_output(
+    selection: dict[str, Any],
+    fragments: dict[str, str],
+    fragment_locations: dict[str, dict[str, Any]] | None = None,
+) -> dict[str, Any]:
+    def selected(kind: str, reference: str, **identity: Any) -> dict[str, Any]:
+        result = {"kind": kind, "reference": reference, **identity}
+        if fragment_locations is not None:
+            result.update(fragment_locations[reference])
+        return result
+
     claims: list[dict[str, Any]] = []
-    selected_references: list[dict[str, str]] = []
+    selected_references: list[dict[str, Any]] = []
     for claim_index, claim in enumerate(selection["claims"]):
         quote_ref = claim["quote_ref"]
         quote = _resolve_reference(quote_ref, fragments, f"claims[{claim_index}].quote_ref")
-        selected_references.append({"kind": "claim", "reference": quote_ref})
+        selected_references.append(selected("claim", quote_ref, claim_key=claim["claim_key"], quote=quote))
         evidence: list[dict[str, str]] = []
         for evidence_index, row in enumerate(claim["evidence"]):
             evidence_ref = row["quote_ref"]
-            evidence.append(
+            evidence_quote = _resolve_reference(
-                {
-                    "quote": _resolve_reference(
                 evidence_ref,
                 fragments,
                 f"claims[{claim_index}].evidence[{evidence_index}].quote_ref",
-                    ),
+            )
+            evidence.append(
+                {
+                    "quote": evidence_quote,
                     "role": row["role"],
                 }
             )
-            selected_references.append({"kind": "evidence", "reference": evidence_ref})
+            selected_references.append(
+                selected(
+                    "evidence",
+                    evidence_ref,
+                    claim_key=claim["claim_key"],
+                    evidence_index=evidence_index,
+                    evidence_role=row["role"],
+                    quote=evidence_quote,
+                )
+            )
         claims.append(
             {
                 "claim_key": claim["claim_key"],
@@ -351,7 +386,14 @@ def resolve_model_output(selection: dict[str, Any], fragments: dict[str, str]) -
                 "reason": duplicate["reason"],
             }
         )
-        selected_references.append({"kind": "duplicate", "reference": source_quote_ref})
+        selected_references.append(
+            selected(
+                "duplicate",
+                source_quote_ref,
+                claim_id=duplicate["claim_id"],
+                quote=duplicates[-1]["source_quote"],
+            )
+        )
 
     return {
         "schema": RESOLVED_OUTPUT_SCHEMA,
@@ -362,6 +404,37 @@ def resolve_model_output(selection: dict[str, Any], fragments: dict[str, str]) -
     }
 
 
+def validate_bundle_source_locations(bundle: dict[str, Any], selected_references: list[dict[str, Any]]) -> None:
+    """Ensure compiler quote offsets match the exact selected fragment occurrence."""
+    available = list(bundle.get("quote_bindings") or [])
+    for selected in selected_references:
+        if selected.get("kind") not in {"claim", "evidence"}:
+            continue
+        match_index = next(
+            (
+                index
+                for index, binding in enumerate(available)
+                if binding.get("kind") == selected.get("kind")
+                and binding.get("claim_key") == selected.get("claim_key")
+                and binding.get("quote") == selected.get("quote")
+                and (
+                    selected.get("kind") != "evidence" or binding.get("evidence_role") == selected.get("evidence_role")
+                )
+            ),
+            None,
+        )
+        if match_index is None:
+            raise PreparationError("compiler dropped a selected claim/evidence source binding")
+        binding = available.pop(match_index)
+        if binding.get("first_start") != selected.get("char_start") or binding.get("first_end") != selected.get(
+            "char_end"
+        ):
+            raise PreparationError(
+                f"selected {selected['reference']} is an ambiguous repeated quote; "
+                "the current compiler cannot preserve that exact occurrence"
+            )
+
+
 def build_manifest(
     *,
     args: argparse.Namespace,
@@ -427,7 +500,7 @@ def prepare(args: argparse.Namespace) -> dict[str, Any]:
     artifact_bytes = _read_nonempty(args.artifact, "artifact")
     text_bytes = extract_utf8_text(args.artifact, args.text)
     text = text_bytes.decode("utf-8", errors="strict")
-    fragments = build_source_fragments(text)
+    fragments, fragment_locations = build_source_fragment_index(text)
     context = _load_context(args.kb_context)
 
     requested_output_dir = args.output_dir.expanduser()
@@ -464,7 +537,7 @@ def prepare(args: argparse.Namespace) -> dict[str, Any]:
         attempts.append({"attempt": attempt, "response_sha256": sha256_bytes(raw.encode("utf-8")), "usage": usage})
         try:
             selection = parse_model_output(raw)
-            extraction = resolve_model_output(selection, fragments)
+            extraction = resolve_model_output(selection, fragments, fragment_locations)
             compiler._validate_dedupe(
                 {
                     "database_search_query": context["database_search_query"],
@@ -494,6 +567,7 @@ def prepare(args: argparse.Namespace) -> dict[str, Any]:
                 with os.fdopen(fd, "wb") as handle:
                     handle.write(_json_bytes(manifest))
                 bundle = compiler.compile_source_packet(args.artifact, temp_text, temp_manifest)
+                validate_bundle_source_locations(bundle, extraction["selected_source_references"])
             finally:
                 if temp_text.exists():
                     temp_text.unlink()
@@ -518,6 +592,7 @@ def prepare(args: argparse.Namespace) -> dict[str, Any]:
             raise PreparationError("prepared extraction has no manifest")
         _write_private(manifest_path, _json_bytes(manifest))
         bundle = compiler.compile_source_packet(args.artifact, text_path, manifest_path)
+        validate_bundle_source_locations(bundle, extraction["selected_source_references"])
 
     receipt = {
         "schema": RECEIPT_SCHEMA,
@@ -545,10 +620,20 @@ def prepare(args: argparse.Namespace) -> dict[str, Any]:
             "model": args.model,
             "attempts": attempts,
             "claim_count": len(extraction["claims"]),
+            "evidence_count": sum(len(claim["evidence"]) for claim in extraction["claims"]),
+            "duplicate_judgment_count": len(extraction["duplicates"]),
             "selectable_source_line_count": len(fragments),
             "selected_source_references": extraction["selected_source_references"],
             "notes": extraction["extraction_notes"],
         },
+        "replay": {
+            "artifact_sha256": artifact_sha256,
+            "extracted_text_sha256": text_sha256,
+            "kb_context_sha256": sha256_bytes(_json_bytes(context)),
+            "fragment_index_sha256": sha256_bytes(_json_bytes(fragment_locations)),
+            "extractor": {"name": f"openrouter:{args.model}", "version": EXTRACTOR_VERSION},
+            "exact_selected_locations_validated": bundle is not None,
+        },
         "outputs": {
             "output_dir": str(output_dir),
             "extracted_text": str(text_path),

scripts/run_approve_claim_isolated_container_canary.sh

@@ -9,6 +9,8 @@ image="${POSTGRES_CANARY_IMAGE:-postgres:16}"
 source_tier="${SOURCE_TIER:-live-readonly}"
 normalization_json=""
 output="${repo_root}/docs/reports/leo-working-state-20260709/approve-claim-clone-canary-current.json"
+lifecycle_receipt_output=""
+rollback_sql_output=""
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
@@ -20,6 +22,14 @@ while [[ $# -gt 0 ]]; do
       output="$2"
       shift 2
       ;;
+    --lifecycle-receipt-output)
+      lifecycle_receipt_output="$2"
+      shift 2
+      ;;
+    --rollback-sql-output)
+      rollback_sql_output="$2"
+      shift 2
+      ;;
     --source-container)
       source_container="$2"
       shift 2
@@ -99,11 +109,19 @@ service_state() {
 }
 
 mkdir -p "$workdir" "$(dirname "$output")"
+if [[ -n "$lifecycle_receipt_output" ]]; then
+  mkdir -p "$(dirname "$lifecycle_receipt_output")"
+fi
+if [[ -n "$rollback_sql_output" ]]; then
+  mkdir -p "$(dirname "$rollback_sql_output")"
+fi
 source_counts_before="$(source_counts)"
 service_before="$(service_state)"
 
 docker run -d --name "$container" \
   --network none \
+  --label livingip.canary=proposal-apply-lifecycle \
+  --label "livingip.canary.instance=${container}" \
   --tmpfs /var/lib/postgresql/data:rw,nosuid,size=512m \
   -e POSTGRES_PASSWORD="isolated-postgres-${RANDOM}-${RANDOM}" \
   -e POSTGRES_DB=teleo \
@@ -127,6 +145,12 @@ if [[ "$ready_streak" -lt 2 ]]; then
 fi
 container_network_mode="$(docker inspect -f '{{.HostConfig.NetworkMode}}' "$container")"
 container_mounts_json="$(docker inspect -f '{{json .Mounts}}' "$container")"
+container_canary_label="$(
+  docker inspect -f '{{index .Config.Labels "livingip.canary"}}' "$container"
+)"
+container_instance_label="$(
+  docker inspect -f '{{index .Config.Labels "livingip.canary.instance"}}' "$container"
+)"
 
 docker exec "$source_container" pg_dump -U postgres -d "$source_db" \
   --schema-only --no-owner --no-privileges >"$workdir/schema.sql"
@@ -165,6 +189,13 @@ normalization_args=()
 if [[ -n "$normalization_json" ]]; then
   normalization_args=(--normalization-json "$normalization_json")
 fi
+artifact_args=()
+if [[ -n "$lifecycle_receipt_output" ]]; then
+  artifact_args+=(--lifecycle-receipt-output "$lifecycle_receipt_output")
+fi
+if [[ -n "$rollback_sql_output" ]]; then
+  artifact_args+=(--rollback-sql-output "$rollback_sql_output")
+fi
 
 set +e
 python3 "$repo_root/scripts/run_approve_claim_clone_canary.py" \
@@ -178,6 +209,7 @@ python3 "$repo_root/scripts/run_approve_claim_clone_canary.py" \
   --review-secrets-file "$workdir/kb-review.env" \
   --secrets-file "$workdir/kb-apply.env" \
   "${normalization_args[@]}" \
+  "${artifact_args[@]}" \
   --output "$output" \
   >"$workdir/stdout.json" 2>"$workdir/stderr.log"
 canary_rc=$?
@@ -192,6 +224,20 @@ container_name_readback="$(
   docker container ls -a --filter "name=^/${container}$" --format '{{.Names}}' 2>&1
 )"
 container_name_readback_rc=$?
+container_label_readback="$(
+  docker container ls -a \
+    --filter "label=livingip.canary=proposal-apply-lifecycle" \
+    --filter "label=livingip.canary.instance=${container}" \
+    --format '{{.Names}}' 2>&1
+)"
+container_label_readback_rc=$?
+if [[ "$container_label_readback_rc" -eq 0 ]]; then
+  container_label_orphan_count="$(
+    awk 'NF { count += 1 } END { print count + 0 }' <<<"$container_label_readback"
+  )"
+else
+  container_label_orphan_count=-1
+fi
 if [[ -e "$workdir" || -L "$workdir" ]]; then
   outer_workdir_lexists=true
 else
@@ -214,6 +260,9 @@ OUTER_CONTAINER_REMOVE_RC="$outer_container_remove_rc" \
 OUTER_WORKDIR_REMOVE_RC="$outer_workdir_remove_rc" \
 CONTAINER_NAME_READBACK="$container_name_readback" \
 CONTAINER_NAME_READBACK_RC="$container_name_readback_rc" \
+CONTAINER_LABEL_READBACK="$container_label_readback" \
+CONTAINER_LABEL_READBACK_RC="$container_label_readback_rc" \
+CONTAINER_LABEL_ORPHAN_COUNT="$container_label_orphan_count" \
 OUTER_WORKDIR_LEXISTS="$outer_workdir_lexists" \
 CANARY_RC="$canary_rc" \
 SOURCE_TIER="$source_tier" \
@@ -221,219 +270,6 @@ SOURCE_NETWORK_MODE="$source_network_mode" \
 SOURCE_CANARY_LABEL="$source_canary_label" \
 CANARY_NETWORK_MODE="$container_network_mode" \
 CANARY_MOUNTS_JSON="$container_mounts_json" \
-python3 - "$output" <<'PY'
+CANARY_LABEL="$container_canary_label" \
-import hashlib
+CANARY_INSTANCE_LABEL="$container_instance_label" \
-import json
+python3 "$repo_root/scripts/finalize_approve_claim_isolated_canary.py" "$output"
-import os
-import sys
-from pathlib import Path
-
-path = Path(sys.argv[1])
-if not path.is_file():
-    raise SystemExit("inner canary did not produce a report")
-
-data = json.loads(path.read_text(encoding="utf-8"))
-
-def service(raw: str) -> dict[str, str]:
-    return dict(line.split("=", 1) for line in raw.splitlines() if "=" in line)
-
-def table_deltas(before: dict[str, int], after: dict[str, int]) -> dict[str, int]:
-    if set(before) != set(after):
-        raise SystemExit(
-            "live source count keys changed during the canary: "
-            f"before={sorted(before)} after={sorted(after)}"
-        )
-    return {key: after[key] - before[key] for key in sorted(before)}
-
-def verify_source_binding(root: Path, records: list[dict[str, object]]) -> dict[str, object]:
-    readbacks = []
-    for record in records:
-        relative_text = str(record.get("repo_relative_path", ""))
-        relative = Path(relative_text)
-        if not relative_text or relative.is_absolute() or ".." in relative.parts:
-            raise SystemExit(f"unsafe repo-relative source path: {relative_text!r}")
-        candidate = (root / relative).resolve()
-        try:
-            candidate.relative_to(root)
-        except ValueError as exc:
-            raise SystemExit(
-                f"source path escaped repository root: {relative_text}"
-            ) from exc
-        if not candidate.is_file():
-            readbacks.append(
-                {
-                    "repo_relative_path": relative.as_posix(),
-                    "expected_sha256": record.get("sha256"),
-                    "actual_sha256": None,
-                    "matches": False,
-                }
-            )
-            continue
-        content = candidate.read_bytes()
-        actual_sha256 = hashlib.sha256(content).hexdigest()
-        readbacks.append(
-            {
-                "repo_relative_path": relative.as_posix(),
-                "expected_sha256": record.get("sha256"),
-                "actual_sha256": actual_sha256,
-                "size_bytes": len(content),
-                "matches": (
-                    actual_sha256 == record.get("sha256")
-                    and len(content) == record.get("size_bytes")
-                ),
-            }
-        )
-    return {
-        "files": readbacks,
-        "all_match": bool(readbacks) and all(row["matches"] for row in readbacks),
-    }
-
-def contains_ephemeral_path(value: object) -> bool:
-    if isinstance(value, str):
-        return "/tmp/" in value
-    if isinstance(value, dict):
-        return any(contains_ephemeral_path(item) for item in value.values())
-    if isinstance(value, list):
-        return any(contains_ephemeral_path(item) for item in value)
-    return False
-
-before_counts = json.loads(os.environ["SOURCE_COUNTS_BEFORE"])
-after_counts = json.loads(os.environ["SOURCE_COUNTS_AFTER"])
-live_table_deltas = table_deltas(before_counts, after_counts)
-before_service = service(os.environ["SERVICE_BEFORE"])
-after_service = service(os.environ["SERVICE_AFTER"])
-source_tier = os.environ["SOURCE_TIER"]
-source_network_mode = os.environ["SOURCE_NETWORK_MODE"]
-source_canary_label = os.environ["SOURCE_CANARY_LABEL"]
-container_network_mode = os.environ["CANARY_NETWORK_MODE"]
-container_mounts = json.loads(os.environ["CANARY_MOUNTS_JSON"])
-container_volume_mounts = [
-    mount for mount in container_mounts if mount.get("Type") == "volume"
-]
-container_isolated = (
-    container_network_mode == "none" and not container_volume_mounts
-)
-source_tier_enforced = (
-    source_tier != "isolated-local"
-    or (
-        source_network_mode == "none"
-        and source_canary_label == "working-leo-approved-source"
-    )
-)
-service_observable = (
-    before_service.get("Available") == "true"
-    and after_service.get("Available") == "true"
-)
-service_stable = (
-    all(
-        before_service.get(key) == after_service.get(key)
-        for key in ("ActiveState", "SubState", "MainPID", "NRestarts")
-    )
-    if service_observable
-    else None
-)
-service_gate_passes = (
-    service_stable is True
-    if source_tier == "live-readonly"
-    else service_stable is not False
-)
-container_absent = (
-    int(os.environ["CONTAINER_NAME_READBACK_RC"]) == 0
-    and not os.environ["CONTAINER_NAME_READBACK"].strip()
-)
-workdir_absent = os.environ["OUTER_WORKDIR_LEXISTS"] == "false"
-source_binding = verify_source_binding(
-    Path(os.environ["REPO_ROOT"]).resolve(),
-    data.get("source_binding", {}).get("files", []),
-)
-data["source_binding"]["independent_post_cleanup_verification"] = source_binding
-source_binding_ok = (
-    data["source_binding"].get("unchanged_during_run") is True
-    and source_binding["all_match"] is True
-)
-stale_ephemeral_paths_absent = not contains_ephemeral_path(data)
-inner_runtime_pass = data.get("status") == "pass" and int(os.environ["CANARY_RC"]) == 0
-outer_ok = (
-    before_counts == after_counts
-    and all(delta == 0 for delta in live_table_deltas.values())
-    and service_gate_passes
-    and container_absent
-    and workdir_absent
-    and source_binding_ok
-    and stale_ephemeral_paths_absent
-    and container_isolated
-    and source_tier_enforced
-)
-if source_tier == "isolated-local":
-    data["required_tier"] = "T2_runtime"
-    data["required_tiers"] = ["T2_runtime"]
-    data["runtime_scope"] = "isolated_postgres_container_from_readonly_local_fixture"
-else:
-    data["required_tier"] = "T3_live_readonly"
-    data["required_tiers"] = ["T2_runtime", "T3_live_readonly"]
-    data["runtime_scope"] = "isolated_postgres_container_from_readonly_live_schema"
-data["outer_isolation"] = {
-    "source_container": os.environ.get("SOURCE_CONTAINER", "teleo-pg"),
-    "source_database": os.environ.get("SOURCE_DB", "teleo"),
-    "source_counts_before": before_counts,
-    "source_counts_after": after_counts,
-    "canonical_table_deltas": live_table_deltas,
-    "source_counts_unchanged": before_counts == after_counts,
-    "service_before": before_service,
-    "service_after": after_service,
-    "service_required": source_tier == "live-readonly",
-    "service_observable": service_observable,
-    "service_stable": service_stable,
-    "service_gate_passes": service_gate_passes,
-    "source_boundary": {
-        "source_tier": source_tier,
-        "network_mode": source_network_mode,
-        "canary_label": source_canary_label,
-        "tier_enforced": source_tier_enforced,
-    },
-    "container_isolation": {
-        "network_mode": container_network_mode,
-        "volume_mounts": container_volume_mounts,
-        "network_disabled": container_network_mode == "none",
-        "no_docker_volumes": not container_volume_mounts,
-    },
-    "cleanup_readback": {
-        "container_remove_returncode": int(os.environ["OUTER_CONTAINER_REMOVE_RC"]),
-        "container_name_query_returncode": int(
-            os.environ["CONTAINER_NAME_READBACK_RC"]
-        ),
-        "container_name_query_stdout": os.environ["CONTAINER_NAME_READBACK"],
-        "temporary_container_absent": container_absent,
-        "workdir_remove_returncode": int(os.environ["OUTER_WORKDIR_REMOVE_RC"]),
-        "workdir_lexists_after_cleanup": not workdir_absent,
-        "temporary_workdir_absent": workdir_absent,
-    },
-}
-data["checks"]["outer_live_counts_exactly_unchanged"] = before_counts == after_counts
-data["checks"]["outer_live_table_deltas_exactly_zero"] = all(
-    delta == 0 for delta in live_table_deltas.values()
-)
-data["checks"]["outer_service_observed_if_required"] = (
-    source_tier != "live-readonly" or service_observable
-)
-data["checks"]["outer_service_stable_if_observed"] = service_gate_passes
-data["checks"]["outer_container_absent_independent_readback"] = container_absent
-data["checks"]["outer_workdir_absent_independent_readback"] = workdir_absent
-data["checks"]["source_binding_independently_verified"] = source_binding_ok
-data["checks"]["stale_ephemeral_paths_absent"] = stale_ephemeral_paths_absent
-data["checks"]["outer_source_tier_enforced"] = source_tier_enforced
-data["checks"]["outer_container_network_disabled"] = (
-    container_network_mode == "none"
-)
-data["checks"]["outer_container_has_no_docker_volumes"] = not container_volume_mounts
-data["checks"]["outer_isolation_complete"] = outer_ok
-if outer_ok and inner_runtime_pass:
-    data["current_tier"] = (
-        "T2_runtime" if source_tier == "isolated-local" else "T3_live_readonly"
-    )
-else:
-    data["status"] = "fail"
-    data["current_tier"] = "T2_runtime" if inner_runtime_pass else "T1_model"
-path.write_text(json.dumps(data, indent=2, sort_keys=True) + "\n", encoding="utf-8")
-raise SystemExit(0 if data["status"] == "pass" else 1)
-PY

scripts/run_leo_identity_reconstruction_canary.py

@@ -0,0 +1,517 @@
+#!/usr/bin/env python3
+"""Prove manifest-driven Leo identity reconstruction across a cold restart."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import UTC, datetime
+from pathlib import Path, PurePosixPath, PureWindowsPath
+from typing import Any
+
+if __package__ in {None, ""}:
+    sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from scripts import leo_behavior_manifest as behavior
+from scripts import leo_identity_manifest as identity
+from scripts import leo_identity_profile as profile_runtime
+
+SCHEMA = "livingip.leoIdentityReconstructionReceipt.v1"
+PRIVATE_PATH_PREFIXES = tuple("/" + value for value in ("Users/", "private/tmp/", "var/folders/"))
+
+
+class CanaryError(RuntimeError):
+    """The disposable identity runtime did not satisfy its T2 contract."""
+
+
+def _require(condition: bool, message: str) -> None:
+    if not condition:
+        raise CanaryError(message)
+
+
+def _receipt_strings(value: object) -> list[str]:
+    if isinstance(value, dict):
+        keys = [key for key in value if isinstance(key, str)]
+        return keys + [text for item in value.values() for text in _receipt_strings(item)]
+    if isinstance(value, list):
+        return [text for item in value for text in _receipt_strings(item)]
+    return [value] if isinstance(value, str) else []
+
+
+def _validate_portable_receipt(value: object) -> None:
+    for text in _receipt_strings(value):
+        if (
+            any(prefix in text for prefix in PRIVATE_PATH_PREFIXES)
+            or PurePosixPath(text).is_absolute()
+            or PureWindowsPath(text).is_absolute()
+        ):
+            raise CanaryError("receipt contains a private or absolute filesystem path")
+
+
+def _process_group_absent(process_group: int) -> bool:
+    try:
+        os.killpg(process_group, 0)
+    except ProcessLookupError:
+        return True
+    except PermissionError:
+        return False
+    return False
+
+
+def _wait_for_process_group_absence(process_group: int, timeout_seconds: float = 5) -> bool:
+    deadline = time.monotonic() + timeout_seconds
+    while time.monotonic() < deadline:
+        if _process_group_absent(process_group):
+            return True
+        time.sleep(0.02)
+    return _process_group_absent(process_group)
+
+
+def _signal_process_group(process_group: int, signal_number: signal.Signals) -> bool:
+    try:
+        os.killpg(process_group, signal_number)
+        return True
+    except (ProcessLookupError, PermissionError):
+        return False
+
+
+def _cleanup_remaining_process_group(process_group: int) -> str | None:
+    if not _signal_process_group(process_group, signal.SIGTERM):
+        return None
+    if _wait_for_process_group_absence(process_group, timeout_seconds=1):
+        return "SIGTERM"
+    if not _signal_process_group(process_group, signal.SIGKILL):
+        return "SIGTERM"
+    return "SIGKILL"
+
+
+def _logical_repo_path(path: Path, *, deployment_root: Path, placeholder: str) -> str:
+    """Return a stable repo-relative path or a non-identifying placeholder."""
+
+    try:
+        relative = path.resolve().relative_to(deployment_root.resolve())
+    except (OSError, ValueError):
+        return placeholder
+    value = relative.as_posix()
+    return value if value != "." else "."
+
+
+def _logical_query_command(
+    *,
+    deployment_root: Path,
+    source_root: Path,
+    hermes_root: Path,
+) -> list[str]:
+    return [
+        "<python>",
+        "-m",
+        "scripts.leo_identity_profile",
+        "query",
+        "--profile",
+        "<temporary-profile>",
+        "--source-root",
+        _logical_repo_path(source_root, deployment_root=deployment_root, placeholder="<source-root>"),
+        "--hermes-root",
+        _logical_repo_path(hermes_root, deployment_root=deployment_root, placeholder="<hermes-root>"),
+        "--deployment-root",
+        ".",
+        "--query",
+        profile_runtime.FIXED_QUERY,
+    ]
+
+
+def _run_query_child(
+    *,
+    deployment_root: Path,
+    profile: Path,
+    source_root: Path,
+    hermes_root: Path,
+    profile_role: str,
+    timeout_seconds: float = 60,
+) -> dict[str, Any]:
+    deployment_root = deployment_root.resolve()
+    profile = profile.resolve()
+    source_root = source_root.resolve()
+    hermes_root = hermes_root.resolve()
+    actual_argv = [
+        sys.executable,
+        "-m",
+        "scripts.leo_identity_profile",
+        "query",
+        "--profile",
+        str(profile),
+        "--source-root",
+        str(source_root),
+        "--hermes-root",
+        str(hermes_root),
+        "--deployment-root",
+        str(deployment_root),
+        "--query",
+        profile_runtime.FIXED_QUERY,
+    ]
+    process = subprocess.Popen(
+        actual_argv,
+        cwd=deployment_root,
+        env={**os.environ, "PYTHONDONTWRITEBYTECODE": "1"},
+        text=True,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        start_new_session=True,
+    )
+    timed_out = False
+    terminated_with: str | None = None
+    stdout = ""
+    stderr = ""
+    process_group_absent_after_wait = False
+    orphan_cleanup_required = False
+    try:
+        try:
+            stdout, stderr = process.communicate(timeout=timeout_seconds)
+        except subprocess.TimeoutExpired:
+            timed_out = True
+            if _signal_process_group(process.pid, signal.SIGTERM):
+                terminated_with = "SIGTERM"
+            try:
+                stdout, stderr = process.communicate(timeout=5)
+            except subprocess.TimeoutExpired:
+                if _signal_process_group(process.pid, signal.SIGKILL):
+                    terminated_with = "SIGKILL"
+                stdout, stderr = process.communicate(timeout=5)
+    finally:
+        if process.poll() is None:
+            if _signal_process_group(process.pid, signal.SIGTERM):
+                terminated_with = terminated_with or "SIGTERM"
+            try:
+                process.communicate(timeout=5)
+            except subprocess.TimeoutExpired:
+                if _signal_process_group(process.pid, signal.SIGKILL):
+                    terminated_with = "SIGKILL"
+                process.communicate(timeout=5)
+        orphan_cleanup_required = not _process_group_absent(process.pid)
+        if orphan_cleanup_required:
+            terminated_with = _cleanup_remaining_process_group(process.pid) or terminated_with
+        process_group_absent_after_wait = _wait_for_process_group_absence(process.pid)
+    try:
+        payload = json.loads(stdout.strip().splitlines()[-1]) if stdout.strip() else {}
+    except json.JSONDecodeError as exc:
+        raise CanaryError("identity child returned invalid JSON") from exc
+    return {
+        "logical_command": _logical_query_command(
+            deployment_root=deployment_root,
+            source_root=source_root,
+            hermes_root=hermes_root,
+        ),
+        "command_serialization": "logical_redacted_v1",
+        "profile_role": profile_role,
+        "actual_argv_persisted": False,
+        "launcher_pid": process.pid,
+        "returncode": process.returncode,
+        "timed_out": timed_out,
+        "terminated_with": terminated_with,
+        "orphan_cleanup_required": orphan_cleanup_required,
+        "stdout": payload,
+        "stderr_sha256": behavior.sha256_bytes(stderr.encode("utf-8")),
+        "process_group_absent_after_wait": process_group_absent_after_wait,
+    }
+
+
+def _query_passed(child: dict[str, Any]) -> bool:
+    payload = child.get("stdout") or {}
+    return bool(
+        child.get("returncode") == 0
+        and child.get("timed_out") is False
+        and child.get("orphan_cleanup_required") is False
+        and child.get("process_group_absent_after_wait") is True
+        and payload.get("schema") == profile_runtime.QUERY_RECEIPT_SCHEMA
+        and payload.get("status") == "pass"
+    )
+
+
+def _drift_attempt(
+    *,
+    deployment_root: Path,
+    source_root: Path,
+    hermes_root: Path,
+    drift_profile: Path,
+) -> dict[str, Any]:
+    with (drift_profile / "SOUL.md").open("a", encoding="utf-8") as handle:
+        handle.write("\nInjected drift must fail closed.\n")
+    child = _run_query_child(
+        deployment_root=deployment_root,
+        profile=drift_profile,
+        source_root=source_root,
+        hermes_root=hermes_root,
+        profile_role="drift_negative",
+    )
+    child["fail_closed"] = bool(
+        child["returncode"] == 3
+        and child["timed_out"] is False
+        and child["orphan_cleanup_required"] is False
+        and child["process_group_absent_after_wait"] is True
+        and (child.get("stdout") or {}).get("error") == "identity_drift"
+        and "compiled view drift detected" in str((child.get("stdout") or {}).get("message"))
+    )
+    child["answer_returned"] = bool((child.get("stdout") or {}).get("answer"))
+    return child
+
+
+def run_canary(args: argparse.Namespace) -> tuple[dict[str, Any], int]:
+    output = args.output.resolve()
+    temporary_root = Path(tempfile.mkdtemp(prefix="leo-identity-reconstruction-"))
+    report: dict[str, Any] = {
+        "schema": SCHEMA,
+        "generated_at_utc": datetime.now(UTC).isoformat(),
+        "required_tier": "T2_runtime",
+        "mode": "drift_before_restart"
+        if args.inject_drift_before_restart
+        else "successful_restart_plus_drift_negative",
+        "fixed_query": profile_runtime.FIXED_QUERY,
+        "fixed_query_sha256": behavior.sha256_bytes(profile_runtime.FIXED_QUERY.encode("utf-8")),
+        "production_profile_replaced": False,
+        "production_database_contacted": False,
+        "telegram_message_sent": False,
+        "actual_hosted_model_call_performed": False,
+        "errors": [],
+    }
+    exit_code = 1
+    try:
+        behavior_manifest = behavior.build_manifest(args.profile_template, args.hermes_root, args.deployment_root)
+        identity.validate_behavior_manifest(behavior_manifest)
+        manifest = identity.build_identity_manifest(
+            behavior_manifest=behavior_manifest,
+            database_fingerprint_path=args.database_fingerprint,
+            constitution_path=args.constitution,
+            database_identity_path=args.database_identity,
+            source_root=args.source_root,
+        )
+        report["manifest"] = manifest
+        report["behavior_observation_before_compile"] = {
+            "behavior_sha256": behavior_manifest["behavior_sha256"],
+            "identity_runtime_sha256": behavior_manifest["identity_runtime_sha256"],
+            "source_commit": behavior_manifest["teleo_infrastructure_runtime"]["git_head"],
+        }
+        compiled_profile = temporary_root / "first-profile"
+        report["compile"] = profile_runtime.compile_profile(
+            manifest,
+            source_root=args.source_root,
+            profile_template=args.profile_template,
+            profile=compiled_profile,
+            hermes_root=args.hermes_root,
+            deployment_root=args.deployment_root,
+        )
+        compiled_behavior_before_query = behavior.build_manifest(
+            compiled_profile, args.hermes_root, args.deployment_root
+        )
+        report["compiled_profile_before_query"] = {
+            "behavior_sha256": compiled_behavior_before_query["behavior_sha256"],
+            "identity_runtime_sha256": compiled_behavior_before_query["identity_runtime_sha256"],
+        }
+        first = _run_query_child(
+            deployment_root=args.deployment_root,
+            profile=compiled_profile,
+            source_root=args.source_root,
+            hermes_root=args.hermes_root,
+            profile_role="first_start",
+        )
+        report["first_start"] = first
+        _require(_query_passed(first), "first disposable identity process did not answer successfully")
+        after_first = behavior.build_manifest(compiled_profile, args.hermes_root, args.deployment_root)
+        report["session_boundary_readback"] = {
+            "full_behavior_changed_after_session": after_first["behavior_sha256"]
+            != compiled_behavior_before_query["behavior_sha256"],
+            "identity_runtime_unchanged_after_session": after_first["identity_runtime_sha256"]
+            == compiled_behavior_before_query["identity_runtime_sha256"],
+            "session_file_count": len(list((compiled_profile / "sessions").glob("*.json"))),
+            "session_classification": "temporary_noncanonical",
+            "session_used_as_output_provenance": False,
+        }
+        if args.inject_drift_before_restart:
+            with (compiled_profile / "SOUL.md").open("a", encoding="utf-8") as handle:
+                handle.write("\nInjected pre-restart drift.\n")
+            rejected = _run_query_child(
+                deployment_root=args.deployment_root,
+                profile=compiled_profile,
+                source_root=args.source_root,
+                hermes_root=args.hermes_root,
+                profile_role="pre_restart_drift",
+            )
+            report["pre_restart_drift"] = rejected
+            report["drift_target"] = "compiled SOUL.md generated view"
+            report["second_start_attempted"] = False
+            report["gates"] = {
+                "first_start_passed": True,
+                "first_process_stopped": first["process_group_absent_after_wait"],
+                "drift_detected_before_restart": rejected["returncode"] == 3
+                and (rejected.get("stdout") or {}).get("error") == "identity_drift",
+                "drift_returned_no_answer": not bool((rejected.get("stdout") or {}).get("answer")),
+                "drift_process_stopped": rejected["process_group_absent_after_wait"],
+                "drift_process_had_no_orphan_cleanup": rejected["orphan_cleanup_required"] is False,
+                "second_start_not_attempted": True,
+            }
+            report["status"] = "pass" if all(report["gates"].values()) else "fail"
+        else:
+            profile_runtime.verify_profile(
+                compiled_profile,
+                source_root=args.source_root,
+                hermes_root=args.hermes_root,
+                deployment_root=args.deployment_root,
+            )
+            report["pre_restart_verification"] = "pass"
+            report["second_start_attempted"] = True
+            restarted_profile = temporary_root / "restart-profile"
+            report["restart_compile"] = profile_runtime.compile_profile(
+                manifest,
+                source_root=args.source_root,
+                profile_template=args.profile_template,
+                profile=restarted_profile,
+                hermes_root=args.hermes_root,
+                deployment_root=args.deployment_root,
+            )
+            profile_runtime.verify_profile(
+                restarted_profile,
+                source_root=args.source_root,
+                hermes_root=args.hermes_root,
+                deployment_root=args.deployment_root,
+            )
+            second = _run_query_child(
+                deployment_root=args.deployment_root,
+                profile=restarted_profile,
+                source_root=args.source_root,
+                hermes_root=args.hermes_root,
+                profile_role="restart",
+            )
+            report["restart"] = second
+            _require(_query_passed(second), "restarted disposable identity process did not answer successfully")
+            first_payload = first["stdout"]
+            second_payload = second["stdout"]
+            drift_profile = temporary_root / "drift-profile"
+            report["drift_compile"] = profile_runtime.compile_profile(
+                manifest,
+                source_root=args.source_root,
+                profile_template=args.profile_template,
+                profile=drift_profile,
+                hermes_root=args.hermes_root,
+                deployment_root=args.deployment_root,
+            )
+            drift = _drift_attempt(
+                deployment_root=args.deployment_root,
+                source_root=args.source_root,
+                hermes_root=args.hermes_root,
+                drift_profile=drift_profile,
+            )
+            report["drift_negative"] = drift
+            report["drift_target"] = "compiled SOUL.md generated view"
+            report["gates"] = {
+                "manifest_generated": identity._is_sha256(manifest["manifest_sha256"]),
+                "views_compiled_and_bound": report["compile"]["status"] == "pass",
+                "first_start_passed": True,
+                "first_process_stopped": first["process_group_absent_after_wait"],
+                "pre_restart_verification_passed": True,
+                "restart_profile_recompiled_from_manifest": report["restart_compile"]["status"] == "pass",
+                "restart_profile_started_without_sessions": report["restart_compile"][
+                    "session_directories_started_empty"
+                ],
+                "restart_passed": True,
+                "restart_process_is_distinct": first_payload["process_id"] != second_payload["process_id"]
+                and first_payload["runtime_instance_id"] != second_payload["runtime_instance_id"],
+                "identity_inputs_reproduced": first_payload["identity_inputs_sha256"]
+                == second_payload["identity_inputs_sha256"],
+                "manifest_reproduced": first_payload["manifest_sha256"] == second_payload["manifest_sha256"],
+                "query_reproduced": first_payload["query_sha256"] == second_payload["query_sha256"],
+                "answer_and_provenance_explainable": first_payload["answer_sha256"] == second_payload["answer_sha256"]
+                and first_payload["output_provenance"] == second_payload["output_provenance"],
+                "session_excluded_from_identity": report["session_boundary_readback"][
+                    "identity_runtime_unchanged_after_session"
+                ],
+                "drift_failed_closed": drift["fail_closed"] and not drift["answer_returned"],
+                "drift_profile_started_without_sessions": report["drift_compile"]["session_directories_started_empty"],
+                "drift_process_stopped": drift["process_group_absent_after_wait"],
+                "drift_process_had_no_orphan_cleanup": drift["orphan_cleanup_required"] is False,
+                "restart_process_stopped": second["process_group_absent_after_wait"],
+            }
+            report["status"] = "pass" if all(report["gates"].values()) else "fail"
+        if report["status"] == "pass":
+            exit_code = 0
+    except (CanaryError, identity.IdentityManifestError, OSError, subprocess.SubprocessError) as exc:
+        report["status"] = "fail"
+        report["errors"].append(
+            {
+                "type": type(exc).__name__,
+                "message": "details_redacted",
+                "detail_sha256": behavior.sha256_bytes(str(exc).encode("utf-8")),
+            }
+        )
+    finally:
+        shutil.rmtree(temporary_root, ignore_errors=True)
+        report["cleanup"] = {
+            "temporary_root_removed": not temporary_root.exists(),
+            "no_profile_retained": not temporary_root.exists(),
+        }
+        if not all(report["cleanup"].values()):
+            report["status"] = "fail"
+            exit_code = 1
+        positive_restart_passed = report.get("status") == "pass" and not args.inject_drift_before_restart
+        report["current_tier"] = "T2_runtime" if positive_restart_passed else "T1_model"
+        report["goal_tier_satisfied"] = positive_restart_passed
+        report["runtime_component_proven"] = (
+            "fresh_profile_recompile_plus_distinct_process_restart"
+            if positive_restart_passed
+            else "first_local_process_plus_pre_restart_drift_refusal"
+        )
+        report["runtime_variant"] = "local_deterministic_identity_compiler_readback"
+        report["tier_basis"] = (
+            "Capability Tier Proof defines T2_runtime as local API/runtime behavior with restart where relevant; "
+            "this is compiler-process runtime proof and explicitly excludes GatewayRunner and hosted-model proof."
+            if positive_restart_passed
+            else "This negative component does not complete the required restart path, so it remains below T2_runtime."
+        )
+        report["claim_ceiling"] = (
+            "Local disposable identity compilation, fresh-profile reconstruction, and cold-process restart only; "
+            "not a live GatewayRunner, hosted-model, Telegram, production database, VPS restart, or T3 proof."
+            if positive_restart_passed
+            else "Local first-process and pre-restart drift-refusal component only; no successful restart proof, "
+            "GatewayRunner, hosted model, production database, VPS, or T3 claim."
+        )
+        _validate_portable_receipt(report)
+        stable = {key: value for key, value in report.items() if key != "receipt_sha256"}
+        report["receipt_sha256"] = behavior.canonical_sha256(stable)
+        identity.write_json(output, report)
+    return report, exit_code
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--profile-template", type=Path, required=True)
+    parser.add_argument("--hermes-root", type=Path, required=True)
+    parser.add_argument("--deployment-root", type=Path, required=True)
+    parser.add_argument("--source-root", type=Path, required=True)
+    parser.add_argument("--database-fingerprint", type=Path, required=True)
+    parser.add_argument("--constitution", type=Path, required=True)
+    parser.add_argument("--database-identity", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--inject-drift-before-restart", action="store_true")
+    args = parser.parse_args()
+    report, exit_code = run_canary(args)
+    print(
+        json.dumps(
+            {
+                "status": report.get("status"),
+                "current_tier": report.get("current_tier"),
+                "receipt_sha256": report.get("receipt_sha256"),
+                "output": str(args.output),
+            },
+            sort_keys=True,
+        )
+    )
+    return exit_code
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/stage_normalized_proposal.py

@@ -57,6 +57,12 @@ def prepare_normalized_child(parent: dict[str, Any]) -> dict[str, Any]:
     manifest = apply_payload.setdefault("normalization_manifest", {})
     if not isinstance(manifest, dict):
         raise bound.CheckpointError("normalized child normalization_manifest must be an object")
+    parent_payload = parent.get("payload")
+    ingestion_manifest = parent_payload.get("ingestion_manifest") if isinstance(parent_payload, dict) else None
+    if ingestion_manifest is not None:
+        if not isinstance(ingestion_manifest, dict):
+            raise bound.CheckpointError("parent payload.ingestion_manifest must be an object")
+        manifest["ingestion_manifest"] = json.loads(json.dumps(ingestion_manifest, sort_keys=True))
     parent_packet_sha256 = canonical_sha256(parent)
     manifest["parent_packet_sha256"] = parent_packet_sha256
     child_payload_sha256 = canonical_sha256(payload)

tests/test_apply_proposal.py

@@ -30,6 +30,10 @@ sys.path.insert(0, str(REPO_ROOT / "scripts"))
 
 import apply_proposal as ap  # noqa: E402
 
+CLAIM_A = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
+CLAIM_B = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
+SOURCE_A = "cccccccc-cccc-4ccc-8ccc-cccccccccccc"
+
 
 def _approval_meta(proposal_type, apply_payload):
     return {
@@ -112,7 +116,7 @@ def test_revise_strategy_rejects_bad_node_type():
 
 # --- add_edge ------------------------------------------------------------- #
 def test_add_edge_sql_dedup_guard():
-    payload = {"from_claim": "aaaa", "to_claim": "bbbb", "edge_type": "supersedes", "weight": 0.9}
+    payload = {"from_claim": CLAIM_A, "to_claim": CLAIM_B, "edge_type": "supersedes", "weight": 0.9}
     sql = ap.build_add_edge_sql(payload, "pid-2", None, _approval_meta("add_edge", payload))
     assert "insert into public.claim_edges" in sql
     assert "not exists" in sql
@@ -122,7 +126,7 @@ def test_add_edge_sql_dedup_guard():
 
 
 def test_add_edge_semantic_row_accepts_match_and_rejects_weight_mismatch():
-    payload = {"from_claim": "aaaa", "to_claim": "bbbb", "edge_type": "supports", "weight": 0.9}
+    payload = {"from_claim": CLAIM_A, "to_claim": CLAIM_B, "edge_type": "supports", "weight": 0.9}
     sql = ap.build_add_edge_sql(payload, "pid-2", None, _approval_meta("add_edge", payload))
     verify = sql[sql.index("do $verify$") : sql.index("kb_stage.finish_approved_proposal")]
 
@@ -131,9 +135,7 @@ def test_add_edge_semantic_row_accepts_match_and_rejects_weight_mismatch():
     assert "claim_edge row does not match strict apply payload" in verify
     assert sql.startswith("begin;")
     assert sql.rstrip().endswith("commit;")
-    assert sql.index("raise exception 'apply_proposal: claim_edge row") < sql.index(
+    assert sql.index("raise exception 'apply_proposal: claim_edge row") < sql.index("kb_stage.finish_approved_proposal")
-        "kb_stage.finish_approved_proposal"
-    )
 
 
 def test_add_edge_rejects_self_loop():
@@ -144,22 +146,18 @@ def test_add_edge_rejects_self_loop():
 
 # --- attach_evidence ------------------------------------------------------ #
 def test_attach_evidence_sql_with_source_id():
-    payload = {"evidence": [{"claim_id": "cccc", "source_id": "dddd", "role": "grounds", "weight": 0.78}]}
+    payload = {"evidence": [{"claim_id": CLAIM_A, "source_id": SOURCE_A, "role": "grounds", "weight": 0.78}]}
     sql = ap.build_attach_evidence_sql(payload, "pid-3", None, _approval_meta("attach_evidence", payload))
     assert "insert into public.claim_evidence" in sql
+    assert "public.claim_evidence (id," not in sql
+    assert "public.claim_evidence (claim_id, source_id, role, weight)" in sql
     assert "::evidence_role" in sql
     assert "not exists" in sql
 
 
 def test_attach_evidence_semantic_row_accepts_match_and_rejects_weight_mismatch():
-    payload = {
+    payload = {"evidence": [{"claim_id": CLAIM_A, "source_id": SOURCE_A, "role": "grounds", "weight": 0.78}]}
-        "evidence": [
+    sql = ap.build_attach_evidence_sql(payload, "pid-3", None, _approval_meta("attach_evidence", payload))
-            {"claim_id": "cccc", "source_id": "dddd", "role": "grounds", "weight": 0.78}
-        ]
-    }
-    sql = ap.build_attach_evidence_sql(
-        payload, "pid-3", None, _approval_meta("attach_evidence", payload)
-    )
     verify = sql[sql.index("do $verify$") : sql.index("kb_stage.finish_approved_proposal")]
 
     assert "weight is not distinct from 0.78" in verify
@@ -167,9 +165,7 @@ def test_attach_evidence_semantic_row_accepts_match_and_rejects_weight_mismatch(
     assert "evidence row % does not match strict apply payload" in verify
     assert sql.startswith("begin;")
     assert sql.rstrip().endswith("commit;")
-    assert sql.index("raise exception 'apply_proposal: evidence row") < sql.index(
+    assert sql.index("raise exception 'apply_proposal: evidence row") < sql.index("kb_stage.finish_approved_proposal")
-        "kb_stage.finish_approved_proposal"
-    )
 
 
 def test_attach_evidence_requires_source_id():
@@ -231,9 +227,7 @@ def _approve_claim_bundle():
             {"claim_id": claim_a, "source_id": source_a, "role": "grounds", "weight": 0.9},
             {"claim_id": claim_b, "source_id": source_b, "role": "illustrates", "weight": None},
         ],
-        "edges": [
+        "edges": [{"from_claim": claim_a, "to_claim": claim_b, "edge_type": "supports", "weight": 0.7}],
-            {"from_claim": claim_a, "to_claim": claim_b, "edge_type": "supports", "weight": 0.7}
-        ],
         "reasoning_tools": [
             {
                 "id": "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee",
@@ -259,6 +253,8 @@ def test_approve_claim_bundle_sql_is_atomic_and_row_verified():
     assert "insert into public.claims" in sql
     assert "insert into public.sources" in sql
     assert "insert into public.claim_evidence" in sql
+    assert "public.claim_evidence (id," not in sql
+    assert "public.claim_evidence (claim_id, source_id, role, weight, created_by)" in sql
     assert "insert into public.claim_edges" in sql
     assert "insert into public.reasoning_tools" in sql
     assert "source hash collision" in sql
@@ -291,9 +287,7 @@ def test_approve_claim_semantic_rows_accept_matches_and_reject_payload_mismatche
     assert "approve_claim: edge row does not match strict apply payload" in verify
     assert sql.startswith("begin;")
     assert sql.rstrip().endswith("commit;")
-    assert sql.index("raise exception 'approve_claim: evidence row") < sql.index(
+    assert sql.index("raise exception 'approve_claim: evidence row") < sql.index("kb_stage.finish_approved_proposal")
-        "kb_stage.finish_approved_proposal"
-    )
 
 
 def test_approve_claim_bundle_rejects_duplicate_source_hashes():
@@ -388,6 +382,34 @@ def test_apply_sql_locks_and_binds_approval_before_canonical_write():
     assert "Reviewed exact strict payload." in sql
 
 
+def test_fresh_owned_apply_uses_strict_inserts_and_binds_preflight_hash():
+    payload = _approve_claim_bundle()
+    proposal = {
+        "id": "99999999-9999-4999-8999-999999999999",
+        "proposal_type": "approve_claim",
+        "status": "approved",
+        "payload": {"apply_payload": payload},
+        "reviewed_by_handle": "m3ta",
+        "reviewed_by_agent_id": None,
+        "reviewed_at": "2026-07-10T00:00:00+00:00",
+        "review_note": "Reviewed exact strict payload.",
+    }
+    preflight_sha256 = "a" * 64
+
+    sql = ap.build_apply_sql(
+        proposal,
+        "kb-apply",
+        fresh_owned=True,
+        fresh_preflight_sha256=preflight_sha256,
+    )
+
+    assert preflight_sha256 in sql
+    assert "set transaction isolation level serializable" in sql.lower()
+    assert "on conflict" not in sql.lower()
+    assert "where not exists" not in sql.lower()
+    assert sql.index("set transaction isolation level serializable") < sql.index("kb_stage.assert_approved_proposal")
+
+
 def test_build_apply_sql_requires_review_provenance():
     proposal = {
         "id": "99999999-9999-4999-8999-999999999999",
@@ -445,7 +467,7 @@ def test_assert_applyable_allows_approved():
 
 # --- ledger flip: concurrency guard + FK stamp --------------------------- #
 def test_ledger_transition_uses_payload_bound_security_functions():
-    payload = {"from_claim": "a", "to_claim": "b", "edge_type": "supports"}
+    payload = {"from_claim": CLAIM_A, "to_claim": CLAIM_B, "edge_type": "supports"}
     sql = ap.build_add_edge_sql(payload, "pid", None, _approval_meta("add_edge", payload))
     assert "kb_stage.assert_approved_proposal" in sql
     assert "kb_stage.finish_approved_proposal" in sql
@@ -459,7 +481,7 @@ def test_ledger_transition_uses_payload_bound_security_functions():
 
 
 def test_ledger_flip_stamps_agent_fk():
-    payload = {"from_claim": "a", "to_claim": "b", "edge_type": "supports"}
+    payload = {"from_claim": CLAIM_A, "to_claim": CLAIM_B, "edge_type": "supports"}
     sql = ap.build_add_edge_sql(payload, "pid", "kb-apply", _approval_meta("add_edge", payload))
     # Hard resolve into a variable + NOT-NULL assert, never a silent inline
     # subselect that would stamp NULL on an unresolved handle.
@@ -468,7 +490,7 @@ def test_ledger_flip_stamps_agent_fk():
 
 
 def test_build_apply_sql_defaults_applied_by_to_service_agent():
-    payload = {"from_claim": "a", "to_claim": "b", "edge_type": "supports"}
+    payload = {"from_claim": CLAIM_A, "to_claim": CLAIM_B, "edge_type": "supports"}
     proposal = {
         "id": "pid",
         "proposal_type": "add_edge",

tests/test_apply_worker.py

@@ -6,7 +6,10 @@ standalone (`python3 tests/test_apply_worker.py`).
 """
 
 import argparse
+import json
+import stat
 import sys
+import tempfile
 from pathlib import Path
 
 try:
@@ -40,19 +43,33 @@ sys.path.insert(0, str(REPO_ROOT / "scripts"))
 import apply_worker as w  # noqa: E402
 
 
-@pytest.fixture(autouse=True)
+def _dependency_restore():
-def restore_apply_worker_dependencies():
     original_load_password = w.ap.load_password
     original_load_failure_state = w.load_failure_state
     original_fetch_candidates = w.fetch_candidates
     original_apply_one = w.apply_one
     original_render_one = w.render_one
+    original_subprocess_run = w.subprocess.run
     yield
     w.ap.load_password = original_load_password
     w.load_failure_state = original_load_failure_state
     w.fetch_candidates = original_fetch_candidates
     w.apply_one = original_apply_one
     w.render_one = original_render_one
+    w.subprocess.run = original_subprocess_run
+
+
+@pytest.fixture(autouse=True)
+def restore_apply_worker_dependencies():
+    restore = _dependency_restore()
+    next(restore)
+    try:
+        yield
+    finally:
+        try:
+            next(restore)
+        except StopIteration:
+            pass
 
 
 # --- candidate query ------------------------------------------------------ #
@@ -116,22 +133,283 @@ def test_render_command_expands_agent_id():
 # --- enablement gate ------------------------------------------------------ #
 def _args(**over):
     base = dict(
-        enable=False, limit=20, max_per_tick=1, max_attempts=3,
+        enable=False,
-        failure_state_file=None, applied_by="kb-apply",
+        limit=20,
-        apply_script="apply_proposal.py", render_cmd="",
+        max_per_tick=1,
-        secrets_file="x", container="teleo-pg", db="teleo",
+        max_attempts=3,
-        host="127.0.0.1", role="kb_apply",
+        failure_state_file=None,
+        applied_by="kb-apply",
+        apply_script="apply_proposal.py",
+        render_cmd="",
+        receipt_dir="/private/tmp/kb-apply-worker-test-receipts",
+        secrets_file="x",
+        container="teleo-pg",
+        db="teleo",
+        host="127.0.0.1",
+        role="kb_apply",
     )
     base.update(over)
     return argparse.Namespace(**base)
 
 
+def _write_valid_private_receipt(path: Path, proposal_id: str) -> None:
+    from_claim = "11111111-1111-4111-8111-111111111111"
+    to_claim = "22222222-2222-4222-8222-222222222222"
+    proposal = {
+        "id": proposal_id,
+        "proposal_type": "add_edge",
+        "status": "applied",
+        "payload": {
+            "apply_payload": {
+                "from_claim": from_claim,
+                "to_claim": to_claim,
+                "edge_type": "supports",
+                "weight": 0.75,
+            }
+        },
+        "reviewed_by_handle": "reviewer",
+        "reviewed_by_agent_id": None,
+        "reviewed_at": "2026-07-15T10:00:00+00:00",
+        "review_note": "Approved for worker receipt testing.",
+        "applied_by_handle": "kb-apply",
+        "applied_by_agent_id": None,
+        "applied_at": "2026-07-15T10:01:00+00:00",
+    }
+    receipt = w.ap.replay_receipt.build_replay_receipt(
+        proposal,
+        {
+            "claim_edges": [
+                {
+                    "id": "33333333-3333-4333-8333-333333333333",
+                    "from_claim": from_claim,
+                    "to_claim": to_claim,
+                    "edge_type": "supports",
+                    "weight": 0.75,
+                    "created_by": None,
+                }
+            ]
+        },
+        apply_sql_sha256="a" * 64,
+        apply_sql_source="exact_executed_sql",
+        exported_at_utc="2026-07-15T10:02:00+00:00",
+    )
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    path.write_text(json.dumps(receipt), encoding="utf-8")
+    path.chmod(0o600)
+
+
+def _load_private_receipt(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def _write_private_receipt(path: Path, receipt: dict) -> None:
+    path.write_text(json.dumps(receipt), encoding="utf-8")
+    path.chmod(0o600)
+
+
+def _completed(returncode: int, *, stdout: str = "", stderr: str = ""):
+    return w.subprocess.CompletedProcess([], returncode, stdout=stdout, stderr=stderr)
+
+
+def _postcommit_receipt_failure(proposal_id: str, detail: str = "receipt write failed") -> str:
+    return (
+        f"proposal {proposal_id} {w.POSTCOMMIT_RECEIPT_FAILURE_MARKER}: {detail}"
+        f"{w.POSTCOMMIT_RECEIPT_RECOVERY_MARKER}"
+        f"apply_proposal.py {proposal_id} --receipt-only"
+    )
+
+
+# --- private receipt and post-COMMIT recovery ---------------------------- #
+def test_private_receipt_requires_complete_canonical_rows_and_hashes():
+    proposal_id = "99999999-9999-4999-8999-999999999999"
+    receipt_path = Path(tempfile.mkdtemp()) / "receipt.json"
+    _write_valid_private_receipt(receipt_path, proposal_id)
+
+    missing_rows = _load_private_receipt(receipt_path)
+    missing_rows.pop("canonical_rows")
+    _write_private_receipt(receipt_path, missing_rows)
+    with pytest.raises(RuntimeError, match="row-level contract is invalid"):
+        w.assert_private_replay_receipt(receipt_path, proposal_id)
+
+    _write_valid_private_receipt(receipt_path, proposal_id)
+    missing_hashes = _load_private_receipt(receipt_path)
+    missing_hashes.pop("hashes")
+    _write_private_receipt(receipt_path, missing_hashes)
+    with pytest.raises(RuntimeError, match="row-level contract is invalid"):
+        w.assert_private_replay_receipt(receipt_path, proposal_id)
+
+
+def test_private_receipt_rejects_canonical_row_tampering_without_recomputed_hashes():
+    proposal_id = "88888888-8888-4888-8888-888888888888"
+    receipt_path = Path(tempfile.mkdtemp()) / "receipt.json"
+    _write_valid_private_receipt(receipt_path, proposal_id)
+    tampered = _load_private_receipt(receipt_path)
+    tampered["canonical_rows"]["claim_edges"][0]["weight"] = 0.5
+    _write_private_receipt(receipt_path, tampered)
+
+    with pytest.raises(RuntimeError, match="row-level contract is invalid|internally inconsistent"):
+        w.assert_private_replay_receipt(receipt_path, proposal_id)
+
+
+def test_apply_one_supplies_deterministic_private_receipt_path():
+    proposal_id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
+    receipt_dir = Path(tempfile.mkdtemp()) / "receipts"
+    calls = []
+
+    def _run(cmd, **_kwargs):
+        calls.append(cmd)
+        receipt_path = Path(cmd[cmd.index("--receipt-out") + 1])
+        _write_valid_private_receipt(receipt_path, proposal_id)
+        return _completed(0, stdout='{"applied": true}')
+
+    w.subprocess.run = _run
+    w.apply_one(_args(receipt_dir=str(receipt_dir)), proposal_id)
+
+    expected = receipt_dir.resolve() / f"{proposal_id}.json"
+    assert len(calls) == 1
+    assert calls[0][calls[0].index("--receipt-dir") + 1] == str(expected.parent)
+    assert calls[0][calls[0].index("--receipt-out") + 1] == str(expected)
+    assert stat.S_IMODE(expected.stat().st_mode) == 0o600
+
+
+def test_apply_one_recovers_postcommit_receipt_failure_without_reapplying():
+    proposal_id = "bbbbbbbb-bbbb-4bbb-8bbb-bbbbbbbbbbbb"
+    receipt_dir = Path(tempfile.mkdtemp()) / "receipts"
+    calls = []
+
+    def _run(cmd, **_kwargs):
+        calls.append(cmd)
+        if len(calls) == 1:
+            return _completed(
+                1,
+                stderr=_postcommit_receipt_failure(proposal_id),
+            )
+        assert "--receipt-only" in cmd
+        receipt_path = Path(cmd[cmd.index("--receipt-out") + 1])
+        _write_valid_private_receipt(receipt_path, proposal_id)
+        return _completed(0, stdout='{"replay_ready": true}')
+
+    w.subprocess.run = _run
+    w.apply_one(_args(receipt_dir=str(receipt_dir)), proposal_id)
+
+    assert len(calls) == 2
+    assert "--receipt-only" not in calls[0]
+    assert "--receipt-only" in calls[1]
+    assert calls[0][calls[0].index("--receipt-out") + 1] == calls[1][calls[1].index("--receipt-out") + 1]
+
+
+def test_apply_one_does_not_recover_a_precommit_apply_failure():
+    calls = []
+
+    def _run(cmd, **_kwargs):
+        calls.append(cmd)
+        return _completed(1, stderr="psql transaction failed before commit")
+
+    w.subprocess.run = _run
+    try:
+        w.apply_one(_args(receipt_dir=tempfile.mkdtemp()), "p1")
+    except w.PostCommitReceiptError as exc:
+        raise AssertionError("pre-COMMIT failure was misclassified as committed") from exc
+    except RuntimeError:
+        pass
+    else:
+        raise AssertionError("expected pre-COMMIT apply failure")
+
+    assert len(calls) == 1
+
+
+def test_apply_one_classifies_unrecovered_receipt_as_postcommit():
+    calls = []
+
+    def _run(cmd, **_kwargs):
+        calls.append(cmd)
+        if len(calls) == 1:
+            return _completed(1, stderr=_postcommit_receipt_failure("p1"))
+        return _completed(1, stderr="receipt directory remains unavailable")
+
+    w.subprocess.run = _run
+    with pytest.raises(w.PostCommitReceiptError):
+        w.apply_one(_args(receipt_dir=tempfile.mkdtemp()), "p1")
+
+    assert len(calls) == 2
+    assert "--receipt-only" in calls[1]
+
+
+def test_forged_marker_in_unknown_field_traceback_is_a_normal_apply_failure():
+    proposal_id = "cccccccc-cccc-4ccc-8ccc-cccccccccccc"
+    calls = []
+
+    def _run(cmd, **_kwargs):
+        calls.append(cmd)
+        return _completed(
+            1,
+            stderr=(
+                "Traceback (most recent call last):\n"
+                "ValueError: approve_claim apply_payload contains unknown fields: "
+                f"['{w.POSTCOMMIT_RECEIPT_FAILURE_MARKER}']"
+            ),
+        )
+
+    w.subprocess.run = _run
+    with pytest.raises(RuntimeError, match="apply failed"):
+        w.apply_one(_args(receipt_dir=tempfile.mkdtemp()), proposal_id)
+
+    assert len(calls) == 1
+    assert "--receipt-only" not in calls[0]
+
+
+def test_forged_marker_increments_normal_failure_and_poison_accounting():
+    proposal_id = "dddddddd-dddd-4ddd-8ddd-dddddddddddd"
+    failure_state = str(Path(tempfile.mkdtemp()) / "failures.json")
+    calls = []
+    w.ap.load_password = lambda _path: "pw"
+    w.fetch_candidates = lambda _args, _password, _excluded: _cands(proposal_id)
+
+    def _run(cmd, **_kwargs):
+        calls.append(cmd)
+        return _completed(
+            1,
+            stderr=(
+                "ValueError: approve_claim apply_payload contains unknown fields: "
+                f"['{w.POSTCOMMIT_RECEIPT_FAILURE_MARKER}']"
+            ),
+        )
+
+    w.subprocess.run = _run
+    rc = w.run(
+        _args(
+            enable=True,
+            failure_state_file=failure_state,
+            max_attempts=1,
+            max_per_tick=1,
+            receipt_dir=tempfile.mkdtemp(),
+        )
+    )
+
+    assert rc == 1
+    assert w.load_failure_state(failure_state) == {proposal_id: 1}
+    assert len(calls) == 1
+
+
+def test_postcommit_receipt_error_does_not_increment_apply_failure_count():
+    path = str(Path(tempfile.mkdtemp()) / "failures.json")
+    w.ap.load_password = lambda _f: "pw"
+    w.fetch_candidates = lambda a, p, excluded: _cands("committed")
+
+    def _postcommit(_args, _proposal_id):
+        raise w.PostCommitReceiptError("committed; receipt recovery failed")
+
+    w.apply_one = _postcommit
+    rc = w.run(_args(enable=True, failure_state_file=path, max_per_tick=1))
+
+    assert rc == 1
+    assert w.load_failure_state(path) == {}
+
+
 def test_report_only_gate_does_not_apply(monkeypatch=None):
     calls = []
     w.ap.load_password = lambda _f: "pw"
-    w.fetch_candidates = lambda a, p, excluded: [
+    w.fetch_candidates = lambda a, p, excluded: [{"id": "p1", "proposal_type": "revise_strategy", "agent_id": "ag"}]
-        {"id": "p1", "proposal_type": "revise_strategy", "agent_id": "ag"}
-    ]
     w.apply_one = lambda a, pid: calls.append(pid)
 
     rc = w.run(_args(enable=False))
@@ -142,9 +420,7 @@ def test_report_only_gate_does_not_apply(monkeypatch=None):
 def test_enabled_worker_applies_and_renders():
     applied, rendered = [], []
     w.ap.load_password = lambda _f: "pw"
-    w.fetch_candidates = lambda a, p, excluded: [
+    w.fetch_candidates = lambda a, p, excluded: [{"id": "p1", "proposal_type": "revise_strategy", "agent_id": "ag"}]
-        {"id": "p1", "proposal_type": "revise_strategy", "agent_id": "ag"}
-    ]
     w.apply_one = lambda a, pid: applied.append(pid)
     w.render_one = lambda a, agent_id: rendered.append(agent_id) or "ok"
 
@@ -157,9 +433,7 @@ def test_enabled_worker_applies_and_renders():
 def test_enabled_worker_skips_render_for_add_edge():
     applied, rendered = [], []
     w.ap.load_password = lambda _f: "pw"
-    w.fetch_candidates = lambda a, p, excluded: [
+    w.fetch_candidates = lambda a, p, excluded: [{"id": "e1", "proposal_type": "add_edge", "agent_id": None}]
-        {"id": "e1", "proposal_type": "add_edge", "agent_id": None}
-    ]
     w.apply_one = lambda a, pid: applied.append(pid)
     w.render_one = lambda a, agent_id: rendered.append(agent_id) or "ok"
 
@@ -172,9 +446,7 @@ def test_enabled_worker_skips_render_for_add_edge():
 def test_enabled_worker_skips_render_for_approve_claim():
     applied, rendered = [], []
     w.ap.load_password = lambda _f: "pw"
-    w.fetch_candidates = lambda a, p, excluded: [
+    w.fetch_candidates = lambda a, p, excluded: [{"id": "c1", "proposal_type": "approve_claim", "agent_id": "ag"}]
-        {"id": "c1", "proposal_type": "approve_claim", "agent_id": "ag"}
-    ]
     w.apply_one = lambda a, pid: applied.append(pid)
     w.render_one = lambda a, agent_id: rendered.append(agent_id) or "ok"
 
@@ -263,7 +535,7 @@ if __name__ == "__main__":
     failures = 0
     for name, fn in sorted(globals().items()):
         if name.startswith("test_") and callable(fn):
-            restore = restore_apply_worker_dependencies()
+            restore = _dependency_restore()
             next(restore)
             try:
                 fn()

tests/test_build_telegram_visible_unseen_chain_packet.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from scripts import build_telegram_visible_unseen_chain_packet as packet
+
+
+def test_packet_binds_handler_receipt_and_preserves_exact_messages() -> None:
+    data = packet.build_packet(git_sha="a" * 40)
+
+    assert data["schema"] == packet.SCHEMA
+    assert data["ready_to_request_action_time_authorization"] is True
+    assert data["telegram_visible_messages_sent"] is False
+    assert data["telegram_visible_message_authorization_present"] is False
+    assert data["mutates_db"] is False
+    assert data["target"]["chat_label"] == "Leo"
+    assert data["target"]["chat_id"] == "-5146042086"
+    assert data["target"]["allowed_transport"] == "authenticated_chrome_telegram_ui"
+    assert [item["message"] for item in data["exact_messages"]] == [item["message"] for item in packet.unseen.PROMPTS]
+    assert [item["sequence"] for item in data["exact_messages"]] == [1, 2, 3]
+    assert all(len(item["message_sha256"]) == 64 for item in data["exact_messages"])
+    assert data["handler_receipt_binding"]["sha256"] == packet._sha256_file(packet.DEFAULT_HANDLER_RECEIPT)
+    assert data["tooling_binding"] == packet.tooling_binding()
+    assert data["manifest_binding"] == packet.manifest_binding()
+    assert data["manifest_binding"]["path"] == "ops/postgres_parity_manifest.sql"
+    assert data["manifest_binding"]["execution_contract"]["effective_role"] == "pg_read_all_data"
+    assert data["manifest_binding"]["execution_contract"]["transaction_read_only"] == "on"
+    assert data["protocol"]["manifest_binding"] == data["manifest_binding"]
+    assert data["operator_context"]["codex_thread_id"] == packet.DEFAULT_CODEX_THREAD_ID
+    assert data["protocol"]["operator_context"] == data["operator_context"]
+    assert packet._canonical_sha256(data["protocol"]) == data["protocol_sha256"]
+    assert all(data["checks"].values())
+
+
+def test_action_time_authorization_contains_destination_transport_and_full_messages() -> None:
+    data = packet.build_packet(git_sha="a" * 40)
+    authorization = data["explicit_operator_authorization_text"]
+
+    assert "Telegram group Leo (chat ID -5146042086)" in authorization
+    assert "already-authenticated Chrome Telegram UI" in authorization
+    assert "do not use the Bot API" in authorization
+    assert "Codex rollout's user-authorization and Chrome tool events" in authorization
+    assert "no additional messages" in authorization
+    for item in data["exact_messages"]:
+        assert item["prompt_id"] in authorization
+        assert json.dumps(item["message"], ensure_ascii=True) in authorization
+
+
+def test_packet_fails_closed_when_handler_receipt_no_longer_passes(tmp_path: Path) -> None:
+    receipt = json.loads(packet.DEFAULT_HANDLER_RECEIPT.read_text(encoding="utf-8"))
+    receipt["status"] = "fail"
+    receipt_path = tmp_path / "handler.json"
+    receipt_path.write_text(json.dumps(receipt), encoding="utf-8")
+
+    data = packet.build_packet(handler_receipt_path=receipt_path, git_sha="a" * 40)
+
+    assert data["ready_to_request_action_time_authorization"] is False
+    assert data["authorization_gate_status"] == "not_ready"
+    assert data["checks"]["handler_receipt_passed"] is False
+
+
+def test_markdown_retains_exact_cta_and_no_send_ceiling(tmp_path: Path) -> None:
+    data = packet.build_packet(git_sha="a" * 40)
+    out = tmp_path / "packet.md"
+
+    packet.write_markdown(out, data)
+
+    text = out.read_text(encoding="utf-8")
+    assert "Telegram-Visible Unseen Chain Authorization Packet" in text
+    assert "Telegram-visible messages sent: `False`" in text
+    assert "Exact Action-Time Authorization" in text
+    assert data["exact_messages"][2]["message"] in text

tests/test_collect_telegram_visible_unseen_chain_state.py

@@ -0,0 +1,320 @@
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+from pathlib import Path
+
+import pytest
+
+from scripts import build_telegram_visible_unseen_chain_packet as packet_builder
+from scripts import collect_telegram_visible_unseen_chain_state as state
+
+
+def manifest_output(*, row_count: int = 7) -> str:
+    rows = [
+        {
+            "kind": "identity",
+            "database": "teleo",
+            "current_user": packet_builder.READ_ONLY_DB_ROLE,
+            "server_version_num": 160014,
+            "server_encoding": "UTF8",
+            "database_collation": "C.UTF-8",
+            "database_ctype": "C.UTF-8",
+            "transaction_read_only": "on",
+        }
+    ]
+    for kind in (
+        "schemas",
+        "extensions",
+        "application_roles",
+        "columns",
+        "constraints",
+        "indexes",
+        "sequences",
+        "views",
+        "functions",
+        "triggers",
+        "types",
+        "policies",
+    ):
+        rows.append({"kind": kind, "items": []})
+    rows.append(
+        {
+            "kind": "table",
+            "schema": "public",
+            "table": "claims",
+            "row_count": row_count,
+            "rowset_md5": "f" * 32,
+        }
+    )
+    return "BEGIN\nSET\n" + "\n".join(json.dumps(item) for item in rows) + "\nROLLBACK\n"
+
+
+def write_packet(tmp_path: Path) -> Path:
+    out = tmp_path / "packet.json"
+    packet_builder.write_json(
+        out,
+        packet_builder.build_packet(
+            handler_receipt_path=packet_builder.DEFAULT_HANDLER_RECEIPT.resolve(),
+            git_sha="a" * 40,
+        ),
+    )
+    return out
+
+
+def args_for(packet: Path, tmp_path: Path, *, phase: str = "preflight") -> argparse.Namespace:
+    return argparse.Namespace(
+        phase=phase,
+        packet=packet,
+        baseline=None,
+        subject_ref=None,
+        manifest_sql=Path("ops/postgres_parity_manifest.sql"),
+        ssh_target="root@example.invalid",
+        ssh_key=tmp_path / "key",
+        connect_timeout=1,
+        timeout=5,
+        fingerprint_timeout=5,
+        ssh_attempts=3,
+        out=tmp_path / f"{phase}.json",
+        markdown_out=tmp_path / f"{phase}.md",
+    )
+
+
+class GoodRunner:
+    def __init__(self) -> None:
+        self.service_calls = 0
+
+    def __call__(self, command: list[str], input_text: str, _timeout: int) -> state.CommandResult:
+        remote_command = command[-1]
+        if "git rev-parse HEAD" in remote_command:
+            sha = "b" * 40
+            return state.CommandResult(
+                0,
+                f"deploy_head={sha}\nlast_deploy_sha={sha}\ndeploy_stamp_ancestor=true\n",
+                "",
+            )
+        if "systemctl show" in remote_command:
+            self.service_calls += 1
+            return state.CommandResult(
+                0,
+                "\n".join(
+                    [
+                        "ActiveState=active",
+                        "SubState=running",
+                        "MainPID=123",
+                        "NRestarts=0",
+                        "ExecMainStartTimestamp=Wed 2026-07-15 00:00:00 UTC",
+                    ]
+                ),
+                "",
+            )
+        if "'subject_ref'" in input_text:
+            assert "default_transaction_read_only=on" in remote_command
+            assert "-c transaction_read_only=on" in remote_command
+            assert f"role={packet_builder.READ_ONLY_DB_ROLE}" in remote_command
+            assert "psql -X" in remote_command
+            payload = {
+                "subject_ref": "c0000000",
+                "matches": [
+                    {
+                        "table": "public.beliefs",
+                        "row": {"id": "c0000000-0000-4000-8000-000000000001"},
+                        "evidence_count": None,
+                    }
+                ],
+            }
+            return state.CommandResult(0, f"BEGIN\n{json.dumps(payload)}\nROLLBACK\n", "")
+        if "postgres_parity_manifest" not in remote_command and input_text.startswith("\\set ON_ERROR_STOP"):
+            assert "default_transaction_read_only=on" in remote_command
+            assert "-c transaction_read_only=on" in remote_command
+            assert f"role={packet_builder.READ_ONLY_DB_ROLE}" in remote_command
+            assert "psql -X" in remote_command
+            return state.CommandResult(0, manifest_output(), "")
+        raise AssertionError(f"unexpected command: {command} / input={input_text[:80]}")
+
+
+def test_preflight_passes_with_two_identical_read_only_fingerprints(tmp_path: Path) -> None:
+    args = args_for(write_packet(tmp_path), tmp_path)
+
+    result = state.collect_state(args, runner=GoodRunner())
+
+    assert result["status"] == "pass"
+    assert result["ready_for_action_time_authorization"] is True
+    assert result["telegram_visible_messages_sent_by_collector"] is False
+    assert result["mutates_db"] is False
+    assert all(result["packet_checks"].values())
+    assert all(result["remote_checks"].values())
+    assert len(result["state_token_sha256"]) == 64
+
+
+def test_preflight_fails_when_second_fingerprint_drifts(tmp_path: Path) -> None:
+    args = args_for(write_packet(tmp_path), tmp_path)
+    fingerprint_calls = 0
+    good = GoodRunner()
+
+    def drift_runner(command: list[str], input_text: str, timeout: int) -> state.CommandResult:
+        nonlocal fingerprint_calls
+        if input_text.startswith("\\set ON_ERROR_STOP") and "'subject_ref'" not in input_text:
+            fingerprint_calls += 1
+            return state.CommandResult(0, manifest_output(row_count=7 + fingerprint_calls - 1), "")
+        return good(command, input_text, timeout)
+
+    result = state.collect_state(args, runner=drift_runner)
+
+    assert result["status"] == "fail"
+    assert result["remote_checks"]["canonical_fingerprint_unchanged_during_probe"] is False
+
+
+def test_preflight_accepts_newer_workspace_head_when_deployed_stamp_is_ancestor(tmp_path: Path) -> None:
+    args = args_for(write_packet(tmp_path), tmp_path)
+
+    class AheadRunner(GoodRunner):
+        def __call__(self, command: list[str], input_text: str, timeout: int) -> state.CommandResult:
+            if "git rev-parse HEAD" in command[-1]:
+                return state.CommandResult(
+                    0,
+                    f"deploy_head={'c' * 40}\nlast_deploy_sha={'b' * 40}\ndeploy_stamp_ancestor=true\n",
+                    "",
+                )
+            return super().__call__(command, input_text, timeout)
+
+    result = state.collect_state(args, runner=AheadRunner())
+
+    assert result["status"] == "pass"
+    assert result["remote"]["workspace_head_matches_deployed_stamp"] is False
+    assert result["remote_checks"]["deployed_stamp_is_ancestor_of_workspace_head"] is True
+
+
+def test_preflight_retries_transient_ssh_failure(tmp_path: Path) -> None:
+    args = args_for(write_packet(tmp_path), tmp_path)
+    good = GoodRunner()
+    deploy_attempts = 0
+
+    def transient_runner(command: list[str], input_text: str, timeout: int) -> state.CommandResult:
+        nonlocal deploy_attempts
+        if "git rev-parse HEAD" in command[-1]:
+            deploy_attempts += 1
+            if deploy_attempts == 1:
+                return state.CommandResult(255, "", "Connection timed out during banner exchange")
+        return good(command, input_text, timeout)
+
+    result = state.collect_state(args, runner=transient_runner)
+
+    assert result["status"] == "pass"
+    assert result["remote"]["readback_attempts"]["deploy"] == 2
+
+
+def test_preflight_rejects_packet_bound_to_different_tooling_source(tmp_path: Path) -> None:
+    packet_path = write_packet(tmp_path)
+    packet = json.loads(packet_path.read_text(encoding="utf-8"))
+    packet["tooling_binding"]["capture_verifier"]["sha256"] = "0" * 64
+    packet_path.write_text(json.dumps(packet), encoding="utf-8")
+
+    result = state.collect_state(args_for(packet_path, tmp_path), runner=GoodRunner())
+
+    assert result["status"] == "fail"
+    assert result["packet_checks"]["packet_tooling_hashes_match_current_sources"] is False
+
+
+def test_postflight_binds_baseline_fingerprint_service_and_subject(tmp_path: Path) -> None:
+    packet = write_packet(tmp_path)
+    pre_args = args_for(packet, tmp_path)
+    preflight = state.collect_state(pre_args, runner=GoodRunner())
+    baseline = tmp_path / "preflight.json"
+    state.write_json(baseline, preflight)
+    post_args = args_for(packet, tmp_path, phase="postflight")
+    post_args.baseline = baseline
+    post_args.subject_ref = "c0000000"
+
+    postflight = state.collect_state(post_args, runner=GoodRunner())
+
+    assert postflight["status"] == "pass"
+    assert postflight["ready_for_visible_capture_verification"] is True
+    assert all(postflight["baseline_checks"].values())
+    assert postflight["remote_checks"]["subject_resolved_to_exactly_one_db_object"] is True
+
+
+def test_postflight_rejects_baseline_fingerprint_mismatch(tmp_path: Path) -> None:
+    packet = write_packet(tmp_path)
+    pre_args = args_for(packet, tmp_path)
+    preflight = state.collect_state(pre_args, runner=GoodRunner())
+    preflight = copy.deepcopy(preflight)
+    preflight["remote"]["fingerprint_after"]["fingerprint_sha256"] = "0" * 64
+    baseline = tmp_path / "preflight.json"
+    state.write_json(baseline, preflight)
+    post_args = args_for(packet, tmp_path, phase="postflight")
+    post_args.baseline = baseline
+    post_args.subject_ref = "c0000000"
+
+    postflight = state.collect_state(post_args, runner=GoodRunner())
+
+    assert postflight["status"] == "fail"
+    assert postflight["baseline_checks"]["canonical_fingerprint_matches_preflight"] is False
+
+
+def test_subject_sql_rejects_untrusted_input() -> None:
+    try:
+        state.subject_readback_sql("c0000000'; delete from public.claims; --")
+    except ValueError as exc:
+        assert "subject_ref" in str(exc)
+    else:
+        raise AssertionError("unsafe subject ref was accepted")
+
+
+class NoSshRunner:
+    def __init__(self) -> None:
+        self.calls = 0
+
+    def __call__(self, _command: list[str], _input_text: str, _timeout: int) -> state.CommandResult:
+        self.calls += 1
+        raise AssertionError("SSH runner must not be called after local fail-closed rejection")
+
+
+def test_write_capable_manifest_override_is_rejected_before_ssh(tmp_path: Path) -> None:
+    packet = write_packet(tmp_path)
+    malicious = tmp_path / "write.sql"
+    malicious.write_text(
+        "\\set ON_ERROR_STOP on\nbegin;\nupdate public.claims set status = 'live';\ncommit;\n",
+        encoding="utf-8",
+    )
+    args = args_for(packet, tmp_path)
+    args.manifest_sql = malicious
+    runner = NoSshRunner()
+
+    result = state.collect_state(args, runner=runner)
+
+    assert result["status"] == "fail"
+    assert result["packet_checks"]["manifest_override_absent_or_exact_canonical_path"] is False
+    assert result["remote"]["readback_attempts"] == {}
+    assert runner.calls == 0
+    assert state._manifest_sql_is_statically_read_only(malicious.read_text(encoding="utf-8")) is False
+
+
+def test_manifest_hash_mismatch_is_rejected_before_ssh(tmp_path: Path) -> None:
+    packet_path = write_packet(tmp_path)
+    packet = json.loads(packet_path.read_text(encoding="utf-8"))
+    packet["manifest_binding"]["sha256"] = "0" * 64
+    packet_path.write_text(json.dumps(packet), encoding="utf-8")
+    runner = NoSshRunner()
+
+    result = state.collect_state(args_for(packet_path, tmp_path), runner=runner)
+
+    assert result["status"] == "fail"
+    assert result["packet_checks"]["manifest_packet_sha256_matches_canonical_file"] is False
+    assert result["remote"]["readback_attempts"] == {}
+    assert runner.calls == 0
+
+
+def test_cli_removes_arbitrary_manifest_override() -> None:
+    with pytest.raises(SystemExit):
+        state.parse_args(["--manifest-sql", "write.sql"])
+
+
+def test_fingerprint_command_enforces_read_only_session_role_and_disables_psql_rc() -> None:
+    command = state.fingerprint_readback_command()
+
+    assert "default_transaction_read_only=on" in command
+    assert "-c transaction_read_only=on" in command
+    assert f"role={packet_builder.READ_ONLY_DB_ROLE}" in command
+    assert "psql -X" in command

tests/test_kb_apply_prereqs.py

@@ -203,6 +203,15 @@ def _lines(completed: subprocess.CompletedProcess[str]) -> set[str]:
     return {line for line in completed.stdout.splitlines() if line}
 
 
+def test_reviewer_principal_seed_timestamp_is_deterministic(migrated_postgres: str) -> None:
+    created_at = _psql(
+        migrated_postgres,
+        "select created_at::text from kb_stage.kb_review_principals where db_role = 'kb_review';",
+    ).stdout.strip()
+
+    assert created_at == "1970-01-01 00:00:00+00"
+
+
 def _catalog_snapshot(container: str) -> str:
     return _psql(
         container,

tests/test_leo_behavior_manifest.py

@@ -4,6 +4,8 @@ import json
 import subprocess
 from pathlib import Path
 
+import pytest
+
 from scripts import leo_behavior_manifest as manifest
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -58,6 +60,11 @@ gateway:
     assert '{"private":"conversation"}' not in encoded
 
 
+def test_identity_config_rejects_nonboolean_smart_model_routing() -> None:
+    with pytest.raises(ValueError, match="smart_model_routing must be boolean"):
+        manifest.identity_config_projection({"smart_model_routing": {"route": "untrusted"}})
+
+
 def test_behavior_manifest_changes_when_a_behavior_layer_changes(tmp_path: Path) -> None:
     profile = tmp_path / "profile"
     hermes = tmp_path / "hermes"
@@ -156,3 +163,64 @@ def test_git_state_marks_untracked_files_dirty(tmp_path: Path) -> None:
 
     assert state["worktree_clean"] is False
     assert len(str(state["status_sha256"])) == 64
+
+
+def test_identity_runtime_omits_secret_values_but_pins_semantic_model_settings(tmp_path: Path) -> None:
+    profile = tmp_path / "profile"
+    hermes = tmp_path / "hermes"
+    deployment = tmp_path / "deployment"
+    config = """model:
+  provider: fixture
+  default: identity-v1
+  max_tokens: 512
+gateway:
+  telegram:
+    bot_token: token-a
+    botToken: camel-token-a
+provider:
+  apiKey: camel-api-key-a
+transport:
+  endpoint: https://fixture-user:fixture-password-a@example.invalid/v1
+  headers: ['Authorization: Bearer fixture-header-a']
+tools:
+  allowed: [identity_readback]
+identity_runtime:
+  network_send_enabled: false
+  database_write_enabled: false
+  allowed_tools: [identity_readback]
+"""
+    _write(profile / "config.yaml", config)
+    _write(profile / "skills" / "identity" / "SKILL.md", "identity\n")
+    _write(profile / "plugins" / "identity" / "__init__.py", "BOUNDARY = True\n")
+    _write(profile / "bin" / "identity.py", "READ_ONLY = True\n")
+    _write(hermes / "run_agent.py", "runtime\n")
+    _write(hermes / "agent" / "prompt_builder.py", "prompts\n")
+    for name in (
+        "leo_behavior_manifest.py",
+        "leo_identity_manifest.py",
+        "leo_identity_profile.py",
+        "run_leo_identity_reconstruction_canary.py",
+    ):
+        _write(deployment / "scripts" / name, f"# {name}\n")
+
+    before = manifest.build_manifest(profile, hermes, deployment)
+    _write(
+        profile / "config.yaml",
+        config.replace("token-a", "token-b")
+        .replace("camel-api-key-a", "camel-api-key-b")
+        .replace("fixture-password-a", "fixture-password-b")
+        .replace("fixture-header-a", "fixture-header-b"),
+    )
+    secret_rotated = manifest.build_manifest(profile, hermes, deployment)
+    _write(profile / "config.yaml", config.replace("max_tokens: 512", "max_tokens: 1024"))
+    model_changed = manifest.build_manifest(profile, hermes, deployment)
+
+    assert before["behavior_sha256"] != secret_rotated["behavior_sha256"]
+    assert before["identity_runtime_sha256"] == secret_rotated["identity_runtime_sha256"]
+    assert before["identity_runtime_sha256"] != model_changed["identity_runtime_sha256"]
+    encoded = json.dumps(before)
+    assert "token-a" not in encoded
+    assert "camel-token-a" not in encoded
+    assert "camel-api-key-a" not in encoded
+    assert "fixture-password-a" not in encoded
+    assert "fixture-header-a" not in encoded

tests/test_leo_identity_manifest.py

@@ -0,0 +1,794 @@
+from __future__ import annotations
+
+import argparse
+import copy
+import json
+import os
+import subprocess
+import time
+from pathlib import Path, PureWindowsPath
+
+import pytest
+
+from scripts import leo_behavior_manifest as behavior
+from scripts import leo_identity_manifest as identity
+from scripts import leo_identity_profile as profile_runtime
+from scripts import run_leo_identity_reconstruction_canary as canary
+
+ROOT = Path(__file__).resolve().parents[1]
+COMMITTED_RECEIPTS = (
+    ROOT / "docs/reports/leo-working-state-20260709/leo-reproducible-identity-t2-current.json",
+    ROOT / "docs/reports/leo-working-state-20260709/leo-reproducible-identity-drift-negative-current.json",
+)
+
+
+def _write(path: Path, value: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(value, encoding="utf-8")
+
+
+def _write_json(path: Path, value: dict) -> None:
+    _write(path, json.dumps(value, indent=2, sort_keys=True) + "\n")
+
+
+def _assert_path_portable_receipt(value: object) -> None:
+    canary._validate_portable_receipt(value)
+
+
+def _assert_logical_child_execution(child: dict, *, profile_role: str) -> None:
+    logical_command = child["logical_command"]
+    assert "command" not in child
+    assert child["profile_role"] == profile_role
+    assert child["command_serialization"] == "logical_redacted_v1"
+    assert child["actual_argv_persisted"] is False
+    assert logical_command[0] == "<python>"
+    assert logical_command[logical_command.index("--profile") + 1] == "<temporary-profile>"
+    _assert_path_portable_receipt(child)
+
+
+def _fixture(tmp_path: Path) -> dict[str, Path | dict]:
+    repo = tmp_path / "repo"
+    profile = repo / "profile-template"
+    hermes = repo / "hermes-runtime"
+    compiled = tmp_path / "compiled-profile"
+    _write(
+        profile / "config.yaml",
+        """model:
+  provider: fixture-local
+  default: identity-v1
+  max_tokens: 512
+memory:
+  enabled: false
+gateway:
+  execution_mode: local_no_send
+  telegram:
+    bot_token: never-emit-this-fixture-value
+transport:
+  endpoint: https://fixture-user:fixture-password@example.invalid/v1
+  headers: ['Authorization: Bearer fixture-secret']
+tools:
+  allowed: [identity_readback]
+  write_enabled: false
+identity_runtime:
+  network_send_enabled: false
+  database_write_enabled: false
+  allowed_tools: [identity_readback]
+""",
+    )
+    _write(profile / "skills" / "identity" / "SKILL.md", "# identity readback\n")
+    _write(profile / "plugins" / "identity" / "__init__.py", "BOUNDARY = True\n")
+    _write(profile / "bin" / "identity_readback.py", "READ_ONLY = True\n")
+    _write(hermes / "run_agent.py", "RUNTIME = 'identity-v1'\n")
+    _write(hermes / "agent" / "prompt_builder.py", "SOUL_IS_GENERATED = True\n")
+    _write(hermes / "gateway" / "run.py", "SESSION_IS_IDENTITY = False\n")
+    _write(hermes / "hermes_cli" / "tools_config.py", "TOOLS = ('identity_readback',)\n")
+    _write(hermes / "tools" / "registry.py", "READ_ONLY = True\n")
+    for name in (
+        "leo_behavior_manifest.py",
+        "leo_identity_manifest.py",
+        "leo_identity_profile.py",
+        "run_leo_identity_reconstruction_canary.py",
+    ):
+        _write(repo / "scripts" / name, (ROOT / "scripts" / name).read_text(encoding="utf-8"))
+
+    fingerprint_path = repo / "fixtures" / "database-fingerprint.json"
+    constitution_path = repo / "fixtures" / "constitution.json"
+    database_identity_path = repo / "fixtures" / "database-identity.json"
+    fingerprint = {
+        "schema": identity.DATABASE_FINGERPRINT_SCHEMA,
+        "status": "ok",
+        "environment": "disposable_fixture",
+        "fingerprint_sha256": "1" * 64,
+        "table_rows_sha256": "2" * 64,
+        "structure_sha256": "3" * 64,
+        "table_count": 2,
+        "total_rows": 2,
+        "read_consistency": {
+            "status": "stable_wal_marker",
+            "before": {
+                "database": "fixture",
+                "database_user": "reader",
+                "system_identifier": "12345",
+                "wal_lsn": "0/1",
+            },
+            "after": {
+                "database": "fixture",
+                "database_user": "reader",
+                "system_identifier": "12345",
+                "wal_lsn": "0/1",
+            },
+        },
+    }
+    constitution = {
+        "schema": identity.CONSTITUTION_SCHEMA,
+        "identity_name": "Leo",
+        "rules": [
+            {"id": "evidence", "text": "Never use temporary session memory as canonical evidence."},
+            {"id": "truth", "text": "Fail closed when a pinned identity input drifts."},
+        ],
+    }
+    database_identity = {
+        "schema": identity.DATABASE_IDENTITY_SCHEMA,
+        "identity_name": "Leo",
+        "database_fingerprint_sha256": "1" * 64,
+        "source_provenance": {
+            "mode": identity.SYNTHETIC_DATABASE_MODE,
+            "canonical_authority_granted": False,
+            "same_transaction_as_fingerprint": False,
+            "export_receipt_sha256": None,
+        },
+        "records": [
+            {
+                "table": "public.personas",
+                "row_id": "persona-1",
+                "kind": "persona",
+                "rank": 0,
+                "text": "Leo is an evidence-bound reasoning interface.",
+                "status": "active",
+                "evidence_sha256": "a" * 64,
+            },
+            {
+                "table": "public.beliefs",
+                "row_id": "belief-1",
+                "kind": "belief",
+                "rank": 0,
+                "text": "Exact provenance is stronger than plausible recollection.",
+                "status": "active",
+                "evidence_sha256": "b" * 64,
+            },
+        ],
+    }
+    _write_json(fingerprint_path, fingerprint)
+    _write_json(constitution_path, constitution)
+    _write_json(database_identity_path, database_identity)
+
+    subprocess.run(["git", "init", "-q", str(repo)], check=True)
+    subprocess.run(["git", "-C", str(repo), "config", "user.email", "test@example.com"], check=True)
+    subprocess.run(["git", "-C", str(repo), "config", "user.name", "Test"], check=True)
+    subprocess.run(["git", "-C", str(repo), "add", "."], check=True)
+    subprocess.run(
+        ["git", "-C", str(repo), "commit", "-qm", "fixture"],
+        check=True,
+        env={
+            **dict(__import__("os").environ),
+            "GIT_AUTHOR_DATE": "2026-01-01T00:00:00Z",
+            "GIT_COMMITTER_DATE": "2026-01-01T00:00:00Z",
+        },
+    )
+    behavior_manifest = behavior.build_manifest(profile, hermes, repo)
+    manifest = identity.build_identity_manifest(
+        behavior_manifest=behavior_manifest,
+        database_fingerprint_path=fingerprint_path,
+        constitution_path=constitution_path,
+        database_identity_path=database_identity_path,
+        source_root=repo,
+    )
+    return {
+        "repo": repo,
+        "profile": profile,
+        "hermes": hermes,
+        "compiled": compiled,
+        "fingerprint": fingerprint_path,
+        "constitution": constitution_path,
+        "database_identity": database_identity_path,
+        "behavior": behavior_manifest,
+        "manifest": manifest,
+    }
+
+
+def _fully_rehash_manifest(fixture: dict[str, Path | dict], manifest: dict) -> None:
+    identity_hash = behavior.canonical_sha256(manifest["identity_inputs"])
+    manifest["identity_inputs_sha256"] = identity_hash
+    fingerprint = identity.load_json(fixture["fingerprint"], "database fingerprint")
+    rules = identity.canonical_rules(identity.load_json(fixture["constitution"], "constitution"))
+    records = identity.canonical_database_records(
+        identity.load_json(fixture["database_identity"], "database identity"),
+        fingerprint_sha256=fingerprint["fingerprint_sha256"],
+    )
+    database_provenance = identity.database_identity_provenance(
+        identity.load_json(fixture["database_identity"], "database identity"),
+        fingerprint=fingerprint,
+    )
+    rendered = identity.render_identity_views(
+        identity_inputs_sha256=identity_hash,
+        database_fingerprint_sha256=fingerprint["fingerprint_sha256"],
+        database_provenance=database_provenance,
+        rules=rules,
+        records=records,
+    )
+    for name, content in rendered.items():
+        manifest["compiled_views"][name]["sha256"] = behavior.sha256_bytes(content.encode("utf-8"))
+        manifest["compiled_views"][name]["generated_from_identity_inputs_sha256"] = identity_hash
+    stable = {key: value for key, value in manifest.items() if key != "manifest_sha256"}
+    manifest["manifest_sha256"] = behavior.canonical_sha256(stable)
+
+
+def _rehash_behavior_manifest(manifest: dict) -> None:
+    manifest["identity_runtime_sha256"] = behavior.canonical_sha256(behavior.identity_runtime_payload(manifest))
+    manifest["static_runtime_sha256"] = behavior.canonical_sha256(behavior.static_runtime_payload(manifest))
+    manifest["behavior_sha256"] = behavior.canonical_sha256(behavior.stable_manifest_payload(manifest))
+
+
+def _canary_args(fixture: dict[str, Path | dict], output: Path, *, inject_drift: bool = False) -> argparse.Namespace:
+    return argparse.Namespace(
+        profile_template=fixture["profile"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+        source_root=fixture["repo"],
+        database_fingerprint=fixture["fingerprint"],
+        constitution=fixture["constitution"],
+        database_identity=fixture["database_identity"],
+        output=output,
+        inject_drift_before_restart=inject_drift,
+    )
+
+
+@pytest.mark.parametrize(
+    "private_path",
+    [
+        "/" + "Users/operator/checkout/profile",
+        "/" + "private/tmp/lane/.venv/bin/python",
+        "/" + "var/folders/cache/temporary-profile",
+        "/" + "tmp/temporary-profile",
+        "/" + "opt/checkout/interpreter",
+        "/" + "workspace/checkout/temporary-profile",
+        str(PureWindowsPath("C:/operator/checkout/temporary-profile")),
+        "\\\\" + "server\\share\\checkout\\temporary-profile",
+    ],
+)
+def test_receipt_path_guard_recursively_rejects_private_and_absolute_paths(private_path: str) -> None:
+    with pytest.raises(canary.CanaryError, match="private or absolute filesystem path"):
+        _assert_path_portable_receipt({"outer": [{"logical_command": ["<python>", private_path]}]})
+
+
+def test_receipt_path_guard_rejects_an_absolute_path_in_a_nested_key() -> None:
+    private_key = "/" + "tmp/checkout/temporary-profile"
+    with pytest.raises(canary.CanaryError, match="private or absolute filesystem path"):
+        _assert_path_portable_receipt({"outer": [{private_key: "<temporary-profile>"}]})
+
+
+def test_logical_command_uses_placeholders_for_paths_outside_the_deployment_root(tmp_path: Path) -> None:
+    logical_command = canary._logical_query_command(
+        deployment_root=tmp_path / "checkout",
+        source_root=tmp_path / "outside-source",
+        hermes_root=tmp_path / "outside-hermes",
+    )
+
+    assert logical_command[logical_command.index("--source-root") + 1] == "<source-root>"
+    assert logical_command[logical_command.index("--hermes-root") + 1] == "<hermes-root>"
+    _assert_path_portable_receipt(logical_command)
+
+
+@pytest.mark.parametrize("receipt_path", COMMITTED_RECEIPTS, ids=lambda path: path.name)
+def test_committed_identity_receipts_are_path_portable_and_self_hashed(receipt_path: Path) -> None:
+    receipt = json.loads(receipt_path.read_text(encoding="utf-8"))
+    _assert_path_portable_receipt(receipt)
+    stable = {key: value for key, value in receipt.items() if key != "receipt_sha256"}
+    assert behavior.canonical_sha256(stable) == receipt["receipt_sha256"]
+
+
+def test_manifest_compiles_generated_views_and_reproduces_identity_across_queries(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    manifest = fixture["manifest"]
+    assert isinstance(manifest, dict)
+    rebuilt = identity.build_identity_manifest(
+        behavior_manifest=fixture["behavior"],
+        database_fingerprint_path=fixture["fingerprint"],
+        constitution_path=fixture["constitution"],
+        database_identity_path=fixture["database_identity"],
+        source_root=fixture["repo"],
+    )
+    assert rebuilt == manifest
+
+    compile_receipt = profile_runtime.compile_profile(
+        manifest,
+        source_root=fixture["repo"],
+        profile_template=fixture["profile"],
+        profile=fixture["compiled"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+    first = profile_runtime.query_profile(
+        fixture["compiled"],
+        query=profile_runtime.FIXED_QUERY,
+        source_root=fixture["repo"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+    second = profile_runtime.query_profile(
+        fixture["compiled"],
+        query=profile_runtime.FIXED_QUERY,
+        source_root=fixture["repo"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+
+    assert compile_receipt["status"] == "pass"
+    assert "never-emit-this-fixture-value" not in (fixture["compiled"] / "config.yaml").read_text(encoding="utf-8")
+    assert "fixture-password" not in (fixture["compiled"] / "config.yaml").read_text(encoding="utf-8")
+    assert "fixture-secret" not in (fixture["compiled"] / "config.yaml").read_text(encoding="utf-8")
+    assert (fixture["compiled"] / "SOUL.md").read_text(encoding="utf-8").startswith("<!-- GENERATED FILE")
+    assert first["manifest_sha256"] == second["manifest_sha256"]
+    assert first["identity_inputs_sha256"] == second["identity_inputs_sha256"]
+    assert first["answer_sha256"] == second["answer_sha256"]
+    assert first["output_provenance"] == second["output_provenance"]
+    assert first["runtime_instance_id"] != second["runtime_instance_id"]
+    assert first["session"]["included_in_output_provenance"] is False
+    assert first["output_provenance"]["database_canonical_authority_granted"] is False
+    assert first["authorization"]["authorization_decision_observed"] is False
+    assert "synthetic noncanonical fixture" in first["answer"]
+    assert len(list((fixture["compiled"] / "sessions").glob("*.json"))) == 2
+
+
+def test_profile_and_bound_source_drift_fail_closed(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    profile_runtime.compile_profile(
+        fixture["manifest"],
+        source_root=fixture["repo"],
+        profile_template=fixture["profile"],
+        profile=fixture["compiled"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+    with (fixture["compiled"] / "SOUL.md").open("a", encoding="utf-8") as handle:
+        handle.write("drift\n")
+    with pytest.raises(identity.IdentityManifestError, match="compiled view drift detected"):
+        profile_runtime.query_profile(
+            fixture["compiled"],
+            query=profile_runtime.FIXED_QUERY,
+            source_root=fixture["repo"],
+            hermes_root=fixture["hermes"],
+            deployment_root=fixture["repo"],
+        )
+
+    _write(fixture["constitution"], fixture["constitution"].read_text(encoding="utf-8") + "\n")
+    with pytest.raises(identity.IdentityManifestError, match="constitution source content drift"):
+        identity.verify_bound_sources(fixture["manifest"], fixture["repo"])
+
+
+@pytest.mark.parametrize(
+    ("relative_path", "content", "message"),
+    [
+        ("memories/USER.md", "untrusted memory\n", "forbidden nonauthoritative"),
+        ("MEMORY.md", "untrusted top-level memory\n", "forbidden nonauthoritative"),
+        ("USER.md", "untrusted top-level user memory\n", "forbidden nonauthoritative"),
+        ("platforms/pairing/telegram.json", "{}\n", "forbidden nonauthoritative"),
+        (".env", "LEO_SECRET=untrusted\n", "profile entry set is not exact"),
+        ("gateway.json", "{}\n", "profile entry set is not exact"),
+        ("unexpected.txt", "untrusted input\n", "profile entry set is not exact"),
+        ("sessions/injected.txt", "untrusted session\n", "unsafe session entry"),
+        ("state/injected.json", "{}\n", "state directory must remain empty"),
+    ],
+)
+def test_profile_rechecks_nonauthoritative_surfaces_before_every_query(
+    tmp_path: Path, relative_path: str, content: str, message: str
+) -> None:
+    fixture = _fixture(tmp_path)
+    profile_runtime.compile_profile(
+        fixture["manifest"],
+        source_root=fixture["repo"],
+        profile_template=fixture["profile"],
+        profile=fixture["compiled"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+    _write(fixture["compiled"] / relative_path, content)
+
+    with pytest.raises(profile_runtime.IdentityProfileError, match=message):
+        profile_runtime.query_profile(
+            fixture["compiled"],
+            query=profile_runtime.FIXED_QUERY,
+            source_root=fixture["repo"],
+            hermes_root=fixture["hermes"],
+            deployment_root=fixture["repo"],
+        )
+
+
+def test_manifest_rejects_rehashed_core_tampering(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    tampered = copy.deepcopy(fixture["manifest"])
+    tampered["identity_inputs"]["session_boundary"]["may_be_used_as_evidence"] = True
+    stable = {key: value for key, value in tampered.items() if key != "manifest_sha256"}
+    tampered["manifest_sha256"] = behavior.canonical_sha256(stable)
+
+    with pytest.raises(identity.IdentityManifestError, match="identity input hash drift"):
+        identity.validate_identity_manifest(tampered)
+
+
+@pytest.mark.parametrize(
+    ("path", "value", "message"),
+    [
+        (("permissions", "runtime_policy", "network_send_enabled"), True, "exact local readback policy"),
+        (("session_boundary", "may_be_used_as_evidence"), True, "session authority boundary"),
+    ],
+)
+def test_manifest_rejects_fully_rehashed_safety_invariant_tampering(
+    tmp_path: Path, path: tuple[str, ...], value: object, message: str
+) -> None:
+    fixture = _fixture(tmp_path)
+    tampered = copy.deepcopy(fixture["manifest"])
+    target = tampered["identity_inputs"]
+    for key in path[:-1]:
+        target = target[key]
+    target[path[-1]] = value
+    _fully_rehash_manifest(fixture, tampered)
+
+    with pytest.raises(identity.IdentityManifestError, match=message):
+        identity.verify_bound_sources(tampered, fixture["repo"])
+
+
+def test_behavior_manifest_rejects_unhashed_model_claim_tampering(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    tampered_behavior = copy.deepcopy(fixture["behavior"])
+    tampered_behavior["model_runtime"]["default_model"] = "tampered-unobserved-model"
+
+    with pytest.raises(identity.IdentityManifestError, match="behavior identity runtime hash drift"):
+        identity.build_identity_manifest(
+            behavior_manifest=tampered_behavior,
+            database_fingerprint_path=fixture["fingerprint"],
+            constitution_path=fixture["constitution"],
+            database_identity_path=fixture["database_identity"],
+            source_root=fixture["repo"],
+        )
+
+
+def test_profile_rejects_a_dangling_extra_symlink(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    profile_runtime.compile_profile(
+        fixture["manifest"],
+        source_root=fixture["repo"],
+        profile_template=fixture["profile"],
+        profile=fixture["compiled"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+    (fixture["compiled"] / ".env").symlink_to(tmp_path / "missing-env")
+
+    with pytest.raises(profile_runtime.IdentityProfileError, match="profile entry set is not exact"):
+        profile_runtime.query_profile(
+            fixture["compiled"],
+            query=profile_runtime.FIXED_QUERY,
+            source_root=fixture["repo"],
+            hermes_root=fixture["hermes"],
+            deployment_root=fixture["repo"],
+        )
+
+
+def test_profile_rejects_a_symlink_in_an_allowed_entry(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    profile_runtime.compile_profile(
+        fixture["manifest"],
+        source_root=fixture["repo"],
+        profile_template=fixture["profile"],
+        profile=fixture["compiled"],
+        hermes_root=fixture["hermes"],
+        deployment_root=fixture["repo"],
+    )
+    external_config = tmp_path / "external-config.yaml"
+    external_config.write_bytes((fixture["compiled"] / "config.yaml").read_bytes())
+    (fixture["compiled"] / "config.yaml").unlink()
+    (fixture["compiled"] / "config.yaml").symlink_to(external_config)
+
+    with pytest.raises(profile_runtime.IdentityProfileError, match="profile entries must not be symlinks"):
+        profile_runtime.query_profile(
+            fixture["compiled"],
+            query=profile_runtime.FIXED_QUERY,
+            source_root=fixture["repo"],
+            hermes_root=fixture["hermes"],
+            deployment_root=fixture["repo"],
+        )
+
+
+@pytest.mark.parametrize(
+    ("mutation", "message"),
+    [
+        ("unreadable_file", "unreadable inputs"),
+        ("symlink", "unsupported symlinks"),
+        ("forged_structure", "is empty"),
+    ],
+)
+def test_behavior_manifest_rejects_unreplayable_identity_components(
+    tmp_path: Path, mutation: str, message: str
+) -> None:
+    fixture = _fixture(tmp_path)
+    tampered_behavior = copy.deepcopy(fixture["behavior"])
+    content = tampered_behavior["components"]["procedural_skills"]["content"]
+    if mutation == "unreadable_file":
+        content["files"][0].pop("sha256")
+        content["files"][0]["status"] = "unavailable"
+    elif mutation == "symlink":
+        content["symlinks"].append(
+            {
+                "path": "skills/identity/link",
+                "target": "/outside/checkout",
+                "target_fingerprint": {"kind": "unavailable", "error": "FileNotFoundError"},
+            }
+        )
+    else:
+        content["files"] = []
+    content["sha256"] = behavior.canonical_sha256({key: content[key] for key in ("files", "missing", "symlinks")})
+    _rehash_behavior_manifest(tampered_behavior)
+
+    with pytest.raises(identity.IdentityManifestError, match=message):
+        identity.validate_behavior_manifest(tampered_behavior)
+
+
+def test_fully_rehashed_model_claim_must_match_observed_runtime(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    tampered = copy.deepcopy(fixture["manifest"])
+    tampered["identity_inputs"]["model"]["default_model"] = "tampered-unobserved-model"
+    _fully_rehash_manifest(fixture, tampered)
+    identity.validate_identity_manifest(tampered)
+
+    with pytest.raises(
+        profile_runtime.IdentityProfileError, match="model runtime binding drift detected: default_model"
+    ):
+        profile_runtime.compile_profile(
+            tampered,
+            source_root=fixture["repo"],
+            profile_template=fixture["profile"],
+            profile=fixture["compiled"],
+            hermes_root=fixture["hermes"],
+            deployment_root=fixture["repo"],
+        )
+    assert not fixture["compiled"].exists()
+
+
+def test_restart_canary_uses_distinct_processes_and_cleans_up(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    output = tmp_path / "restart-receipt.json"
+    report, exit_code = canary.run_canary(_canary_args(fixture, output))
+
+    assert exit_code == 0
+    assert report["status"] == "pass"
+    assert report["gates"]["restart_process_is_distinct"] is True
+    assert report["gates"]["restart_profile_recompiled_from_manifest"] is True
+    assert report["restart_compile"]["session_directories_started_empty"] is True
+    assert report["drift_compile"]["session_directories_started_empty"] is True
+    _assert_logical_child_execution(report["first_start"], profile_role="first_start")
+    _assert_logical_child_execution(report["restart"], profile_role="restart")
+    _assert_logical_child_execution(report["drift_negative"], profile_role="drift_negative")
+    _assert_path_portable_receipt(report)
+    assert report["first_start"]["launcher_pid"] != report["restart"]["launcher_pid"]
+    assert report["first_start"]["process_group_absent_after_wait"] is True
+    assert report["restart"]["process_group_absent_after_wait"] is True
+    assert report["drift_negative"]["fail_closed"] is True
+    assert report["drift_negative"]["process_group_absent_after_wait"] is True
+    assert report["goal_tier_satisfied"] is True
+    assert report["current_tier"] == "T2_runtime"
+    assert report["cleanup"]["temporary_root_removed"] is True
+    assert behavior.git_state(fixture["repo"])["worktree_clean"] is True
+    assert json.loads(output.read_text(encoding="utf-8")) == report
+
+
+def test_restart_canary_rejects_drift_before_second_start(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    output = tmp_path / "drift-receipt.json"
+    report, exit_code = canary.run_canary(_canary_args(fixture, output, inject_drift=True))
+
+    assert exit_code == 0
+    assert report["status"] == "pass"
+    assert report["gates"]["drift_detected_before_restart"] is True
+    assert report["second_start_attempted"] is False
+    assert "restart" not in report
+    _assert_logical_child_execution(report["first_start"], profile_role="first_start")
+    _assert_logical_child_execution(report["pre_restart_drift"], profile_role="pre_restart_drift")
+    _assert_path_portable_receipt(report)
+    assert report["pre_restart_drift"]["process_group_absent_after_wait"] is True
+    assert all(report["gates"].values())
+    assert report["goal_tier_satisfied"] is False
+    assert report["current_tier"] == "T1_model"
+    assert report["cleanup"]["temporary_root_removed"] is True
+    assert json.loads(output.read_text(encoding="utf-8")) == report
+
+
+def test_query_child_timeout_terminates_process_group(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    marker = tmp_path / "descendant.pid"
+    sleeping_module = f"""import subprocess
+import sys
+import time
+from pathlib import Path
+
+child = subprocess.Popen([sys.executable, '-c', 'import time; time.sleep(60)'])
+Path({str(marker)!r}).write_text(str(child.pid), encoding='utf-8')
+time.sleep(60)
+"""
+    _write(fixture["repo"] / "scripts" / "leo_identity_profile.py", sleeping_module)
+
+    result = canary._run_query_child(
+        deployment_root=fixture["repo"],
+        profile=fixture["compiled"],
+        source_root=fixture["repo"],
+        hermes_root=fixture["hermes"],
+        profile_role="timeout_test",
+        timeout_seconds=0.5,
+    )
+
+    assert result["timed_out"] is True
+    assert result["terminated_with"] in {"SIGTERM", "SIGKILL"}
+    assert result["returncode"] != 0
+    assert result["process_group_absent_after_wait"] is True
+    descendant_pid = int(marker.read_text(encoding="utf-8"))
+    deadline = time.monotonic() + 5
+    while time.monotonic() < deadline:
+        try:
+            os.kill(descendant_pid, 0)
+        except ProcessLookupError:
+            break
+        time.sleep(0.02)
+    with pytest.raises(ProcessLookupError):
+        os.kill(descendant_pid, 0)
+
+
+def test_query_child_cleans_and_rejects_orphan_from_completed_launcher(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    marker = tmp_path / "completed-descendant.pid"
+    query_payload = {"schema": profile_runtime.QUERY_RECEIPT_SCHEMA, "status": "pass"}
+    leaking_module = f"""import json
+import subprocess
+import sys
+from pathlib import Path
+
+child = subprocess.Popen(
+    [sys.executable, '-c', 'import time; time.sleep(60)'],
+    stdin=subprocess.DEVNULL,
+    stdout=subprocess.DEVNULL,
+    stderr=subprocess.DEVNULL,
+)
+Path({str(marker)!r}).write_text(str(child.pid), encoding='utf-8')
+print(json.dumps({query_payload!r}))
+"""
+    _write(fixture["repo"] / "scripts" / "leo_identity_profile.py", leaking_module)
+
+    result = canary._run_query_child(
+        deployment_root=fixture["repo"],
+        profile=fixture["compiled"],
+        source_root=fixture["repo"],
+        hermes_root=fixture["hermes"],
+        profile_role="orphan_cleanup_test",
+        timeout_seconds=5,
+    )
+
+    assert result["returncode"] == 0
+    assert result["orphan_cleanup_required"] is True
+    assert result["terminated_with"] in {"SIGTERM", "SIGKILL"}
+    assert result["process_group_absent_after_wait"] is True
+    assert canary._query_passed(result) is False
+
+
+def test_wal_capture_marker_is_not_an_identity_input(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    original = fixture["manifest"]
+    fingerprint = json.loads(fixture["fingerprint"].read_text(encoding="utf-8"))
+    fingerprint["read_consistency"]["before"]["wal_lsn"] = "0/2"
+    fingerprint["read_consistency"]["after"]["wal_lsn"] = "0/2"
+    _write_json(fixture["fingerprint"], fingerprint)
+    rebuilt = identity.build_identity_manifest(
+        behavior_manifest=fixture["behavior"],
+        database_fingerprint_path=fixture["fingerprint"],
+        constitution_path=fixture["constitution"],
+        database_identity_path=fixture["database_identity"],
+        source_root=fixture["repo"],
+    )
+
+    assert rebuilt["identity_inputs_sha256"] == original["identity_inputs_sha256"]
+    assert rebuilt["manifest_sha256"] == original["manifest_sha256"]
+
+
+def test_database_identity_and_system_markers_are_identity_inputs(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    original = fixture["manifest"]
+    fingerprint = json.loads(fixture["fingerprint"].read_text(encoding="utf-8"))
+    for marker in (fingerprint["read_consistency"]["before"], fingerprint["read_consistency"]["after"]):
+        marker["database"] = "different_database"
+        marker["database_user"] = "different_reader"
+        marker["system_identifier"] = "99999"
+    _write_json(fixture["fingerprint"], fingerprint)
+    rebuilt = identity.build_identity_manifest(
+        behavior_manifest=fixture["behavior"],
+        database_fingerprint_path=fixture["fingerprint"],
+        constitution_path=fixture["constitution"],
+        database_identity_path=fixture["database_identity"],
+        source_root=fixture["repo"],
+    )
+
+    assert rebuilt["identity_inputs_sha256"] != original["identity_inputs_sha256"]
+    with pytest.raises(identity.IdentityManifestError, match="database fingerprint semantic drift"):
+        identity.verify_bound_sources(original, fixture["repo"])
+
+
+def test_synthetic_database_rows_cannot_claim_canonical_authority(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    database_identity = json.loads(fixture["database_identity"].read_text(encoding="utf-8"))
+    database_identity["source_provenance"] = {
+        "mode": identity.CANONICAL_DATABASE_MODE,
+        "canonical_authority_granted": True,
+        "same_transaction_as_fingerprint": True,
+        "export_receipt_sha256": "f" * 64,
+    }
+    _write_json(fixture["database_identity"], database_identity)
+
+    with pytest.raises(identity.IdentityManifestError, match="independently verified output"):
+        identity.build_identity_manifest(
+            behavior_manifest=fixture["behavior"],
+            database_fingerprint_path=fixture["fingerprint"],
+            constitution_path=fixture["constitution"],
+            database_identity_path=fixture["database_identity"],
+            source_root=fixture["repo"],
+        )
+
+
+def test_self_hashed_database_export_receipt_cannot_grant_canonical_authority(tmp_path: Path) -> None:
+    fixture = _fixture(tmp_path)
+    fingerprint = json.loads(fixture["fingerprint"].read_text(encoding="utf-8"))
+    fingerprint["environment"] = "canonical_readonly_capture"
+    _write_json(fixture["fingerprint"], fingerprint)
+    database_identity = json.loads(fixture["database_identity"].read_text(encoding="utf-8"))
+    records = identity.canonical_database_records(
+        database_identity,
+        fingerprint_sha256=fingerprint["fingerprint_sha256"],
+    )
+    marker = fingerprint["read_consistency"]["before"]
+    receipt_stable = {
+        "schema": "livingip.untrustedCallerSuppliedExportReceipt.v1",
+        "read_only": True,
+        "same_transaction_as_fingerprint": True,
+        "transaction_isolation": "repeatable_read_read_only",
+        "database": marker["database"],
+        "database_user": marker["database_user"],
+        "system_identifier": marker["system_identifier"],
+        "database_fingerprint_sha256": fingerprint["fingerprint_sha256"],
+        "records_sha256": behavior.canonical_sha256(records),
+    }
+    receipt_hash = behavior.canonical_sha256(receipt_stable)
+    database_identity["source_provenance"] = {
+        "mode": identity.CANONICAL_DATABASE_MODE,
+        "canonical_authority_granted": True,
+        "same_transaction_as_fingerprint": True,
+        "export_receipt_sha256": receipt_hash,
+    }
+    database_identity["export_receipt"] = {**receipt_stable, "receipt_sha256": receipt_hash}
+    _write_json(fixture["database_identity"], database_identity)
+
+    with pytest.raises(identity.IdentityManifestError, match="independently verified output"):
+        identity.build_identity_manifest(
+            behavior_manifest=fixture["behavior"],
+            database_fingerprint_path=fixture["fingerprint"],
+            constitution_path=fixture["constitution"],
+            database_identity_path=fixture["database_identity"],
+            source_root=fixture["repo"],
+        )
+
+
+def test_same_clean_commit_reproduces_identity_from_different_checkout_paths(tmp_path: Path) -> None:
+    first = _fixture(tmp_path / "checkout-a")
+    second = _fixture(tmp_path / "checkout-b")
+
+    assert (
+        first["behavior"]["teleo_infrastructure_runtime"]["git_head"]
+        == second["behavior"]["teleo_infrastructure_runtime"]["git_head"]
+    )
+    assert first["behavior"]["identity_runtime_sha256"] == second["behavior"]["identity_runtime_sha256"]
+    assert first["manifest"]["identity_inputs_sha256"] == second["manifest"]["identity_inputs_sha256"]
+    assert first["manifest"]["manifest_sha256"] == second["manifest"]["manifest_sha256"]

tests/test_observatory_read_adapter.py

@@ -0,0 +1,346 @@
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+from aiohttp.test_utils import TestClient, TestServer
+
+from observatory_read_adapter.app import create_app
+from observatory_read_adapter.config import EXPECTED_CONNECTION_NAME, Settings
+from observatory_read_adapter.db import CloudSqlClaimReader
+
+CLAIM_ID = "d0000000-0000-0000-0000-000000000005"
+API_KEY = "observatory-test-api-key-000000000000000000000000"
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def settings(**overrides: object) -> Settings:
+    values = {
+        "project_id": "teleo-501523",
+        "instance_connection_name": EXPECTED_CONNECTION_NAME,
+        "database": "teleo_canonical",
+        "iam_database_user": "sa-observatory-read-adapter@teleo-501523.iam",
+        "authorization_role": "kb_observatory_read",
+        "api_key": API_KEY,
+        "service_revision": "test-revision",
+    }
+    values.update(overrides)
+    return Settings(**values)
+
+
+class FakeReader:
+    def __init__(self) -> None:
+        self.closed = False
+
+    def check_ready(self) -> dict[str, object]:
+        return {
+            "ready": True,
+            "database": "teleo_canonical",
+            "authorization_role": "kb_observatory_read",
+            "transaction_read_only": True,
+        }
+
+    def read_claim(self, claim_id: str | None = None) -> dict[str, object] | None:
+        if claim_id not in (None, CLAIM_ID):
+            return None
+        return {
+            "schema": "livingip.observatory-canonical-claim.v1",
+            "read_only": True,
+            "provenance": {
+                "database": "teleo_canonical",
+                "database_principal": "sa-observatory-read-adapter@teleo-501523.iam",
+                "authorization_role": "kb_observatory_read",
+                "transaction_read_only": True,
+                "write_privileges_denied": True,
+            },
+            "canonical": {
+                "claim": {"id": CLAIM_ID, "status": "open", "text": "Canonical claim"},
+                "evidence": [{"source_id": "e0000000-0000-0000-0000-000000000006"}],
+            },
+            "proposal_ledger": {
+                "distinct_from_canonical": True,
+                "status_counts": {"pending_review": 2, "approved": 1, "applied": 1},
+                "related": [{"status": "approved", "applied_at": None}],
+            },
+        }
+
+    def close(self) -> None:
+        self.closed = True
+
+
+class FakeCursor:
+    def __init__(self) -> None:
+        self.description: list[tuple[str]] = []
+        self.result: list[tuple[object, ...]] = []
+        self.executed: list[tuple[str, tuple[object, ...]]] = []
+
+    def execute(self, sql: str, parameters: tuple[object, ...] = ()) -> None:
+        normalized = " ".join(sql.split()).lower()
+        self.executed.append((normalized, parameters))
+        self.description = []
+        self.result = []
+        if "current_database() as database" in normalized:
+            self.description = [
+                ("database",),
+                ("database_principal",),
+                ("transaction_read_only",),
+                ("has_authorization_role",),
+                ("has_required_reads",),
+                ("required_writes_denied",),
+            ]
+            self.result = [
+                (
+                    "teleo_canonical",
+                    "sa-observatory-read-adapter@teleo-501523.iam",
+                    "on",
+                    True,
+                    True,
+                    True,
+                )
+            ]
+        elif "from public.claims c" in normalized:
+            self.description = [
+                ("id",),
+                ("type",),
+                ("text",),
+                ("status",),
+                ("confidence",),
+                ("tags",),
+                ("superseded_by",),
+                ("created_at",),
+                ("updated_at",),
+            ]
+            self.result = [
+                (
+                    CLAIM_ID,
+                    "strategy",
+                    "Canonical claim",
+                    "open",
+                    0.8,
+                    ["test"],
+                    None,
+                    "2026-07-15T00:00:00+00:00",
+                    "2026-07-15T00:00:00+00:00",
+                )
+            ]
+        elif "from public.claim_evidence ce" in normalized:
+            self.description = [
+                ("evidence_id",),
+                ("role",),
+                ("weight",),
+                ("linked_at",),
+                ("source_id",),
+                ("source_type",),
+                ("url",),
+                ("storage_path",),
+                ("excerpt",),
+                ("content_hash",),
+                ("captured_at",),
+                ("source_created_at",),
+            ]
+            self.result = [
+                (
+                    "e0000000-0000-0000-0000-000000000006",
+                    "grounds",
+                    1.0,
+                    "2026-07-15T00:00:00+00:00",
+                    "f0000000-0000-0000-0000-000000000007",
+                    "document",
+                    "https://example.test/source",
+                    None,
+                    "Source excerpt",
+                    "sha256:test",
+                    "2026-07-15T00:00:00+00:00",
+                    "2026-07-15T00:00:00+00:00",
+                )
+            ]
+        elif "from public.claim_edges e" in normalized:
+            self.description = [
+                ("edge_id",),
+                ("direction",),
+                ("edge_type",),
+                ("weight",),
+                ("connected_claim_id",),
+                ("created_at",),
+            ]
+            self.result = []
+        elif "group by status" in normalized:
+            self.description = [("status",), ("count",)]
+            self.result = [("approved", 1), ("applied", 1), ("pending_review", 2)]
+        elif "where p.payload::text like" in normalized:
+            self.description = [
+                ("id",),
+                ("proposal_type",),
+                ("status",),
+                ("source_ref",),
+                ("reviewed_at",),
+                ("applied_at",),
+                ("updated_at",),
+            ]
+            self.result = [
+                (
+                    "a0000000-0000-0000-0000-000000000001",
+                    "revise_claim",
+                    "approved",
+                    "source:test",
+                    "2026-07-15T00:00:00+00:00",
+                    None,
+                    "2026-07-15T00:00:00+00:00",
+                )
+            ]
+        elif "from kb_stage.kb_proposals p" in normalized:
+            self.description = [
+                ("id",),
+                ("proposal_type",),
+                ("status",),
+                ("source_ref",),
+                ("reviewed_at",),
+                ("applied_at",),
+                ("updated_at",),
+            ]
+            self.result = []
+
+    def fetchone(self) -> tuple[object, ...] | None:
+        return self.result.pop(0) if self.result else None
+
+    def fetchall(self) -> list[tuple[object, ...]]:
+        result, self.result = self.result, []
+        return result
+
+
+class FakeConnection:
+    def __init__(self) -> None:
+        self.cursor_value = FakeCursor()
+        self.rolled_back = False
+        self.closed = False
+
+    def cursor(self) -> FakeCursor:
+        return self.cursor_value
+
+    def rollback(self) -> None:
+        self.rolled_back = True
+
+    def close(self) -> None:
+        self.closed = True
+
+
+def test_settings_fail_closed_on_wrong_database_role_or_short_key() -> None:
+    for overrides in (
+        {"database": "teleo"},
+        {"authorization_role": "leoclean_kb_runtime"},
+        {"api_key": "too-short"},
+        {"instance_connection_name": "other:region:instance"},
+    ):
+        candidate = settings(**overrides)
+        try:
+            candidate.validate()
+        except ValueError:
+            pass
+        else:
+            raise AssertionError(f"unsafe settings accepted: {overrides}")
+
+
+def test_authenticated_claim_response_and_negative_http_paths() -> None:
+    async def exercise() -> None:
+        reader = FakeReader()
+        client = TestClient(TestServer(create_app(settings(), reader=reader)))
+        await client.start_server()
+        try:
+            anonymous = await client.get("/v1/claims/sample")
+            assert anonymous.status == 401
+            assert await anonymous.json() == {"error": "unauthorized"}
+
+            response = await client.get(
+                f"/v1/claims/{CLAIM_ID}",
+                headers={"X-Api-Key": API_KEY},
+            )
+            assert response.status == 200
+            assert response.headers["Cache-Control"] == "private, no-store, max-age=0"
+            payload = await response.json()
+            assert payload["schema"] == "livingip.observatory-canonical-claim.v1"
+            assert payload["provenance"]["database"] == "teleo_canonical"
+            assert payload["provenance"]["write_privileges_denied"] is True
+            assert payload["canonical"]["evidence"]
+            assert payload["proposal_ledger"]["distinct_from_canonical"] is True
+            assert payload["proposal_ledger"]["related"][0]["applied_at"] is None
+            assert API_KEY not in json.dumps(payload)
+
+            write_attempt = await client.post(
+                f"/v1/claims/{CLAIM_ID}",
+                headers={"X-Api-Key": API_KEY},
+                json={"status": "applied"},
+            )
+            assert write_attempt.status == 405
+
+            invalid = await client.get(
+                "/v1/claims/not-a-uuid",
+                headers={"X-Api-Key": API_KEY},
+            )
+            assert invalid.status == 400
+        finally:
+            await client.close()
+        assert reader.closed is True
+
+    asyncio.run(exercise())
+
+
+def test_readiness_checks_database_contract_without_exposing_claims() -> None:
+    async def exercise() -> None:
+        client = TestClient(TestServer(create_app(settings(), reader=FakeReader())))
+        await client.start_server()
+        try:
+            response = await client.get("/readyz")
+            payload = await response.json()
+            assert response.status == 200
+            assert payload == {"status": "ready"}
+        finally:
+            await client.close()
+
+    asyncio.run(exercise())
+
+
+def test_database_reader_returns_provenance_and_keeps_proposals_distinct() -> None:
+    connection = FakeConnection()
+    reader = CloudSqlClaimReader(settings(), connection_factory=lambda: connection)
+
+    payload = reader.read_claim(CLAIM_ID)
+
+    assert payload is not None
+    assert payload["provenance"]["database"] == "teleo_canonical"
+    assert payload["provenance"]["database_principal"] == settings().iam_database_user
+    assert payload["provenance"]["write_privileges_denied"] is True
+    assert payload["canonical"]["claim"]["id"] == CLAIM_ID
+    assert payload["canonical"]["evidence"][0]["content_hash"] == "sha256:test"
+    assert payload["proposal_ledger"]["distinct_from_canonical"] is True
+    assert payload["proposal_ledger"]["related"][0]["status"] == "approved"
+    assert payload["proposal_ledger"]["related"][0]["applied_at"] is None
+    assert connection.rolled_back is True
+    assert connection.closed is True
+    assert any("set transaction read only" in sql for sql, _parameters in connection.cursor_value.executed)
+
+
+def test_database_role_contract_is_select_only_and_iam_scoped() -> None:
+    sql = (ROOT / "ops" / "observatory_read_role.sql").read_text(encoding="utf-8")
+    lowered = sql.lower()
+
+    assert "kb_observatory_read nologin" in lowered
+    assert "default_transaction_read_only = on" in lowered
+    assert "public.claims" in lowered
+    assert "public.sources" in lowered
+    assert "public.claim_evidence" in lowered
+    assert "public.claim_edges" in lowered
+    assert "kb_stage.kb_proposals" in lowered
+    assert "grant select on" in lowered
+    assert "grant insert" not in lowered
+    assert "grant update" not in lowered
+    assert "grant delete" not in lowered
+    assert "effective_table_writes_denied" in lowered
+
+
+def test_container_runs_as_non_root_and_contains_no_password_contract() -> None:
+    dockerfile = (ROOT / "Dockerfile.observatory-read-adapter").read_text(encoding="utf-8")
+
+    assert "USER 10001:10001" in dockerfile
+    assert "PGPASSWORD" not in dockerfile
+    assert "DB_PASS" not in dockerfile

tests/test_observatory_read_role_postgres.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import time
+import uuid
+from pathlib import Path
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+ROLE_SQL = ROOT / "ops" / "observatory_read_role.sql"
+POSTGRES_IMAGE = "postgres:16-alpine"
+DATABASE = "teleo_canonical"
+IAM_USER = "sa-observatory-read-adapter@teleo-501523.iam"
+TEST_PASSWORD = "generated-test-only-password"
+
+BOOTSTRAP_SQL = f"""
+begin;
+create schema kb_stage;
+create role "{IAM_USER}" login inherit password '{TEST_PASSWORD}';
+create table public.claims (id uuid primary key);
+create table public.sources (id uuid primary key);
+create table public.claim_evidence (id uuid primary key);
+create table public.claim_edges (id uuid primary key);
+create table public.private_notes (id uuid primary key);
+create table kb_stage.kb_proposals (id uuid primary key);
+insert into public.claims values ('11111111-1111-1111-1111-111111111111');
+commit;
+"""
+
+
+def run(command: list[str], *, input_text: str | None = None, check: bool = True) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        command,
+        input=input_text,
+        text=True,
+        capture_output=True,
+        check=check,
+        timeout=30,
+    )
+
+
+@pytest.mark.skipif(shutil.which("docker") is None, reason="Docker is required")
+def test_observatory_role_is_read_only_and_exactly_allowlisted() -> None:
+    container = f"teleo-observatory-role-{uuid.uuid4().hex[:10]}"
+    run(
+        [
+            "docker",
+            "run",
+            "--detach",
+            "--rm",
+            "--name",
+            container,
+            "--env",
+            f"POSTGRES_PASSWORD={TEST_PASSWORD}",
+            "--env",
+            f"POSTGRES_DB={DATABASE}",
+            POSTGRES_IMAGE,
+        ]
+    )
+    try:
+        deadline = time.monotonic() + 25
+        while time.monotonic() < deadline:
+            ready = run(
+                ["docker", "exec", container, "pg_isready", "-U", "postgres", "-d", DATABASE],
+                check=False,
+            )
+            if ready.returncode == 0:
+                break
+            time.sleep(0.25)
+        else:
+            raise AssertionError("ephemeral Postgres did not become ready")
+
+        bootstrap: subprocess.CompletedProcess[str] | None = None
+        deadline = time.monotonic() + 15
+        while time.monotonic() < deadline:
+            bootstrap = run(
+                [
+                    "docker",
+                    "exec",
+                    "-i",
+                    container,
+                    "psql",
+                    "--set",
+                    "ON_ERROR_STOP=1",
+                    "-U",
+                    "postgres",
+                    "-d",
+                    DATABASE,
+                ],
+                input_text=BOOTSTRAP_SQL,
+                check=False,
+            )
+            if bootstrap.returncode == 0:
+                break
+            time.sleep(0.25)
+        else:
+            assert bootstrap is not None
+            raise AssertionError(f"ephemeral Postgres bootstrap failed: {bootstrap.stderr[-1000:]}")
+        migration = run(
+            [
+                "docker",
+                "exec",
+                "-e",
+                f"OBSERVATORY_DB_IAM_USER={IAM_USER}",
+                "-i",
+                container,
+                "psql",
+                "-U",
+                "postgres",
+                "-d",
+                DATABASE,
+            ],
+            input_text=ROLE_SQL.read_text(encoding="utf-8"),
+        )
+        assert '"effective_table_writes_denied": true' in migration.stdout
+
+        readback = run(
+            [
+                "docker",
+                "exec",
+                "-e",
+                f"PGPASSWORD={TEST_PASSWORD}",
+                container,
+                "psql",
+                "-h",
+                "127.0.0.1",
+                "-U",
+                IAM_USER,
+                "-d",
+                DATABASE,
+                "-At",
+                "-c",
+                "show default_transaction_read_only; select count(*) from public.claims;",
+            ]
+        )
+        assert readback.stdout.splitlines() == ["on", "1"]
+
+        write_attempt = run(
+            [
+                "docker",
+                "exec",
+                "-e",
+                f"PGPASSWORD={TEST_PASSWORD}",
+                container,
+                "psql",
+                "-h",
+                "127.0.0.1",
+                "-U",
+                IAM_USER,
+                "-d",
+                DATABASE,
+                "-c",
+                "insert into public.claims values ('22222222-2222-2222-2222-222222222222');",
+            ],
+            check=False,
+        )
+        assert write_attempt.returncode != 0
+
+        outside_allowlist = run(
+            [
+                "docker",
+                "exec",
+                "-e",
+                f"PGPASSWORD={TEST_PASSWORD}",
+                container,
+                "psql",
+                "-h",
+                "127.0.0.1",
+                "-U",
+                IAM_USER,
+                "-d",
+                DATABASE,
+                "-c",
+                "select * from public.private_notes;",
+            ],
+            check=False,
+        )
+        assert outside_allowlist.returncode != 0
+    finally:
+        run(["docker", "rm", "--force", container], check=False)

tests/test_prepare_kb_source_manifest.py

@@ -123,11 +123,17 @@ def test_prepare_builds_private_compiler_validated_manifest_without_db_write(
     assert manifest["dedupe"]["duplicates"][0]["claim_id"] == CANDIDATE_ID
     assert manifest["claims"][0]["quote"] == CLAIM_QUOTE
     assert manifest["dedupe"]["duplicates"][0]["source_quote"] == DUPLICATE_QUOTE
-    assert receipt["extraction"]["selected_source_references"] == [
+    selected = receipt["extraction"]["selected_source_references"]
-        {"kind": "claim", "reference": "S00003"},
+    assert [(row["kind"], row["reference"]) for row in selected] == [
-        {"kind": "evidence", "reference": "S00003"},
+        ("claim", "S00003"),
-        {"kind": "duplicate", "reference": "S00002"},
+        ("evidence", "S00003"),
+        ("duplicate", "S00002"),
     ]
+    assert all(row["char_end"] > row["char_start"] for row in selected)
+    assert all(len(row["quote_sha256"]) == 64 for row in selected)
+    assert receipt["replay"]["exact_selected_locations_validated"] is True
+    assert receipt["extraction"]["evidence_count"] == 1
+    assert receipt["extraction"]["duplicate_judgment_count"] == 1
     assert stat.S_IMODE(output_dir.stat().st_mode) == 0o700
     for path in output_dir.iterdir():
         assert stat.S_IMODE(path.stat().st_mode) == 0o600
@@ -173,6 +179,63 @@ def test_source_fragment_ids_are_dense_across_blank_lines() -> None:
     assert fragments == {"S00001": "first", "S00002": "second"}
 
 
+def test_source_fragment_index_trims_indentation_but_preserves_exact_offsets() -> None:
+    text = "  indented Unicode: \u201creviewed\u201d  \nnext\n"
+
+    fragments, locations = preparer.build_source_fragment_index(text)
+
+    assert fragments["S00001"] == "indented Unicode: \u201creviewed\u201d"
+    selected = locations["S00001"]
+    assert selected["line"] == 1
+    assert text[selected["char_start"] : selected["char_end"]] == fragments["S00001"]
+
+
+def test_bundle_location_validation_rejects_ambiguous_rebound() -> None:
+    text = "same line\nsame line\n"
+    fragments, locations = preparer.build_source_fragment_index(text)
+    extraction = preparer.resolve_model_output(
+        {
+            "claims": [
+                {
+                    "claim_key": "second_occurrence",
+                    "type": "structural",
+                    "text": "The second occurrence was selected.",
+                    "quote_ref": "S00002",
+                    "confidence": 0.5,
+                    "tags": [],
+                    "evidence": [{"quote_ref": "S00002", "role": "grounds"}],
+                }
+            ],
+            "duplicates": [],
+            "extraction_notes": "Select the second repeated line.",
+        },
+        fragments,
+        locations,
+    )
+    fake_bundle = {
+        "quote_bindings": [
+            {
+                "kind": "claim",
+                "claim_key": "second_occurrence",
+                "quote": "same line",
+                "first_start": 0,
+                "first_end": 9,
+            },
+            {
+                "kind": "evidence",
+                "claim_key": "second_occurrence",
+                "evidence_role": "grounds",
+                "quote": "same line",
+                "first_start": 0,
+                "first_end": 9,
+            },
+        ]
+    }
+
+    with pytest.raises(preparer.PreparationError, match="ambiguous repeated quote"):
+        preparer.validate_bundle_source_locations(fake_bundle, extraction["selected_source_references"])
+
+
 def test_prepare_returns_no_novel_claims_without_manifest_or_stageable_packet(
     tmp_path: Path, monkeypatch: pytest.MonkeyPatch
 ) -> None:
@@ -195,6 +258,13 @@ def test_binary_artifact_requires_explicit_utf8_extraction(tmp_path: Path) -> No
         preparer.extract_utf8_text(artifact, None)
 
 
+def test_repo_native_jsonl_transcript_is_accepted_as_strict_utf8(tmp_path: Path) -> None:
+    artifact = tmp_path / "telegram.jsonl"
+    artifact.write_text('{"chat_id":1,"message_id":2,"message":"hello"}\n', encoding="utf-8")
+
+    assert preparer.extract_utf8_text(artifact, None) == artifact.read_bytes()
+
+
 def test_openrouter_key_cannot_be_redirected_to_an_unapproved_endpoint(tmp_path: Path) -> None:
     with pytest.raises(preparer.PreparationError, match=r"must equal https://openrouter\.ai"):
         preparer.call_openrouter(

tests/test_run_approve_claim_clone_canary.py

@@ -13,6 +13,11 @@ sys.path.insert(0, str(ROOT / "scripts"))
 import run_approve_claim_clone_canary as canary  # noqa: E402
 
 
+def test_unrelated_fingerprint_orders_legacy_claim_evidence_by_composite_key() -> None:
+    assert canary.CLAIM_EVIDENCE_FINGERPRINT_ORDER == ("ce.claim_id::text, ce.source_id::text, ce.role::text")
+    assert "ce.id" not in canary.CLAIM_EVIDENCE_FINGERPRINT_ORDER
+
+
 def _passing_result(expected_rows: dict, expected_deltas: dict) -> dict:
     proposal_id = "aaaaaaaa-aaaa-4aaa-8aaa-aaaaaaaaaaaa"
     return {

tests/test_run_approve_claim_clone_canary_macos_path.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+import hashlib
+import json
 import subprocess
 import sys
 from pathlib import Path
@@ -11,8 +13,10 @@ import pytest
 ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT / "scripts"))
 WRAPPER = ROOT / "scripts" / "run_approve_claim_isolated_container_canary.sh"
+FINALIZER = ROOT / "scripts" / "finalize_approve_claim_isolated_canary.py"
 
 import apply_proposal as apply  # noqa: E402
+import finalize_approve_claim_isolated_canary as finalizer  # noqa: E402
 import run_approve_claim_clone_canary as canary  # noqa: E402
 
 
@@ -24,9 +28,7 @@ def test_role_psql_resolves_docker_before_scrubbing_path(
     monkeypatch.setattr(
         canary.shutil,
         "which",
-        lambda executable: "/opt/homebrew/bin/docker"
+        lambda executable: "/opt/homebrew/bin/docker" if executable == "docker" else None,
-        if executable == "docker"
-        else None,
     )
 
     def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
@@ -58,9 +60,7 @@ def test_apply_tool_resolves_docker_before_scrubbing_path(
     monkeypatch.setattr(
         apply.shutil,
         "which",
-        lambda executable: "/opt/homebrew/bin/docker"
+        lambda executable: "/opt/homebrew/bin/docker" if executable == "docker" else None,
-        if executable == "docker"
-        else None,
     )
 
     def fake_run(command: list[str], **kwargs: object) -> subprocess.CompletedProcess[str]:
@@ -89,14 +89,76 @@ def test_apply_tool_resolves_docker_before_scrubbing_path(
 
 
 def test_outer_wrapper_enforces_local_source_and_networkless_tmpfs() -> None:
-    text = WRAPPER.read_text(encoding="utf-8")
+    wrapper = WRAPPER.read_text(encoding="utf-8")
+    finalizer = FINALIZER.read_text(encoding="utf-8")
+    text = wrapper + "\n" + finalizer
 
     assert 'source_canary_label" != "working-leo-approved-source"' in text
     assert "--network none" in text
     assert "--tmpfs /var/lib/postgresql/data:rw,nosuid,size=512m" in text
     assert 'CANARY_NETWORK_MODE="$container_network_mode"' in text
     assert 'CANARY_MOUNTS_JSON="$container_mounts_json"' in text
-    assert 'data["checks"]["outer_source_tier_enforced"]' in text
+    assert 'checks["outer_source_tier_enforced"]' in text
-    assert 'data["checks"]["outer_container_network_disabled"]' in text
+    assert 'checks["outer_container_network_disabled"]' in text
-    assert 'data["checks"]["outer_container_has_no_docker_volumes"]' in text
+    assert 'checks["outer_container_has_no_docker_volumes"]' in text
     assert 'source_tier != "live-readonly" or service_observable' in text
+    assert "<<'PY'" not in wrapper
+    assert "finalize_approve_claim_isolated_canary.py" in wrapper
+
+
+def test_outer_finalizer_runs_from_a_normal_file_without_heredoc(tmp_path: Path) -> None:
+    content = FINALIZER.read_bytes()
+    report = tmp_path / "canary.json"
+    report.write_text(
+        json.dumps(
+            {
+                "status": "pass",
+                "checks": {},
+                "source_binding": {
+                    "unchanged_during_run": True,
+                    "files": [
+                        {
+                            "repo_relative_path": FINALIZER.relative_to(ROOT).as_posix(),
+                            "sha256": hashlib.sha256(content).hexdigest(),
+                            "size_bytes": len(content),
+                        }
+                    ],
+                },
+            }
+        ),
+        encoding="utf-8",
+    )
+    counts = json.dumps({"public.claims": 2, "kb_stage.kb_proposals": 0})
+    data = finalizer.finalize(
+        report,
+        {
+            "SOURCE_COUNTS_BEFORE": counts,
+            "SOURCE_COUNTS_AFTER": counts,
+            "SOURCE_CONTAINER": "isolated-source",
+            "SOURCE_DB": "teleo",
+            "SERVICE_BEFORE": "Available=false\nReason=systemctl_unavailable\n",
+            "SERVICE_AFTER": "Available=false\nReason=systemctl_unavailable\n",
+            "REPO_ROOT": str(ROOT),
+            "OUTER_CONTAINER_REMOVE_RC": "0",
+            "OUTER_WORKDIR_REMOVE_RC": "0",
+            "CONTAINER_NAME_READBACK": "",
+            "CONTAINER_NAME_READBACK_RC": "0",
+            "CONTAINER_LABEL_READBACK": "",
+            "CONTAINER_LABEL_READBACK_RC": "0",
+            "CONTAINER_LABEL_ORPHAN_COUNT": "0",
+            "OUTER_WORKDIR_LEXISTS": "false",
+            "CANARY_RC": "0",
+            "SOURCE_TIER": "isolated-local",
+            "SOURCE_NETWORK_MODE": "none",
+            "SOURCE_CANARY_LABEL": "working-leo-approved-source",
+            "CANARY_NETWORK_MODE": "none",
+            "CANARY_MOUNTS_JSON": "[]",
+            "CANARY_LABEL": "proposal-apply-lifecycle",
+            "CANARY_INSTANCE_LABEL": "working-leo-approve-claim-test",
+        },
+    )
+
+    assert data["status"] == "pass"
+    assert data["current_tier"] == "T2_runtime"
+    assert data["checks"]["outer_isolation_complete"] is True
+    assert data["outer_isolation"]["cleanup_readback"]["label_scoped_orphan_count"] == 0

tests/test_run_leo_local_ingestion_proposal_canary.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import copy
+import hashlib
 import json
 import sys
 from pathlib import Path
@@ -13,90 +14,420 @@ sys.path.insert(0, str(REPO_ROOT / "scripts"))
 import run_leo_local_ingestion_proposal_canary as canary  # noqa: E402
 
 
-def _loaded() -> tuple[dict, dict, dict]:
+def _loaded(path: Path) -> tuple[dict, dict, dict, dict, dict]:
-    fixture, input_receipt = canary.load_fixture(canary.DEFAULT_FIXTURE)
+    fixture, input_receipt = canary.load_fixture(path)
-    row_ids = canary.build_row_ids(input_receipt["artifact_sha256"])
+    row_ids = canary.build_row_ids(input_receipt, fixture)
-    return fixture, input_receipt, row_ids
-
-
-def test_fixture_is_realistic_hash_bound_and_exactly_evidenced() -> None:
-    fixture, input_receipt, row_ids = _loaded()
-
-    assert fixture["extraction"]["evidence"]["body"] in fixture["source"]["body"]
-    assert len(input_receipt["artifact_sha256"]) == 64
-    assert len(input_receipt["source_content_sha256"]) == 64
-    assert input_receipt["artifact_sha256"] != input_receipt["source_content_sha256"]
-    assert len(set(row_ids.values())) == 4
-
-
-def test_fixture_validation_fails_closed_when_evidence_is_not_in_source(tmp_path: Path) -> None:
-    fixture = json.loads(canary.DEFAULT_FIXTURE.read_text(encoding="utf-8"))
-    fixture["extraction"]["evidence"]["body"] = "invented evidence"
-    path = tmp_path / "bad-fixture.json"
-    path.write_text(json.dumps(fixture), encoding="utf-8")
-
-    with pytest.raises(canary.CanaryError, match="exact substring"):
-        canary.load_fixture(path)
-
-
-def test_fixture_validation_fails_closed_when_claim_body_is_not_in_source(
-    tmp_path: Path,
-) -> None:
-    fixture = json.loads(canary.DEFAULT_FIXTURE.read_text(encoding="utf-8"))
-    fixture["extraction"]["claim"]["body"] = "invented claim body"
-    path = tmp_path / "bad-claim-fixture.json"
-    path.write_text(json.dumps(fixture), encoding="utf-8")
-
-    with pytest.raises(canary.CanaryError, match="claim body must be an exact substring"):
-        canary.load_fixture(path)
-
-
-def test_capture_sql_escapes_quotes_and_backslashes_from_fixture(
-    tmp_path: Path,
-) -> None:
-    fixture = json.loads(canary.DEFAULT_FIXTURE.read_text(encoding="utf-8"))
-    fixture["source"]["title"] = "O'Brien\\review"
-    fixture["source"]["metadata"]["note"] = "quoted ' value \\ path"
-    path = tmp_path / "quoted-fixture.json"
-    path.write_text(json.dumps(fixture), encoding="utf-8")
-    loaded, input_receipt = canary.load_fixture(path)
-    row_ids = canary.build_row_ids(input_receipt["artifact_sha256"])
-
-    sql = canary.build_capture_sql(loaded, input_receipt, row_ids)
-
-    assert canary.ap.sql_literal(fixture["source"]["title"]) in sql
-    assert canary.ap.sql_literal(
-        json.dumps(fixture["source"]["metadata"], sort_keys=True)
-    ) in sql
-
-
-def test_parent_normalizes_to_hash_bound_pending_proposal_with_embedded_row_links() -> None:
-    fixture, input_receipt, row_ids = _loaded()
     parent = canary.build_parent_packet(fixture, input_receipt, row_ids)
     child = canary.normalized_stage.prepare_normalized_child(parent)
-    payload = child["payload"]["apply_payload"]
+    return fixture, input_receipt, row_ids, parent, child
-
-    assert child["status"] == "pending_review"
-    assert child["proposal_type"] == "approve_claim"
-    assert len(payload["claims"]) == 1
-    assert len(payload["sources"]) == 2
-    assert len(payload["evidence"]) == 2
-    assert input_receipt["source_content_sha256"] in {row["hash"] for row in payload["sources"]}
-    excerpts = "\n".join(row["excerpt"] for row in payload["sources"])
-    assert input_receipt["artifact_sha256"] in excerpts
-    assert row_ids["source_capture_id"] in excerpts
-    assert row_ids["claim_extraction_id"] in excerpts
-    assert row_ids["evidence_extraction_id"] in excerpts
 
 
-def test_capture_and_stage_sql_never_mutate_canonical_public_tables() -> None:
+def _copy_scenario(tmp_path: Path, scenario_path: Path) -> Path:
-    fixture, input_receipt, row_ids = _loaded()
+    scenario = json.loads(scenario_path.read_text(encoding="utf-8"))
-    child = canary.normalized_stage.prepare_normalized_child(
+    artifact_source = scenario_path.parent / scenario["artifact"]["path"]
-        canary.build_parent_packet(fixture, input_receipt, row_ids)
+    artifact_target = tmp_path / artifact_source.name
+    artifact_target.write_bytes(artifact_source.read_bytes())
+    scenario_target = tmp_path / scenario_path.name
+    scenario_target.write_text(json.dumps(scenario), encoding="utf-8")
+    return scenario_target
+
+
+def _canonical_snapshot() -> dict:
+    return {
+        "claims": [{"id": "1"}],
+        "sources": [{"id": "2"}],
+        "claim_evidence": [{"claim_id": "1"}],
+        "claim_edges": [{"from_claim": "1"}],
+    }
+
+
+def _row_id_values(row_ids: dict) -> set[str]:
+    values: set[str] = set()
+    for value in row_ids.values():
+        if isinstance(value, dict):
+            values.update(_row_id_values(value))
+        else:
+            values.add(value)
+    return values
+
+
+def _planned_uuid_values(child: dict) -> set[str]:
+    apply_payload = child["payload"]["apply_payload"]
+    values = {child["id"]}
+    for row in apply_payload["claims"] + apply_payload["sources"]:
+        values.add(row["id"])
+    for row in apply_payload["evidence"]:
+        values.update((row["claim_id"], row["source_id"]))
+    for row in apply_payload["edges"]:
+        values.update((row["from_claim"], row["to_claim"]))
+    return values
+
+
+def _synthetic_readback(fixture: dict, input_receipt: dict, row_ids: dict, child: dict) -> dict:
+    claim_rows = []
+    evidence_rows = []
+    segment_by_id = {segment["id"]: segment for segment in fixture["segments"]}
+    for claim in fixture["extraction"]["claims"]:
+        claim_id = row_ids["claim_extraction_ids"][claim["claim_key"]]
+        claim_rows.append(
+            {
+                "id": claim_id,
+                "source_capture_id": row_ids["source_capture_id"],
+                "claim_key": claim["claim_key"],
+                "body": claim["body"],
+                "metadata": {
+                    **claim["metadata"],
+                    "claim_type": claim["type"],
+                    "confidence": claim["confidence"],
+                    "text": claim["text"],
+                    "extractor": input_receipt["extractor"],
+                    "replay_identity_sha256": input_receipt["replay_identity_sha256"],
+                },
+            }
         )
+        for index, evidence in enumerate(claim["evidence"]):
+            segment = segment_by_id[evidence["segment_id"]]
+            evidence_rows.append(
+                {
+                    "id": row_ids["evidence_extraction_ids"][f"{claim['claim_key']}:{index}"],
+                    "claim_extraction_id": claim_id,
+                    "source_capture_id": row_ids["source_capture_id"],
+                    "source_segment_id": segment["id"],
+                    "source_locator": segment["locator"],
+                    "source_json_pointer": segment["json_pointer"],
+                    "role": evidence["role"],
+                    "source_content_sha256": segment["content_sha256"],
+                    "body": evidence["excerpt"],
+                    "body_sha256": canary.sha256_bytes(evidence["excerpt"].encode()),
+                    "metadata": {
+                        **evidence.get("metadata", {}),
+                        "source_text_sha256": segment["text_sha256"],
+                    },
+                }
+            )
+    duplicate_rows = []
+    for index, duplicate in enumerate(fixture["extraction"]["duplicates"]):
+        duplicate_rows.append(
+            {
+                "id": row_ids["duplicate_assessment_ids"][str(index)],
+                "source_capture_id": row_ids["source_capture_id"],
+                "source_segment_id": duplicate["segment_id"],
+                "source_locator": duplicate["source_locator"],
+                "duplicate_of_claim_key": duplicate["duplicate_of_claim_key"],
+                "excerpt": duplicate["excerpt"],
+                "excerpt_sha256": canary.sha256_bytes(duplicate["excerpt"].encode()),
+                "reason": duplicate["reason"],
+                "metadata": {
+                    "json_pointer": duplicate["source_json_pointer"],
+                    "source_content_sha256": duplicate["source_content_sha256"],
+                    "source_text_sha256": duplicate["source_text_sha256"],
+                },
+            }
+        )
+    conflict_rows = []
+    for index, conflict in enumerate(fixture["extraction"]["conflicts"]):
+        conflict_rows.append(
+            {
+                "id": row_ids["conflict_assessment_ids"][str(index)],
+                "source_capture_id": row_ids["source_capture_id"],
+                "from_claim_key": conflict["from_claim_key"],
+                "to_claim_key": conflict["to_claim_key"],
+                "relationship": conflict["relationship"],
+                "metadata": {
+                    key: value
+                    for key, value in conflict.items()
+                    if key not in {"from_claim_key", "to_claim_key", "relationship"}
+                },
+            }
+        )
+    proposal = {
+        **child,
+        "reviewed_by_handle": None,
+        "reviewed_at": None,
+        "applied_by_handle": None,
+        "applied_at": None,
+    }
+    counts = input_receipt["counts"]
+    return {
+        "source_captures": [
+            {
+                "id": row_ids["source_capture_id"],
+                "source_identity": fixture["source"]["identity"],
+                "source_type": fixture["source"]["source_type"],
+                "title": fixture["source"]["title"],
+                "locator": fixture["source"]["locator"],
+                "artifact_path": input_receipt["artifact_path"],
+                "artifact_sha256": input_receipt["artifact_sha256"],
+                "content_sha256": input_receipt["source_content_sha256"],
+                "replay_identity_sha256": input_receipt["replay_identity_sha256"],
+                "metadata": {**fixture["source"]["metadata"], "extractor": input_receipt["extractor"]},
+            }
+        ],
+        "claim_extractions": claim_rows,
+        "evidence_extractions": evidence_rows,
+        "duplicate_assessments": duplicate_rows,
+        "conflict_assessments": conflict_rows,
+        "staged_proposal": proposal,
+        "counts": {
+            "source_captures": 1,
+            "claim_extractions": counts["claim_candidates"],
+            "evidence_extractions": counts["evidence_candidates"],
+            "duplicate_assessments": counts["duplicate_judgments"],
+            "conflict_assessments": counts["conflict_relationships"],
+            "staged_proposals": 1,
+        },
+    }
+
+
+@pytest.mark.parametrize("scenario_path", canary.DEFAULT_FIXTURES)
+def test_source_artifact_is_separate_hash_bound_and_replayable(scenario_path: Path) -> None:
+    fixture, input_receipt, row_ids, parent, child = _loaded(scenario_path)
+    artifact_path = Path(input_receipt["artifact_path"])
+
+    assert input_receipt["artifact_sha256"] == hashlib.sha256(artifact_path.read_bytes()).hexdigest()
+    assert input_receipt["artifact_sha256"] != input_receipt["scenario_sha256"]
+    assert len(input_receipt["replay_identity_sha256"]) == 64
+    assert row_ids == canary.build_row_ids(input_receipt, fixture)
+    ingestion = child["payload"]["apply_payload"]["normalization_manifest"]["ingestion_manifest"]
+    assert ingestion["artifact_sha256"] == input_receipt["artifact_sha256"]
+    assert ingestion["extractor"] == input_receipt["extractor"]
+    assert ingestion["replay_identity_sha256"] == input_receipt["replay_identity_sha256"]
+    assert ingestion["row_ids"] == row_ids
+    assert parent["status"] == child["status"] == "pending_review"
+
+
+def test_document_and_telegram_candidate_accounting_is_exact() -> None:
+    _doc, doc_input, _doc_ids, _doc_parent, doc_child = _loaded(canary.DEFAULT_DOCUMENT_FIXTURE)
+    telegram, telegram_input, _telegram_ids, _telegram_parent, telegram_child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+
+    assert doc_input["counts"] == {
+        "source_segments": 3,
+        "claim_candidates": 1,
+        "evidence_candidates": 1,
+        "duplicate_judgments": 0,
+        "conflict_relationships": 0,
+    }
+    assert telegram_input["counts"] == {
+        "source_segments": 3,
+        "claim_candidates": 2,
+        "evidence_candidates": 3,
+        "duplicate_judgments": 1,
+        "conflict_relationships": 1,
+    }
+    doc_payload = doc_child["payload"]["apply_payload"]
+    telegram_payload = telegram_child["payload"]["apply_payload"]
+    assert {key: len(doc_payload[key]) for key in ("claims", "sources", "evidence", "edges")} == {
+        "claims": 1,
+        "sources": 2,
+        "evidence": 2,
+        "edges": 0,
+    }
+    assert {key: len(telegram_payload[key]) for key in ("claims", "sources", "evidence", "edges")} == {
+        "claims": 2,
+        "sources": 5,
+        "evidence": 5,
+        "edges": 1,
+    }
+    assessment = telegram_payload["normalization_manifest"]["dedupe_conflict_assessment"]
+    assert assessment["duplicates"] == telegram["extraction"]["duplicates"]
+    assert assessment["conflicts"] == telegram["extraction"]["conflicts"]
+    assert telegram_payload["edges"][0]["edge_type"] == "contradicts"
+
+
+def test_telegram_duplicate_text_keeps_distinct_exact_message_provenance() -> None:
+    fixture, _input, _row_ids, _parent, _child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+    first, _second, repeated = fixture["segments"]
+
+    assert first["body"] == repeated["body"]
+    assert first["text_sha256"] == repeated["text_sha256"]
+    assert first["content_sha256"] != repeated["content_sha256"]
+    assert first["locator"] == "telegram://chat/900001/message/7301"
+    assert repeated["locator"] == "telegram://chat/900001/message/7303"
+    duplicate = fixture["extraction"]["duplicates"][0]
+    assert duplicate["source_locator"] == repeated["locator"]
+    assert duplicate["source_json_pointer"] == "jsonl://line/3/message"
+
+
+def test_fixture_validation_fails_closed_on_invented_evidence(tmp_path: Path) -> None:
+    scenario_path = _copy_scenario(tmp_path, canary.DEFAULT_TELEGRAM_FIXTURE)
+    scenario = json.loads(scenario_path.read_text(encoding="utf-8"))
+    scenario["extraction"]["claims"][0]["evidence"][0]["excerpt"] = "invented evidence"
+    scenario_path.write_text(json.dumps(scenario), encoding="utf-8")
+
+    with pytest.raises(canary.CanaryError, match="not an exact segment substring"):
+        canary.load_fixture(scenario_path)
+
+
+def test_fixture_artifact_path_cannot_escape_scenario_directory(tmp_path: Path) -> None:
+    scenario = json.loads(canary.DEFAULT_DOCUMENT_FIXTURE.read_text(encoding="utf-8"))
+    scenario["artifact"]["path"] = "../outside.txt"
+    path = tmp_path / "scenario.json"
+    path.write_text(json.dumps(scenario), encoding="utf-8")
+
+    with pytest.raises(canary.CanaryError, match="remain inside"):
+        canary.load_fixture(path)
+
+
+def test_capture_sql_escapes_quotes_and_backslashes(tmp_path: Path) -> None:
+    scenario_path = _copy_scenario(tmp_path, canary.DEFAULT_DOCUMENT_FIXTURE)
+    scenario = json.loads(scenario_path.read_text(encoding="utf-8"))
+    scenario["source"]["title"] = "O'Brien\\review"
+    scenario["source"]["metadata"]["note"] = "quoted ' value \\ path"
+    scenario_path.write_text(json.dumps(scenario), encoding="utf-8")
+    fixture, input_receipt, row_ids, _parent, _child = _loaded(scenario_path)
+
+    sql = canary.build_capture_sql(fixture, input_receipt, row_ids)
+
+    assert canary.ap.sql_literal(scenario["source"]["title"]) in sql
+    expected_metadata = {
+        **scenario["source"]["metadata"],
+        "extractor": input_receipt["extractor"],
+    }
+    assert canary.ap.sql_literal(json.dumps(expected_metadata, sort_keys=True)) in sql
+
+
+def test_replay_identity_and_ids_change_with_extractor_version(tmp_path: Path) -> None:
+    scenario_path = _copy_scenario(tmp_path, canary.DEFAULT_DOCUMENT_FIXTURE)
+    fixture, original, original_ids, _parent, original_child = _loaded(scenario_path)
+    scenario = json.loads(scenario_path.read_text(encoding="utf-8"))
+    scenario["extractor"]["version"] = "3"
+    scenario_path.write_text(json.dumps(scenario), encoding="utf-8")
+    changed_fixture, changed, changed_ids, _changed_parent, changed_child = _loaded(scenario_path)
+
+    assert original["artifact_sha256"] == changed["artifact_sha256"]
+    assert original["replay_identity_sha256"] != changed["replay_identity_sha256"]
+    assert original_ids["source_capture_id"] != changed_ids["source_capture_id"]
+    assert original_ids["claim_extraction_ids"] != changed_ids["claim_extraction_ids"]
+    assert original_ids["parent_proposal_id"] != changed_ids["parent_proposal_id"]
+    assert original_child["payload_sha256"] != changed_child["payload_sha256"]
+    assert fixture["segments"] == changed_fixture["segments"]
+
+
+@pytest.mark.parametrize(
+    ("source_field", "replacement"),
+    (
+        ("identity", "document:mutated-exact-source-identity"),
+        ("locator", "fixture://working-leo/mutated-exact-source-locator"),
+    ),
+)
+def test_replay_identity_and_every_row_id_bind_exact_source_identity(
+    tmp_path: Path, source_field: str, replacement: str
+) -> None:
+    scenario_path = _copy_scenario(tmp_path, canary.DEFAULT_DOCUMENT_FIXTURE)
+    fixture, before, before_ids, _parent, before_child = _loaded(scenario_path)
+    scenario = json.loads(scenario_path.read_text(encoding="utf-8"))
+    scenario["source"][source_field] = replacement
+    scenario_path.write_text(json.dumps(scenario), encoding="utf-8")
+
+    changed_fixture, after, after_ids, _changed_parent, after_child = _loaded(scenario_path)
+
+    assert before["artifact_sha256"] == after["artifact_sha256"]
+    assert before["extraction_spec_sha256"] == after["extraction_spec_sha256"]
+    assert before["replay_identity_sha256"] != after["replay_identity_sha256"]
+    assert _row_id_values(before_ids).isdisjoint(_row_id_values(after_ids))
+    assert _planned_uuid_values(before_child).isdisjoint(_planned_uuid_values(after_child))
+    assert fixture["source"][source_field] != changed_fixture["source"][source_field]
+
+
+@pytest.mark.parametrize(
+    ("segment_field", "replacement"),
+    (
+        ("id", "message-900001-mutated"),
+        ("locator", "telegram://chat/900001/message/999999"),
+        ("json_pointer", "jsonl://line/999/message"),
+        ("content_sha256", "a" * 64),
+        ("text_sha256", "b" * 64),
+    ),
+)
+def test_replay_identity_and_every_row_id_bind_complete_normalized_segment(
+    segment_field: str, replacement: str
+) -> None:
+    fixture, before, before_ids, _parent, before_child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+    changed_fixture = copy.deepcopy(fixture)
+    after = copy.deepcopy(before)
+    segment = changed_fixture["segments"][-1]
+    original_id = segment["id"]
+    segment[segment_field] = replacement
+    for claim in changed_fixture["extraction"]["claims"]:
+        for evidence in claim["evidence"]:
+            if evidence["segment_id"] == original_id:
+                evidence["segment_id"] = segment["id"]
+                evidence["source_locator"] = segment["locator"]
+                evidence["source_json_pointer"] = segment["json_pointer"]
+                evidence["source_content_sha256"] = segment["content_sha256"]
+                evidence["source_text_sha256"] = segment["text_sha256"]
+    for duplicate in changed_fixture["extraction"]["duplicates"]:
+        if duplicate["segment_id"] == original_id:
+            duplicate["segment_id"] = segment["id"]
+            duplicate["source_locator"] = segment["locator"]
+            duplicate["source_json_pointer"] = segment["json_pointer"]
+            duplicate["source_content_sha256"] = segment["content_sha256"]
+            duplicate["source_text_sha256"] = segment["text_sha256"]
+    after["source_content_sha256"] = canary.canonical_sha256(
+        canary.normalized_segment_manifest(changed_fixture["segments"])
+    )
+    after["replay_identity_components"] = canary.replay_identity_payload(
+        artifact_sha256=after["artifact_sha256"],
+        artifact_format=after["artifact_format"],
+        source_identity=after["source_identity"],
+        source_locator=after["source_locator"],
+        normalized_segments_sha256=after["source_content_sha256"],
+        extractor=after["extractor"],
+        extraction_spec_sha256=after["extraction_spec_sha256"],
+    )
+    after["replay_identity_sha256"] = canary.canonical_sha256(after["replay_identity_components"])
+    after_ids = canary.build_row_ids(after, changed_fixture)
+    after_parent = canary.build_parent_packet(changed_fixture, after, after_ids)
+    after_child = canary.normalized_stage.prepare_normalized_child(after_parent)
+
+    assert before["artifact_sha256"] == after["artifact_sha256"]
+    assert before["scenario_sha256"] == after["scenario_sha256"]
+    assert before["extraction_spec_sha256"] == after["extraction_spec_sha256"]
+    assert before["replay_identity_sha256"] != after["replay_identity_sha256"]
+    assert _row_id_values(before_ids).isdisjoint(_row_id_values(after_ids))
+    assert _planned_uuid_values(before_child).isdisjoint(_planned_uuid_values(after_child))
+
+
+def test_source_byte_tamper_changes_hashes_and_replay_ids(tmp_path: Path) -> None:
+    scenario_path = _copy_scenario(tmp_path, canary.DEFAULT_DOCUMENT_FIXTURE)
+    fixture, before, before_ids, _parent, _child = _loaded(scenario_path)
+    artifact_path = Path(before["artifact_path"])
+    artifact_path.write_text(
+        artifact_path.read_text(encoding="utf-8") + "\n\nA new source paragraph.", encoding="utf-8"
+    )
+    changed_fixture, after, after_ids, _changed_parent, _changed_child = _loaded(scenario_path)
+
+    assert before["artifact_sha256"] != after["artifact_sha256"]
+    assert before["source_content_sha256"] != after["source_content_sha256"]
+    assert before["replay_identity_sha256"] != after["replay_identity_sha256"]
+    assert before_ids["source_capture_id"] != after_ids["source_capture_id"]
+    assert before_ids["claim_extraction_ids"] != after_ids["claim_extraction_ids"]
+    assert len(changed_fixture["segments"]) == len(fixture["segments"]) + 1
+
+
+def test_replay_properties_hold_across_many_version_labels(tmp_path: Path) -> None:
+    scenario_path = _copy_scenario(tmp_path, canary.DEFAULT_DOCUMENT_FIXTURE)
+    base = json.loads(scenario_path.read_text(encoding="utf-8"))
+    observed: set[str] = set()
+    for index in range(40):
+        scenario = copy.deepcopy(base)
+        scenario["extractor"]["version"] = f"property-{index}"
+        scenario_path.write_text(json.dumps(scenario), encoding="utf-8")
+        fixture_a, receipt_a = canary.load_fixture(scenario_path)
+        fixture_b, receipt_b = canary.load_fixture(scenario_path)
+        ids_a = canary.build_row_ids(receipt_a, fixture_a)
+        ids_b = canary.build_row_ids(receipt_b, fixture_b)
+        assert receipt_a == receipt_b
+        assert ids_a == ids_b
+        observed.add(receipt_a["replay_identity_sha256"])
+    assert len(observed) == 40
+
+
+@pytest.mark.parametrize("scenario_path", canary.DEFAULT_FIXTURES)
+def test_capture_and_stage_sql_do_not_mutate_canonical_tables(scenario_path: Path) -> None:
+    fixture, input_receipt, row_ids, parent, child = _loaded(scenario_path)
     sql = "\n".join(
         (
-            canary.build_schema_sql(),
             canary.build_capture_sql(fixture, input_receipt, row_ids),
             canary.normalized_stage.build_stage_sql(child),
         )
@@ -106,59 +437,346 @@ def test_capture_and_stage_sql_never_mutate_canonical_public_tables() -> None:
     assert "update public." not in sql
     assert "delete from public." not in sql
     assert "insert into kb_canary.source_captures" in sql
-    assert "insert into kb_canary.claim_extractions" in sql
-    assert "insert into kb_canary.evidence_extractions" in sql
     assert "insert into kb_stage.kb_proposals" in sql
+    assert parent["payload"]["ingestion_manifest"]["row_ids"] == row_ids
 
 
-def test_check_evaluation_requires_every_row_link_and_staging_boundary() -> None:
+def test_canonical_snapshot_covers_all_nonempty_canonical_tables() -> None:
-    fixture, input_receipt, row_ids = _loaded()
+    schema_sql = canary.build_schema_sql().lower()
-    child = canary.normalized_stage.prepare_normalized_child(
+    snapshot_sql = canary.build_canonical_snapshot_sql().lower()
-        canary.build_parent_packet(fixture, input_receipt, row_ids)
+
+    for table in ("claims", "sources", "claim_evidence", "claim_edges"):
+        assert f"insert into public.{table}" in schema_sql
+        assert f"from public.{table}" in snapshot_sql
+    assert "order by" in snapshot_sql
+    assert "begin transaction read only" in snapshot_sql
+    assert canary.canonical_snapshot_complete({}) is False
+    assert (
+        canary.canonical_snapshot_complete(
+            {
+                "claims": [{"id": "1"}],
+                "sources": [{"id": "2"}],
+                "claim_evidence": [{"claim_id": "1"}],
+                "claim_edges": [{"from_claim": "1"}],
+            }
         )
-    apply_payload = child["payload"]["apply_payload"]
+        is True
-    readback = {
+    )
-        "source_capture": {
+
-            "id": row_ids["source_capture_id"],
+
-            "artifact_sha256": input_receipt["artifact_sha256"],
+def test_evaluation_fails_when_exact_evidence_locator_is_changed() -> None:
-            "content_sha256": input_receipt["source_content_sha256"],
+    fixture, input_receipt, row_ids, _parent, child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
-            "source_identity": input_receipt["source_identity"],
+    readback = _synthetic_readback(fixture, input_receipt, row_ids, child)
-        },
+    canonical = {
-        "claim_extraction": {
+        "claims": [{"id": "1"}],
-            "id": row_ids["claim_extraction_id"],
+        "sources": [{"id": "2"}],
-            "source_capture_id": row_ids["source_capture_id"],
+        "claim_evidence": [{"claim_id": "1"}],
-            "body": fixture["extraction"]["claim"]["body"],
+        "claim_edges": [{"from_claim": "1"}],
-            "metadata": {"text": fixture["extraction"]["claim"]["text"]},
-        },
-        "evidence_extraction": {
-            "id": row_ids["evidence_extraction_id"],
-            "claim_extraction_id": row_ids["claim_extraction_id"],
-            "source_capture_id": row_ids["source_capture_id"],
-            "body": fixture["extraction"]["evidence"]["body"],
-            "metadata": fixture["extraction"]["evidence"]["metadata"],
-        },
-        "staged_proposal": {
-            "id": child["id"],
-            "status": "pending_review",
-            "source_ref": child["source_ref"],
-            "payload": {"apply_payload": apply_payload},
-            "reviewed_by_handle": None,
-            "reviewed_at": None,
-            "applied_by_handle": None,
-            "applied_at": None,
-        },
-        "counts": {
-            "source_captures": 1,
-            "claim_extractions": 1,
-            "evidence_extractions": 1,
-            "staged_proposals": 1,
-        },
     }
 
-    checks = canary.evaluate_checks(fixture, input_receipt, row_ids, readback)
+    checks = canary.evaluate_checks(fixture, input_receipt, row_ids, readback, canonical, copy.deepcopy(canonical))
     assert all(checks.values())
     broken = copy.deepcopy(readback)
-    broken["evidence_extraction"]["claim_extraction_id"] = canary.stable_uuid("0" * 64, "wrong")
+    broken["evidence_extractions"][0]["source_locator"] = "telegram://chat/900001/message/9999"
     assert (
-        canary.evaluate_checks(fixture, input_receipt, row_ids, broken)["evidence_links_to_claim_and_source"] is False
+        canary.evaluate_checks(fixture, input_receipt, row_ids, broken, canonical, copy.deepcopy(canonical))[
+            "all_evidence_has_exact_source_location"
+        ]
+        is False
     )
+
+
+def test_evaluation_recomputes_instead_of_trusting_supplied_row_ids() -> None:
+    fixture, input_receipt, row_ids, _parent, _child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+    tampered_ids = copy.deepcopy(row_ids)
+    tampered_ids["source_capture_id"] = "00000000-0000-4000-8000-000000009990"
+    tampered_parent = canary.build_parent_packet(fixture, input_receipt, tampered_ids)
+    tampered_child = canary.normalized_stage.prepare_normalized_child(tampered_parent)
+    readback = _synthetic_readback(fixture, input_receipt, tampered_ids, tampered_child)
+
+    checks = canary.evaluate_checks(
+        fixture, input_receipt, tampered_ids, readback, _canonical_snapshot(), _canonical_snapshot()
+    )
+
+    assert checks["deterministic_row_ids_recomputed_exact"] is False
+    assert checks["source_capture_identity_exact"] is False
+    assert checks["planned_proposal_identities_and_linkages_exact"] is False
+
+
+def test_independent_graph_oracle_rejects_consistent_generator_edge_corruption(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    fixture, input_receipt = canary.load_fixture(canary.DEFAULT_TELEGRAM_FIXTURE)
+    row_ids = canary.build_row_ids(input_receipt, fixture)
+    parent = canary.build_parent_packet(fixture, input_receipt, row_ids)
+    original_prepare = canary.normalized_stage.prepare_normalized_child
+
+    def corrupted_prepare(parent_packet: dict) -> dict:
+        child = copy.deepcopy(original_prepare(parent_packet))
+        child["payload"]["apply_payload"]["edges"][0]["to_claim"] = "00000000-0000-4000-8000-000000009996"
+        return child
+
+    monkeypatch.setattr(canary.normalized_stage, "prepare_normalized_child", corrupted_prepare)
+    corrupted_child = corrupted_prepare(parent)
+    readback = _synthetic_readback(fixture, input_receipt, row_ids, corrupted_child)
+
+    checks = canary.evaluate_checks(
+        fixture, input_receipt, row_ids, readback, _canonical_snapshot(), _canonical_snapshot()
+    )
+
+    assert checks["planned_graph_matches_independent_source_oracle"] is False
+    assert checks["planned_proposal_identities_and_linkages_exact"] is False
+    assert checks["conflicts_and_relationships_persisted"] is False
+
+
+@pytest.mark.parametrize(
+    ("mutation", "failed_check"),
+    (
+        ("source_id", "source_capture_identity_exact"),
+        ("source_identity", "source_capture_identity_exact"),
+        ("source_locator", "source_capture_identity_exact"),
+        ("claim_id", "claim_extraction_identities_and_fks_exact"),
+        ("claim_source_fk", "claim_extraction_identities_and_fks_exact"),
+        ("evidence_id", "evidence_extraction_identities_and_fks_exact"),
+        ("evidence_claim_fk", "evidence_extraction_identities_and_fks_exact"),
+        ("evidence_source_fk", "evidence_extraction_identities_and_fks_exact"),
+        ("evidence_segment_id", "evidence_extraction_identities_and_fks_exact"),
+        ("evidence_json_pointer", "evidence_extraction_identities_and_fks_exact"),
+        ("evidence_role", "evidence_extraction_identities_and_fks_exact"),
+        ("evidence_body_sha256", "evidence_extraction_identities_and_fks_exact"),
+        ("proposal_id", "planned_proposal_identities_and_linkages_exact"),
+        ("planned_claim_id", "planned_proposal_identities_and_linkages_exact"),
+        ("planned_source_id", "planned_proposal_identities_and_linkages_exact"),
+        ("planned_evidence_claim_fk", "planned_proposal_identities_and_linkages_exact"),
+        ("planned_evidence_source_fk", "planned_proposal_identities_and_linkages_exact"),
+        ("planned_evidence_role", "planned_proposal_identities_and_linkages_exact"),
+        ("manifest_row_id", "planned_proposal_identities_and_linkages_exact"),
+    ),
+)
+def test_evaluation_rejects_wrong_deterministic_ids_and_every_fk_linkage(mutation: str, failed_check: str) -> None:
+    fixture, input_receipt, row_ids, _parent, child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+    readback = _synthetic_readback(fixture, input_receipt, row_ids, child)
+    broken = copy.deepcopy(readback)
+    wrong_uuid = "00000000-0000-4000-8000-000000009999"
+    apply_payload = broken["staged_proposal"]["payload"]["apply_payload"]
+    if mutation == "source_id":
+        broken["source_captures"][0]["id"] = wrong_uuid
+    elif mutation == "source_identity":
+        broken["source_captures"][0]["source_identity"] = "fixture:wrong-source-identity"
+    elif mutation == "source_locator":
+        broken["source_captures"][0]["locator"] = "fixture://working-leo/wrong-source-locator"
+    elif mutation == "claim_id":
+        broken["claim_extractions"][0]["id"] = broken["claim_extractions"][1]["id"]
+    elif mutation == "claim_source_fk":
+        broken["claim_extractions"][0]["source_capture_id"] = wrong_uuid
+    elif mutation == "evidence_id":
+        broken["evidence_extractions"][0]["id"] = broken["evidence_extractions"][1]["id"]
+    elif mutation == "evidence_claim_fk":
+        broken["evidence_extractions"][0]["claim_extraction_id"] = broken["claim_extractions"][1]["id"]
+    elif mutation == "evidence_source_fk":
+        broken["evidence_extractions"][0]["source_capture_id"] = wrong_uuid
+    elif mutation == "evidence_segment_id":
+        broken["evidence_extractions"][0]["source_segment_id"] = "message-900001-9999"
+    elif mutation == "evidence_json_pointer":
+        broken["evidence_extractions"][0]["source_json_pointer"] = "jsonl://line/999/message"
+    elif mutation == "evidence_role":
+        broken["evidence_extractions"][0]["role"] = "supports"
+    elif mutation == "evidence_body_sha256":
+        broken["evidence_extractions"][0]["body_sha256"] = "d" * 64
+    elif mutation == "proposal_id":
+        broken["staged_proposal"]["id"] = wrong_uuid
+    elif mutation == "planned_claim_id":
+        apply_payload["claims"][0]["id"] = apply_payload["claims"][1]["id"]
+    elif mutation == "planned_source_id":
+        apply_payload["sources"][0]["id"] = apply_payload["sources"][1]["id"]
+    elif mutation == "planned_evidence_claim_fk":
+        apply_payload["evidence"][0]["claim_id"] = apply_payload["claims"][1]["id"]
+    elif mutation == "planned_evidence_source_fk":
+        apply_payload["evidence"][0]["source_id"] = apply_payload["sources"][1]["id"]
+    elif mutation == "planned_evidence_role":
+        apply_payload["evidence"][0]["role"] = "supports"
+    elif mutation == "manifest_row_id":
+        apply_payload["normalization_manifest"]["ingestion_manifest"]["row_ids"]["source_capture_id"] = wrong_uuid
+
+    checks = canary.evaluate_checks(
+        fixture, input_receipt, row_ids, broken, _canonical_snapshot(), _canonical_snapshot()
+    )
+
+    assert checks[failed_check] is False
+    assert not all(checks.values())
+
+
+@pytest.mark.parametrize(
+    ("surface", "field", "replacement", "failed_check"),
+    (
+        ("duplicate", "id", "00000000-0000-4000-8000-000000009991", "duplicate_judgments_persisted"),
+        (
+            "duplicate",
+            "source_capture_id",
+            "00000000-0000-4000-8000-000000009992",
+            "duplicate_judgments_persisted",
+        ),
+        ("duplicate", "source_segment_id", "message-900001-9999", "duplicate_judgments_persisted"),
+        (
+            "duplicate",
+            "source_locator",
+            "telegram://chat/900001/message/9999",
+            "duplicate_judgments_persisted",
+        ),
+        ("duplicate", "duplicate_of_claim_key", "approval_alone_makes_canonical", "duplicate_judgments_persisted"),
+        ("duplicate", "excerpt", "fabricated duplicate excerpt", "duplicate_judgments_persisted"),
+        ("duplicate", "excerpt_sha256", "c" * 64, "duplicate_judgments_persisted"),
+        ("duplicate", "reason", "fabricated duplicate reason", "duplicate_judgments_persisted"),
+        ("duplicate", "metadata", {"json_pointer": "fabricated"}, "duplicate_judgments_persisted"),
+        ("conflict", "id", "00000000-0000-4000-8000-000000009993", "conflicts_and_relationships_persisted"),
+        (
+            "conflict",
+            "source_capture_id",
+            "00000000-0000-4000-8000-000000009994",
+            "conflicts_and_relationships_persisted",
+        ),
+        ("conflict", "from_claim_key", "approval_alone_makes_canonical", "conflicts_and_relationships_persisted"),
+        (
+            "conflict",
+            "to_claim_key",
+            "pending_review_does_not_change_canonical",
+            "conflicts_and_relationships_persisted",
+        ),
+        ("conflict", "relationship", "supports", "conflicts_and_relationships_persisted"),
+        ("conflict", "metadata", {"reason": "fabricated"}, "conflicts_and_relationships_persisted"),
+        ("edge", "from_claim", "00000000-0000-4000-8000-000000009995", "conflicts_and_relationships_persisted"),
+        ("edge", "to_claim", "00000000-0000-4000-8000-000000009996", "conflicts_and_relationships_persisted"),
+        ("edge", "edge_type", "supports", "conflicts_and_relationships_persisted"),
+        ("edge", "weight", 0.5, "conflicts_and_relationships_persisted"),
+        ("edge", "created_by", "00000000-0000-4000-8000-000000009997", "conflicts_and_relationships_persisted"),
+    ),
+)
+def test_evaluation_rejects_mutated_duplicate_conflict_and_edge_identities(
+    surface: str, field: str, replacement: object, failed_check: str
+) -> None:
+    fixture, input_receipt, row_ids, _parent, child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+    broken = _synthetic_readback(fixture, input_receipt, row_ids, child)
+    if surface == "duplicate":
+        broken["duplicate_assessments"][0][field] = replacement
+    elif surface == "conflict":
+        broken["conflict_assessments"][0][field] = replacement
+    else:
+        broken["staged_proposal"]["payload"]["apply_payload"]["edges"][0][field] = replacement
+
+    checks = canary.evaluate_checks(
+        fixture, input_receipt, row_ids, broken, _canonical_snapshot(), _canonical_snapshot()
+    )
+
+    assert checks[failed_check] is False
+    assert not all(checks.values())
+
+
+@pytest.mark.parametrize(
+    ("field", "replacement"),
+    (
+        ("reviewed_by_handle", "reviewer"),
+        ("reviewed_by_agent_id", "00000000-0000-4000-8000-000000009981"),
+        ("reviewed_at", "2026-07-15T00:00:00+00:00"),
+        ("review_note", "fabricated review note"),
+        ("applied_by_handle", "applier"),
+        ("applied_by_agent_id", "00000000-0000-4000-8000-000000009982"),
+        ("applied_at", "2026-07-15T00:00:01+00:00"),
+    ),
+)
+def test_evaluation_rejects_every_review_and_apply_metadata_mutation(field: str, replacement: str) -> None:
+    fixture, input_receipt, row_ids, _parent, child = _loaded(canary.DEFAULT_TELEGRAM_FIXTURE)
+    broken = _synthetic_readback(fixture, input_receipt, row_ids, child)
+    broken["staged_proposal"][field] = replacement
+
+    checks = canary.evaluate_checks(
+        fixture, input_receipt, row_ids, broken, _canonical_snapshot(), _canonical_snapshot()
+    )
+
+    assert checks["no_review_or_apply_metadata"] is False
+    assert checks["planned_proposal_identities_and_linkages_exact"] is False
+
+
+def _suite_child(artifact_format: str, *, passed: bool = True, canonical_unchanged: bool = True) -> dict:
+    before = "a" * 64
+    after = before if canonical_unchanged else "b" * 64
+    return {
+        "status": "pass" if passed else "fail",
+        "input": {"artifact_format": artifact_format},
+        "canonical": {
+            "fingerprint_before": before,
+            "fingerprint_after": after,
+            "unchanged": canonical_unchanged,
+        },
+        "checks": {"canonical_fingerprint_unchanged": canonical_unchanged},
+    }
+
+
+def test_single_fixture_suite_is_truthfully_partial(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
+    monkeypatch.setattr(canary, "run_canary", lambda _path: _suite_child("plain_text"))
+
+    suite = canary.run_suite([tmp_path / "document.scenario.json"])
+
+    assert suite["status"] == "partial"
+    assert suite["full_suite_passed"] is False
+    assert suite["coverage_status"] == "partial"
+    assert suite["missing_required_coverage"] == ["social_conversation"]
+
+
+def test_malformed_fixture_fails_closed_with_receipt_and_without_runtime(tmp_path: Path) -> None:
+    malformed = tmp_path / "malformed.scenario.json"
+    malformed.write_text("{not-json", encoding="utf-8")
+
+    receipt = canary.run_canary(malformed)
+    suite = canary.run_suite([malformed])
+
+    assert receipt["status"] == "fail"
+    assert receipt["error"]["type"] == "CanaryError"
+    assert receipt["cleanup"]["runtime_not_started"] is True
+    assert receipt["cleanup"]["container_absent"] is True
+    assert suite["status"] == "fail"
+    assert suite["receipts"][0]["error"]["type"] == "CanaryError"
+
+
+@pytest.mark.parametrize(
+    ("children", "expected_status"),
+    (
+        (
+            [_suite_child("plain_text"), _suite_child("telegram_jsonl")],
+            "pass",
+        ),
+        (
+            [_suite_child("plain_text", canonical_unchanged=False), _suite_child("telegram_jsonl")],
+            "fail",
+        ),
+        (
+            [_suite_child("plain_text"), _suite_child("telegram_jsonl", passed=False)],
+            "fail",
+        ),
+    ),
+)
+def test_full_suite_status_requires_both_shapes_all_children_and_canonical_invariance(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path, children: list[dict], expected_status: str
+) -> None:
+    queue = iter(children)
+    monkeypatch.setattr(canary, "run_canary", lambda _path: next(queue))
+
+    suite = canary.run_suite([tmp_path / "document.scenario.json", tmp_path / "telegram.scenario.json"])
+
+    assert suite["status"] == expected_status
+    assert suite["full_suite_passed"] is (expected_status == "pass")
+
+
+def test_suite_recomputes_canonical_invariance_instead_of_trusting_stale_boolean(
+    monkeypatch: pytest.MonkeyPatch, tmp_path: Path
+) -> None:
+    children = [_suite_child("plain_text"), _suite_child("telegram_jsonl")]
+    children[0]["canonical"]["fingerprint_after"] = "c" * 64
+    queue = iter(children)
+    monkeypatch.setattr(canary, "run_canary", lambda _path: next(queue))
+
+    suite = canary.run_suite([tmp_path / "document.scenario.json", tmp_path / "telegram.scenario.json"])
+
+    assert suite["status"] == "fail"
+    assert suite["canonical_fingerprint_invariant_all"] is False
+    assert suite["full_suite_passed"] is False
+    assert "canonical_fingerprint_invariance" in suite["missing_required_coverage"]

tests/test_run_local_genesis_ledger_rebuild.py

@@ -23,6 +23,18 @@ REVIEWER_ID = "11111111-1111-4111-8111-111111111111"
 SERVICE_ID = "44444444-4444-4444-4444-444444444444"
 PROPOSAL_ID = "99999999-9999-4999-8999-999999999999"
 EDGE_ID = "eeeeeeee-eeee-4eee-8eee-eeeeeeeeeeee"
+OTHER_AGENT_ID = "22222222-2222-4222-8222-222222222222"
+REVISE_PROPOSAL_ID = "88888888-8888-4888-8888-888888888888"
+PRIOR_STRATEGY_ID = "33333333-3333-4333-8333-333333333333"
+PRIOR_ACTIVE_NODE_ID = "55555555-5555-4555-8555-555555555555"
+PRIOR_RETIRED_NODE_ID = "66666666-6666-4666-8666-666666666666"
+OTHER_STRATEGY_ID = "77777777-7777-4777-8777-777777777777"
+OTHER_ACTIVE_NODE_ID = "12121212-1212-4212-8212-121212121212"
+NULL_AGENT_NODE_ID = "13131313-1313-4313-8313-131313131313"
+PRIOR_NODE_ANCHOR_ID = "19191919-1919-4919-8919-191919191919"
+RECEIPT_STRATEGY_ID = "14141414-1414-4414-8414-141414141414"
+RECEIPT_NODE_A_ID = "15151515-1515-4515-8515-151515151515"
+RECEIPT_NODE_B_ID = "16161616-1616-4616-8616-161616161616"
 PRIVATE_MARKER = "PRIVATE-REPLAY-MATERIAL-MUST-NOT-LEAK"
 
 
@@ -155,6 +167,58 @@ def proposal_rows() -> tuple[dict, dict, dict]:
     return approved, applied, approval
 
 
+def revise_strategy_proposal_rows() -> tuple[dict, dict, dict]:
+    approved, _, approval = proposal_rows()
+    payload = {
+        "apply_payload": {
+            "agent_id": REVIEWER_ID,
+            "strategy": {
+                "diagnosis": "Deterministic reconstruction needs exact mutation deltas.",
+                "guiding_policy": "Replay every guarded transition and fail closed on drift.",
+                "proximate_objectives": ["exact parity", "zero orphan containers"],
+            },
+            "strategy_nodes": [
+                {
+                    "node_type": "policy",
+                    "title": "Replay exactly",
+                    "body": "Bind the guarded transition to its canonical receipt.",
+                    "rank": 1,
+                },
+                {
+                    "node_type": "policy",
+                    "title": "Replay exactly",
+                    "body": "Bind the guarded transition to its canonical receipt.",
+                    "rank": 1,
+                },
+            ],
+        },
+        "private_title": PRIVATE_MARKER,
+    }
+    approved = {
+        **approved,
+        "id": REVISE_PROPOSAL_ID,
+        "proposal_type": "revise_strategy",
+        "payload": payload,
+        "created_at": "2026-07-14T00:58:00+00:00",
+        "updated_at": "2026-07-14T01:00:00+00:00",
+    }
+    applied = {
+        **approved,
+        "status": "applied",
+        "applied_by_handle": "kb-apply",
+        "applied_by_agent_id": SERVICE_ID,
+        "applied_at": "2026-07-14T01:01:00+00:00",
+        "updated_at": "2026-07-14T01:01:00.000001+00:00",
+    }
+    approval = {
+        **approval,
+        "proposal_id": REVISE_PROPOSAL_ID,
+        "proposal_type": "revise_strategy",
+        "payload": payload,
+    }
+    return approved, applied, approval
+
+
 def applied_envelope(applied: dict) -> dict:
     fields = (
         "id",
@@ -202,6 +266,73 @@ def replay_material() -> dict:
     }
 
 
+def revise_strategy_replay_material(*, apply_sql_source: str = "exact_executed_sql", version: int = 2) -> dict:
+    approved, applied, approval = revise_strategy_proposal_rows()
+    proposal = applied_envelope(applied)
+    transaction_timestamp = "2026-07-14T01:00:30+00:00"
+    canonical_rows = {
+        "strategies": [
+            {
+                "id": RECEIPT_STRATEGY_ID,
+                "agent_id": REVIEWER_ID,
+                **proposal["payload"]["apply_payload"]["strategy"],
+                "version": version,
+                "active": True,
+                "created_at": transaction_timestamp,
+            }
+        ],
+        "strategy_nodes": [
+            {
+                "id": node_id,
+                "agent_id": REVIEWER_ID,
+                **node,
+                "status": "active",
+                "horizon": None,
+                "measure": None,
+                "source_ref": None,
+                "metadata": {},
+                "created_at": transaction_timestamp,
+                "updated_at": transaction_timestamp,
+            }
+            for node_id, node in zip(
+                (RECEIPT_NODE_A_ID, RECEIPT_NODE_B_ID),
+                proposal["payload"]["apply_payload"]["strategy_nodes"],
+                strict=True,
+            )
+        ],
+    }
+    apply_sql = rebuild.apply_engine.build_apply_sql(proposal, applied["applied_by_handle"])
+    receipt = rebuild.replay_receipt.build_replay_receipt(
+        proposal,
+        canonical_rows,
+        apply_sql_sha256=rebuild.replay_receipt.sha256_text(apply_sql),
+        apply_sql_source=apply_sql_source,
+        exported_at_utc="2026-07-14T01:02:00+00:00",
+    )
+    return {
+        "artifact": rebuild.MATERIAL_ARTIFACT,
+        "contract_version": rebuild.MATERIAL_CONTRACT_VERSION,
+        "sequence": 1,
+        "approved_proposal": approved,
+        "approval_snapshot": approval,
+        "applied_proposal": applied,
+        "replay_receipt": receipt,
+    }
+
+
+def rehash_revise_strategy_receipt(material: dict) -> None:
+    prior_receipt = material["replay_receipt"]
+    proposal = applied_envelope(material["applied_proposal"])
+    apply_sql = rebuild.apply_engine.build_apply_sql(proposal, material["applied_proposal"]["applied_by_handle"])
+    material["replay_receipt"] = rebuild.replay_receipt.build_replay_receipt(
+        proposal,
+        prior_receipt["canonical_rows"],
+        apply_sql_sha256=rebuild.replay_receipt.sha256_text(apply_sql),
+        apply_sql_source=prior_receipt["apply_engine"]["source"],
+        exported_at_utc=prior_receipt["exported_at_utc"],
+    )
+
+
 def write_bundle(tmp_path: Path, *, material: dict | None = None) -> argparse.Namespace:
     dump = tmp_path / "genesis.dump"
     dump.write_bytes(b"PGDMPfixture")
@@ -238,7 +369,7 @@ def write_bundle(tmp_path: Path, *, material: dict | None = None) -> argparse.Na
         ledger=ledger_path,
         ledger_sha256=sha256_file(ledger_path),
         database="teleo",
-        image=rebuild.canonical_rebuild.DEFAULT_IMAGE,
+        image=rebuild.DEFAULT_REBUILD_IMAGE,
         container_prefix="teleo-genesis-ledger-test",
         tmpfs_mb=256,
         startup_timeout=30.0,
@@ -302,18 +433,192 @@ def test_dump_hash_mismatch_fails_before_container_start(tmp_path: Path, monkeyp
     assert not any(len(command) > 1 and command[1] == "run" for command in commands)
 
 
-def test_revise_strategy_receipt_fails_closed_before_receipt_rows_are_used(tmp_path: Path) -> None:
+def test_revise_strategy_material_validates_exact_engine_and_canonicalizes_row_order(
-    material = replay_material()
+    tmp_path: Path,
-    material["replay_receipt"]["proposal"]["proposal_type"] = "revise_strategy"
+) -> None:
-    material["applied_proposal"]["proposal_type"] = "revise_strategy"
+    material = revise_strategy_replay_material()
-    material["approved_proposal"]["proposal_type"] = "revise_strategy"
+    material["replay_receipt"]["canonical_rows"]["strategy_nodes"].reverse()
-    material["approval_snapshot"]["proposal_type"] = "revise_strategy"
     args = write_bundle(tmp_path, material=material)
 
-    with pytest.raises(rebuild.ReconstructionError, match="prior strategy") as exc_info:
+    entry = rebuild.load_bundle(args).entries[0]
+
+    assert entry.applied_proposal["proposal_type"] == "revise_strategy"
+    assert entry.receipt["apply_engine"]["source"] == "exact_executed_sql"
+    assert entry.receipt["apply_engine"]["apply_sql_sha256"] == entry.current_apply_sql_sha256
+    assert entry.receipt["canonical_rows"]["strategy_nodes"] == sorted(
+        entry.receipt["canonical_rows"]["strategy_nodes"], key=rebuild._canonical_json
+    )
+
+
+def test_revise_strategy_material_rejects_reconstructed_apply_engine(tmp_path: Path) -> None:
+    args = write_bundle(
+        tmp_path,
+        material=revise_strategy_replay_material(apply_sql_source="reconstructed_current_engine"),
+    )
+
+    with pytest.raises(rebuild.ReconstructionError) as exc_info:
         rebuild.load_bundle(args)
 
-    assert exc_info.value.code == "unsupported_mutating_receipt"
+    assert exc_info.value.code == "mutating_apply_engine_mismatch"
+
+
+def test_revise_strategy_rejects_fully_rehashed_transaction_before_approval(
+    tmp_path: Path,
+) -> None:
+    material = revise_strategy_replay_material()
+    original_receipt = material["replay_receipt"]
+    forged_timestamp = "2026-07-13T01:00:30+00:00"
+    canonical_rows = copy.deepcopy(original_receipt["canonical_rows"])
+    canonical_rows["strategies"][0]["created_at"] = forged_timestamp
+    for row in canonical_rows["strategy_nodes"]:
+        row["created_at"] = forged_timestamp
+        row["updated_at"] = forged_timestamp
+    material["replay_receipt"]["canonical_rows"] = canonical_rows
+    rehash_revise_strategy_receipt(material)
+    args = write_bundle(tmp_path, material=material)
+    ledger = json.loads(args.ledger.read_text(encoding="utf-8"))
+    material_path = args.ledger.parent / ledger["entries"][0]["material"]
+
+    assert material["replay_receipt"]["hashes"] != original_receipt["hashes"]
+    assert ledger["entries"][0]["sha256"] == sha256_file(material_path)
+    assert (
+        ledger["entries"][0]["replay_material_sha256"] == material["replay_receipt"]["hashes"]["replay_material_sha256"]
+    )
+    assert args.ledger_sha256 == sha256_file(args.ledger)
+    with pytest.raises(rebuild.ReconstructionError) as exc_info:
+        rebuild.load_bundle(args)
+
+    assert exc_info.value.code == "invalid_mutating_receipt"
+    assert "before proposal approval" in exc_info.value.safe_message
+
+
+@pytest.mark.parametrize(
+    ("reviewed_at", "transaction_timestamp", "applied_at"),
+    (
+        (
+            "2026-07-14T03:00:00+02:00",
+            "2026-07-14T01:00:00+00:00",
+            "2026-07-14T01:01:00+00:00",
+        ),
+        (
+            "2026-07-14T01:00:00+00:00",
+            "2026-07-14T01:01:00+00:00",
+            "2026-07-14T03:01:00+02:00",
+        ),
+    ),
+)
+def test_revise_strategy_accepts_timezone_aware_closed_timestamp_boundaries(
+    tmp_path: Path,
+    reviewed_at: str,
+    transaction_timestamp: str,
+    applied_at: str,
+) -> None:
+    material = revise_strategy_replay_material()
+    for proposal_row in (material["approved_proposal"], material["applied_proposal"]):
+        proposal_row["reviewed_at"] = reviewed_at
+    material["approval_snapshot"]["reviewed_at"] = reviewed_at
+    material["applied_proposal"]["applied_at"] = applied_at
+    rows = material["replay_receipt"]["canonical_rows"]
+    rows["strategies"][0]["created_at"] = transaction_timestamp
+    for row in rows["strategy_nodes"]:
+        row["created_at"] = transaction_timestamp
+        row["updated_at"] = transaction_timestamp
+    rehash_revise_strategy_receipt(material)
+
+    entry = rebuild.load_bundle(write_bundle(tmp_path, material=material)).entries[0]
+
+    assert entry.receipt["canonical_rows"]["strategies"][0]["created_at"] == transaction_timestamp
+
+
+def test_revise_strategy_rejects_reviewed_at_without_timezone(tmp_path: Path) -> None:
+    material = revise_strategy_replay_material()
+    reviewed_at = "2026-07-14T01:00:00"
+    for proposal_row in (material["approved_proposal"], material["applied_proposal"]):
+        proposal_row["reviewed_at"] = reviewed_at
+    material["approval_snapshot"]["reviewed_at"] = reviewed_at
+    rehash_revise_strategy_receipt(material)
+
+    with pytest.raises(rebuild.ReconstructionError) as exc_info:
+        rebuild.load_bundle(write_bundle(tmp_path, material=material))
+
+    assert exc_info.value.code == "invalid_mutating_receipt"
+    assert "reviewed_at must include a timezone" in exc_info.value.safe_message
+
+
+@pytest.mark.parametrize(
+    "invalid_case",
+    ("extra_strategy_field", "duplicate_node_id", "node_timestamp_drift", "transaction_after_apply"),
+)
+def test_revise_strategy_receipt_rejects_impossible_poststate(tmp_path: Path, invalid_case: str) -> None:
+    material = revise_strategy_replay_material()
+    rows = material["replay_receipt"]["canonical_rows"]
+    if invalid_case == "extra_strategy_field":
+        rows["strategies"][0]["unexpected"] = "ignored by jsonb_populate_record"
+    elif invalid_case == "duplicate_node_id":
+        rows["strategy_nodes"][1]["id"] = rows["strategy_nodes"][0]["id"]
+    elif invalid_case == "node_timestamp_drift":
+        rows["strategy_nodes"][0]["updated_at"] = "2026-07-14T01:00:31+00:00"
+    else:
+        rows["strategies"][0]["created_at"] = "2026-07-14T01:01:01+00:00"
+        for row in rows["strategy_nodes"]:
+            row["created_at"] = "2026-07-14T01:01:01+00:00"
+            row["updated_at"] = "2026-07-14T01:01:01+00:00"
+    args = write_bundle(tmp_path, material=material)
+
+    with pytest.raises(rebuild.ReconstructionError) as exc_info:
+        rebuild.load_bundle(args)
+
+    assert exc_info.value.code == "invalid_mutating_receipt"
+
+
+def test_revise_strategy_transition_builders_preserve_historical_prestate(tmp_path: Path) -> None:
+    entry = rebuild.load_bundle(write_bundle(tmp_path, material=revise_strategy_replay_material())).entries[0]
+    prestate = {
+        "strategy_ids": [PRIOR_STRATEGY_ID],
+        "active_strategy_ids": [PRIOR_STRATEGY_ID],
+        "max_strategy_version": 1,
+        "strategy_node_ids": [PRIOR_ACTIVE_NODE_ID, PRIOR_RETIRED_NODE_ID],
+        "non_retired_strategy_node_ids": [PRIOR_ACTIVE_NODE_ID],
+    }
+    generated_rows = copy.deepcopy(entry.receipt["canonical_rows"])
+    generated_rows["strategies"][0]["id"] = "17171717-1717-4717-8717-171717171717"
+    generated_rows["strategies"][0]["created_at"] = "2026-07-15T01:00:30+00:00"
+    for index, row in enumerate(generated_rows["strategy_nodes"], start=1):
+        row["id"] = f"18181818-1818-4818-8818-18181818181{index}"
+        row["created_at"] = "2026-07-15T01:00:30+00:00"
+        row["updated_at"] = "2026-07-15T01:00:30+00:00"
+
+    sql = rebuild.build_revise_strategy_normalization_sql(entry, prestate, generated_rows)
+
+    assert PRIOR_ACTIVE_NODE_ID in sql
+    assert PRIOR_RETIRED_NODE_ID not in sql
+    assert PRIOR_STRATEGY_ID in sql
+    assert RECEIPT_STRATEGY_ID in sql
+    assert "updated_at = E'2026-07-14T01:00:30+00:00'::timestamptz" in sql
+
+
+def test_revise_strategy_transition_builders_allow_empty_prestate(tmp_path: Path) -> None:
+    entry = rebuild.load_bundle(write_bundle(tmp_path, material=revise_strategy_replay_material(version=1))).entries[0]
+    prestate = {
+        "strategy_ids": [],
+        "active_strategy_ids": [],
+        "max_strategy_version": 0,
+        "strategy_node_ids": [],
+        "non_retired_strategy_node_ids": [],
+    }
+    generated_rows = copy.deepcopy(entry.receipt["canonical_rows"])
+    generated_rows["strategies"][0]["id"] = "17171717-1717-4717-8717-171717171717"
+    generated_rows["strategies"][0]["created_at"] = "2026-07-15T01:00:30+00:00"
+    for index, row in enumerate(generated_rows["strategy_nodes"], start=1):
+        row["id"] = f"18181818-1818-4818-8818-18181818181{index}"
+        row["created_at"] = "2026-07-15T01:00:30+00:00"
+        row["updated_at"] = "2026-07-15T01:00:30+00:00"
+
+    sql = rebuild.build_revise_strategy_normalization_sql(entry, prestate, generated_rows)
+
+    assert "prior active strategy transition mismatch" not in sql
+    assert "prior node normalization mismatch" not in sql
+    assert RECEIPT_STRATEGY_ID in sql
 
 
 def test_legacy_freeform_receipt_fails_closed(tmp_path: Path) -> None:
@@ -331,6 +636,17 @@ def test_legacy_freeform_receipt_fails_closed(tmp_path: Path) -> None:
     assert PRIVATE_MARKER not in exc_info.value.safe_message
 
 
+def test_unknown_proposal_operation_fails_closed_before_replay(tmp_path: Path) -> None:
+    material = replay_material()
+    material["replay_receipt"]["proposal"]["proposal_type"] = "delete_claim"
+    args = write_bundle(tmp_path, material=material)
+
+    with pytest.raises(rebuild.ReconstructionError) as exc_info:
+        rebuild.load_bundle(args)
+
+    assert exc_info.value.code == "unsupported_proposal_type"
+
+
 def test_proposal_metadata_outside_apply_transition_is_rejected(tmp_path: Path) -> None:
     material = replay_material()
     material["applied_proposal"]["rationale"] = "silently changed after review"
@@ -354,6 +670,28 @@ def test_output_cannot_overwrite_a_fixed_guard_or_engine_file(tmp_path: Path) ->
     assert exc_info.value.code == "unsafe_output_path"
 
 
+def test_cli_defaults_to_pinned_image_and_rejects_moving_tag(tmp_path: Path) -> None:
+    bundle = write_bundle(tmp_path)
+    argv = [
+        "--genesis-dump",
+        str(bundle.genesis_dump),
+        "--genesis-manifest",
+        str(bundle.genesis_manifest),
+        "--ledger",
+        str(bundle.ledger),
+        "--ledger-sha256",
+        bundle.ledger_sha256,
+        "--output",
+        str(tmp_path / "receipt.json"),
+    ]
+
+    assert rebuild.parse_args(argv).image == rebuild.DEFAULT_REBUILD_IMAGE
+    with pytest.raises(SystemExit) as exc_info:
+        rebuild.parse_args([*argv, "--image", "postgres:16-alpine"])
+
+    assert exc_info.value.code == 2
+
+
 def test_unknown_private_field_name_is_not_echoed_in_public_error(tmp_path: Path) -> None:
     material = replay_material()
     material[PRIVATE_MARKER] = "private value"
@@ -484,17 +822,18 @@ create table public.reasoning_tools (
   created_at timestamptz not null default now()
 );
 create table public.strategies (
-  id uuid primary key,
+  id uuid primary key default gen_random_uuid(),
   agent_id uuid not null references public.agents(id),
   diagnosis text,
   guiding_policy text,
   proximate_objectives jsonb,
   version integer not null default 1,
   active boolean not null default true,
-  created_at timestamptz not null default now()
+  created_at timestamptz not null default now(),
+  unique (agent_id, version)
 );
 create table public.strategy_nodes (
-  id uuid primary key,
+  id uuid primary key default gen_random_uuid(),
   agent_id uuid references public.agents(id),
   node_type text,
   title text,
@@ -508,6 +847,20 @@ create table public.strategy_nodes (
   created_at timestamptz not null default now(),
   updated_at timestamptz not null default now()
 );
+create table public.strategy_node_anchors (
+  id uuid primary key default gen_random_uuid(),
+  from_node_id uuid not null references public.strategy_nodes(id) on delete cascade,
+  anchor_role text not null,
+  to_node_id uuid references public.strategy_nodes(id) on delete cascade,
+  to_shared_root_id uuid,
+  belief_id uuid,
+  claim_id uuid,
+  source_id uuid,
+  weight numeric,
+  note text,
+  created_at timestamptz not null default now(),
+  check (num_nonnulls(to_node_id, to_shared_root_id, belief_id, claim_id, source_id) = 1)
+);
 create table kb_stage.kb_proposals (
   id uuid primary key,
   proposal_type text not null,
@@ -530,10 +883,34 @@ create table kb_stage.kb_proposals (
 );
 
 insert into public.agents (id, handle, kind) values
-  ('{REVIEWER_ID}', 'm3ta', 'human');
+  ('{REVIEWER_ID}', 'm3ta', 'human'),
+  ('{OTHER_AGENT_ID}', 'other-agent', 'system');
 insert into public.claims (id, type, text, status, confidence, tags, created_by) values
   ('{CLAIM_A}', 'structural', 'Fixture claim A', 'open', 0.8, array['fixture'], '{REVIEWER_ID}'),
   ('{CLAIM_B}', 'structural', 'Fixture claim B', 'open', 0.8, array['fixture'], '{REVIEWER_ID}');
+insert into public.strategies
+  (id, agent_id, diagnosis, guiding_policy, proximate_objectives, version, active, created_at)
+values
+  ('{PRIOR_STRATEGY_ID}', '{REVIEWER_ID}', 'Prior diagnosis', 'Prior policy', '["prior"]', 1, true,
+   '2026-07-01T00:00:00+00:00'),
+  ('{OTHER_STRATEGY_ID}', '{OTHER_AGENT_ID}', 'Other diagnosis', 'Other policy', '["other"]', 1, true,
+   '2026-07-01T00:00:00+00:00');
+insert into public.strategy_nodes
+  (id, agent_id, node_type, title, body, rank, status, created_at, updated_at)
+values
+  ('{PRIOR_ACTIVE_NODE_ID}', '{REVIEWER_ID}', 'policy', 'Prior active', 'Retire exactly once', 1,
+   'active', '2026-07-01T00:00:00+00:00', '2026-07-01T00:00:00+00:00'),
+  ('{PRIOR_RETIRED_NODE_ID}', '{REVIEWER_ID}', 'policy', 'Prior retired', 'Leave timestamp unchanged', 2,
+   'retired', '2026-06-01T00:00:00+00:00', '2026-06-02T00:00:00+00:00'),
+  ('{OTHER_ACTIVE_NODE_ID}', '{OTHER_AGENT_ID}', 'policy', 'Other active', 'Leave other agent unchanged', 1,
+   'active', '2026-07-01T00:00:00+00:00', '2026-07-01T00:00:00+00:00'),
+  ('{NULL_AGENT_NODE_ID}', null, 'policy', 'Shared active', 'Leave shared node unchanged', 1,
+   'active', '2026-07-01T00:00:00+00:00', '2026-07-01T00:00:00+00:00');
+insert into public.strategy_node_anchors
+  (id, from_node_id, anchor_role, to_node_id, weight, note, created_at)
+values
+  ('{PRIOR_NODE_ANCHOR_ID}', '{PRIOR_ACTIVE_NODE_ID}', 'serves', '{PRIOR_RETIRED_NODE_ID}', 1.0,
+   'Existing anchor must survive strategy revision replay', '2026-07-01T00:00:00+00:00');
 """
 
 
@@ -631,13 +1008,17 @@ def source_postgres() -> Iterator[tuple[str, str]]:
             "run",
             "--rm",
             "--detach",
+            "--network",
+            "none",
             "--name",
             container,
+            "--label",
+            f"{rebuild.canonical_rebuild.CANARY_LABEL}={container}",
             "--env",
             f"POSTGRES_DB={database}",
             "--env",
             "POSTGRES_HOST_AUTH_METHOD=trust",
-            rebuild.canonical_rebuild.DEFAULT_IMAGE,
+            rebuild.DEFAULT_REBUILD_IMAGE,
         ],
         text=True,
         capture_output=True,
@@ -692,14 +1073,24 @@ def source_postgres() -> Iterator[tuple[str, str]]:
             capture_output=True,
             check=False,
         )
+        inspected = subprocess.run(
+            ["docker", "container", "inspect", container],
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        if inspected.returncode == 0:
+            pytest.fail(f"fixture PostgreSQL container was not removed: {container}")
 
 
-def test_live_genesis_plus_ledger_command_rebuilds_exactly_and_proves_cleanup(
+def capture_source_snapshot(
+    source_container: str,
+    database: str,
     tmp_path: Path,
-    source_postgres: tuple[str, str],
+    *,
-) -> None:
+    stem: str,
-    source_container, database = source_postgres
+) -> tuple[Path, Path]:
-    genesis_dump = tmp_path / "genesis.dump"
+    dump = tmp_path / f"{stem}.dump"
     dump_result = subprocess.run(
         [
             "docker",
@@ -711,7 +1102,7 @@ def test_live_genesis_plus_ledger_command_rebuilds_exactly_and_proves_cleanup(
             "-d",
             database,
             "--format=custom",
-            "--file=/tmp/genesis.dump",
+            f"--file=/tmp/{stem}.dump",
         ],
         text=True,
         capture_output=True,
@@ -719,15 +1110,130 @@ def test_live_genesis_plus_ledger_command_rebuilds_exactly_and_proves_cleanup(
     )
     assert dump_result.returncode == 0, dump_result.stderr
     copy_result = subprocess.run(
-        ["docker", "cp", f"{source_container}:/tmp/genesis.dump", str(genesis_dump)],
+        ["docker", "cp", f"{source_container}:/tmp/{stem}.dump", str(dump)],
         text=True,
         capture_output=True,
         check=False,
     )
     assert copy_result.returncode == 0, copy_result.stderr
+    manifest = tmp_path / f"{stem}-manifest.jsonl"
+    capture_manifest(source_container, database, manifest)
+    return dump, manifest
 
-    genesis_manifest = tmp_path / "genesis-manifest.jsonl"
+
-    capture_manifest(source_container, database, genesis_manifest)
+def seed_proposal_and_approval(
+    source_container: str,
+    database: str,
+    approved: dict,
+    approval: dict,
+) -> dict:
+    sql = f"""begin;
+set local standard_conforming_strings = on;
+insert into kb_stage.kb_proposals
+select seeded.* from jsonb_populate_record(
+  null::kb_stage.kb_proposals, {rebuild._jsonb_literal(approved)}
+) seeded;
+insert into kb_stage.kb_proposal_approvals
+select seeded.* from jsonb_populate_record(
+  null::kb_stage.kb_proposal_approvals, {rebuild._jsonb_literal(approval)}
+) seeded;
+commit;
+"""
+    docker_psql(source_container, database, sql)
+    raw = docker_psql(
+        source_container,
+        database,
+        rebuild.build_proposal_readback_sql(approved["id"]),
+    ).stdout.strip()
+    return json.loads(raw)
+
+
+def run_genesis_ledger_command(
+    *,
+    tmp_path: Path,
+    database: str,
+    genesis_dump: Path,
+    genesis_manifest: Path,
+    material_path: Path,
+    final_manifest: Path,
+    artifact_stem: str,
+    container_prefix: str,
+    run_number: int,
+) -> tuple[subprocess.CompletedProcess[str], dict, Path]:
+    ledger = {
+        "artifact": rebuild.LEDGER_ARTIFACT,
+        "contract_version": rebuild.LEDGER_CONTRACT_VERSION,
+        "engine": rebuild._engine_hashes(),
+        "genesis": {
+            "dump_sha256": sha256_file(genesis_dump),
+            "parity_manifest_sha256": sha256_file(genesis_manifest),
+        },
+        "entries": [
+            {
+                "sequence": 1,
+                "material": material_path.name,
+                "sha256": sha256_file(material_path),
+                "replay_material_sha256": json.loads(material_path.read_text(encoding="utf-8"))["replay_receipt"][
+                    "hashes"
+                ]["replay_material_sha256"],
+            }
+        ],
+        "final_parity": {
+            "manifest": final_manifest.name,
+            "sha256": sha256_file(final_manifest),
+        },
+    }
+    ledger_path = write_json(tmp_path / f"{artifact_stem}-ledger-run-{run_number}.json", ledger)
+    output = tmp_path / f"{artifact_stem}-reconstruction-receipt-run-{run_number}.json"
+    command = [
+        sys.executable,
+        str(Path(rebuild.__file__).resolve()),
+        "--genesis-dump",
+        str(genesis_dump),
+        "--genesis-manifest",
+        str(genesis_manifest),
+        "--ledger",
+        str(ledger_path),
+        "--ledger-sha256",
+        sha256_file(ledger_path),
+        "--database",
+        database,
+        "--container-prefix",
+        container_prefix,
+        "--tmpfs-mb",
+        "256",
+        "--max-target-query-ms",
+        "5000",
+        "--max-target-source-ratio",
+        "100",
+        "--output",
+        str(output),
+    ]
+    completed = subprocess.run(
+        command,
+        cwd=rebuild.REPO_ROOT,
+        text=True,
+        capture_output=True,
+        check=False,
+        timeout=180,
+    )
+    assert completed.returncode == 0, completed.stderr + completed.stdout
+    assert output.is_file(), "rebuild command succeeded without writing its receipt"
+    receipt = json.loads(output.read_text(encoding="utf-8"))
+    return completed, receipt, output
+
+
+def test_live_genesis_plus_ledger_command_rebuilds_exactly_and_proves_cleanup(
+    tmp_path: Path,
+    source_postgres: tuple[str, str],
+) -> None:
+    source_container, database = source_postgres
+    genesis_dump, genesis_manifest = capture_source_snapshot(
+        source_container,
+        database,
+        tmp_path,
+        stem="insert-only-genesis",
+    )
 
     material = replay_material()
     material_path = write_json(tmp_path / "entry-0001.json", material)
@@ -753,64 +1259,18 @@ def test_live_genesis_plus_ledger_command_rebuilds_exactly_and_proves_cleanup(
 
     final_manifest = tmp_path / "final-manifest.jsonl"
     capture_manifest(source_container, database, final_manifest)
-    ledger = {
+    completed, receipt, output = run_genesis_ledger_command(
-        "artifact": rebuild.LEDGER_ARTIFACT,
+        tmp_path=tmp_path,
-        "contract_version": rebuild.LEDGER_CONTRACT_VERSION,
+        database=database,
-        "engine": rebuild._engine_hashes(),
+        genesis_dump=genesis_dump,
-        "genesis": {
+        genesis_manifest=genesis_manifest,
-            "dump_sha256": sha256_file(genesis_dump),
+        material_path=material_path,
-            "parity_manifest_sha256": sha256_file(genesis_manifest),
+        final_manifest=final_manifest,
-        },
+        artifact_stem="insert-only",
-        "entries": [
+        container_prefix="teleo-genesis-ledger-live-test",
-            {
+        run_number=1,
-                "sequence": 1,
-                "material": material_path.name,
-                "sha256": sha256_file(material_path),
-                "replay_material_sha256": entry.replay_material_sha256,
-            }
-        ],
-        "final_parity": {
-            "manifest": final_manifest.name,
-            "sha256": sha256_file(final_manifest),
-        },
-    }
-    ledger_path = write_json(tmp_path / "ledger.json", ledger)
-    output = tmp_path / "reconstruction-receipt.json"
-    command = [
-        sys.executable,
-        str(Path(rebuild.__file__).resolve()),
-        "--genesis-dump",
-        str(genesis_dump),
-        "--genesis-manifest",
-        str(genesis_manifest),
-        "--ledger",
-        str(ledger_path),
-        "--ledger-sha256",
-        sha256_file(ledger_path),
-        "--database",
-        database,
-        "--container-prefix",
-        "teleo-genesis-ledger-live-test",
-        "--tmpfs-mb",
-        "256",
-        "--max-target-query-ms",
-        "5000",
-        "--max-target-source-ratio",
-        "100",
-        "--output",
-        str(output),
-    ]
-    completed = subprocess.run(
-        command,
-        cwd=rebuild.REPO_ROOT,
-        text=True,
-        capture_output=True,
-        check=False,
-        timeout=180,
     )
 
-    assert completed.returncode == 0, completed.stderr + completed.stdout
-    receipt = json.loads(output.read_text(encoding="utf-8"))
     assert receipt["status"] == "pass"
     assert receipt["genesis_parity"]["status"] == "pass"
     assert receipt["ledger"]["entries"][0]["status"] == "pass"
@@ -831,3 +1291,131 @@ def test_live_genesis_plus_ledger_command_rebuilds_exactly_and_proves_cleanup(
         check=False,
     )
     assert inspect.returncode != 0
+
+
+def test_live_revise_strategy_rebuild_is_exact_repeatable_and_leaves_no_container(
+    tmp_path: Path,
+    source_postgres: tuple[str, str],
+) -> None:
+    source_container, database = source_postgres
+    genesis_dump, genesis_manifest = capture_source_snapshot(
+        source_container,
+        database,
+        tmp_path,
+        stem="revise-strategy-genesis",
+    )
+
+    approved, _, approval = revise_strategy_proposal_rows()
+    pre_apply = seed_proposal_and_approval(
+        source_container,
+        database,
+        approved,
+        approval,
+    )
+    apply_sql = rebuild.apply_engine.build_apply_sql(pre_apply["proposal"], "kb-apply")
+    docker_psql(source_container, database, apply_sql, role="kb_apply")
+    post_apply = json.loads(
+        docker_psql(
+            source_container,
+            database,
+            rebuild.build_proposal_readback_sql(REVISE_PROPOSAL_ID),
+        ).stdout.strip()
+    )
+    applied_proposal = post_apply["proposal"]
+    proposal_envelope = applied_envelope(applied_proposal)
+    source_receipt_path, receipt = rebuild.apply_engine.capture_replay_receipt(
+        argparse.Namespace(
+            container=source_container,
+            role="kb_apply",
+            host="127.0.0.1",
+            db=database,
+            receipt_out=str(tmp_path / "source-revise-strategy-private-receipt.json"),
+            receipt_dir=None,
+        ),
+        proposal_envelope,
+        "",
+        apply_sql=apply_sql,
+    )
+    assert source_receipt_path.is_file()
+    assert stat.S_IMODE(source_receipt_path.stat().st_mode) == 0o600
+    material = {
+        "artifact": rebuild.MATERIAL_ARTIFACT,
+        "contract_version": rebuild.MATERIAL_CONTRACT_VERSION,
+        "sequence": 1,
+        "approved_proposal": pre_apply["proposal"],
+        "approval_snapshot": pre_apply["approval_snapshot"],
+        "applied_proposal": applied_proposal,
+        "replay_receipt": receipt,
+    }
+    material_path = write_json(tmp_path / "revise-strategy-entry-0001.json", material)
+    final_manifest = tmp_path / "revise-strategy-final-manifest.jsonl"
+    capture_manifest(source_container, database, final_manifest)
+
+    runs = [
+        run_genesis_ledger_command(
+            tmp_path=tmp_path,
+            database=database,
+            genesis_dump=genesis_dump,
+            genesis_manifest=genesis_manifest,
+            material_path=material_path,
+            final_manifest=final_manifest,
+            artifact_stem="revise-strategy",
+            container_prefix="teleo-genesis-ledger-revise",
+            run_number=run_number,
+        )
+        for run_number in (1, 2)
+    ]
+
+    for completed, reconstruction, output in runs:
+        assert reconstruction["status"] == "pass"
+        assert reconstruction["genesis_parity"]["status"] == "pass"
+        assert reconstruction["final_parity"]["status"] == "pass"
+        entry_summary = reconstruction["ledger"]["entries"][0]
+        assert entry_summary["proposal_type"] == "revise_strategy"
+        assert entry_summary["proposal_seed_exact"] is True
+        assert entry_summary["canonical_seed_exact"] is False
+        assert entry_summary["seed_exact"] is False
+        assert entry_summary["guarded_apply_executed"] is True
+        assert entry_summary["mutating_prestate_captured"] is True
+        assert entry_summary["mutating_delta_validated"] is True
+        assert entry_summary["mutating_poststate_normalized"] is True
+        assert entry_summary["proposal_exact"] is True
+        assert entry_summary["canonical_rows_exact"] is True
+        assert reconstruction["cleanup"]["container_absent"] is True
+        assert reconstruction["safety"]["network_access_available_to_container"] is False
+        assert reconstruction["safety"]["private_replay_material_emitted"] is False
+        assert PRIVATE_MARKER not in completed.stdout
+        assert PRIVATE_MARKER not in output.read_text(encoding="utf-8")
+        assert stat.S_IMODE(output.stat().st_mode) == 0o600
+
+        container_name = reconstruction["container"]["name"]
+        inspect = subprocess.run(
+            ["docker", "container", "inspect", container_name],
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        assert inspect.returncode != 0
+        labeled = subprocess.run(
+            [
+                "docker",
+                "ps",
+                "-aq",
+                "--filter",
+                f"label={rebuild.canonical_rebuild.CANARY_LABEL}={container_name}",
+            ],
+            text=True,
+            capture_output=True,
+            check=False,
+        )
+        assert labeled.returncode == 0
+        assert labeled.stdout.strip() == ""
+
+    first = runs[0][1]
+    second = runs[1][1]
+    assert first["inputs"] == second["inputs"]
+    assert first["ledger"]["entries"][0]["material_sha256"] == second["ledger"]["entries"][0]["material_sha256"]
+    assert (
+        first["ledger"]["entries"][0]["replay_material_sha256"]
+        == second["ledger"]["entries"][0]["replay_material_sha256"]
+    )

tests/test_stage_normalized_proposal.py

@@ -116,6 +116,37 @@ def test_invalid_source_hash_refuses_to_prepare_a_child() -> None:
         stage.prepare_normalized_child(parent)
 
 
+def test_prepare_normalized_child_preserves_replayable_ingestion_manifest() -> None:
+    parent = _parent()
+    parent["payload"]["ingestion_manifest"] = {
+        "artifact_sha256": "a" * 64,
+        "extractor": {"name": "deterministic_fixture_replay", "version": "2"},
+        "replay_identity_sha256": "b" * 64,
+        "segments": [
+            {
+                "id": "message-1",
+                "locator": "telegram://chat/1/message/1",
+                "content_sha256": "c" * 64,
+            }
+        ],
+    }
+
+    child = stage.prepare_normalized_child(parent)
+
+    assert (
+        child["payload"]["apply_payload"]["normalization_manifest"]["ingestion_manifest"]
+        == parent["payload"]["ingestion_manifest"]
+    )
+
+
+def test_prepare_normalized_child_rejects_non_object_ingestion_manifest() -> None:
+    parent = _parent()
+    parent["payload"]["ingestion_manifest"] = "not-an-object"
+
+    with pytest.raises(stage.bound.CheckpointError, match="ingestion_manifest must be an object"):
+        stage.prepare_normalized_child(parent)
+
+
 def test_stage_sql_validates_exact_pending_row_before_commit_and_never_writes_public() -> None:
     child = stage.prepare_normalized_child(_parent())
     sql = stage.build_stage_sql(child)

tests/test_verify_telegram_visible_unseen_chain.py

@@ -0,0 +1,766 @@
+from __future__ import annotations
+
+import copy
+import hashlib
+import json
+import struct
+import zlib
+from pathlib import Path
+
+import pytest
+
+from scripts import build_telegram_visible_unseen_chain_packet as packet_builder
+from scripts import collect_telegram_visible_unseen_chain_state as state_collector
+from scripts import verify_telegram_visible_unseen_chain as verifier
+
+SUBJECT_ID = "c0000000-0000-4000-8000-000000000001"
+CHALLENGE_NONCE = "a" * 64
+TURN_CAPTURE_CALL_IDS = ["call_chrome_turn_1", "call_chrome_turn_2", "call_chrome_turn_3"]
+FINAL_CAPTURE_CALL_ID = "call_chrome_final"
+
+
+def packet_and_path(tmp_path: Path) -> tuple[dict, Path]:
+    packet = packet_builder.build_packet(
+        handler_receipt_path=packet_builder.DEFAULT_HANDLER_RECEIPT.resolve(),
+        git_sha="a" * 40,
+    )
+    path = tmp_path / "packet.json"
+    packet_builder.write_json(path, packet)
+    return packet, path
+
+
+def _finish_state_token(value: dict) -> dict:
+    value["state_token_sha256"] = state_collector.derive_state_token(value)
+    return value
+
+
+def preflight(packet: dict, packet_path: Path) -> dict:
+    return _finish_state_token(
+        {
+            "schema": state_collector.SCHEMA,
+            "generated_at_utc": "2026-07-14T23:59:00+00:00",
+            "phase": "preflight",
+            "status": "pass",
+            "protocol_sha256": packet["protocol_sha256"],
+            "packet_file_sha256": verifier._sha256_file(packet_path),
+            "manifest_binding": packet["manifest_binding"],
+            "capture_challenge_nonce": CHALLENGE_NONCE,
+            "baseline_state_token_sha256": "",
+            "subject_ref": "",
+            "packet_checks": {"fixture_packet_checks_pass": True},
+            "remote_checks": {"fixture_remote_checks_pass": True},
+            "baseline_checks": {},
+            "remote": {
+                "deploy_head": "d" * 40,
+                "last_deploy_sha": "d" * 40,
+                "fingerprint_after": {"fingerprint_sha256": "f" * 64},
+                "service_after": {
+                    "MainPID": "123",
+                    "NRestarts": "0",
+                    "ExecMainStartTimestamp": "Wed 2026-07-15 00:00:00 UTC",
+                },
+                "subject_readback": None,
+            },
+        }
+    )
+
+
+def postflight(packet: dict, packet_path: Path, before: dict) -> dict:
+    return _finish_state_token(
+        {
+            "schema": state_collector.SCHEMA,
+            "generated_at_utc": "2026-07-15T00:04:00Z",
+            "phase": "postflight",
+            "status": "pass",
+            "protocol_sha256": packet["protocol_sha256"],
+            "packet_file_sha256": verifier._sha256_file(packet_path),
+            "manifest_binding": packet["manifest_binding"],
+            "capture_challenge_nonce": CHALLENGE_NONCE,
+            "baseline_state_token_sha256": before["state_token_sha256"],
+            "subject_ref": "c0000000",
+            "packet_checks": {"fixture_packet_checks_pass": True},
+            "remote_checks": {"fixture_remote_checks_pass": True},
+            "baseline_checks": {"fixture_baseline_checks_pass": True},
+            "remote": {
+                "deploy_head": "d" * 40,
+                "last_deploy_sha": "d" * 40,
+                "fingerprint_after": {"fingerprint_sha256": "f" * 64},
+                "service_after": {
+                    "MainPID": "123",
+                    "NRestarts": "0",
+                    "ExecMainStartTimestamp": "Wed 2026-07-15 00:00:00 UTC",
+                },
+                "subject_readback": {
+                    "subject_ref": "c0000000",
+                    "matches": [
+                        {
+                            "table": "public.beliefs",
+                            "row": {"id": SUBJECT_ID, "statement": "Coordination is the bottleneck."},
+                        }
+                    ],
+                },
+            },
+        }
+    )
+
+
+def write_png(path: Path, rgba: tuple[int, int, int, int]) -> None:
+    width = verifier.MIN_SCREENSHOT_WIDTH
+    height = verifier.MIN_SCREENSHOT_HEIGHT
+    scanline = b"\x00" + bytes(rgba) * width
+    pixels = scanline * height
+
+    def chunk(kind: bytes, payload: bytes) -> bytes:
+        return (
+            struct.pack(">I", len(payload))
+            + kind
+            + payload
+            + struct.pack(">I", zlib.crc32(kind + payload) & 0xFFFFFFFF)
+        )
+
+    ihdr = struct.pack(">IIBBBBB", width, height, 8, 6, 0, 0, 0)
+    path.write_bytes(
+        b"\x89PNG\r\n\x1a\n" + chunk(b"IHDR", ihdr) + chunk(b"IDAT", zlib.compress(pixels)) + chunk(b"IEND", b"")
+    )
+
+
+def _artifact_hashes(capture: dict) -> dict:
+    source = capture["capture_source"]
+    return {
+        "final_screenshot": verifier._sha256_file(Path(source["final_screenshot"])),
+        "final_accessibility": verifier._sha256_file(Path(source["final_accessibility"])),
+        "turn_screenshots": [verifier._sha256_file(Path(item["turn_screenshot"])) for item in capture["messages"]],
+        "turn_accessibility": [verifier._sha256_file(Path(item["turn_accessibility"])) for item in capture["messages"]],
+    }
+
+
+def authorization_event(packet: dict, capture: dict) -> dict:
+    return {
+        "timestamp": capture["operator_authorization_captured_at_utc"],
+        "type": "response_item",
+        "payload": {
+            "type": "message",
+            "role": "user",
+            "content": [{"type": "input_text", "text": capture["operator_authorization_text"]}],
+            "internal_chat_message_metadata_passthrough": {"turn_id": "user-message-20260715-authorization"},
+        },
+    }
+
+
+def write_browser_provenance(packet: dict, capture: dict, path: Path) -> str:
+    source = capture["capture_source"]
+    auth_event = authorization_event(packet, capture)
+    auth_event_sha256 = hashlib.sha256(
+        json.dumps(auth_event, sort_keys=True, separators=(",", ":")).encode("utf-8")
+    ).hexdigest()
+    final_call_id = TURN_CAPTURE_CALL_IDS[2] if source["final_capture_reuses_turn_3"] else FINAL_CAPTURE_CALL_ID
+    provenance = {
+        "schema": verifier.BROWSER_PROVENANCE_SCHEMA,
+        "status": "pass",
+        "capture_channel": "codex_chrome_extension",
+        "capture_challenge_nonce": CHALLENGE_NONCE,
+        "protocol_sha256": packet["protocol_sha256"],
+        "turn_capture_call_ids": TURN_CAPTURE_CALL_IDS,
+        "final_capture_call_id": final_call_id,
+        "browser": {
+            "browser_type": "extension",
+            "browser_id": "chrome-backend-20260715",
+            "session_id": "chrome-session-20260715",
+            "tab_id": "telegram-tab-20260715",
+            "provider_capture_id": "chrome-capture-20260715",
+            "page_url": "https://web.telegram.org/k/#-5146042086",
+            "page_title": "Leo - Telegram",
+            "captured_at_utc": source["captured_at_utc"],
+        },
+        "authorization": {
+            "source": "codex_platform_user_message",
+            "thread_id": packet["operator_context"]["codex_thread_id"],
+            "user_message_id": "user-message-20260715-authorization",
+            "source_receipt_id": auth_event_sha256,
+            "text_sha256": hashlib.sha256(capture["operator_authorization_text"].encode("utf-8")).hexdigest(),
+            "captured_at_utc": capture["operator_authorization_captured_at_utc"],
+        },
+        "telegram": {
+            "chat_label": "Leo",
+            "chat_id": "-5146042086",
+            "message_ids": [item["telegram_message_id"] for item in capture["messages"]],
+            "reply_ids": [item["reply_message_id"] for item in capture["messages"]],
+        },
+        "artifacts": _artifact_hashes(capture),
+        "checks": {
+            "authenticated_chrome_extension_session": True,
+            "telegram_web_origin_observed": True,
+            "chat_identity_observed_in_browser": True,
+            "message_ids_observed_in_browser": True,
+            "accessibility_captured_from_browser": True,
+            "screenshots_captured_from_browser": True,
+            "authorization_read_from_codex_user_message": True,
+        },
+    }
+    path.write_text(json.dumps(provenance, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    return verifier._sha256_file(path)
+
+
+def write_codex_rollout(packet: dict, capture: dict, tmp_path: Path, provenance_sha256: str) -> Path:
+    provenance_path = Path(capture["capture_source"]["browser_provenance"])
+    provenance = json.loads(provenance_path.read_text(encoding="utf-8"))
+    browser = provenance["browser"]
+    artifacts = provenance["artifacts"]
+    thread_id = packet["operator_context"]["codex_thread_id"]
+    sessions_root = tmp_path.parent / f"{tmp_path.name}-codex-sessions"
+    rollout_dir = sessions_root / "2026" / "07" / "15"
+    rollout_dir.mkdir(parents=True, exist_ok=True)
+    rollout_path = rollout_dir / f"rollout-2026-07-15T00-00-00-{thread_id}.jsonl"
+    events = [
+        {
+            "timestamp": "2026-07-14T23:58:00Z",
+            "type": "session_meta",
+            "payload": {"id": thread_id},
+        },
+        authorization_event(packet, capture),
+    ]
+
+    def chrome_event(call_id: str, timestamp: str, values: list[str]) -> dict:
+        return {
+            "timestamp": timestamp,
+            "type": "event_msg",
+            "payload": {
+                "type": "mcp_tool_call_end",
+                "call_id": call_id,
+                "invocation": {
+                    "server": "node_repl",
+                    "tool": "js",
+                    "arguments": {
+                        "code": (
+                            "await tab.screenshot({fullPage:false}); "
+                            "await tab.playwright.domSnapshot(); await tab.url(); await tab.title();"
+                        )
+                    },
+                },
+                "result": {
+                    "Ok": {
+                        "content": [{"type": "text", "text": json.dumps(values)}],
+                        "isError": False,
+                        "_meta": {
+                            "codex/toolSurface": {
+                                "backend": "chrome",
+                                "browserId": browser["browser_id"],
+                                "kind": "browserUse",
+                                "openTabIds": [browser["tab_id"]],
+                            }
+                        },
+                    }
+                },
+            },
+        }
+
+    turn_timestamps = ["2026-07-15T00:01:30Z", "2026-07-15T00:02:30Z", "2026-07-15T00:03:30Z"]
+    for index, (call_id, timestamp, message) in enumerate(
+        zip(TURN_CAPTURE_CALL_IDS, turn_timestamps, capture["messages"], strict=True)
+    ):
+        values = [
+            artifacts["turn_screenshots"][index],
+            artifacts["turn_accessibility"][index],
+            message["telegram_message_id"],
+            message["reply_message_id"],
+            browser["page_url"],
+            browser["page_title"],
+            packet["target"]["chat_id"],
+        ]
+        if provenance["final_capture_call_id"] == call_id:
+            values.extend(
+                [
+                    artifacts["final_screenshot"],
+                    artifacts["final_accessibility"],
+                    provenance_sha256,
+                    *[item["telegram_message_id"] for item in capture["messages"]],
+                    *[item["reply_message_id"] for item in capture["messages"]],
+                ]
+            )
+            timestamp = capture["capture_source"]["captured_at_utc"]
+        events.append(chrome_event(call_id, timestamp, values))
+    if provenance["final_capture_call_id"] == FINAL_CAPTURE_CALL_ID:
+        events.append(
+            chrome_event(
+                FINAL_CAPTURE_CALL_ID,
+                capture["capture_source"]["captured_at_utc"],
+                [
+                    artifacts["final_screenshot"],
+                    artifacts["final_accessibility"],
+                    provenance_sha256,
+                    *[item["telegram_message_id"] for item in capture["messages"]],
+                    *[item["reply_message_id"] for item in capture["messages"]],
+                ],
+            )
+        )
+    rollout_path.write_text(
+        "".join(json.dumps(event, sort_keys=True) + "\n" for event in events),
+        encoding="utf-8",
+    )
+    return rollout_path
+
+
+def refresh_provenance_and_rollout(packet: dict, capture: dict, tmp_path: Path) -> Path:
+    provenance_path = Path(capture["capture_source"]["browser_provenance"])
+    provenance_sha256 = write_browser_provenance(packet, capture, provenance_path)
+    return write_codex_rollout(packet, capture, tmp_path, provenance_sha256)
+
+
+def good_capture(packet: dict, tmp_path: Path) -> tuple[dict, Path]:
+    screenshot = tmp_path / "final.png"
+    accessibility = tmp_path / "final.txt"
+    write_png(screenshot, (10, 20, 30, 255))
+    accessibility.write_text("telegram final accessibility proof", encoding="utf-8")
+    replies = [
+        (
+            "The database public.beliefs object c0000000 is an axiom with confidence 0.85. What supports it in "
+            "the DB: nothing supports it; there are zero evidence rows and no external primary source."
+        ),
+        (
+            "Claim c0000000 is still the coordination bottleneck belief. Assumption versus observed support: the "
+            "priority leap is assumed and the evidence is absent. Falsifier: a contrary case. Proposal A and "
+            "Proposal B are staged only for review; nothing applied and neither is live knowledge."
+        ),
+        (
+            "Revised proposal: separate the mechanism from the business outcome. What would resolve the "
+            "disagreement: a randomized study and its primary source dataset. Keep it pending_review for human "
+            "review; approved is not apply and applied_at remains null. This is not an apply."
+        ),
+    ]
+    colors = [(40, 50, 60, 255), (70, 80, 90, 255), (100, 110, 120, 255)]
+    messages = []
+    for item, reply, color in zip(packet["exact_messages"], replies, colors, strict=True):
+        sequence = item["sequence"]
+        turn_screenshot = tmp_path / f"turn-{sequence}.png"
+        turn_accessibility = tmp_path / f"turn-{sequence}.txt"
+        write_png(turn_screenshot, color)
+        turn_accessibility.write_text(
+            f"Telegram message: {item['message']}\nLeo reply: {reply}\n",
+            encoding="utf-8",
+        )
+        messages.append(
+            {
+                "sequence": sequence,
+                "prompt_id": item["prompt_id"],
+                "sent_text": item["message"],
+                "reply": reply,
+                "sent_at_utc": f"2026-07-15T00:0{sequence}:00Z",
+                "reply_at_utc": f"2026-07-15T00:0{sequence}:20Z",
+                "telegram_message_id": f"sent-{sequence}",
+                "reply_message_id": f"reply-{sequence}",
+                "turn_screenshot": str(turn_screenshot),
+                "turn_accessibility": str(turn_accessibility),
+            }
+        )
+    provenance_path = tmp_path / "browser-provenance.json"
+    capture = {
+        "schema": verifier.CAPTURE_SCHEMA,
+        "protocol_sha256": packet["protocol_sha256"],
+        "preflight_state_token_sha256": "",
+        "operator_authorization_text": packet["explicit_operator_authorization_text"],
+        "operator_authorization_captured_at_utc": "2026-07-15T00:00:00Z",
+        "extra_messages_sent": 0,
+        "capture_source": {
+            "platform": "telegram",
+            "transport": "authenticated_chrome_telegram_ui",
+            "chat_label": "Leo",
+            "chat_id": "-5146042086",
+            "captured_at_utc": "2026-07-15T00:03:40Z",
+            "captured_by": "codex_chrome_extension",
+            "final_screenshot": str(screenshot),
+            "final_accessibility": str(accessibility),
+            "browser_provenance": str(provenance_path),
+            "final_capture_reuses_turn_3": False,
+            "final_capture_reuse_reason": "",
+        },
+        "messages": messages,
+    }
+    rollout_path = refresh_provenance_and_rollout(packet, capture, tmp_path)
+    return capture, rollout_path
+
+
+def verified_fixture(tmp_path: Path) -> tuple[dict, Path, dict, dict, dict, Path]:
+    packet, packet_path = packet_and_path(tmp_path)
+    before = preflight(packet, packet_path)
+    after = postflight(packet, packet_path, before)
+    capture, rollout = good_capture(packet, tmp_path)
+    capture["preflight_state_token_sha256"] = before["state_token_sha256"]
+    return packet, packet_path, before, after, capture, rollout
+
+
+def run_verifier(
+    packet: dict,
+    packet_path: Path,
+    before: dict,
+    after: dict,
+    capture: dict,
+    rollout_log: Path | None,
+    tmp_path: Path,
+) -> dict:
+    return verifier.verify_capture(
+        packet,
+        before,
+        capture,
+        after,
+        packet_path=packet_path,
+        evidence_root=tmp_path,
+        codex_rollout_log=rollout_log,
+        codex_sessions_root=(
+            rollout_log.parents[3] if rollout_log is not None else tmp_path.parent / f"{tmp_path.name}-codex-sessions"
+        ),
+    )
+
+
+def test_no_capture_returns_awaiting_authorization_template(tmp_path: Path) -> None:
+    packet, packet_path = packet_and_path(tmp_path)
+    before = preflight(packet, packet_path)
+
+    receipt = verifier.verify_capture(
+        packet,
+        before,
+        None,
+        None,
+        packet_path=packet_path,
+        evidence_root=tmp_path,
+    )
+
+    assert receipt["status"] == "awaiting_action_time_authorization"
+    assert receipt["preparation_ready"] is True
+    assert receipt["receipt_ready"] is False
+    assert receipt["current_tier"] == verifier.PREPARATION_TIER
+    assert receipt["telegram_visible_messages_sent"] is False
+    assert receipt["live_receipt_boundary"]["accepted_by_this_api"] is False
+    assert receipt["live_receipt_boundary"]["verified"] is False
+    assert receipt["capture_template"]["schema"] == verifier.CAPTURE_SCHEMA
+    assert receipt["capture_template"]["messages"][0]["prompt_id"] == "OOS-CHAIN-01"
+
+
+def test_public_verifier_keeps_fully_well_formed_all_local_forgery_preparation_only(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    preflight_path = tmp_path / "preflight.json"
+    capture_path = tmp_path / "capture.json"
+    postflight_path = tmp_path / "postflight.json"
+    out_path = tmp_path / "receipt.json"
+    markdown_path = tmp_path / "receipt.md"
+    verifier.write_json(preflight_path, before)
+    verifier.write_json(capture_path, capture)
+    verifier.write_json(postflight_path, after)
+    monkeypatch.setattr(verifier, "DEFAULT_CODEX_SESSIONS_ROOT", rollout.parents[3])
+
+    exit_code = verifier.main(
+        [
+            "--packet",
+            str(packet_path),
+            "--preflight",
+            str(preflight_path),
+            "--capture-json",
+            str(capture_path),
+            "--postflight",
+            str(postflight_path),
+            "--evidence-root",
+            str(tmp_path),
+            "--codex-rollout-log",
+            str(rollout),
+            "--out",
+            str(out_path),
+            "--markdown-out",
+            str(markdown_path),
+        ]
+    )
+    receipt = json.loads(out_path.read_text(encoding="utf-8"))
+
+    assert exit_code == 0
+    assert receipt["status"] == verifier.PREPARATION_STATUS
+    assert receipt["verification_scope"] == "caller_writable_preparation_structure"
+    assert receipt["preparation_ready"] is True
+    assert receipt["receipt_ready"] is False
+    assert receipt["current_tier"] == verifier.PREPARATION_TIER
+    assert receipt["telegram_visible_messages_sent"] is False
+    assert receipt["live_receipt_boundary"] == {
+        "accepted_by_this_api": False,
+        "authority": "independently_authenticated_platform_browser_receipt",
+        "local_inputs_are": "caller_writable_preparation_evidence",
+        "required": True,
+        "verified": False,
+    }
+    assert all(receipt["checks"].values())
+    assert all(receipt["preparation_outcomes"].values())
+    assert receipt["selected_subject"]["row_id"] == SUBJECT_ID
+    assert "T3_live_readonly" not in receipt["current_tier"]
+    assert "caller-writable preparation evidence only" in markdown_path.read_text(encoding="utf-8")
+
+
+def test_self_declared_browser_provenance_without_codex_rollout_cannot_pass_t3(
+    tmp_path: Path,
+) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, None, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["telegram_visible_messages_sent"] is False
+    assert receipt["checks"]["codex_rollout_log_has_expected_local_sessions_shape"] is False
+    assert receipt["checks"]["codex_rollout_capture_events_are_chrome_backend"] is False
+
+
+def test_non_chrome_rollout_capture_events_are_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    events = [json.loads(line) for line in rollout.read_text(encoding="utf-8").splitlines()]
+    for event in events:
+        payload = event.get("payload") or {}
+        if payload.get("type") == "mcp_tool_call_end":
+            payload["result"]["Ok"]["_meta"]["codex/toolSurface"]["backend"] = "computerUse"
+    rollout.write_text(
+        "".join(json.dumps(event, sort_keys=True) + "\n" for event in events),
+        encoding="utf-8",
+    )
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["codex_rollout_capture_events_are_chrome_backend"] is False
+
+
+def test_bot_api_capture_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    capture["capture_source"]["transport"] = "telegram_bot_api"
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["authenticated_chrome_transport_declared"] is False
+    assert receipt["checks"]["bot_api_not_substituted"] is False
+
+
+def test_postflight_fingerprint_drift_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    after["remote"]["fingerprint_after"]["fingerprint_sha256"] = "0" * 64
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["postflight_state_token_derivation_valid"] is False
+    assert receipt["checks"]["canonical_fingerprint_unchanged_from_preflight"] is False
+
+
+def test_message_text_drift_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    capture["messages"][1]["sent_text"] += " extra"
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["sent_text_exact"] is False
+
+
+def test_sent_and_reply_message_id_reuse_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+    capture["messages"][0]["reply_message_id"] = capture["messages"][0]["telegram_message_id"]
+    rollout = refresh_provenance_and_rollout(packet, capture, tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["message_and_reply_ids_present_unique"] is False
+
+
+def test_copied_reply_not_present_in_accessibility_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    capture["messages"][0]["reply"] += " copied-only suffix"
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["turn_accessibility_binds_exact_messages_and_replies"] is False
+
+
+def test_all_prompts_sent_before_replies_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    capture["messages"][0]["reply_at_utc"] = "2026-07-15T00:02:30Z"
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["strict_send_reply_turn_order"] is False
+
+
+def test_after_the_fact_authorization_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+    capture["operator_authorization_captured_at_utc"] = "2026-07-15T00:01:10Z"
+    rollout = refresh_provenance_and_rollout(packet, capture, tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["captured_authorization_before_first_send"] is False
+
+
+@pytest.mark.parametrize("timestamp", ["2026-07-15T00:01:00", "not-a-timestamp"])
+def test_naive_or_malformed_timestamps_are_rejected(tmp_path: Path, timestamp: str) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    capture["messages"][0]["sent_at_utc"] = timestamp
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["timestamps_valid_and_timezone_aware"] is False
+
+
+def test_reused_per_turn_evidence_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+    capture["messages"][1]["turn_screenshot"] = capture["messages"][0]["turn_screenshot"]
+    capture["messages"][1]["turn_accessibility"] = capture["messages"][0]["turn_accessibility"]
+    rollout = refresh_provenance_and_rollout(packet, capture, tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["per_turn_screenshot_hashes_distinct_nonempty"] is False
+    assert receipt["checks"]["per_turn_accessibility_hashes_distinct_nonempty"] is False
+
+
+def test_final_capture_may_reuse_turn_three_when_documented(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+    capture["capture_source"]["final_screenshot"] = capture["messages"][2]["turn_screenshot"]
+    capture["capture_source"]["final_accessibility"] = capture["messages"][2]["turn_accessibility"]
+    capture["capture_source"]["final_capture_reuses_turn_3"] = True
+    capture["capture_source"]["final_capture_reuse_reason"] = (
+        "The final Chrome capture is the retained third-turn response state."
+    )
+    rollout = refresh_provenance_and_rollout(packet, capture, tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == verifier.PREPARATION_STATUS
+    assert receipt["preparation_ready"] is True
+    assert receipt["receipt_ready"] is False
+    assert receipt["telegram_visible_messages_sent"] is False
+    assert receipt["checks"]["final_capture_reuse_policy_satisfied"] is True
+
+
+def test_undocumented_final_turn_three_reuse_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+    capture["capture_source"]["final_screenshot"] = capture["messages"][2]["turn_screenshot"]
+    rollout = refresh_provenance_and_rollout(packet, capture, tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["final_capture_reuse_policy_satisfied"] is False
+
+
+def test_evidence_path_escape_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    outside = tmp_path.parent / "outside-turn.png"
+    write_png(outside, (1, 2, 3, 255))
+    capture["messages"][0]["turn_screenshot"] = str(outside)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["all_evidence_paths_contained_in_root"] is False
+
+
+def test_non_png_screenshot_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, _rollout = verified_fixture(tmp_path)
+    Path(capture["messages"][0]["turn_screenshot"]).write_bytes(b"not a png")
+    rollout = refresh_provenance_and_rollout(packet, capture, tmp_path)
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["screenshots_are_valid_png_with_metadata"] is False
+
+
+def test_malformed_local_bundle_without_supported_state_or_rollout_structure_fails(
+    tmp_path: Path,
+) -> None:
+    packet, packet_path = packet_and_path(tmp_path)
+    before = {
+        "phase": "preflight",
+        "status": "pass",
+        "generated_at_utc": "2026-07-14T23:59:00Z",
+        "protocol_sha256": packet["protocol_sha256"],
+        "packet_file_sha256": verifier._sha256_file(packet_path),
+        "state_token_sha256": "1" * 64,
+        "remote": {"fingerprint_after": {"fingerprint_sha256": "f" * 64}, "service_after": {}},
+    }
+    after = {
+        "phase": "postflight",
+        "status": "pass",
+        "generated_at_utc": "2026-07-15T00:04:00Z",
+        "protocol_sha256": packet["protocol_sha256"],
+        "state_token_sha256": "2" * 64,
+        "subject_ref": "c0000000",
+        "remote": {
+            "fingerprint_after": {"fingerprint_sha256": "f" * 64},
+            "service_after": {},
+            "subject_readback": {"subject_ref": "c0000000", "matches": []},
+        },
+    }
+    fake_png = tmp_path / "fake.png"
+    fake_text = tmp_path / "fake.txt"
+    fake_png.write_bytes(b"arbitrary non-PNG bytes")
+    fake_text.write_text("copied prompts and replies", encoding="utf-8")
+    capture = {
+        "protocol_sha256": packet["protocol_sha256"],
+        "preflight_state_token_sha256": "1" * 64,
+        "operator_authorization_text": packet["explicit_operator_authorization_text"],
+        "operator_authorization_captured_at_utc": "2026-07-15T00:00:00Z",
+        "extra_messages_sent": 0,
+        "capture_source": {
+            "platform": "telegram",
+            "transport": "authenticated_chrome_telegram_ui",
+            "chat_label": "Leo",
+            "chat_id": "-5146042086",
+            "captured_at_utc": "2026-07-15T00:03:40Z",
+            "captured_by": "fabricated",
+            "final_screenshot": str(fake_png),
+            "final_accessibility": str(fake_text),
+            "browser_provenance": "",
+            "final_capture_reuses_turn_3": False,
+            "final_capture_reuse_reason": "",
+        },
+        "messages": [
+            {
+                "sequence": item["sequence"],
+                "prompt_id": item["prompt_id"],
+                "sent_text": item["message"],
+                "reply": f"fabricated reply {item['sequence']}",
+                "sent_at_utc": f"2026-07-15T00:0{item['sequence']}:00Z",
+                "reply_at_utc": f"2026-07-15T00:0{item['sequence']}:20Z",
+                "telegram_message_id": f"sent-{item['sequence']}",
+                "reply_message_id": f"reply-{item['sequence']}",
+                "turn_screenshot": str(fake_png),
+                "turn_accessibility": str(fake_text),
+            }
+            for item in packet["exact_messages"]
+        ],
+    }
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, None, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["current_tier"] != "T3_live_readonly"
+    assert receipt["telegram_visible_messages_sent"] is False
+    assert receipt["checks"]["capture_schema_supported"] is False
+    assert receipt["checks"]["preflight_schema_supported"] is False
+    assert receipt["checks"]["preflight_state_token_derivation_valid"] is False
+    assert receipt["checks"]["codex_rollout_log_has_expected_local_sessions_shape"] is False
+    assert receipt["checks"]["codex_rollout_has_exact_single_authorization_event"] is False
+    assert receipt["checks"]["screenshots_are_valid_png_with_metadata"] is False
+    assert receipt["checks"]["per_turn_screenshot_hashes_distinct_nonempty"] is False
+
+
+def test_state_token_tampering_is_rejected(tmp_path: Path) -> None:
+    packet, packet_path, before, after, capture, rollout = verified_fixture(tmp_path)
+    before = copy.deepcopy(before)
+    before["generated_at_utc"] = "2026-07-14T23:58:00Z"
+
+    receipt = run_verifier(packet, packet_path, before, after, capture, rollout, tmp_path)
+
+    assert receipt["status"] == "fail"
+    assert receipt["checks"]["preflight_state_token_derivation_valid"] is False