harness-everything 0.30.8 → 0.30.10

package/ci/mechanism-2ao-plugin-sync.test.js

@@ -14,14 +14,18 @@ const {
 } = require('../scripts/plugin-sync');
 
 const ROOT = path.resolve(__dirname, '..');
+const codexHooksCompat = require('../scripts/codex-hooks-compat');
 
-function fakeHost({ claudeInstalled = false, codexInstalled = false, claudeMarketplace = true, codexMarketplace = true, unknownClaudePluginState = false, unknownClaudeYesFlag = false, unknownClaudeJsonFlag = false, clapCodexJsonFlag = false, missingCodexPluginCommand = false } = {}) {
+function fakeHost({ claudeInstalled = false, codexInstalled = false, codexPluginSourcePath = path.join(ROOT, 'plugins', 'harness-everything'), codexPluginSourceType = 'local', codexAvailableOnly = false, claudeMarketplace = true, codexMarketplace = true, unknownClaudePluginState = false, unknownClaudeYesFlag = false, unknownClaudeJsonFlag = false, clapCodexJsonFlag = false, missingCodexPluginCommand = false, codexHooksError = null } = {}) {
   const calls = [];
+  const codexHookInstalls = [];
   const state = {
     claudeInstalled,
     codexInstalled,
     claudeMarketplace,
-    codexMarketplace
+    codexMarketplace,
+    codexPluginSourcePath,
+    codexAvailableOnly
   };
   const runner = (command, args) => {
     calls.push({ command, args: [...args] });
@@ -93,13 +97,29 @@ function fakeHost({ claudeInstalled = false, codexInstalled = false, claudeMarke
       }
       if (joined.startsWith('plugin marketplace upgrade')) return { status: 0, stdout: '{}', stderr: '' };
       if (joined.includes('plugin list --marketplace harness-everything --json') || joined === 'plugin list --json') {
-        return { status: 0, stdout: JSON.stringify({ plugins: state.codexInstalled ? [{ name: 'harness-everything', marketplace: 'harness-everything' }] : [] }), stderr: '' };
+        const source = state.codexPluginSourcePath ? {
+          source: codexPluginSourceType,
+          ...(codexPluginSourceType === 'git-subdir' ? { url: 'https://github.com/dyphn1/Harness-everything.git' } : {}),
+          path: state.codexPluginSourcePath
+        } : null;
+        if (state.codexAvailableOnly) {
+          return { status: 0, stdout: JSON.stringify({ installed: [], available: [{
+            pluginId: 'harness-everything@harness-everything',
+            name: 'harness-everything',
+            marketplaceName: 'harness-everything',
+            installed: false,
+            source
+          }] }), stderr: '' };
+        }
+        const plugin = state.codexInstalled ? [{ name: 'harness-everything', marketplace: 'harness-everything', ...(source ? { source } : {}) }] : [];
+        return { status: 0, stdout: JSON.stringify({ plugins: plugin }), stderr: '' };
       }
       if (joined === 'plugin list --marketplace harness-everything' || joined === 'plugin list') {
         return { status: 0, stdout: state.codexInstalled ? 'harness-everything@harness-everything\n' : '', stderr: '' };
       }
       if (joined.startsWith('plugin add')) {
         state.codexInstalled = true;
+        state.codexAvailableOnly = false;
         return { status: 0, stdout: '{}', stderr: '' };
       }
     }
@@ -110,7 +130,13 @@ function fakeHost({ claudeInstalled = false, codexInstalled = false, claudeMarke
   return {
     calls,
     runner,
-    commandAvailable: () => true
+    commandAvailable: () => true,
+    codexHookInstalls,
+    codexHooksInstall: options => {
+      codexHookInstalls.push(options);
+      if (codexHooksError) throw new Error(codexHooksError);
+      return { status: codexInstalled ? 'updated' : 'installed', entries: 8, trustChanged: false };
+    }
   };
 }
 
@@ -176,6 +202,17 @@ assert.strictEqual(findPlugin({ plugins: [{ id: 'harness-everything@harness-ever
   assert.strictEqual(result.failed, 0);
   assert.strictEqual(result.results[0].action, 'install');
   assert.strictEqual(callsFor(fake.calls, 'codex', 'plugin add').length, 1, 'absent Codex plugin must install');
+  assert.strictEqual(fake.codexHookInstalls.length, 1, 'install must also refresh the Codex compatibility hooks');
+  assert.strictEqual(result.results[0].compatHooks.status, 'installed');
+}
+
+{
+  const fake = fakeHost({ codexAvailableOnly: true });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 0, 'an available-only entry must be installed and verified after its state changes');
+  assert.strictEqual(result.results[0].action, 'install', 'installed:false must not make an available plugin appear installed');
+  assert.strictEqual(callsFor(fake.calls, 'codex', 'plugin add').length, 1, 'available-only entries must take the plugin add path');
+  assert.strictEqual(fake.codexHookInstalls.length, 1, 'hooks refresh only after the post-add listing verifies an installed local source');
 }
 
 {
@@ -185,8 +222,82 @@ assert.strictEqual(findPlugin({ plugins: [{ id: 'harness-everything@harness-ever
   assert.strictEqual(result.results[0].action, 'update');
   assert.strictEqual(callsFor(fake.calls, 'codex', 'plugin marketplace upgrade').length, 1, 'installed Codex plugin must upgrade its marketplace');
   assert.strictEqual(callsFor(fake.calls, 'codex', 'plugin add').length, 0, 'installed Codex plugin must not be re-added');
+  assert.strictEqual(fake.codexHookInstalls.length, 1, 'marketplace update must refresh the copied Codex hooks');
+  assert.strictEqual(result.results[0].compatHooks.status, 'updated');
+}
+
+{
+  const installedSource = path.join(os.tmpdir(), 'newer-marketplace-plugin');
+  const fake = fakeHost({ codexInstalled: true, codexPluginSourcePath: installedSource });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 0);
+  assert.strictEqual(fake.codexHookInstalls[0].sourcePluginRoot, installedSource,
+    'compatibility hooks must be copied from the installed marketplace plugin, not this older package checkout');
+  assert.notStrictEqual(fake.codexHookInstalls[0].sourcePluginRoot, codexHooksCompat.SOURCE_PLUGIN_ROOT);
+}
+
+{
+  const fake = fakeHost({ codexInstalled: true, codexPluginSourcePath: null });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 1, 'sync must fail visibly when it cannot identify the installed plugin source');
+  assert.strictEqual(fake.codexHookInstalls.length, 0, 'sync must not overwrite compatibility hooks from an unverified local package');
+  assert.match(result.results[0].error, /source/i);
+}
+
+{
+  const staleCheckout = path.join(ROOT, 'plugins', 'harness-everything');
+  const fake = fakeHost({ codexInstalled: true, codexPluginSourcePath: staleCheckout, codexPluginSourceType: 'git-subdir' });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 1, 'a tagged git-subdir source must not be treated as a local plugin directory');
+  assert.strictEqual(fake.codexHookInstalls.length, 0, 'an unsupported source variant must not copy hooks from the stale package checkout');
+  assert.match(result.results[0].error, /git-subdir|source/i);
+}
+
+{
+  const fake = fakeHost({
+    codexInstalled: true,
+    codexPluginSourcePath: 'plugins/harness-everything',
+    codexPluginSourceType: 'git-subdir'
+  });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 1, 'a repository-relative git-subdir path must not be resolved against the sync process CWD');
+  assert.strictEqual(fake.codexHookInstalls.length, 0, 'a git-subdir URL and relative path must not be passed to the local compatibility installer');
+  assert.match(result.results[0].error, /git-subdir|source/i);
+}
+
+for (const sourceType of ['git', 'npm', 'remote', 'unknown']) {
+  const fake = fakeHost({ codexInstalled: true, codexPluginSourcePath: path.join(ROOT, 'plugins', 'harness-everything'), codexPluginSourceType: sourceType });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 1, `the ${sourceType} source variant must fail closed`);
+  assert.strictEqual(fake.codexHookInstalls.length, 0, `the ${sourceType} source variant must not run the compatibility installer`);
 }
 
+{
+  const fake = fakeHost({ codexInstalled: true, codexPluginSourcePath: 'plugins/harness-everything' });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 1, 'a relative local source path is not a verified installed plugin directory');
+  assert.strictEqual(fake.codexHookInstalls.length, 0, 'a relative source path must not be copied from the sync process CWD');
+  assert.match(result.results[0].error, /absolute|source/i);
+}
+
+{
+  const codexHome = fs.mkdtempSync(path.join(os.tmpdir(), 'harness-plugin-sync-codex-home-'));
+  try {
+    const fake = fakeHost({ codexInstalled: true });
+    const result = sync({ host: 'codex', codexHome }, {
+      runner: fake.runner,
+      commandAvailable: fake.commandAvailable,
+      log: () => {},
+      warn: () => {},
+    });
+    assert.strictEqual(result.failed, 0);
+    assert.strictEqual(result.results[0].compatHooks.status, 'installed');
+    const state = codexHooksCompat.status({ codexHome });
+    assert(state.installed && state.healthy, 'plugin-sync default path installs the actual packaged compatibility hooks');
+  } finally {
+    fs.rmSync(codexHome, { recursive: true, force: true });
+  }
+}
 {
   const fake = fakeHost({ codexInstalled: false, codexMarketplace: false, clapCodexJsonFlag: true });
   const result = runHost('codex', fake);
@@ -210,6 +321,20 @@ assert.strictEqual(findPlugin({ plugins: [{ id: 'harness-everything@harness-ever
   assert.ok(!upgradeCalls[1].args.includes('--json'), 'Codex upgrade retry must omit unsupported --json');
 }
 
+{
+  const fake = fakeHost({ codexInstalled: true, codexHooksError: 'user hook config drift' });
+  const result = runHost('codex', fake);
+  assert.strictEqual(result.failed, 1, 'a failed compatibility-hook refresh must be visible');
+  assert.match(result.results[0].error, /compatibility hooks/i);
+}
+
+{
+  const fake = fakeHost({ codexInstalled: true });
+  const result = sync({ host: 'codex', dryRun: true }, { ...fake, log: () => {}, warn: () => {} });
+  assert.strictEqual(result.results[0].compatHooks.status, 'dry-run');
+  assert.strictEqual(fake.codexHookInstalls.length, 0, 'dry-run must not install or rewrite Codex hooks');
+}
+
 {
   const fake = fakeHost({ codexMarketplace: false, missingCodexPluginCommand: true, clapCodexJsonFlag: true });
   const result = runHost('codex', fake);

package/ci/mechanism-2w-platform-compatibility.test.js

@@ -85,6 +85,18 @@ for (const platform of matrix.platforms) {
     assert.ok(compliance.totalEdits > 0);
     assert.ok(fs.statSync(path.join(session, 'edit-state.json')).size > 0);
     assert.ok(fs.statSync(path.join(session, 'zoom-out-report.md')).size > 0);
+  } else if (platform.id === 'codex') {
+    const capability = platform.capabilities.liveHostVerification;
+    assert.strictEqual(capability.status, 'Partial');
+    assert.strictEqual(capability.evidence, 'benchmarks/results/live-host/codex-2026-10-13/README.md');
+    const artifactRoot = path.dirname(path.join(ROOT, capability.evidence));
+    for (const file of ['README.md', 'observation-records.json']) {
+      assert.ok(fs.statSync(path.join(artifactRoot, file)).size > 0, `Missing Codex evidence: ${file}`);
+    }
+    const evidence = JSON.parse(fs.readFileSync(path.join(artifactRoot, 'observation-records.json'), 'utf8'));
+    assert.strictEqual(evidence.format, 'harness-codex-live-observation-evidence-v1');
+    assert.strictEqual(evidence.turns.length, 2, 'Codex artifact must preserve both consecutive turns');
+    assert.ok(evidence.turns.every(turn => turn.host === 'codex' && turn.selfReportReason === null));
   } else {
     assert.strictEqual(platform.capabilities.liveHostVerification.status, 'Unknown', `${platform.id}: no preserved live evidence`);
   }

package/ci/mechanism-34-observations.test.js

@@ -58,6 +58,45 @@ test('commands are classified without keeping their text', () => {
   assert.strictEqual(lib.classifyCommand('cd x && git push'), 'git', 'the first recognizable segment decides');
 });
 
+test('detailed appends distinguish duplicates and bounded lock timeouts', () => {
+  const s = sandbox();
+  const record = {
+    id: 'append-detail-one',
+    host: 'codex',
+    turn: 1,
+    writer: { sessionId: 'append-detail-session' },
+    contentSha256: 'append-detail-content-one',
+  };
+  const options = { dedupeById: true, dedupeByTurn: true };
+  assert.deepStrictEqual(lib.appendRecordDetailed(s.store, record, { prompt: 'first' }, options), { status: 'appended' });
+  assert.strictEqual(lib.appendRecord(s.store, record, { prompt: 'first' }, options), false,
+    'the legacy boolean wrapper still reports a duplicate as false');
+  assert.deepStrictEqual(lib.appendRecordDetailed(s.store, {
+    ...record,
+    id: 'append-detail-ambiguous',
+    captureMethod: 'session-backfill',
+    writer: { sessionId: 'append-detail-session', turnId: 'turn-one' },
+    contentSha256: 'different-content-for-legacy-turn',
+  }, { prompt: 'uncertain match' }, options), { status: 'ambiguous' },
+  'a partial legacy live-turn match is checked under the append lock and remains distinct from an exact duplicate');
+
+  const lockPath = path.join(s.store, '.index.lock');
+  fs.writeFileSync(lockPath, 'held by deterministic fixture');
+  const blocked = lib.appendRecordDetailed(s.store, {
+    ...record,
+    id: 'append-detail-two',
+    turn: 2,
+    writer: { sessionId: 'append-detail-session', turnId: 'turn-two' },
+    contentSha256: 'append-detail-content-two',
+  }, { prompt: 'second' }, { ...options, lockTimeoutMs: 25 });
+  assert.deepStrictEqual(blocked, { status: 'lock-timeout' }, 'lock contention is distinct from a duplicate');
+  assert.strictEqual(lib.markSessionBackfillBehaviorUnobserved(s.store, { lockTimeoutMs: 25 }), null,
+    'migration reports lock acquisition failure consistently');
+  assert.strictEqual(JSON.parse(fs.readFileSync(path.join(s.store, 'observations-index.json'), 'utf8')).records.length, 1,
+    'a timed out append leaves no durable index record');
+  fs.unlinkSync(lockPath);
+});
+
 test('tier comes from the self-report, owner review overrides, behavior only flags contradictions', () => {
   assert.strictEqual(typeof lib.breadthTier, 'undefined', 'no file-count tier rule');
   assert.deepStrictEqual(lib.labelTier({ tier: 'tier2' }, null), { tier: 'tier2', source: 'self-report' });
@@ -222,6 +261,31 @@ test('exporter derives labels, splits by time and reports agreement', () => {
   assert(!fs.readFileSync(path.join(out, 'export-report.json'), 'utf8').includes('parser'), 'the report holds no text');
 });
 
+test('exporter can select post-cutoff rows with self-reported labels for training', () => {
+  const s = sandbox();
+  writeFixtureStore(s);
+  const indexFile = path.join(s.store, 'observations-index.json');
+  const index = JSON.parse(fs.readFileSync(indexFile, 'utf8'));
+  index.records[0].observedAt = '2026-09-26T23:59:59.000Z';
+  index.records.push({ ...index.records[1], id: 'missing-self-report', selfReport: null });
+  fs.writeFileSync(indexFile, JSON.stringify(index));
+  const out = path.join(s.dir, 'filtered-export');
+  const r = spawnSync('node', [EXPORTER, '--store', s.store, '--out', out, '--since', '2026-09-27', '--self-report-only'], {
+    encoding: 'utf8',
+    env: s.env,
+  });
+  assert.strictEqual(r.status, 0, r.stderr);
+  const prompts = fs.readFileSync(path.join(out, 'prompts-observed.jsonl'), 'utf8').trim().split('\n').map(JSON.parse);
+  const labels = fs.readFileSync(path.join(out, 'labels-observed.jsonl'), 'utf8').trim().split('\n').map(JSON.parse);
+  assert.strictEqual(prompts.length, 3);
+  assert.strictEqual(labels.length, 3);
+  assert(labels.every(label => label.validity && label.intents.length >= 0), 'only self-reported turns are included');
+  const report = JSON.parse(fs.readFileSync(path.join(out, 'export-report.json'), 'utf8'));
+  assert.strictEqual(report.since, '2026-09-27');
+  assert.strictEqual(report.selfReportOnly, true);
+  assert.strictEqual(report.skippedBeforeSince, 1);
+  assert.strictEqual(report.skippedUnlabeled, 1);
+});
 test('review page lists disagreements blind and owner decisions override', () => {
   const s = sandbox();
   writeFixtureStore(s);

package/ci/mechanism-system-one-resident.test.js

@@ -29,10 +29,57 @@ function fixture(modelId = 'stub', extra = {}) {
   const deps = { command: m => { spawns.push(m.modelId); return [python, [stub, '--serve']]; } };
   return { dir, manifest, manifestPath, spawns, deps };
 }
+// State-file unlink precedes process exit. Windows cleanup must wait for the
+// captured resident PID, not merely for the disappearance of its state file.
+function pidAlive(pid) {
+  try { process.kill(pid, 0); return true; }
+  catch (err) { return err.code === 'EPERM'; }
+}
 function cleanup(f) {
-  try { resident.stop(f.manifest, f.manifestPath); } catch (_) { /* best effort */ }
-  fs.rmSync(f.dir, { recursive: true, force: true });
+  const { state } = resident.stateFiles(f.manifest, f.manifestPath);
+  const server = resident.readState(state);
+  try { resident.stop(f.manifest, f.manifestPath); } catch (_) { /* best effort after an assertion failure */ }
+  const deadline = Date.now() + 7500;
+  while ((fs.existsSync(state) || (process.platform === 'win32' && server && pidAlive(server.pid)))
+      && Date.now() < deadline) sleep(25);
+  assert.equal(fs.existsSync(state), false, 'resident state must disappear before fixture removal');
+  if (process.platform === 'win32' && server) {
+    assert.equal(pidAlive(server.pid), false, `detached resident PID ${server.pid} survived shutdown`);
+  }
+  fs.rmSync(f.dir, { recursive: true, force: true, maxRetries: 20, retryDelay: 50 });
+}
+// Windows Node 23 (nodejs/node#56645) and Node 24 before the fix in
+// 24.20.0 (nodejs/node#61999) can abort during libuv/process shutdown.
+// Preserve RS13's actual evaluator subprocess on unaffected runtimes.
+function windowsNodeShutdownIssue(platform, version) {
+  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  if (platform !== 'win32' || !parts) return false;
+  const major = Number(parts[1]);
+  if (major === 23) {
+    return 'Windows Node 23.x has a known process-shutdown assertion (nodejs/node#56645); use Node 22 or Node 24.20+';
+  }
+  if (major === 24 && Number(parts[2]) < 20) {
+    return 'Windows Node 24 < 24.20.0 lacks upstream shutdown fix nodejs/node#61999; use Node 24.20+ or Node 22';
+  }
+  return false;
 }
+const nodeShutdownIssue = windowsNodeShutdownIssue(process.platform, process.versions.node);
+
+test('S1-RS00 Windows Node 23 and 24 shutdown compatibility boundary', () => {
+  for (const version of ['23.0.0', '23.4.0', '23.6.0', '23.11.1']) {
+    assert.match(windowsNodeShutdownIssue('win32', version), /Node 23/);
+    assert.equal(windowsNodeShutdownIssue('linux', version), false);
+    assert.equal(windowsNodeShutdownIssue('darwin', version), false);
+  }
+  for (const version of ['24.0.0', '24.15.0', '24.18.0', '24.19.9']) {
+    assert.match(windowsNodeShutdownIssue('win32', version), /Node 24/);
+    assert.equal(windowsNodeShutdownIssue('linux', version), false);
+  }
+  for (const version of ['22.16.0', '24.20.0', '24.21.0', '25.0.0', '26.0.0', 'bogus']) {
+    assert.equal(windowsNodeShutdownIssue('win32', version), false, version);
+  }
+});
+
 // A client view whose state file names the live server with a wrong token. The server polls only its own
 // state file and exits once that file stops naming it, so rewriting it would race the wrong-token request.
 function wrongTokenView(f) {
@@ -295,7 +342,7 @@ test('S1-RS12 the evaluator times the async path: no worker thread per warm scor
   } finally { cleanup(f); }
 });
 
-test('S1-RS13 manifest acceptance thresholds are validated, carried by scored results and applied by the evaluator', async () => {
+test('S1-RS13 manifest acceptance thresholds are validated, carried by scored results and applied by the evaluator', { skip: nodeShutdownIssue }, async () => {
   const acceptance = { minConfidence: 0.6, minMargin: 0.3 };
   const base = fixture();
   try {
@@ -344,3 +391,23 @@ test('S1-RS14 resident transport names its adapter and stays inside the scripts
     assert.throws(() => resident.defaultCommand({ ...f.manifest, adapter: '../evil.py' }));
   } finally { cleanup(f); }
 });
+
+
+// The test server keeps its PID alive for 500 ms after state-file unlink.
+// A state-only teardown passes too early, whereas PID-aware cleanup cannot.
+test('S1-RS15 repeated teardown waits for resident PID and removes every fixture', () => {
+  for (let round = 0; round < 6; round++) {
+    const f = fixture('stub-exit-linger');
+    let pid;
+    try {
+      assert.equal(resident.ensureReady(f.manifest, f.manifestPath, 20000, f.deps), true);
+      const state = resident.readState(resident.stateFiles(f.manifest, f.manifestPath).state);
+      assert.ok(state && state.pid > 0);
+      pid = state.pid;
+    } finally { cleanup(f); }
+    assert.equal(fs.existsSync(f.dir), false, `fixture remained after teardown ${round}`);
+    if (process.platform === 'win32') {
+      assert.equal(pidAlive(pid), false, `resident PID ${pid} leaked in teardown ${round}`);
+    }
+  }
+});

package/docs/platform-capabilities.md

@@ -15,7 +15,7 @@ Statuses are intentionally explicit:
 - `Unsupported`: official host documentation explicitly rules out the capability.
 - `Unknown`: the capability or its current host behavior was not established.
 
-All `liveHostVerification` rows except OpenCode are `Unknown`. OpenCode's row is `Partial`: retained evidence supports project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS), not durable hard enforcement. No fresh artifacts exist yet for the other surfaces, managed-workspace import, or public OpenAI approval.
+Codex and OpenCode are `Partial` in `liveHostVerification`. The Codex artifact verifies user-hook compatibility capture for two consecutive turns on one Windows Codex CLI host; native plugin-hook mounting and other host/version combinations remain unverified. OpenCode's retained evidence supports project-scope `.js` loading and edit/verification state on OpenCode 1.18.31 (macOS), not durable hard enforcement. No fresh artifacts exist yet for the other surfaces, managed-workspace import, or public OpenAI approval.
 
 ### Routing contract vs. host evidence
 
@@ -27,7 +27,7 @@ This is a **repository/agent contract**, not an automatic upgrade to any platfor
 
 | Platform surface | Standalone skills | Plugin support | Hooks/lifecycle | Project scope | Global scope | Current evidence boundary |
 | --- | --- | --- | --- | --- | --- | --- |
-| Codex | `Supported` | `Mechanism verified` | `Mechanism verified` for the local OpenAI package, including session, prompt, supported-tool, subagent, and stop hooks | `.agents/skills/`, `AGENTS.md` | `~/.agents/skills/` | Local package hooks and the state-specific marketplace sync command are mechanically checked; live loading and marketplace refresh remain unverified. |
+| Codex | `Supported` | `Mechanism verified` | `Partial`: user-hook compatibility capture is live-verified for `UserPromptSubmit` and `Stop` on one Windows Codex CLI host; native plugin hooks remain mechanism-verified | `.agents/skills/`, `AGENTS.md` | `~/.agents/skills/` | [Live evidence](../benchmarks/results/live-host/codex-2026-10-13/README.md) verifies two consecutive turns on Codex CLI 0.162.1; native plugin mounting, other lifecycle events, and other versions remain unverified. |
 | ChatGPT / OpenAI Plugin | `Unknown` for a repository-local standalone path | `Mechanism verified` | `Partial`: local Work/Codex hooks are separate from ordinary Chat | Managed workspace marketplace | Not established | The public Skills-only bundle is mechanically reproducible; import, approval, and live behavior remain `Unknown`. |
 | Claude Code | `Supported` | `Supported` | `Mechanism verified` for Harness configuration | `.claude/skills/` | `~/.claude/skills/` | Native Claude surfaces and the state-specific plugin sync command are mechanically checked; fresh-host execution is not preserved here. |
 | OpenCode | `Supported` | `Partial` live-host loading for the project-scope, `.js`-filename install path on OpenCode 1.18.31 (macOS); other install paths remain `Mechanism verified` | `Partial` live-host evidence for project-scope `.js` loading and edit/verification state; hard lock reported only, with no retained blocked-tool trace and a post-reset final snapshot | `.opencode/skills/`, `.agents/skills/`, `.opencode/plugins/` | `~/.config/opencode/skills/`, `~/.agents/skills/`, `~/.config/opencode/plugins/` | [Retained evidence](../benchmarks/results/live-host/opencode-2026-09-16/README.md): loading and state effects verified in one host session; final snapshot post-reset; hard lock only an interactive observation; reflection operator-seeded, then agent-rewritten; no raw transcript or behavioral-effectiveness claim. `.mjs` auto-discovery broken (issue #127); global scope, npm-package installation, and other host versions remain unverified. |
@@ -68,9 +68,9 @@ The advisory installer text generated for Codex/Cursor/Copilot/Continue/Hermes c
 Codex has two paths that must not be collapsed:
 
 1. The general `--codex` installer writes advisory `AGENTS.md` plus repo-scoped skills under `.agents/skills/`. Its generated instructions require reading/evaluating every router-suggested skill before omission, but this remains instruction-governed.
-2. The local OpenAI plugin at `plugins/harness-everything/` packages the skills plus lifecycle hooks for session start, prompt routing, supported local tool calls, subagent lifecycle, and stop verification. Those hooks are mechanically checked, but no live plugin/session artifact is committed.
+2. The local OpenAI plugin at `plugins/harness-everything/` packages the skills plus lifecycle hooks for session start, prompt routing, supported local tool calls, subagent lifecycle, and stop verification. Those hooks are mechanically checked. A separate live run verifies the user-hook compatibility fallback for prompt/stop observation only; native plugin hook mounting remains unverified.
 
-The package is tested at the mechanism layer and remains subject to the host’s hook review/trust flow. A fresh host session is still required before claiming that a particular ChatGPT/Codex installation loaded and fired the hooks or that the model followed read-before-skip.
+The package remains subject to the host’s hook review/trust flow. The retained Codex CLI session proves that the selected user-level observation hooks were trusted and fired on one Windows setup; it does not prove that the model followed read-before-skip or that another ChatGPT/Codex installation loaded the same hooks.
 
 ### Native plugin install/update synchronization
 
@@ -98,13 +98,13 @@ The command detects Claude Code and Codex independently, ensures the Harness mar
 
 Mutating commands are issued with the current option set and retried without any option the host rejects, covering both commander wording (`unknown option '--json'`) and clap wording (`unexpected argument '--json' found`), so older Claude and Codex builds stay supported.
 
-The installed branch is intentionally an update branch even when the current release is already the newest version; the host command may report “already latest.” Codex marketplace upgrade is the current native refresh operation; the command does not edit private cache paths or `config.toml`. These are deterministic command/state tests, not live-host evidence, so `liveHostVerification` remains `Unknown` in the matrix.
+The installed branch is intentionally an update branch even when the current release is already the newest version; the host command may report “already latest.” Codex marketplace upgrade is the current native refresh operation. After successful Codex plugin install/update and verification, `plugin-sync.js` reads the installed plugin's tagged JSON source. It refreshes compatibility hooks only for `source: "local"` with an absolute filesystem path; `git`, `git-subdir`, `npm`, `remote`, unknown or missing variants, and relative paths fail closed before the installer runs. It does not reinterpret a repository subdirectory relative to the sync process working directory. An ownership/configuration error also makes Codex sync report failure. The installer does not alter trust state or private `config.toml`. Deterministic tests cover this source-shape policy; live Codex marketplace source reporting/sync remains unverified. The separate compatibility fallback has one retained live dispatch artifact on Windows, as recorded in the matrix.
 
 On Windows, the synchronizer resolves `codex`/`claude` the same way an interactive shell does: it walks `PATH` directories in order and tries `PATHEXT` extensions within each directory before moving on, so directory order — not which candidate happens to be a directly launchable `.exe` — decides the match. This matters because Node's non-shell `spawnSync` cannot execute a `.cmd`/`.bat` shim directly and, left to its own resolution, can silently prefer an unrelated, older standalone `.exe` elsewhere on `PATH` over a newer npm-installed shim with no error to signal it. Only the one case Windows genuinely requires an interpreter for — a resolved `.cmd`/`.bat` target — is run through `ComSpec`, using the already-resolved absolute path rather than re-resolving the bare command name.
 
 ### Explicit Codex user-hook compatibility fallback
 
-Current Codex documentation supports plugin-bundled hooks, so native plugin mounting remains the preferred path. Some host/source combinations have nevertheless failed to expose enabled plugin hooks for review/entry attribution (#122 and upstream Codex reports). Harness therefore provides an **explicit compatibility fallback**, not an automatic replacement for native plugin hooks:
+Current Codex documentation supports lifecycle hooks for manually installed Codex desktop plugins and requires users to review and trust non-managed hook definitions. The retained codex-cli 0.157.1 evidence records plugin_hooks as removed, so the user-hook compatibility installer remains necessary for that CLI path. Harness provides the compatibility path alongside the native plugin package:
 
 ```bash
 harness codex-hooks install
@@ -112,11 +112,11 @@ harness codex-hooks status
 harness codex-hooks uninstall
 ```
 
-The fallback copies the current packaged runtime into `$CODEX_HOME/harness-everything/compat-hooks/` and merges absolute-path entries into `$CODEX_HOME/hooks.json`. It does **not** modify `config.toml`, trust hashes, approval policy, or hook enablement. Codex must still show/review/trust the resulting non-managed hooks through its normal `/hooks` flow.
+The installer copies the current packaged runtime into `$CODEX_HOME/harness-everything/compat-hooks/` and merges absolute-path entries into `$CODEX_HOME/hooks.json`. harness codex-hooks status reports `inactive` when the compatibility hooks are absent, or `configured-unverified` when their files are healthy; it cannot read Codex trust state. A successful Codex run of plugin-sync.js installs or refreshes this copy automatically. The installer does **not** modify `config.toml`, trust hashes, approval policy, or hook enablement. Codex must still show/review/trust the resulting non-managed hooks through its normal `/hooks` flow.
 
 Ownership is deliberately strict: update/uninstall removes only exact entries recorded in the Harness compatibility manifest. If an installed Harness entry was edited after installation, the operation fails closed rather than overwriting or deleting that user-modified entry. Unrelated pre-existing and later-added user hooks are preserved.
 
-This fallback solves only plugin-source discovery/mounting. It does not claim to repair a Codex carrier that fails to dispatch `PreToolUse` at all; those host-level execution-path limitations remain a live compatibility boundary.
+The compatibility path registers hook commands in Codex user configuration and covers the missing plugin-mount route where user hooks dispatch. It does not repair a Codex carrier that fails to dispatch `PreToolUse` at all; those host-level execution-path limitations remain a live compatibility boundary.
 
 The public OpenAI Skills-only plugin is narrower again. Its ZIP contains the packaged `skills/` tree and referenced files, but not the local `.codex-plugin` lifecycle hooks. Public submission readiness is therefore a package/form contract, not evidence of public-directory approval or live hook execution.
 

package/docs/platform-compatibility.json

@@ -1,6 +1,6 @@
 {
   "format": "harness-platform-compatibility-v1",
-  "last_reviewed": "2026-09-21",
+  "last_reviewed": "2026-10-13",
   "status_vocabulary": {
     "Supported": "An official or native mechanism exists and the Harness behavior is verified.",
     "Mechanism verified": "Harness package, adapter, or installer checks pass, but a real host run is not confirmed.",
@@ -109,13 +109,13 @@
         "standaloneSkills": {"status": "Supported", "paths": {"project": [".agents/skills"], "global": ["~/.agents/skills"]}},
         "pluginSupport": {"status": "Mechanism verified", "paths": {"manifest": ["plugin.json", ".codex-plugin/plugin.json"]}},
         "bundledSkills": {"status": "Mechanism verified", "notes": "The local package contains a root skills/ tree."},
-        "hooksLifecycle": {"status": "Mechanism verified", "notes": "Codex officially supports plugin-bundled hooks and the local package is mechanism-tested. The plugin intentionally does not declare unsupported PostToolUseFailure; Codex uses documented PostToolUse semantics instead. Harness also provides an explicit user-config compatibility fallback that copies the packaged runtime and merges exact-owned entries into $CODEX_HOME/hooks.json without changing trust/config.toml. Neither path is promoted to live verified until a real host exposes and executes the hooks."},
+        "hooksLifecycle": {"status": "Partial", "notes": "Codex documents plugin-bundled hooks for manually installed desktop plugins, and the local package is mechanism-tested. The plugin intentionally does not declare unsupported PostToolUseFailure; Codex uses documented PostToolUse semantics instead. Harness also provides a user-config compatibility installer that copies the packaged runtime and merges exact-owned entries into $CODEX_HOME/hooks.json without changing trust/config.toml; successful plugin sync refreshes this copy. Live evidence verifies the UserPromptSubmit and Stop observation handlers through the compatibility fallback on one Windows Codex CLI 0.162.1 host; native plugin-bundled hook mounting and other lifecycle events remain unverified."},
         "projectScope": {"status": "Mechanism verified", "paths": {"skills": [".agents/skills"], "instructions": ["AGENTS.md"]}},
         "globalScope": {"status": "Mechanism verified", "paths": {"skills": ["~/.agents/skills"]}},
-        "installUninstallSymmetry": {"status": "Mechanism verified", "notes": "General Harness installer ownership is mechanism-tested. The optional codex-hooks compatibility fallback separately has exact-entry update/uninstall ownership tests and preserves unrelated user hooks; live Codex trust/dispatch still requires host evidence."},
+        "installUninstallSymmetry": {"status": "Mechanism verified", "notes": "General Harness installer ownership is mechanism-tested. The optional codex-hooks compatibility fallback separately has exact-entry update/uninstall ownership tests and preserves unrelated user hooks. Live evidence confirms trusted dispatch for the two observation handlers on one Windows Codex CLI host; native plugin mounting and other scopes remain unverified."},
         "assetsReferences": {"status": "Mechanism verified", "notes": "Packaged skill references are checked and remain inside the package."},
-        "updateSync": {"status": "Mechanism verified", "notes": "scripts/plugin-sync.js detects installed state and uses marketplace upgrade for an installed Codex plugin; unsupported CLI options are dropped and retried, and a Codex build without codex plugin list/add is reported as an actionable capability-boundary skip. No live Codex host refresh is preserved."},
-        "liveHostVerification": {"status": "Unknown", "notes": "No preserved Codex plugin/session artifact proves current bundled-hook entry. Native plugin mounting is preferred; the explicit user-hook fallback is mechanism-verified only and does not solve host carriers that bypass hook dispatch."}
+        "updateSync": {"status": "Mechanism verified", "notes": "scripts/plugin-sync.js detects installed state and uses marketplace upgrade for an installed Codex plugin; after successful install/update verification it refreshes the local codex-hooks compatibility runtime and hooks.json entries. Unsupported CLI options are dropped and retried, and a Codex build without codex plugin list/add is reported as an actionable capability-boundary skip. Live marketplace source reporting and plugin-sync refresh remain unverified; the separate compatibility fallback dispatch is live-verified as recorded in the evidence artifact."},
+        "liveHostVerification": {"status": "Partial", "evidence": "benchmarks/results/live-host/codex-2026-10-13/README.md", "notes": "The preserved artifact verifies two consecutive observation captures through the user-hook compatibility fallback on Codex CLI 0.162.1 for Windows, including current-turn labels. Native plugin mounting, marketplace source reporting, other lifecycle events, and other host/version combinations remain unverified."}
       }
     },
     {

package/docs/system-one-observations.md

@@ -2,8 +2,8 @@
 
 Status: **accepted**, 2026-09-27. Owner decisions are recorded below.
 Implementation: `hooks/scripts/observation-hook.js`,
-`hooks/scripts/lib/observations.js`, `scripts/system-one-observations-export.js`
-and `scripts/system-one-observations-review.js`; tests in
+`hooks/scripts/lib/observations.js`, `scripts/system-one-observations-export.js`, `scripts/system-one-observations-import-codex-sessions.js` and
+`scripts/system-one-observations-review.js`; tests in
 `ci/mechanism-34-observations.test.js`. Issue
 [#233](https://github.com/dyphn1/Harness-everything/issues/233).
 
@@ -43,7 +43,7 @@ A turn runs from `UserPromptSubmit` to `Stop`. Its record:
 | `prompt` | `UserPromptSubmit` | stored in the private text store only (see Storage) |
 | `previous` | the last assistant message before the prompt | truncated to 2 KB; text store only |
 | `router` | kernel-router output | lexical tier, strategy, suggested skills; System One shadow scores when present |
-| `behavior` | `PostToolUse`, `PostToolUseFailure` | counts and categories, never arguments: files written, distinct repositories written, files created, commands by class (git, gh, test, build, package, shell), skills loaded or read, subagents started. Failed attempts are counted separately (`toolFailures`, `failedWrites`, `failedSkillLoads`) and never count as a write or a load |
+| `behavior` | `PostToolUse`, `PostToolUseFailure` | counts and categories, never arguments: files written, distinct repositories written, files created, commands by class (git, gh, test, build, package, shell), skills loaded or read, subagents started. Failed attempts are counted separately (`toolFailures`, `failedWrites`, `failedSkillLoads`) and never count as a write or a load. `null` means the capture source did not observe tool events; it is not a zero count. |
 | `workflow` | `workflow-run.json` / `workflow-disposition` | selected and confirmed strategy |
 | `selfReport` | label line in the final message | see below; `null` if missing or invalid |
 | `derived` | exporter | labels computed from the fields above |
@@ -98,6 +98,12 @@ purposes:
 - **Future features.** The counters can train or check later models
   without re-reading transcripts.
 
+Session backfill reads prompts and final labels, but does not reconstruct
+tool events or file writes. Its `behavior` is therefore `null`. Exports count
+observed and unobserved behavior separately and derive contradictions only
+from observed behavior. The default review page includes unobserved records
+and identifies the evidence gap.
+
 **Owner review.** Missing labels, contradictions, and turns where the
 router's tier and the self-reported tier differ go to a blind review page.
 The owner decides validity, context dependence and tier; each decision
@@ -157,11 +163,16 @@ warning sign. The review page samples the turns where they differ.
     it wrote no label; the same text as JSON reached the model and all five
     test turns carried a label. The Codex manifest therefore runs the router
     through `hooks/scripts/codex-user-prompt.js`, which wraps its output.
-  - Plugin-bundled hooks do not run on this version (`plugin_hooks` is
-    `removed`); the explicit fallback `harness codex-hooks install` is
-    needed, and Codex runs the hooks only after they are trusted in
-    `/hooks`.
+  - The retained `codex-cli 0.157.1` evidence found plugin hooks removed
+    (`plugin_hooks`); the local CLI path therefore uses the user-hook
+    compatibility installer. Successful `plugin:hosts` runs now install or
+    refresh that copied runtime and its `hooks.json` entries. The installer
+    does not change trust state; Codex still requires hook review/trust in
+    `/hooks`. Status reports `inactive` when absent and
+    `configured-unverified` when the files are healthy, because this command
+    cannot read Codex trust state.
   - The final message comes from the rollout's `task_complete` event.
+- Fresh live-host verification on Windows (Codex CLI 0.162.1, 2026-10-13) exercised the user-hook compatibility fallback: only the `UserPromptSubmit` and `Stop` observation hooks were individually reviewed/trusted. Two consecutive real turns produced `host: "codex"` records with distinct current `turn_id` values and their respective valid self-reports. The sanitized record excerpt and scope limits are preserved in [Codex live-host evidence](../benchmarks/results/live-host/codex-2026-10-13/README.md). This does not verify native plugin-bundled hooks, other lifecycle events, or tool behavior capture.
 - The final message must belong to the current turn. A transcript scan
   stops at the start of the current turn (Codex `task_started` or a user
   message; a Claude user prompt) and a Codex `task_complete` must carry the
@@ -174,18 +185,34 @@ warning sign. The review page samples the turns where they differ.
 - A missing field records `null` with a reason code. Collection must never
   block, slow down, or fail a turn; each hook has a short time budget.
 
+## Session backfill
+
+To recover self-reported labels written before the observation hooks were active, run:
+
+    node scripts/system-one-observations-import-codex-sessions.js --since 2026-09-27
+
+The importer scans local Codex rollout files and pairs each completed turn with its first user text item. It reads the final label from `task_complete.last_agent_message`; when that field is absent or not a string, the last assistant `response_item` can provide it unless that item is marked `commentary`. When a string completion has no label and the last assistant item is not marked `commentary` and has a valid label, their bodies are compared after `obs.stripLabels` removes label comments and trims surrounding whitespace. A match lets the assistant label provide the missing label; a difference reports `ambiguousFinalMessage`, skips the turn, and clears previous-message context rather than choosing one representation. An explicitly unlabeled completion never inherits a commentary or earlier assistant label, and an invalid completion label is not replaced by the assistant label.
+
+The importer accepts only valid label lines, applies the same email/home-path redaction, and appends idempotently to the private observations store. Backfill and live hook records deduplicate by `(host, writer.sessionId, writer.turnId)`. For older live records without a turn ID, an exact turn-and-text match is skipped; a partial match is counted as ambiguous and skipped to avoid silently duplicating training data. Duplicate and ambiguous legacy live matches are checked atomically under the store lock. A bounded lock timeout is reported as a persistence failure, not as a duplicate, and gives the importer a nonzero exit status; migration lock timeouts are reported the same way. Existing backfill behavior placeholders are migrated to `null`. Reports contain counts and generic error descriptions without printing session text. The cutoff defaults to the date the label contract was accepted. The importer never uploads or writes session content into the repository.
+
 ## Export
 
 `scripts/system-one-observations-export.js` writes to the private data
 repository:
 
 - `prompts-observed.jsonl`: `{id, family, source: "observation", split, text}`
-- `labels-observed.jsonl`: `{id, validity, contextDependent, tier, tierSource, intents, workflow, skills}`
+- `labels-observed.jsonl`: `{id, validity, contextDependent, tier, tierSource, intents, workflow, skills, behaviorEvidence, contradictions}`
 
 `family` groups near-duplicate prompts. The split is by time: the newest 15%
 is validation. The existing holdouts stay frozen and separate. Observed data
 may later seed a new holdout, but only after owner review.
 
+For a training candidate restricted to labels from the accepted label-line date, use an output directory outside the repository:
+
+    node scripts/system-one-observations-export.js --out <private-output-dir> --since 2026-09-27 --self-report-only
+
+This keeps unlabeled observations out of the candidate and leaves existing model and holdout directories untouched.
+
 ## Phases
 
 1. **Contract.** Define the label-line format in `AGENTS.md` rule 11 and in