harness-everything 0.30.8 → 0.30.10

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
       "name": "harness-everything",
       "source": "./",
       "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-      "version": "0.30.8",
+      "version": "0.30.10",
       "author": {
         "name": "Miya Daniel"
       },

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "harness-everything",
   "description": "Harness OS: an orchestrated agent operating system — tier routing, circuit breaker guardrails, verification gates, WAL session memory, and self-evolving workspace rules.",
-  "version": "0.30.8",
+  "version": "0.30.10",
   "author": {
     "name": "Miya Daniel"
   },

package/.github/workflows/ci.yml

@@ -29,6 +29,37 @@ jobs:
       - name: Run focused mutation checks
         run: npm run test:mutations
 
+  # Pin the patched version: floating Node 24 already passed before #284.
+  system-one-windows-node24-patched:
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: '24.20.0'
+      - name: Verify exact patched runtime
+        run: node -e "if (process.versions.node !== '24.20.0') process.exit(1)"
+      - name: Exercise real evaluator subprocess and repeated resident teardown
+        run: node --test ci/mechanism-system-one-resident.test.js
+
+  # Node >=22 also includes the odd-numbered Node 23 line. Keep its
+  # documented Windows shutdown failure visible, without narrowing engines.
+  system-one-windows-node-legacy-policy:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        node: ['23.6.0', '24.15.0']
+    steps:
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
+        with:
+          node-version: ${{ matrix.node }}
+      - name: Verify exact affected runtime
+        run: node -e "if (process.versions.node !== '${{ matrix.node }}') process.exit(1)"
+      - name: Confirm explicit RS13 skip with version-policy unit coverage
+        run: node --test --test-name-pattern="S1-RS00|S1-RS13" ci/mechanism-system-one-resident.test.js
+
   runtime-floor:
     runs-on: ubuntu-latest
     steps:

package/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to this project are documented in this file.
 
+## [0.30.10](https://github.com/dyphn1/Harness-everything/compare/v0.30.9...v0.30.10) (2026-10-13)
+
+### Bug Fixes
+
+* **codex:** address observation review findings ([b869cfb](https://github.com/dyphn1/Harness-everything/commit/b869cfbdb44172ee88ad6ae3f76e29c8da6e9da8))
+* **codex:** sync hooks and recover turn labels ([d29112e](https://github.com/dyphn1/Harness-everything/commit/d29112e15ac255c5ded6fcf2aab3a21c710b3def)), closes [#304](https://github.com/dyphn1/Harness-everything/issues/304)
+* **codex:** validate sources and report import failures ([3f57b8b](https://github.com/dyphn1/Harness-everything/commit/3f57b8b376bfd437c8cff6ddbe4ddbf036380198)), closes [#304](https://github.com/dyphn1/Harness-everything/issues/304)
+
+## [Unreleased]
+
+### Bug Fixes
+
+* **codex:** keep compatibility hooks and session labels in sync
+
+## [0.30.9](https://github.com/dyphn1/Harness-everything/compare/v0.30.8...v0.30.9) (2026-10-08)
+
+### Bug Fixes
+
+* **system-one:** cover Windows Node 23 shutdown regression ([75ef983](https://github.com/dyphn1/Harness-everything/commit/75ef9833e4fcfb697c8323836f08eed3dfc7ff8d))
+* **test:** correct Windows Node version policy regex ([c0b63cc](https://github.com/dyphn1/Harness-everything/commit/c0b63cc3f18dc7126e4680f4fa7682ea2a4729ef))
+
 ## [0.30.8](https://github.com/dyphn1/Harness-everything/compare/v0.30.7...v0.30.8) (2026-10-07)
 
 ### Bug Fixes

package/README.md

@@ -48,7 +48,7 @@ The exact "Harness" behavior depends on the installation surface. Claude Code ha
 
 Harness integrates directly into your workspace. There is no heavy daemon, no paid external APIs, and zero configuration required.
 
-**Runtime:** Harness supports **Node.js 22+**. Node.js **24** is the primary development and CI runtime (`.nvmrc`). The generated current-state runtime/workflow summary is [docs/repository-contract.md](docs/repository-contract.md).
+**Runtime:** Harness supports **Node.js 22+** (including odd-numbered versions); Node.js **24** is the primary development and CI runtime (`.nvmrc`). **On Windows, System One evaluator subprocess verification should use Node 22 or Node 24.20+**. Node 23.x has a documented Windows process-shutdown assertion ([nodejs/node#56645](https://github.com/nodejs/node/issues/56645)); Node 24.0–24.19 predates the backported libuv fix ([nodejs/node#61999](https://github.com/nodejs/node/pull/61999)) and may likewise crash at process exit (`0xC0000409`). RS13 visibly skips **only** on those Windows versions while retaining the real evaluator subprocess elsewhere. A skip is not a pass or evidence of a fixed Node runtime. CI pins Windows Node 23.6.0 and 24.15.0 to validate their skip policy, and Node 24.20.0 to run the complete subprocess/regression suite. These tests do not reduce the package's general `>=22` engine compatibility claim. The generated current-state runtime/workflow summary is [docs/repository-contract.md](docs/repository-contract.md).
 
 ```bash
 # Option A: Claude Code plugin (marketplace manifest included)

package/benchmarks/results/live-host/codex-2026-10-13/README.md

@@ -0,0 +1,55 @@
+# Live-host evidence: Codex CLI observation capture
+
+This records live dispatch of the Codex user-hook compatibility fallback on one Windows host. It is mechanism/live-host evidence for turn capture, not a behavioral-effectiveness benchmark and not evidence for native plugin-hook mounting.
+
+- Date: 2026-10-13 UTC
+- Host: Codex CLI 0.162.1; Windows `10.0.26200` x64; Node.js v24.18.0
+- Repository revision under test: PR #305, `3f57b8b376bfd437c8cff6ddbe4ddbf036380198`
+- Packaged compatibility runtime: version 0.30.9; SHA-256 `7f4e7801d9fdb7350072b01c91034cd28890dfe7190d143ec7760c85fd5a29df`, matching `plugins/harness-everything/`
+- Compatibility status: files healthy; status command reports `configured-unverified` because it cannot read Codex trust state.
+
+## Procedure
+
+The Codex `/hooks` UI showed the observation handlers as new/untrusted. I reviewed and trusted only the `UserPromptSubmit` and `Stop` handlers named `Recording a local System One turn observation`. I did not trust all hooks. No trust bypass flag was used. The successful probes ran through `codex exec` with read-only sandboxing and no tool calls. A second turn resumed the same session.
+
+Two preliminary attempts were not counted as passing evidence: before trust, a completed CLI turn produced no observation; a later argument-passed prompt lost JSON quotes in Windows `.cmd` argument handling and created an invalid-label record. The accepted run passed its prompt through stdin, preserving the valid JSON label. The probe prompt and raw rollout stay in the private local Codex/observation stores and are not committed here.
+
+## Results
+
+The sanitized snapshot is [observation-records.json](observation-records.json). Both records have `host: "codex"`, the same session ID, sequential `turn` values, distinct `turn_id` values, and the self-report expected for their own turn:
+
+| Turn | Record ID | Turn ID | Self-report intent | Result |
+|---:|---|---|---|---|
+| 1 | `09ba6878d736e3f7183e7c3a` | `01a1338c-9727-7743-824d-92f8ceb51f00` | `test` | Passed |
+| 2 | `81a4c3a35f7894653aaf9f64` | `01a1338f-6ea2-7671-997f-e9a205b96102` | `discuss` | Passed |
+
+The second turn did not reuse the first turn's label. Prompt text, prompt hashes, and raw session content are omitted from this committed artifact. The live records showed zero tool calls, as expected for these reply-only probes; this run does not verify tool-event counting.
+
+## Limits
+
+- Verified scope: one Windows Codex CLI 0.162.1 setup using the user-hook compatibility fallback.
+- Not verified: native plugin-bundled hook mounting, marketplace source reporting during `plugin-sync`, other Codex versions/platforms, other lifecycle events, or behavioral effectiveness.
+- The CLI emitted a non-fatal GitHub MCP `AuthRequired` diagnostic and a bundled `SessionEnd` timeout-clamping notice. Both turns completed with exit code 0 and their observation records were present.
+
+## Repository verification
+
+All repository gates listed in `AGENTS.md` passed on this PR revision. The four gates affected by the new Codex evidence (`npm test`, `test:mechanism`, `test:consistency`, and `test:docs:capabilities`) initially exposed stale assertions that required Codex live evidence to remain `Unknown`; the assertions were updated to validate the retained artifact, then those gates passed on rerun.
+
+| Gate | Result |
+| --- | --- |
+| `npm test` | Passed on rerun; 2 environment-dependent cases skipped |
+| `npm run test:mutations` | Passed |
+| `npm run test:mechanism` | Passed on rerun |
+| `npm run test:consistency` | Passed on rerun |
+| `npm run test:repo-contract` | Passed |
+| `npm run test:docs:capabilities` | Passed on rerun |
+| `npm run test:references` | Passed |
+| `npm run test:release` | Passed |
+| `npm run test:collision` | Passed |
+| `npm run test:routing:skills` | Passed |
+| `npm run test:routing:invariants` | Passed |
+| `npm run test:plugin:openai` | Passed |
+| `npm run test:plugin:submission` | Passed |
+| `npm run test:platform:compatibility` | Passed on rerun |
+
+The gates were invoked through `npm.cmd` in PowerShell because this host blocks the `npm.ps1` shim by execution policy. Waza was not installed, so optional Waza checks were unavailable.

package/benchmarks/results/live-host/codex-2026-10-13/observation-records.json

@@ -0,0 +1,88 @@
+{
+  "format": "harness-codex-live-observation-evidence-v1",
+  "testedAt": "2026-10-13",
+  "source": {
+    "pr": 305,
+    "commit": "3f57b8b376bfd437c8cff6ddbe4ddbf036380198",
+    "runtimeVersion": "0.30.9",
+    "runtimeSha256": "7f4e7801d9fdb7350072b01c91034cd28890dfe7190d143ec7760c85fd5a29df"
+  },
+  "host": {
+    "product": "Codex CLI",
+    "version": "0.162.1",
+    "os": "win32 10.0.26200 x64",
+    "node": "v24.18.0"
+  },
+  "capture": {
+    "path": "user-hook compatibility fallback",
+    "trustedHandlers": [
+      "UserPromptSubmit: Recording a local System One turn observation",
+      "Stop: Recording a local System One turn observation"
+    ],
+    "trustBypass": false,
+    "rawPromptCommitted": false,
+    "rawSessionCommitted": false
+  },
+  "sessionId": "01a1338c-914c-7bf0-b893-3b5e538a129d",
+  "turns": [
+    {
+      "recordId": "09ba6878d736e3f7183e7c3a",
+      "host": "codex",
+      "observedAt": "2026-10-13T04:37:02.348Z",
+      "turn": 1,
+      "turnId": "01a1338c-9727-7743-824d-92f8ceb51f00",
+      "selfReport": {
+        "v": 1,
+        "validity": "actionable",
+        "contextDependent": false,
+        "tier": "tier1",
+        "intents": [
+          "test"
+        ],
+        "workflow": null,
+        "skills": []
+      },
+      "selfReportReason": null,
+      "behavior": {
+        "toolCalls": 0,
+        "toolFailures": 0,
+        "filesWritten": 0,
+        "filesCreated": 0
+      }
+    },
+    {
+      "recordId": "81a4c3a35f7894653aaf9f64",
+      "host": "codex",
+      "observedAt": "2026-10-13T04:40:07.308Z",
+      "turn": 2,
+      "turnId": "01a1338f-6ea2-7671-997f-e9a205b96102",
+      "selfReport": {
+        "v": 1,
+        "validity": "actionable",
+        "contextDependent": false,
+        "tier": "tier1",
+        "intents": [
+          "discuss"
+        ],
+        "workflow": null,
+        "skills": []
+      },
+      "selfReportReason": null,
+      "behavior": {
+        "toolCalls": 0,
+        "toolFailures": 0,
+        "filesWritten": 0,
+        "filesCreated": 0
+      }
+    }
+  ],
+  "assertions": {
+    "oneRecordPerTurn": true,
+    "bothHostCodex": true,
+    "sameSession": true,
+    "sequentialTurns": true,
+    "distinctTurnIds": true,
+    "currentTurnLabelsMatch": true,
+    "promptContentOmitted": true
+  }
+}

package/ci/doc-capability-consistency.test.js

@@ -190,6 +190,7 @@ for (const rel of OPENCODE_SURFACES) {
 
 const matrix = JSON.parse(read('docs/platform-compatibility.json'));
 const opencode = matrix.platforms.find(platform => platform.id === 'opencode');
+const codex = matrix.platforms.find(platform => platform.id === 'codex');
 for (const dimension of ['hooksLifecycle', 'liveHostVerification']) {
   if (opencode?.capabilities[dimension]?.status !== 'Partial') {
     fail(`OpenCode ${dimension}: must remain Partial`);
@@ -198,7 +199,16 @@ for (const dimension of ['hooksLifecycle', 'liveHostVerification']) {
 if (opencode?.capabilities.liveHostVerification.evidence !== OPENCODE_EVIDENCE) {
   fail('OpenCode liveHostVerification: missing exact retained artifact path');
 }
-for (const platform of matrix.platforms.filter(platform => platform.id !== 'opencode')) {
+if (codex?.capabilities.hooksLifecycle.status !== 'Partial') {
+  fail('Codex hooksLifecycle: expected partial live verification for the compatibility fallback');
+}
+if (codex?.capabilities.liveHostVerification.status !== 'Partial') {
+  fail('Codex liveHostVerification: expected partial status with preserved evidence');
+}
+if (codex?.capabilities.liveHostVerification.evidence !== 'benchmarks/results/live-host/codex-2026-10-13/README.md') {
+  fail('Codex liveHostVerification: missing exact retained artifact path');
+}
+for (const platform of matrix.platforms.filter(platform => !['opencode', 'codex'].includes(platform.id))) {
   if (platform.capabilities.liveHostVerification.status !== 'Unknown') {
     fail(`${platform.id}: liveHostVerification must remain Unknown without its own evidence`);
   }

package/ci/fixtures/system-one-resident-stub.py

@@ -1,5 +1,6 @@
 """Stub scorer behind the real resident server code; never model-quality evidence."""
 import importlib.util
+import json
 from pathlib import Path
 import sys
 import time
@@ -28,4 +29,9 @@ def factory(weights, manifest):
 if __name__ == '__main__':
     if sys.argv[1:2] != ['--serve']:
         sys.exit(2)
-    sys.exit(adapter.serve_main(sys.argv[2:], scorer_factory=factory))
+    result = adapter.serve_main(sys.argv[2:], scorer_factory=factory)
+    # Deterministic teardown fixture: the state/socket are closed, but PID is
+    # deliberately alive to distinguish state unlink from full process exit.
+    if json.loads(sys.argv[2]).get('modelId') == 'stub-exit-linger':
+        time.sleep(0.5)
+    sys.exit(result)

package/ci/mechanism-2al-codex-hooks-compat.test.js

@@ -73,6 +73,8 @@ try {
   const state = compat.status({ codexHome });
   check(state.installed && state.healthy && state.exactEntriesPresent === state.expectedEntries,
     'status verifies exact installed entry hashes and runtime tree');
+  check(state.observationCapture.status === 'configured-unverified' && state.observationCapture.trustRequired,
+    'status distinguishes installed hooks from Codex-trusted live capture');
 
   const config = read(hooksFile);
   check(config.description === original.description &&
@@ -158,6 +160,18 @@ try {
   check(!fs.existsSync(path.join(emptyHome, 'hooks.json')),
     'uninstall removes hooks.json only when Harness created it and no user entries remain');
 
+  const marketplaceSource = path.join(root, 'marketplace-plugin');
+  const marketplaceHome = path.join(root, 'marketplace-codex');
+  fs.cpSync(compat.SOURCE_PLUGIN_ROOT, marketplaceSource, { recursive: true });
+  fs.writeFileSync(path.join(marketplaceSource, 'hooks', 'marketplace-source-marker.txt'), 'newer marketplace source\n');
+  const marketplaceInstall = compat.install({ codexHome: marketplaceHome, sourcePluginRoot: marketplaceSource });
+  const marketplaceManifest = read(path.join(marketplaceHome, 'harness-everything', 'compat-hooks', 'manifest.json'));
+  check(marketplaceInstall.sourcePluginSha256 === compat.treeHash(marketplaceSource) &&
+    marketplaceManifest.sourcePluginSha256 === compat.treeHash(marketplaceSource) &&
+    fs.readFileSync(path.join(marketplaceManifest.runtimeDir, 'hooks', 'marketplace-source-marker.txt'), 'utf8') === 'newer marketplace source\n',
+    'compatibility runtime is copied from the verified installed marketplace source');
+  compat.uninstall({ codexHome: marketplaceHome });
+
   const duplicateHome = path.join(root, 'duplicate-codex');
   fs.mkdirSync(duplicateHome, { recursive: true });
   compat.install({ codexHome: duplicateHome });
@@ -273,6 +287,11 @@ try {
   check(malformedRefused && fs.readFileSync(malformed, 'utf8') === malformedBefore,
     'malformed user hooks.json fails closed without replacement');
 
+  const inactive = compat.status({ codexHome: path.join(root, 'not-installed') });
+  check(inactive.observationCapture.status === 'inactive' &&
+    inactive.observationCapture.reason === 'compatibility-hooks-not-installed',
+    'status clearly reports inactive observation capture when hooks are absent');
+
   const source = read(path.join(compat.SOURCE_PLUGIN_ROOT, 'hooks', 'hooks.json'));
   const sourceCount = Object.values(source.hooks).reduce((sum, entries) => sum + entries.length, 0);
   check(sourceCount === installed.entries,

package/ci/mechanism-2am-observations-session-import.test.js

@@ -0,0 +1,221 @@
+#!/usr/bin/env node
+'use strict';
+
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const ROOT = path.resolve(__dirname, '..');
+const IMPORTER = path.join(ROOT, 'scripts', 'system-one-observations-import-codex-sessions.js');
+const EXPORTER = path.join(ROOT, 'scripts', 'system-one-observations-export.js');
+const REVIEW = path.join(ROOT, 'scripts', 'system-one-observations-review.js');
+const obs = require('../hooks/scripts/lib/observations');
+const LABEL = '<!-- harness-label {"v":1,"validity":"actionable","contextDependent":false,"tier":"tier2","intents":["fix"],"workflow":null,"skills":[]} -->';
+const TIER1_LABEL = '<!-- harness-label {"v":1,"validity":"actionable","contextDependent":false,"tier":"tier1","intents":["fix"],"workflow":null,"skills":[]} -->';
+
+const root = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-session-label-import-'));
+const sessions = path.join(root, 'sessions');
+const store = path.join(root, 'observations');
+fs.mkdirSync(path.join(sessions, '2026', '10'), { recursive: true });
+const rollout = path.join(sessions, '2026', '10', 'rollout-fixture.jsonl');
+
+const rows = [
+  { type: 'session_meta', payload: { session_id: 'fixture-session' } },
+  { type: 'event_msg', timestamp: '2026-09-26T23:59:59.000Z', payload: { type: 'task_started', turn_id: 'old', started_at: '2026-09-26T23:59:59.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'pre-revision prompt' }] } },
+  { type: 'event_msg', timestamp: '2026-09-26T23:59:59.500Z', payload: { type: 'task_complete', turn_id: 'old', last_agent_message: LABEL } },
+  { type: 'event_msg', timestamp: '2026-09-27T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'included', started_at: '2026-09-27T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [
+    { type: 'input_text', text: 'Please fix the parser. Contact user@example.com.' },
+    { type: 'input_text', text: 'injected host context must stay out of the prompt row' }
+  ] } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'later context message' }] } },
+  { type: 'event_msg', timestamp: '2026-09-27T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'included', last_agent_message: 'Done.\n' + LABEL } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'assistant-fallback', started_at: '2026-09-30T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'fallback prompt from the rollout message' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'Completed answer.\n' + LABEL }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'assistant-fallback' } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'explicit-unlabeled-final', started_at: '2026-09-30T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'an earlier assistant message had a label' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', phase: 'commentary', content: [{ type: 'output_text', text: 'Earlier answer.\n' + TIER1_LABEL }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'explicit-unlabeled-final', last_agent_message: 'This is the explicit final reply without a label.' } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'unobserved-write', started_at: '2026-09-30T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'write a small parser change' }] } },
+  { type: 'response_item', payload: { type: 'function_call', name: 'apply_patch', arguments: '*** Begin Patch\n*** Add File: parser.js\n+module.exports = true;\n*** End Patch' } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'unobserved-write', last_agent_message: TIER1_LABEL } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'not-final-assistant', started_at: '2026-09-30T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'do not use an earlier assistant message label' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: LABEL }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'A later assistant message replaced this one.' }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'not-final-assistant', last_agent_message: 'No label in the final assistant message.' } },
+  { type: 'event_msg', timestamp: '2026-09-28T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'missing-prompt', started_at: '2026-09-28T00:00:00.000Z' } },
+  { type: 'event_msg', timestamp: '2026-09-28T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'missing-prompt', last_agent_message: LABEL } },
+  { type: 'event_msg', timestamp: '2026-09-29T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'invalid-label', started_at: '2026-09-29T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'malformed label prompt' }] } },
+  { type: 'event_msg', timestamp: '2026-09-29T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'invalid-label', last_agent_message: '<!-- harness-label {bad json} -->' } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'ambiguous-summary', started_at: '2026-09-30T00:00:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'resolve conflicting final representations' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', phase: 'final_answer', content: [{ type: 'output_text', text: 'Actual final answer.\n' + LABEL }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'ambiguous-summary', last_agent_message: 'The completion summary omitted the final response text.' } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:02:00.000Z', payload: { type: 'task_started', turn_id: 'after-ambiguous', started_at: '2026-09-30T00:02:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'continue after ambiguous final representations' }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:03:00.000Z', payload: { type: 'task_complete', turn_id: 'after-ambiguous', last_agent_message: 'Follow-up answer.\n' + LABEL } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:04:00.000Z', payload: { type: 'task_started', turn_id: 'equivalent-body', started_at: '2026-09-30T00:04:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'recover an equivalent assistant body' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', phase: 'final_answer', content: [{ type: 'output_text', text: 'Equivalent final answer.\n' + LABEL }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:05:00.000Z', payload: { type: 'task_complete', turn_id: 'equivalent-body', last_agent_message: 'Equivalent final answer.' } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:06:00.000Z', payload: { type: 'task_started', turn_id: 'nonstring-completion', started_at: '2026-09-30T00:06:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'fallback from non-string completion' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', content: [{ type: 'output_text', text: 'Non-string fallback answer.\n' + LABEL }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:07:00.000Z', payload: { type: 'task_complete', turn_id: 'nonstring-completion', last_agent_message: null } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:08:00.000Z', payload: { type: 'task_started', turn_id: 'invalid-with-assistant-label', started_at: '2026-09-30T00:08:00.000Z' } },
+  { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'reject malformed completion despite assistant label' }] } },
+  { type: 'response_item', payload: { type: 'message', role: 'assistant', phase: 'final_answer', content: [{ type: 'output_text', text: 'A different assistant body.\n' + LABEL }] } },
+  { type: 'event_msg', timestamp: '2026-09-30T00:09:00.000Z', payload: { type: 'task_complete', turn_id: 'invalid-with-assistant-label', last_agent_message: '<!-- harness-label {bad json} -->' } },
+];
+fs.writeFileSync(rollout, rows.map(row => JSON.stringify(row)).join('\n') + '\n');
+
+function runImport(targetStore = store) {
+  return spawnSync(process.execPath, [IMPORTER, '--sessions', sessions, '--store', targetStore, '--since', '2026-09-27'], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+}
+
+try {
+  const hookEnv = { HARNESS_OBSERVATIONS: 'on', HARNESS_OBSERVATIONS_DIR: store };
+  obs.handle({ hook_event_name: 'UserPromptSubmit', session_id: 'fixture-session', turn_id: 'included',
+    prompt: 'Please fix the parser. Contact user@example.com.', cwd: root }, hookEnv);
+  obs.handle({ hook_event_name: 'PostToolUse', session_id: 'fixture-session', turn_id: 'included', cwd: root,
+    tool_name: 'apply_patch', tool_input: { patch: '*** Begin Patch\n*** Add File: parser.js\n+module.exports = true;\n*** End Patch' } }, hookEnv);
+  obs.handle({ hook_event_name: 'Stop', session_id: 'fixture-session', turn_id: 'included', last_agent_message: TIER1_LABEL }, hookEnv);
+
+  const first = runImport();
+  assert.strictEqual(first.status, 0, 'session import failed:\n' + first.stdout + '\n' + first.stderr);
+  const report = JSON.parse(first.stdout);
+  assert.strictEqual(report.imported, 5);
+  assert.strictEqual(report.skipped.beforeCutoff, 1);
+  assert.strictEqual(report.skipped.missingPrompt, 1);
+  assert.strictEqual(report.skipped.missingLabel, 2, 'an explicit unlabeled completion remains a missing-label skip when the labeled assistant item was commentary');
+  assert.strictEqual(report.skipped.ambiguousFinalMessage, 1, 'conflicting final representations with a labeled final assistant item are reported as ambiguous');
+  assert.strictEqual(report.skipped.invalidLabel, 2, 'an invalid completion label remains invalid even when an assistant item has a valid label');
+  assert.strictEqual(report.skipped.duplicate, 1, 'backfill skips a turn already captured by live Codex hooks');
+  assert.strictEqual(report.skipped.ambiguousLiveMatch, 0);
+
+  const index = JSON.parse(fs.readFileSync(path.join(store, 'observations-index.json'), 'utf8'));
+  assert.strictEqual(index.records.length, 6);
+  const liveRecord = index.records.find(entry => entry.writer && entry.writer.turnId === 'included');
+  assert(liveRecord, 'live records retain Codex turn IDs for cross-source dedupe');
+  assert.strictEqual(liveRecord.behavior.filesWritten, 1, 'the live fixture contains an observed file write');
+  assert.deepStrictEqual(obs.contradictions(liveRecord.selfReport, liveRecord.behavior), ['tier1-with-writes']);
+  assert.strictEqual(index.records.filter(entry => entry.writer && entry.writer.sessionId === 'fixture-session' && entry.writer.turnId === 'included').length, 1,
+    'live capture and session backfill leave one record for a turn');
+
+  const fallbackRecord = index.records.find(entry => entry.captureMethod === 'session-backfill' && entry.turn === 3);
+  assert(fallbackRecord, 'the response_item assistant label is recovered when task_complete omits it');
+  const fallbackText = JSON.parse(fs.readFileSync(path.join(store, 'text', fallbackRecord.contentSha256 + '.json'), 'utf8'));
+  assert.strictEqual(fallbackText.prompt, 'fallback prompt from the rollout message');
+  const backfilledTier1 = index.records.find(entry => entry.captureMethod === 'session-backfill' && entry.selfReport.tier === 'tier1');
+  assert(backfilledTier1, 'the tier1 label from the rollout is imported');
+  assert.strictEqual(backfilledTier1.behavior, null, 'session backfill records behavior as unobserved rather than zero');
+  assert(!index.records.some(entry => entry.writer && entry.writer.turnId === 'ambiguous-summary'),
+    'a differing completion string must not inherit the assistant message label');
+  const afterAmbiguous = index.records.find(entry => entry.writer && entry.writer.turnId === 'after-ambiguous');
+  assert(afterAmbiguous, 'the turn after an ambiguous final can still be imported');
+  const afterAmbiguousText = JSON.parse(fs.readFileSync(path.join(store, 'text', afterAmbiguous.contentSha256 + '.json'), 'utf8'));
+  assert.strictEqual(afterAmbiguousText.previous, '', 'an unresolved final disagreement must not seed later previous-message context');
+  assert(index.records.some(entry => entry.writer && entry.writer.turnId === 'equivalent-body'),
+    'a completion string matching the assistant body after label removal safely recovers its label');
+  assert(index.records.some(entry => entry.writer && entry.writer.turnId === 'nonstring-completion'),
+    'a non-string task_complete field falls back to the final assistant label');
+  assert(!index.records.some(entry => entry.writer && entry.writer.turnId === 'invalid-with-assistant-label'),
+    'a valid assistant label never replaces an invalid completion label');
+
+  const exportDir = path.join(root, 'export');
+  const exported = spawnSync(process.execPath, [EXPORTER, '--store', store, '--out', exportDir, '--self-report-only'], { cwd: ROOT, encoding: 'utf8', timeout: 10000 });
+  assert.strictEqual(exported.status, 0, 'export after backfill failed:\n' + exported.stdout + '\n' + exported.stderr);
+  const labels = fs.readFileSync(path.join(exportDir, 'labels-observed.jsonl'), 'utf8').trim().split('\n').map(JSON.parse);
+  const exportReport = JSON.parse(fs.readFileSync(path.join(exportDir, 'export-report.json'), 'utf8'));
+  assert.strictEqual(labels.filter(label => label.behaviorEvidence === 'unobserved').length, 5);
+  assert.deepStrictEqual(exportReport.behaviorEvidence, { observed: 1, unobserved: 5 });
+  assert.strictEqual(exportReport.contradictions['tier1-with-writes'], 1, 'only the observed live write contributes a contradiction');
+
+  const reviewHtml = path.join(root, 'review.html');
+  const reviewed = spawnSync(process.execPath, [REVIEW, '--store', store, '--out', reviewHtml], { cwd: ROOT, encoding: 'utf8', timeout: 10000 });
+  assert.strictEqual(reviewed.status, 0, 'observation review page failed:\n' + reviewed.stdout + '\n' + reviewed.stderr);
+  assert.match(fs.readFileSync(reviewHtml, 'utf8'), /Behavior evidence is unobserved/);
+
+  const legacyStore = path.join(root, 'legacy-observations');
+  fs.mkdirSync(legacyStore, { recursive: true });
+  fs.writeFileSync(path.join(legacyStore, 'observations-index.json'), JSON.stringify({ schemaVersion: 1, records: [
+    {
+      id: 'legacy-live-record', source: 'observation', host: 'codex', turn: 2,
+      writer: { sessionId: 'fixture-session' }, contentSha256: 'legacy-content-hash', behavior: { filesWritten: 1 }
+    },
+    {
+      id: 'old-backfill-record', source: 'observation', captureMethod: 'session-backfill', host: 'codex', turn: 1,
+      writer: { sessionId: 'older-session', turnId: 'old' }, behavior: { filesWritten: 0, toolCalls: 0 }
+    }
+  ] }));
+  const legacy = runImport(legacyStore);
+  assert.strictEqual(legacy.status, 0, legacy.stderr);
+  const legacyReport = JSON.parse(legacy.stdout);
+  assert.strictEqual(legacyReport.skipped.ambiguousLiveMatch, 1,
+    'legacy live records without a turn ID are explicitly skipped when the same session/turn is ambiguous');
+  assert.strictEqual(legacyReport.migratedUnobservedBehavior, 1, 'prior backfill records are migrated away from synthetic zero behavior');
+  const legacyIndex = JSON.parse(fs.readFileSync(path.join(legacyStore, 'observations-index.json'), 'utf8'));
+  assert.strictEqual(legacyIndex.records.find(entry => entry.id === 'old-backfill-record').behavior, null);
+
+  const second = runImport();
+  assert.strictEqual(second.status, 0, second.stderr);
+  assert.strictEqual(JSON.parse(second.stdout).imported, 0, 'repeated imports must not duplicate records');
+  assert.strictEqual(JSON.parse(second.stdout).skipped.duplicate, 6);
+  assert.strictEqual(JSON.parse(fs.readFileSync(path.join(store, 'observations-index.json'), 'utf8')).records.length, 6);
+
+  const lockSessions = path.join(root, 'lock-timeout-sessions');
+  fs.mkdirSync(lockSessions, { recursive: true });
+  const lockRollout = path.join(lockSessions, 'lock-timeout.jsonl');
+  fs.writeFileSync(lockRollout, [
+    { type: 'event_msg', timestamp: '2026-10-01T00:00:00.000Z', payload: { type: 'task_started', turn_id: 'lock-timeout', started_at: '2026-10-01T00:00:00.000Z' } },
+    { type: 'response_item', payload: { type: 'message', role: 'user', content: [{ type: 'input_text', text: 'a unique turn that cannot be persisted while locked' }] } },
+    { type: 'event_msg', timestamp: '2026-10-01T00:01:00.000Z', payload: { type: 'task_complete', turn_id: 'lock-timeout', last_agent_message: LABEL } },
+  ].map(row => JSON.stringify(row)).join('\n') + '\n');
+  const lockStore = path.join(root, 'lock-timeout-store');
+  fs.mkdirSync(lockStore, { recursive: true });
+  fs.writeFileSync(path.join(lockStore, '.index.lock'), 'held for importer timeout fixture');
+  const locked = spawnSync(process.execPath, [IMPORTER, '--sessions', lockSessions, '--store', lockStore, '--since', '2026-09-27'], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  assert.strictEqual(locked.status, 1, 'an importer lock timeout must return a failing CLI exit code');
+  const lockReport = JSON.parse(locked.stdout);
+  assert.strictEqual(lockReport.failed.lockTimeout, 1, 'the report distinguishes a lock timeout from a duplicate');
+  assert.strictEqual(fs.existsSync(path.join(lockStore, 'observations-index.json')), false,
+    'a unique turn must not be reported as persisted when the index lock times out');
+
+  const migrationStore = path.join(root, 'migration-timeout-store');
+  fs.mkdirSync(migrationStore, { recursive: true });
+  fs.writeFileSync(path.join(migrationStore, 'observations-index.json'), JSON.stringify({ schemaVersion: 1, records: [
+    { id: 'old-backfill', captureMethod: 'session-backfill', behavior: { filesWritten: 0 } }
+  ] }));
+  fs.writeFileSync(path.join(migrationStore, '.index.lock'), 'held during migration fixture');
+  const migrationLocked = spawnSync(process.execPath, [IMPORTER, '--sessions', lockSessions, '--store', migrationStore, '--since', '2026-09-27'], {
+    cwd: ROOT,
+    encoding: 'utf8',
+    timeout: 10000,
+  });
+  assert.strictEqual(migrationLocked.status, 1, 'a migration lock timeout must also fail the importer CLI');
+  assert.strictEqual(JSON.parse(migrationLocked.stdout).failed.lockTimeout, 1,
+    'the migration path reports its lock timeout through the same failure count');
+  const migrationIndex = JSON.parse(fs.readFileSync(path.join(migrationStore, 'observations-index.json'), 'utf8'));
+  assert.deepStrictEqual(migrationIndex.records[0].behavior, { filesWritten: 0 },
+    'a failed migration does not rewrite the index or proceed with imports');
+} finally {
+  fs.rmSync(root, { recursive: true, force: true });
+}
+
+console.log('PASS: post-revision Codex session labels import as redacted, prompt-paired, idempotent observations.');