oh-my-codex 0.20.2 → 0.20.5

package/dist/subagents/__tests__/tracker.test.js

@@ -1,125 +1,12 @@
 import assert from 'node:assert/strict';
-import { createHash } from 'node:crypto';
 import { spawn } from 'node:child_process';
-import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
-import { mkdtemp, mkdir, rm, symlink, writeFile } from 'node:fs/promises';
+import { existsSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { mkdtemp, mkdir, rm, writeFile } from 'node:fs/promises';
 import { hostname, tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { describe, it } from 'node:test';
-import { getBaseStateDir } from '../../state/paths.js';
-import { canonicalizeOriginCwd } from '../../leader/contract.js';
-import { __setCrossProcessPublishBarrierForTest, __setCrossProcessQuarantineBarrierForTest, CrossProcessLockLostError, bindPendingRoleIntentUnderLock, buildSubagentResumeLedger, completeAdaptedRoleBinding, CROSS_PROCESS_LOCK_ARTIFACT_SWEEP_CAP, CROSS_PROCESS_LOCK_LEASE_MS, createSubagentTrackingState, crossProcessLockPath, consumePendingRoleIntent, recordSubagentTurn, NATIVE_SUBAGENT_PROVENANCE, OMX_ADAPTED_PROVENANCE, readProcessStartIdentity, readSubagentTrackingState, recordPendingRoleIntent, selectReusableSubagentEntry, summarizeSubagentSession, withCrossProcessFileLockSync } from '../tracker.js';
-import { subagentTrackingPath } from '../tracker.js';
+import { __setCrossProcessPublishBarrierForTest, __setCrossProcessQuarantineBarrierForTest, consumeDirectChildReopenContext, CrossProcessLockLostError, buildSubagentResumeLedger, CROSS_PROCESS_LOCK_ARTIFACT_SWEEP_CAP, CROSS_PROCESS_LOCK_LEASE_MS, createSubagentTrackingState, crossProcessLockPath, DESCRIPTIVE_ADAPTED_PROVENANCE, fenceNativeSubagentAuthorities, forceGlobalAuthorityDenial, recordNativeSubagentAuthorityObservation, recordSubagentTurn, recordSubagentTurnForSession, NATIVE_SUBAGENT_PROVENANCE, readProcessStartIdentity, readSubagentTrackingState, readSubagentTrackingStateStrict, repairPersistedRootIdentity, revokeNativeSubagentAuthorities, selectReusableSubagentEntry, subagentTrackingPath, summarizeSubagentSession, withCrossProcessFileLockSync, writeSubagentTrackingState } from '../tracker.js';
 import { NATIVE_SUBAGENT_ROLE_ROUTING_MARKER_FILE, readRoleRoutingMarker, writeRoleRoutingMarker } from '../role-routing-marker.js';
-const credentialDigest = (value) => createHash('sha256').update(value).digest('hex');
-const canonicalCorrelationToken = (value) => credentialDigest(value).slice(0, 32);
-const canonicalClaimantToken = (value) => {
-    const digest = credentialDigest(value);
-    return `${digest.slice(0, 8)}-${digest.slice(8, 12)}-4${digest.slice(13, 16)}-8${digest.slice(17, 20)}-${digest.slice(20, 32)}`;
-};
-const PENDING_ROLE_INTENT_WORKER_SOURCE = `
-  import { existsSync } from 'node:fs';
-
-  const input = JSON.parse(process.env.OMX_PENDING_ROLE_INTENT_WORKER_INPUT ?? '{}');
-  const tracker = await import(process.env.OMX_TRACKER_MODULE_URL ?? '');
-  const startSignal = process.env.OMX_PENDING_ROLE_INTENT_START_SIGNAL ?? '';
-  const waitArray = new Int32Array(new SharedArrayBuffer(4));
-  const startedAt = Date.now();
-
-  process.stdout.write('ready\\n');
-  while (!existsSync(startSignal)) {
-    if (Date.now() - startedAt > 10_000) {
-      throw new Error('Timed out waiting for pending role intent test start signal');
-    }
-    Atomics.wait(waitArray, 0, 0, 5);
-  }
-
-  const result = input.operation === 'record'
-    ? tracker.recordPendingRoleIntent(input.cwd, input)
-    : input.operation === 'consume'
-      ? tracker.consumePendingRoleIntent(input.cwd, input)
-      : (await tracker.recordSubagentTurnForSession(input.cwd, input), { ok: true });
-  process.stdout.write(JSON.stringify(result));
-`;
-function spawnPendingRoleIntentWorker(startSignal, input) {
-    const child = spawn(process.execPath, ['--input-type=module', '--eval', PENDING_ROLE_INTENT_WORKER_SOURCE], {
-        env: {
-            ...process.env,
-            OMX_PENDING_ROLE_INTENT_START_SIGNAL: startSignal,
-            OMX_PENDING_ROLE_INTENT_WORKER_INPUT: JSON.stringify(input),
-            OMX_TRACKER_MODULE_URL: new URL('../tracker.js', import.meta.url).href,
-        },
-        stdio: ['ignore', 'pipe', 'pipe'],
-    });
-    if (!child.stdout || !child.stderr) {
-        throw new Error('Pending role intent test worker did not expose output streams');
-    }
-    let stdout = '';
-    let stderr = '';
-    let ready = false;
-    let resolveReady;
-    let rejectReady;
-    let resolveResult;
-    let rejectResult;
-    const readyPromise = new Promise((resolve, reject) => {
-        resolveReady = resolve;
-        rejectReady = reject;
-    });
-    const resultPromise = new Promise((resolve, reject) => {
-        resolveResult = resolve;
-        rejectResult = reject;
-    });
-    child.stdout.setEncoding('utf-8');
-    child.stdout.on('data', (chunk) => {
-        stdout += chunk;
-        if (!ready && stdout.includes('ready\n')) {
-            ready = true;
-            resolveReady();
-        }
-    });
-    child.stderr.setEncoding('utf-8');
-    child.stderr.on('data', (chunk) => {
-        stderr += chunk;
-    });
-    child.once('error', (error) => {
-        if (!ready)
-            rejectReady(error);
-        rejectResult(error);
-    });
-    child.once('close', (code) => {
-        if (!ready) {
-            rejectReady(new Error(`Pending role intent test worker exited before ready: ${stderr || `code ${code}`}`));
-        }
-        if (code !== 0) {
-            rejectResult(new Error(`Pending role intent test worker failed: ${stderr || `code ${code}`}`));
-            return;
-        }
-        try {
-            const resultJson = stdout.slice(stdout.indexOf('ready\n') + 'ready\n'.length);
-            resolveResult(JSON.parse(resultJson));
-        }
-        catch (error) {
-            rejectResult(error instanceof Error ? error : new Error(String(error)));
-        }
-    });
-    return { ready: readyPromise, result: resultPromise };
-}
-async function runConcurrentPendingRoleIntentWorkers(cwd, inputs) {
-    const startSignal = join(cwd, 'pending-role-intent-workers-start');
-    const workers = inputs.map((input) => spawnPendingRoleIntentWorker(startSignal, input));
-    await Promise.all(workers.map((worker) => worker.ready));
-    await writeFile(startSignal, 'start\n');
-    return Promise.all(workers.map((worker) => worker.result));
-}
-function isSuccessfulRoleIntentRecord(result) {
-    return result !== null && 'ok' in result && result.ok === true;
-}
-function isSingleFlightConflict(result) {
-    return result !== null && 'ok' in result && result.ok === false && result.reason === 'single_flight_conflict';
-}
-function isConsumedRoleIntent(result) {
-    return result !== null && 'role' in result;
-}
 const CROSS_PROCESS_LOCK_HOLDER_SOURCE = `
   const tracker = await import(process.env.OMX_TRACKER_MODULE_URL ?? '');
   const { existsSync, writeFileSync } = await import('node:fs');
@@ -139,6 +26,44 @@ const CROSS_PROCESS_LOCK_HOLDER_SOURCE = `
     }
   });
 `;
+const AUTHORITY_COMPETITOR_SOURCE = `
+  const tracker = await import(process.env.OMX_TRACKER_MODULE_URL ?? '');
+  const { writeFileSync } = await import('node:fs');
+  const cwd = process.env.OMX_AUTHORITY_CWD ?? '';
+  const readyPath = process.env.OMX_AUTHORITY_READY_PATH ?? '';
+  const resultPath = process.env.OMX_AUTHORITY_RESULT_PATH ?? '';
+  const operation = process.env.OMX_AUTHORITY_OPERATION ?? '';
+  const waitArray = new Int32Array(new SharedArrayBuffer(4));
+  let observedContention = false;
+  for (let attempt = 0; attempt < 200; attempt += 1) {
+    try {
+      const result = operation === 'reopen'
+        ? tracker.consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' })
+        : tracker.recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'other-root'], childThreadId: 'child', parentThreadId: 'other-root', rootNativeSessionId: 'other-root', authorityEvidence: 'valid' });
+      writeFileSync(resultPath, JSON.stringify({ observedContention, result: operation === 'reopen' ? result : 'revoked' }));
+      process.exit(0);
+    } catch {
+      if (!observedContention) {
+        observedContention = true;
+        writeFileSync(readyPath, 'contended\\n');
+      }
+      Atomics.wait(waitArray, 0, 0, 25);
+    }
+  }
+  throw new Error('Authority competitor never acquired the released lock');
+`;
+function spawnAuthorityCompetitor(cwd, operation, readyPath, resultPath) {
+    return spawn(process.execPath, ['--input-type=module', '--eval', AUTHORITY_COMPETITOR_SOURCE], {
+        env: {
+            ...process.env,
+            OMX_TRACKER_MODULE_URL: new URL('../tracker.js', import.meta.url).href,
+            OMX_AUTHORITY_CWD: cwd,
+            OMX_AUTHORITY_OPERATION: operation,
+            OMX_AUTHORITY_READY_PATH: readyPath,
+            OMX_AUTHORITY_RESULT_PATH: resultPath,
+        },
+    });
+}
 function crossProcessLockClaim(token, pid, acquiredAtMs, host = hostname(), pidStartId) {
     return `${JSON.stringify({
         token,
@@ -243,6 +168,802 @@ describe('subagents/tracker', () => {
         });
         assert.deepEqual(drained?.activeSubagentThreadIds, []);
     });
+    it('authorizes only attested direct children for persisted reopen', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-authority-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            root: { thread_id: 'root', kind: 'subagent', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                            direct: { thread_id: 'direct', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                            nested: { thread_id: 'nested', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'direct', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                            revoked: { thread_id: 'revoked', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', reopen_authority_revoked: true, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.match(context, /resume_agent\("direct"\)/);
+            assert.doesNotMatch(context, /resume_agent\("root"\)|resume_agent\("nested"\)|resume_agent\("revoked"\)/);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.match(persisted.sessions.root.threads.direct.resume_requested_at, /^\d{4}-\d{2}-\d{2}T/);
+            assert.equal(persisted.sessions.root.threads.root.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('atomically revokes conflicting direct-child authority across correlation records', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-conflict-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root-a'], childThreadId: 'child', parentThreadId: 'root-a', rootNativeSessionId: 'root-a' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root-b'], childThreadId: 'child', parentThreadId: 'root-b', rootNativeSessionId: 'root-b' });
+            const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(state.sessions.canonical.threads.child.reopen_authority_revoked, true);
+            assert.equal(state.sessions['root-a'].threads.child.reopen_authority_revoked, true);
+            assert.equal(state.sessions['root-b'].threads.child.reopen_authority_revoked, true);
+            assert.equal(state.sessions.canonical.threads.child.reopen_authority_conflict_reason, 'root_or_parent_mismatch');
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root-a'], childThreadId: 'child', parentThreadId: 'root-a', rootNativeSessionId: 'root-a' });
+            const repaired = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(repaired.sessions.canonical.threads.child.reopen_authority_revoked, undefined);
+            assert.equal(repaired.sessions['root-a'].threads.child.reopen_authority_revoked, undefined);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root-a', source: 'resume' }) ?? '', /resume_agent\("child"\)/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps malformed tracker bytes unchanged across authority reads and writes', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-malformed-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const malformed = '{not-json\n';
+            writeFileSync(path, malformed);
+            assert.throws(() => recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root' }));
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /malformed_tracker_state/);
+            assert.equal(readFileSync(path, 'utf8'), malformed);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies a leader-colliding attested child without bookkeeping', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-leader-collision-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', leader_thread_id: 'child', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const state = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(state.sessions.root.threads.child.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies malformed valid-JSON authority evidence without rewriting bytes', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-malformed-authority-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const raw = JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', reopen_authority_revoked: 'false', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } });
+            writeFileSync(path, raw);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /malformed_tracker_state/);
+            assert.equal(readFileSync(path, 'utf8'), raw);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies malformed status authority evidence without rewriting bytes', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-malformed-status-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const raw = JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'bogus', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } });
+            writeFileSync(path, raw);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /malformed_tracker_state/);
+            assert.equal(readFileSync(path, 'utf8'), raw);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies an unattested descriptive correlation view', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-partial-correlation-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const common = { thread_id: 'child', kind: 'subagent', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 };
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: { child: { ...common, provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root' } } },
+                    correlation: { session_id: 'correlation', updated_at: '2026-07-23T00:00:00.000Z', threads: { child: common } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies cross-partition authority disagreement', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-partition-disagreement-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const thread = { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 };
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: { child: thread } },
+                    correlation: { session_id: 'correlation', updated_at: '2026-07-23T00:00:00.000Z', threads: { child: { ...thread, direct_child_root_id: 'foreign', direct_child_parent_id: 'foreign' } } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('preserves attested authority on pointerless descriptive reobservation', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-pointerless-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root' });
+            const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(state.sessions.canonical.threads.child.reopen_authority_revoked, undefined);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /resume_agent\("child"\)/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('revokes cached authority after an identity-untrusted reobservation', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-untrusted-reobserve-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', authorityEvidence: 'untrusted' });
+            const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(state.sessions.canonical.threads.child.reopen_authority_revoked, true);
+            assert.equal(state.sessions.root.threads.child.reopen_authority_revoked, true);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('allows legacy adapted descriptive records to coexist with a newly attested child', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-legacy-coexist-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            legacy: { thread_id: 'legacy', kind: 'subagent', provenance_kind: 'adapted', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.match(context, /resume_agent\("child"\)/);
+            assert.doesNotMatch(context, /resume_agent\("legacy"\)/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('ignores a same-child adapted legacy peer when validating a newly attested child', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-adapted-peer-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    correlation: { session_id: 'correlation', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: DESCRIPTIVE_ADAPTED_PROVENANCE, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                } }));
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.match(context, /resume_agent\("child"\)/);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.correlation.threads.child.provenance_kind, DESCRIPTIVE_ADAPTED_PROVENANCE);
+            assert.equal(persisted.sessions.correlation.threads.child.direct_child_root_id, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps the generic shared writer fail closed on malformed authority bytes', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-generic-writer-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const raw = JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', reopen_authority_revoked: 'false', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } });
+            writeFileSync(path, raw);
+            const strict = await readSubagentTrackingStateStrict(cwd);
+            assert.equal(strict.ok, false);
+            const tolerantState = createSubagentTrackingState();
+            await assert.rejects(writeSubagentTrackingState(cwd, tolerantState));
+            assert.equal(readFileSync(path, 'utf8'), raw);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /malformed_tracker_state/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies a canonical-key-colliding attested child without destructive reclassification', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-canonical-collision-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            canonical: { thread_id: 'canonical', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', resume_requested_at: '2026-07-23T00:02:00.000Z', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.doesNotMatch(context, /resume_agent\("canonical"\)/);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.canonical.threads.canonical.kind, 'subagent');
+            assert.equal(persisted.sessions.canonical.threads.canonical.reopen_authority_revoked, true);
+            assert.equal(persisted.sessions.canonical.threads.canonical.reopen_authority_conflict_reason, 'canonical_root_collision');
+            assert.equal(persisted.sessions.canonical.threads.canonical.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps a legacy plain canonical-key collision as ambiguous without revocation or reclassification', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-legacy-collision-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            canonical: { thread_id: 'canonical', kind: 'subagent', resume_requested_at: '2026-07-23T00:02:00.000Z', status: 'closed', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.doesNotMatch(context, /resume_agent\("canonical"\)/);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.canonical.threads.canonical.kind, 'subagent');
+            assert.equal(persisted.sessions.canonical.threads.canonical.reopen_authority_revoked, undefined);
+            assert.equal(persisted.sessions.canonical.threads.canonical.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies an adapted peer view recorded with leader kind', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-adapted-leader-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const attested = { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 };
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: { child: attested } },
+                    correlation: { session_id: 'correlation', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'leader', provenance_kind: DESCRIPTIVE_ADAPTED_PROVENANCE, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies an adapted peer view colliding with the session leader boundary', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-adapted-leader-boundary-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const attested = { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 };
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: { child: attested } },
+                    correlation: { session_id: 'correlation', leader_thread_id: 'child', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: DESCRIPTIVE_ADAPTED_PROVENANCE, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps the legacy notice silent when an authority-bearing denial is present in another partition', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-mixed-notice-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            legacy: { thread_id: 'legacy', kind: 'subagent', provenance_kind: DESCRIPTIVE_ADAPTED_PROVENANCE, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                    correlation: { session_id: 'correlation', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            legacy: { thread_id: 'legacy', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', reopen_authority_revoked: true, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('rejects malformed proposed state in the generic writer even without an existing tracker', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-malformed-proposed-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            const malformedProposed = { schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', reopen_authority_revoked: 'false', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } };
+            await assert.rejects(writeSubagentTrackingState(cwd, malformedProposed));
+            assert.equal(existsSync(path), false);
+            const validState = recordSubagentTurn(createSubagentTrackingState(), { sessionId: 'root', threadId: 'child', kind: 'subagent' });
+            await writeSubagentTrackingState(cwd, validState);
+            assert.equal(existsSync(path), true);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('refuses a stale generic write that would roll back a newer authority revocation', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-stale-generic-write-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            // A descriptive caller snapshots the tracker outside the lock.
+            const stale = await readSubagentTrackingState(cwd);
+            // A competing negative observation revokes that authority.
+            revokeNativeSubagentAuthorities(cwd, ['child'], 'foreign_parent');
+            assert.equal(JSON.parse(readFileSync(path, 'utf8')).sessions.canonical.threads.child.reopen_authority_revoked, true);
+            // Publishing the stale snapshot must not resurrect the revoked authority.
+            await assert.rejects(writeSubagentTrackingState(cwd, stale), /Stale subagent tracker authority state/);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.canonical.threads.child.reopen_authority_revoked, true);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('still allows a descriptive generic write when authority has not moved', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-descriptive-write-ok-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            const snapshot = await readSubagentTrackingState(cwd);
+            const descriptive = recordSubagentTurn(snapshot, { sessionId: 'canonical', threadId: 'child', kind: 'subagent' });
+            await writeSubagentTrackingState(cwd, descriptive);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /resume_agent\("child"\)/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('leaves an uncorrelated partition untouched when a thread id collides with the canonical key', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-uncorrelated-collision-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: {} },
+                    unrelated: { session_id: 'unrelated', leader_thread_id: 'foreign-root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            canonical: { thread_id: 'canonical', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'foreign-root', direct_child_parent_id: 'foreign-root', resume_requested_at: '2026-07-23T00:02:00.000Z', resume_completed_at: '2026-07-23T00:03:00.000Z', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            const foreignChild = persisted.sessions.unrelated.threads.canonical;
+            assert.equal(foreignChild.reopen_authority_revoked, undefined);
+            assert.equal(foreignChild.reopen_authority_conflict_reason, undefined);
+            assert.equal(foreignChild.direct_child_root_id, 'foreign-root');
+            assert.equal(foreignChild.resume_requested_at, '2026-07-23T00:02:00.000Z');
+            assert.equal(foreignChild.resume_completed_at, '2026-07-23T00:03:00.000Z');
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('still quarantines a canonical-key collision inside a correlated partition', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-correlated-collision-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: {
+                    correlated: { session_id: 'correlated', leader_thread_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            root: { thread_id: 'root', kind: 'leader', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                            canonical: { thread_id: 'canonical', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', resume_requested_at: '2026-07-23T00:02:00.000Z', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } },
+                } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const collided = JSON.parse(readFileSync(path, 'utf8')).sessions.correlated.threads.canonical;
+            assert.equal(collided.kind, 'subagent');
+            assert.equal(collided.reopen_authority_revoked, true);
+            assert.equal(collided.reopen_authority_conflict_reason, 'canonical_root_collision');
+            assert.equal(collided.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('keeps authority denied when a revocation could not be published', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-authority-fence-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /resume_agent\("child"\)/);
+            // Simulate a revocation whose transaction failed: the tracker still shows
+            // valid authority, but the fence records the unpublished denial.
+            fenceNativeSubagentAuthorities(cwd, ['child'], 'identity_untrusted_revocation_failed');
+            assert.equal(JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8')).sessions.canonical.threads.child.reopen_authority_revoked, undefined);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            // Once the revocation is durably applied, the fence is released.
+            revokeNativeSubagentAuthorities(cwd, ['child'], 'identity_untrusted');
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            assert.equal(JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8')).sessions.canonical.threads.child.reopen_authority_revoked, true);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('fails closed for every id when the authority fence is unreadable', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-fence-unreadable-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            writeFileSync(`${subagentTrackingPath(cwd)}.authority-fence.json`, '{ not json');
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /unreadable_authority_fence/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('refuses a fresh generic write that would grant or remove reopen authority', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-fresh-generic-authority-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            revokeNativeSubagentAuthorities(cwd, ['child'], 'foreign_parent');
+            // A FRESH read still must not let the descriptive writer lift a revocation.
+            const fresh = await readSubagentTrackingState(cwd);
+            delete fresh.sessions.canonical.threads.child.reopen_authority_revoked;
+            delete fresh.sessions.canonical.threads.child.reopen_authority_conflict_reason;
+            delete fresh.sessions.canonical.threads.child.reopen_authority_conflict_at;
+            await assert.rejects(writeSubagentTrackingState(cwd, fresh), /Stale subagent tracker authority state/);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            // A fresh read must equally not let it GRANT authority. Attaching a fresh
+            // attestation to a previously unattested thread is refused as a stale
+            // authority change rather than published.
+            const granting = await readSubagentTrackingState(cwd);
+            const plain = recordSubagentTurn(granting, { sessionId: 'canonical', threadId: 'newcomer', kind: 'subagent' });
+            plain.sessions.canonical.threads.newcomer.provenance_kind = NATIVE_SUBAGENT_PROVENANCE;
+            plain.sessions.canonical.threads.newcomer.direct_child_root_id = 'root';
+            plain.sessions.canonical.threads.newcomer.direct_child_parent_id = 'root';
+            await assert.rejects(writeSubagentTrackingState(cwd, plain), /Stale subagent tracker authority state/);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('refuses a generic write that would mint authority into a fresh tracker', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-mint-authority-'));
+        try {
+            const minted = recordSubagentTurn(createSubagentTrackingState(), { sessionId: 'canonical', threadId: 'child', kind: 'subagent' });
+            minted.sessions.canonical.threads.child.provenance_kind = NATIVE_SUBAGENT_PROVENANCE;
+            minted.sessions.canonical.threads.child.direct_child_root_id = 'root';
+            minted.sessions.canonical.threads.child.direct_child_parent_id = 'root';
+            await assert.rejects(writeSubagentTrackingState(cwd, minted), /Stale subagent tracker authority state/);
+            assert.equal(existsSync(subagentTrackingPath(cwd)), false);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('lets a fresh generic write set a descriptive leader_thread_id but never mint authority', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-mint-leader-'));
+        try {
+            // leader_thread_id alone is descriptive lifecycle data that legitimate
+            // first writers set; it never makes a thread an eligible reopen target.
+            const descriptive = recordSubagentTurn(createSubagentTrackingState(), { sessionId: 'canonical', threadId: 'child', kind: 'subagent', leaderThreadId: 'thread-leader' });
+            await writeSubagentTrackingState(cwd, descriptive);
+            assert.doesNotMatch(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /resume_agent\(/);
+            // Attaching attestation to that same fresh create is refused.
+            rmSync(subagentTrackingPath(cwd), { force: true });
+            const minted = recordSubagentTurn(createSubagentTrackingState(), { sessionId: 'canonical', threadId: 'child', kind: 'subagent', leaderThreadId: 'thread-leader' });
+            minted.sessions.canonical.threads.child.provenance_kind = NATIVE_SUBAGENT_PROVENANCE;
+            minted.sessions.canonical.threads.child.direct_child_root_id = 'root';
+            minted.sessions.canonical.threads.child.direct_child_parent_id = 'root';
+            await assert.rejects(writeSubagentTrackingState(cwd, minted), /Stale subagent tracker authority state/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('denies every reopen target after a forced global authority denial', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-global-denial-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /resume_agent\("child"\)/);
+            // Simulates both the tracker revocation AND the locked fence failing.
+            assert.equal(forceGlobalAuthorityDenial(cwd, 'identity_untrusted_denial_escalated'), true);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /unreadable_authority_fence/);
+            // The escalated denial survives an unrelated successful revocation.
+            revokeNativeSubagentAuthorities(cwd, ['other'], 'identity_untrusted');
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /unreadable_authority_fence/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('refuses a generic write that would roll an authorized child back to available', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-status-rollback-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            const snapshot = await readSubagentTrackingState(cwd);
+            snapshot.sessions.canonical.threads.child.status = 'unavailable';
+            await assert.rejects(writeSubagentTrackingState(cwd, snapshot), /Stale subagent tracker authority state/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('never destroys an unreadable global fence during an unrelated revocation clear', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-fence-preserved-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'a', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'b', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            const fencePath = `${subagentTrackingPath(cwd)}.authority-fence.json`;
+            writeFileSync(fencePath, '{ not json');
+            // An unrelated revocation must not delete the global denial.
+            revokeNativeSubagentAuthorities(cwd, ['a'], 'identity_untrusted');
+            assert.equal(existsSync(fencePath), true);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /unreadable_authority_fence/);
+            // A no-op revocation for an unknown id must not clear it either.
+            revokeNativeSubagentAuthorities(cwd, ['nonexistent'], 'identity_untrusted');
+            assert.equal(existsSync(fencePath), true);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('does not weaken an unreadable global fence when a later fence records more ids', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-fence-no-weaken-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            const fencePath = `${subagentTrackingPath(cwd)}.authority-fence.json`;
+            writeFileSync(fencePath, '{ not json');
+            assert.equal(fenceNativeSubagentAuthorities(cwd, ['other'], 'identity_untrusted_revocation_failed'), true);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /unreadable_authority_fence/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('clears only fully reconciled fence ids and keeps the rest denied', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-fence-partial-clear-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'a', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'b', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            assert.equal(fenceNativeSubagentAuthorities(cwd, ['a', 'b'], 'identity_untrusted_revocation_failed'), true);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            revokeNativeSubagentAuthorities(cwd, ['a'], 'identity_untrusted');
+            // `b` is still fenced, so it must not be emitted even though its tracker
+            // record still looks valid.
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const fence = JSON.parse(readFileSync(`${subagentTrackingPath(cwd)}.authority-fence.json`, 'utf8'));
+            assert.deepEqual(fence.ids, ['b']);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('repairs a root inversion even when the canonical tracker partition is missing', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-native-only-repair-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', leader_thread_id: 'turn-like-foreign', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            root: { thread_id: 'root', kind: 'subagent', status: 'closed', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.root.threads.root.kind, 'leader');
+            assert.equal(persisted.sessions.root.leader_thread_id, 'root');
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('repairs a root inversion through the decoupled repair entrypoint', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-decoupled-repair-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', leader_thread_id: 'turn-like-foreign', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            root: { thread_id: 'root', kind: 'subagent', status: 'closed', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            assert.equal(repairPersistedRootIdentity(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root' }), true);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.root.threads.root.kind, 'leader');
+            assert.equal(persisted.sessions.root.leader_thread_id, 'root');
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('surfaces an explicit notice when only legacy non-authoritative records are excluded', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-legacy-notice-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { canonical: { session_id: 'canonical', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            legacy: { thread_id: 'legacy', kind: 'subagent', provenance_kind: DESCRIPTIVE_ADAPTED_PROVENANCE, status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } }));
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.match(context, /\[Persisted subagent reopen\]/);
+            assert.match(context, /excluded as non-authoritative or legacy/);
+            assert.doesNotMatch(context, /resume_agent\(/);
+            const persisted = JSON.parse(readFileSync(path, 'utf8'));
+            assert.equal(persisted.sessions.canonical.threads.legacy.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('prevents descriptive writers from normalizing malformed authority into reopen access', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-shared-writer-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const raw = JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads: {
+                            child: { thread_id: 'child', kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', reopen_authority_revoked: 'false', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 },
+                        } } } });
+            writeFileSync(path, raw);
+            await assert.rejects(recordSubagentTurnForSession(cwd, { sessionId: 'root', threadId: 'other', kind: 'subagent' }));
+            assert.equal(readFileSync(path, 'utf8'), raw);
+            assert.match(consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '', /malformed_tracker_state/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('counts omission caps from authorized targets and warnings only', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-caps-'));
+        try {
+            const path = subagentTrackingPath(cwd);
+            mkdirSync(join(cwd, '.omx', 'state'), { recursive: true });
+            const threads = {};
+            for (let index = 0; index < 14; index += 1)
+                threads[`child-${index}`] = { thread_id: `child-${index}`, kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: `2026-07-23T00:${String(index).padStart(2, '0')}:00.000Z`, turn_count: 1 };
+            for (let index = 0; index < 10; index += 1)
+                threads[`warning-${index}`] = { thread_id: `warning-${index}`, kind: 'subagent', provenance_kind: NATIVE_SUBAGENT_PROVENANCE, direct_child_root_id: 'root', direct_child_parent_id: 'root', status: 'unavailable', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 };
+            threads.legacy = { thread_id: 'legacy', kind: 'subagent', status: 'available', first_seen_at: '2026-07-23T00:00:00.000Z', last_seen_at: '2026-07-23T00:00:00.000Z', turn_count: 1 };
+            writeFileSync(path, JSON.stringify({ schemaVersion: 1, sessions: { root: { session_id: 'root', updated_at: '2026-07-23T00:00:00.000Z', threads } } }));
+            const context = consumeDirectChildReopenContext(cwd, { sessionId: 'root', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.match(context, /2 more saved subagent id\(s\) omitted/);
+            assert.match(context, /2 more warning\(s\) omitted/);
+            assert.doesNotMatch(context, /resume_agent\("legacy"\)/);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('revokes direct-child authority when an authoritative observation moves it under a nested parent', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-direct-to-nested-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'nested-parent'], childThreadId: 'child', parentThreadId: 'nested-parent', rootNativeSessionId: 'root' });
+            const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(state.sessions.canonical.threads.child.reopen_authority_revoked, true);
+            assert.equal(state.sessions.root.threads.child.reopen_authority_revoked, true);
+            assert.equal(state.sessions['nested-parent'].threads.child.reopen_authority_revoked, true);
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('linearizes revocation before reopen as a denied operation', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-revoke-first-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root' });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'other-root'], childThreadId: 'child', parentThreadId: 'other-root', rootNativeSessionId: 'other-root' });
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(state.sessions.canonical.threads.child.resume_requested_at, undefined);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('linearizes reopen before a later revocation and denies subsequent reopen', () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-reopen-first-'));
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root' });
+            const first = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            assert.match(first, /resume_agent\("child"\)/);
+            const requestedAt = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8')).sessions.canonical.threads.child.resume_requested_at;
+            assert.match(requestedAt, /^\d{4}-\d{2}-\d{2}T/);
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'other-root'], childThreadId: 'child', parentThreadId: 'other-root', rootNativeSessionId: 'other-root' });
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const revoked = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(revoked.sessions.canonical.threads.child.resume_requested_at, requestedAt);
+            assert.equal(revoked.sessions.canonical.threads.child.reopen_authority_revoked, true);
+        }
+        finally {
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('serializes a queued reopen behind revocation publication', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-contended-revoke-first-'));
+        const readyPath = join(cwd, 'reopen-contended');
+        const resultPath = join(cwd, 'reopen-result.json');
+        let competitor;
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            __setCrossProcessPublishBarrierForTest(() => {
+                competitor = spawnAuthorityCompetitor(cwd, 'reopen', readyPath, resultPath);
+                waitForFileSync(readyPath, 10_000);
+            });
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'other-root'], childThreadId: 'child', parentThreadId: 'other-root', rootNativeSessionId: 'other-root', authorityEvidence: 'valid' });
+            __setCrossProcessPublishBarrierForTest(null);
+            assert.ok(competitor);
+            await waitForChildExit(competitor);
+            const result = JSON.parse(readFileSync(resultPath, 'utf8'));
+            assert.equal(result.observedContention, true);
+            assert.equal(result.result, null);
+            const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(state.sessions.canonical.threads.child.resume_requested_at, undefined);
+            assert.equal(state.sessions.canonical.threads.child.reopen_authority_revoked, true);
+        }
+        finally {
+            __setCrossProcessPublishBarrierForTest(null);
+            await stopChild(competitor);
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('serializes queued revocation behind completed reopen publication', async () => {
+        const cwd = mkdtempSync(join(tmpdir(), 'omx-3284-tracker-contended-reopen-first-'));
+        const readyPath = join(cwd, 'revoke-contended');
+        const resultPath = join(cwd, 'revoke-result.json');
+        let competitor;
+        try {
+            recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence: 'valid' });
+            __setCrossProcessPublishBarrierForTest(() => {
+                competitor = spawnAuthorityCompetitor(cwd, 'revoke', readyPath, resultPath);
+                waitForFileSync(readyPath, 10_000);
+            });
+            const first = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+            __setCrossProcessPublishBarrierForTest(null);
+            assert.match(first, /resume_agent\("child"\)/);
+            const requestedAt = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8')).sessions.canonical.threads.child.resume_requested_at;
+            assert.match(requestedAt, /^\d{4}-\d{2}-\d{2}T/);
+            assert.ok(competitor);
+            await waitForChildExit(competitor);
+            const result = JSON.parse(readFileSync(resultPath, 'utf8'));
+            assert.equal(result.observedContention, true);
+            assert.equal(result.result, 'revoked');
+            assert.equal(consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }), null);
+            const revoked = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+            assert.equal(revoked.sessions.canonical.threads.child.resume_requested_at, requestedAt);
+            assert.equal(revoked.sessions.canonical.threads.child.reopen_authority_revoked, true);
+        }
+        finally {
+            __setCrossProcessPublishBarrierForTest(null);
+            await stopChild(competitor);
+            rmSync(cwd, { recursive: true, force: true });
+        }
+    });
+    it('never grants fresh authority from absent or untrusted evidence', () => {
+        for (const authorityEvidence of ['absent', 'untrusted']) {
+            const cwd = mkdtempSync(join(tmpdir(), `omx-3284-tracker-${authorityEvidence}-fresh-`));
+            try {
+                recordNativeSubagentAuthorityObservation(cwd, { sessionIds: ['canonical', 'root'], childThreadId: 'child', parentThreadId: 'root', rootNativeSessionId: 'root', authorityEvidence });
+                const state = JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8'));
+                assert.equal(state.sessions.canonical.threads.child.direct_child_root_id, undefined);
+                const context = consumeDirectChildReopenContext(cwd, { sessionId: 'canonical', rootNativeSessionId: 'root', source: 'resume' }) ?? '';
+                // Fail-closed denial: no authority, no bookkeeping, no resume output. An
+                // explicit exclusion notice is allowed in place of a bare null.
+                assert.doesNotMatch(context, /resume_agent\(/);
+                assert.equal(JSON.parse(readFileSync(subagentTrackingPath(cwd), 'utf8')).sessions.canonical.threads.child.resume_requested_at, undefined);
+            }
+            finally {
+                rmSync(cwd, { recursive: true, force: true });
+            }
+        }
+    });
     it('can record an explicitly spawned subagent as subagent even when it is the first seen thread', () => {
         let state = createSubagentTrackingState();
         state = recordSubagentTurn(state, {
@@ -1106,937 +1827,5 @@ describe('subagents/tracker', () => {
             await rm(baseStateDir, { recursive: true, force: true });
         }
     });
-    it('rejects pending role intents for unknown roles', () => {
-        assert.deepEqual(recordPendingRoleIntent(process.cwd(), {
-            role: 'not-a-known-role',
-            sessionId: 'sess-role-intent',
-            parentThreadId: 'thread-parent',
-            correlationToken: canonicalCorrelationToken('correlation-token'),
-        }), { ok: false, reason: 'unknown_role' });
-    });
-    it('rejects pending role intents with an empty correlation token', () => {
-        assert.deepEqual(recordPendingRoleIntent(process.cwd(), {
-            role: 'architect',
-            sessionId: 'sess-role-intent',
-            parentThreadId: 'thread-parent',
-            correlationToken: '',
-        }), { ok: false, reason: 'invalid_correlation_token' });
-    });
-    it('rejects parser-invalid tokens before persistence and round-trips valid tokens', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-token-grammar-'));
-        try {
-            assert.deepEqual(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: 'session-token-grammar',
-                parentThreadId: 'parent-token-grammar',
-                correlationToken: 'abc_def',
-            }), { ok: false, reason: 'invalid_correlation_token' });
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents.length, 0);
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: 'session-token-grammar',
-                parentThreadId: 'parent-token-grammar',
-                correlationToken: canonicalCorrelationToken('abc123'),
-            }).ok, true);
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents[0]?.correlation_token, canonicalCorrelationToken('abc123'));
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('rejects a second live role intent for the same parent thread', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_000,
-            }).ok, true);
-            assert.deepEqual(recordPendingRoleIntent(cwd, {
-                role: 'critic',
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('critictoken'),
-                nowMs: 1_001,
-            }), { ok: false, reason: 'single_flight_conflict' });
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('serializes concurrent pending role intent records across processes', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        try {
-            const results = await runConcurrentPendingRoleIntentWorkers(cwd, [
-                {
-                    operation: 'record',
-                    cwd,
-                    role: 'architect',
-                    sessionId: 'sess-role-intent-concurrent-record',
-                    parentThreadId: 'thread-parent',
-                    correlationToken: canonicalCorrelationToken('architecttoken'),
-                    nowMs: 1_000,
-                },
-                {
-                    operation: 'record',
-                    cwd,
-                    role: 'critic',
-                    sessionId: 'sess-role-intent-concurrent-record',
-                    parentThreadId: 'thread-parent',
-                    correlationToken: canonicalCorrelationToken('critictoken'),
-                    nowMs: 1_000,
-                },
-            ]);
-            assert.equal(results.filter(isSuccessfulRoleIntentRecord).length, 1);
-            assert.equal(results.filter(isSingleFlightConflict).length, 1);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('preserves expired foreign-origin journals through successful pending-role lifecycle writes', async () => {
-        const sharedRoot = await mkdtemp(join(tmpdir(), 'omx-tracker-shared-writeback-'));
-        const cwdA = join(sharedRoot, 'workspace-a');
-        const cwdB = join(sharedRoot, 'workspace-b');
-        const previousStateRoot = process.env.OMX_STATE_ROOT;
-        try {
-            process.env.OMX_STATE_ROOT = sharedRoot;
-            await mkdir(cwdA, { recursive: true });
-            await mkdir(cwdB, { recursive: true });
-            assert.equal(getBaseStateDir(cwdA), getBaseStateDir(cwdB));
-            const foreignResult = recordPendingRoleIntent(cwdA, {
-                role: 'architect',
-                sessionId: 'session-foreign',
-                parentThreadId: 'parent-foreign',
-                correlationToken: canonicalCorrelationToken('tokenforeign'),
-                ttlMs: 1,
-                nowMs: 1_000,
-            });
-            assert.equal(foreignResult.ok, true);
-            if (!foreignResult.ok)
-                throw new Error('Expected the foreign role intent to record.');
-            const foreignIntent = foreignResult.intent;
-            const assertForeignRetained = async () => {
-                const retained = (await readSubagentTrackingState(cwdB)).pending_role_intents
-                    .find((intent) => intent.correlation_token === foreignIntent.correlation_token);
-                assert.deepEqual(retained, foreignIntent);
-            };
-            const nowMs = 1_002;
-            assert.equal(recordPendingRoleIntent(cwdB, {
-                role: 'critic',
-                sessionId: 'session-bound',
-                parentThreadId: 'parent-bound',
-                correlationToken: canonicalCorrelationToken('tokenbound'),
-                nowMs,
-            }).ok, true);
-            await assertForeignRetained();
-            const binding = bindPendingRoleIntentUnderLock(cwdB, {
-                sessionId: 'session-bound',
-                parentThreadId: 'parent-bound',
-                correlationToken: canonicalCorrelationToken('tokenbound'),
-                nowMs,
-            }, (state) => state);
-            assert.ok(binding?.claimantToken);
-            await assertForeignRetained();
-            assert.equal(completeAdaptedRoleBinding(cwdB, {
-                sessionId: 'session-bound',
-                parentThreadId: 'parent-bound',
-                correlationToken: canonicalCorrelationToken('tokenbound'),
-                claimantToken: binding?.claimantToken,
-                nowMs,
-            }), 'completed');
-            await assertForeignRetained();
-            assert.equal(recordPendingRoleIntent(cwdB, {
-                role: 'critic',
-                sessionId: 'session-consume',
-                parentThreadId: 'parent-consume',
-                correlationToken: canonicalCorrelationToken('tokenconsume'),
-                nowMs,
-            }).ok, true);
-            assert.deepEqual(consumePendingRoleIntent(cwdB, {
-                sessionId: 'session-consume',
-                parentThreadId: 'parent-consume',
-                correlationToken: canonicalCorrelationToken('tokenconsume'),
-                nowMs,
-            }), { role: 'critic', provenanceKind: OMX_ADAPTED_PROVENANCE });
-            await assertForeignRetained();
-        }
-        finally {
-            if (previousStateRoot === undefined)
-                delete process.env.OMX_STATE_ROOT;
-            else
-                process.env.OMX_STATE_ROOT = previousStateRoot;
-            await rm(sharedRoot, { recursive: true, force: true });
-        }
-    });
-    it('binds a pending role intent only when its correlation token matches', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        const input = {
-            sessionId: 'sess-role-intent',
-            parentThreadId: 'thread-parent',
-            nowMs: 1_001,
-        };
-        let bindCount = 0;
-        const bind = (state, intent) => {
-            bindCount += 1;
-            assert.deepEqual(intent, { role: 'architect', provenanceKind: OMX_ADAPTED_PROVENANCE });
-            return state;
-        };
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: input.sessionId,
-                parentThreadId: input.parentThreadId,
-                correlationToken: canonicalCorrelationToken('expectedtoken'),
-                nowMs: 1_000,
-            }).ok, true);
-            assert.equal(bindPendingRoleIntentUnderLock(cwd, input, bind), null);
-            assert.equal(bindPendingRoleIntentUnderLock(cwd, { ...input, correlationToken: canonicalCorrelationToken('wrongtoken') }, bind), null);
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents[0]?.correlation_token, canonicalCorrelationToken('expectedtoken'));
-            const firstBinding = bindPendingRoleIntentUnderLock(cwd, { ...input, correlationToken: canonicalCorrelationToken('expectedtoken') }, bind);
-            assert.equal(firstBinding?.role, 'architect');
-            assert.equal(firstBinding?.provenanceKind, OMX_ADAPTED_PROVENANCE);
-            assert.equal(firstBinding?.alreadyBound, false);
-            assert.ok(firstBinding?.claimantToken);
-            const retainedIntent = (await readSubagentTrackingState(cwd)).pending_role_intents[0];
-            assert.equal(retainedIntent?.binding_state, 'bound');
-            assert.equal(retainedIntent?.binding_claimant_token, firstBinding?.claimantToken);
-            const replay = bindPendingRoleIntentUnderLock(cwd, { ...input, correlationToken: canonicalCorrelationToken('expectedtoken') }, bind);
-            assert.deepEqual(replay, {
-                role: 'architect',
-                provenanceKind: OMX_ADAPTED_PROVENANCE,
-                claimantToken: undefined,
-                alreadyBound: true,
-            });
-            assert.equal(bindCount, 1);
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...input, correlationToken: canonicalCorrelationToken('expectedtoken'), claimantToken: replay?.claimantToken }), 'claimant_mismatch');
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...input, correlationToken: canonicalCorrelationToken('expectedtoken'), claimantToken: firstBinding?.claimantToken }), 'completed');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('migrates a same-workspace cwd-partitioned legacy journal on bind and still consumes one', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-legacy-'));
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const previousStateRoot = process.env.OMX_STATE_ROOT;
-        const nowMs = Date.now();
-        try {
-            delete process.env.OMX_ROOT;
-            delete process.env.OMX_TEAM_STATE_ROOT;
-            delete process.env.OMX_STATE_ROOT;
-            await mkdir(getBaseStateDir(cwd), { recursive: true });
-            const legacyIntent = {
-                role: 'architect',
-                session_id: 'legacy-session-bind',
-                parent_thread_id: 'legacy-parent-bind',
-                correlation_token: canonicalCorrelationToken('legacy-token-bind'),
-                created_at: new Date(nowMs).toISOString(),
-                expires_at: new Date(nowMs + 60_000).toISOString(),
-            };
-            await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                schemaVersion: 1,
-                sessions: {},
-                pending_role_intents: [legacyIntent],
-            })}\n`);
-            const binding = bindPendingRoleIntentUnderLock(cwd, {
-                sessionId: legacyIntent.session_id,
-                parentThreadId: legacyIntent.parent_thread_id,
-                correlationToken: legacyIntent.correlation_token,
-                nowMs,
-            }, (state) => state);
-            assert.equal(binding?.alreadyBound, false);
-            assert.ok(binding?.claimantToken);
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents[0]?.origin_cwd, canonicalizeOriginCwd(cwd));
-            assert.equal(completeAdaptedRoleBinding(cwd, {
-                sessionId: legacyIntent.session_id,
-                parentThreadId: legacyIntent.parent_thread_id,
-                correlationToken: legacyIntent.correlation_token,
-                claimantToken: binding?.claimantToken,
-                nowMs,
-            }), 'completed');
-            const legacyConsumeIntent = {
-                ...legacyIntent,
-                session_id: 'legacy-session-consume',
-                parent_thread_id: 'legacy-parent-consume',
-                correlation_token: canonicalCorrelationToken('legacy-token-consume'),
-            };
-            await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                schemaVersion: 1,
-                sessions: {},
-                pending_role_intents: [legacyConsumeIntent],
-            })}\n`);
-            assert.deepEqual(consumePendingRoleIntent(cwd, {
-                sessionId: legacyConsumeIntent.session_id,
-                parentThreadId: legacyConsumeIntent.parent_thread_id,
-                correlationToken: legacyConsumeIntent.correlation_token,
-                nowMs,
-            }), { role: 'architect', provenanceKind: OMX_ADAPTED_PROVENANCE });
-        }
-        finally {
-            if (previousOmxRoot === undefined)
-                delete process.env.OMX_ROOT;
-            else
-                process.env.OMX_ROOT = previousOmxRoot;
-            if (previousTeamStateRoot === undefined)
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            else
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            if (previousStateRoot === undefined)
-                delete process.env.OMX_STATE_ROOT;
-            else
-                process.env.OMX_STATE_ROOT = previousStateRoot;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('stamps an owned already-bound cwd-default legacy journal on bind replay without disclosing its claimant', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-bound-legacy-'));
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const previousStateRoot = process.env.OMX_STATE_ROOT;
-        const nowMs = Date.now();
-        try {
-            delete process.env.OMX_ROOT;
-            delete process.env.OMX_TEAM_STATE_ROOT;
-            delete process.env.OMX_STATE_ROOT;
-            await mkdir(getBaseStateDir(cwd), { recursive: true });
-            const legacyIntent = {
-                role: 'architect',
-                session_id: 'legacy-bound-session',
-                parent_thread_id: 'legacy-bound-parent',
-                correlation_token: canonicalCorrelationToken('a3118b'),
-                created_at: new Date(nowMs).toISOString(),
-                expires_at: new Date(nowMs + 60_000).toISOString(),
-                binding_state: 'bound',
-                binding_claimant_token: canonicalClaimantToken('legacy-claimant'),
-                bound_at: new Date(nowMs).toISOString(),
-            };
-            await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                schemaVersion: 1,
-                sessions: {},
-                pending_role_intents: [legacyIntent],
-            })}\n`);
-            let bindCalled = false;
-            assert.deepEqual(bindPendingRoleIntentUnderLock(cwd, {
-                sessionId: legacyIntent.session_id,
-                parentThreadId: legacyIntent.parent_thread_id,
-                correlationToken: legacyIntent.correlation_token,
-                nowMs,
-            }, (state) => {
-                bindCalled = true;
-                return state;
-            }), {
-                role: 'architect',
-                provenanceKind: OMX_ADAPTED_PROVENANCE,
-                claimantToken: undefined,
-                alreadyBound: true,
-            });
-            assert.equal(bindCalled, false);
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents[0]?.origin_cwd, canonicalizeOriginCwd(cwd));
-        }
-        finally {
-            if (previousOmxRoot === undefined)
-                delete process.env.OMX_ROOT;
-            else
-                process.env.OMX_ROOT = previousOmxRoot;
-            if (previousTeamStateRoot === undefined)
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            else
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            if (previousStateRoot === undefined)
-                delete process.env.OMX_STATE_ROOT;
-            else
-                process.env.OMX_STATE_ROOT = previousStateRoot;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not allow a shared-root workspace to claim another originless legacy journal', async () => {
-        const sharedRoot = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-shared-legacy-'));
-        const cwdA = join(sharedRoot, 'workspace-a');
-        const cwdB = join(sharedRoot, 'workspace-b');
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const previousStateRoot = process.env.OMX_STATE_ROOT;
-        const nowMs = Date.now();
-        try {
-            delete process.env.OMX_ROOT;
-            delete process.env.OMX_TEAM_STATE_ROOT;
-            process.env.OMX_STATE_ROOT = sharedRoot;
-            await mkdir(cwdA, { recursive: true });
-            await mkdir(cwdB, { recursive: true });
-            const legacyIntent = {
-                role: 'architect',
-                session_id: 'shared-legacy-session',
-                parent_thread_id: 'shared-legacy-parent',
-                correlation_token: canonicalCorrelationToken('shared-legacy-token'),
-                created_at: new Date(nowMs).toISOString(),
-                expires_at: new Date(nowMs + 60_000).toISOString(),
-            };
-            await mkdir(getBaseStateDir(cwdA), { recursive: true });
-            await writeFile(subagentTrackingPath(cwdA), `${JSON.stringify({
-                schemaVersion: 1,
-                sessions: {},
-                pending_role_intents: [legacyIntent],
-            })}\n`);
-            let bindCalled = false;
-            assert.equal(bindPendingRoleIntentUnderLock(cwdB, {
-                sessionId: legacyIntent.session_id,
-                parentThreadId: legacyIntent.parent_thread_id,
-                correlationToken: legacyIntent.correlation_token,
-                nowMs,
-            }, (state) => {
-                bindCalled = true;
-                return state;
-            }), null);
-            assert.equal(bindCalled, false);
-            assert.equal(consumePendingRoleIntent(cwdB, {
-                sessionId: legacyIntent.session_id,
-                parentThreadId: legacyIntent.parent_thread_id,
-                correlationToken: legacyIntent.correlation_token,
-                nowMs,
-            }), null);
-            assert.equal(completeAdaptedRoleBinding(cwdB, {
-                sessionId: legacyIntent.session_id,
-                parentThreadId: legacyIntent.parent_thread_id,
-                correlationToken: legacyIntent.correlation_token,
-                nowMs,
-            }), 'not_found');
-            assert.deepEqual((await readSubagentTrackingState(cwdA)).pending_role_intents, [legacyIntent]);
-        }
-        finally {
-            if (previousOmxRoot === undefined)
-                delete process.env.OMX_ROOT;
-            else
-                process.env.OMX_ROOT = previousOmxRoot;
-            if (previousTeamStateRoot === undefined)
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            else
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            if (previousStateRoot === undefined)
-                delete process.env.OMX_STATE_ROOT;
-            else
-                process.env.OMX_STATE_ROOT = previousStateRoot;
-            await rm(sharedRoot, { recursive: true, force: true });
-        }
-    });
-    it('selects exact-origin duplicate journals deterministically and consumes every own duplicate', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-duplicate-origin-'));
-        const previousOmxRoot = process.env.OMX_ROOT;
-        const previousTeamStateRoot = process.env.OMX_TEAM_STATE_ROOT;
-        const previousStateRoot = process.env.OMX_STATE_ROOT;
-        const nowMs = Date.now();
-        const scope = {
-            sessionId: 'duplicate-session',
-            parentThreadId: 'duplicate-parent',
-            correlationToken: canonicalCorrelationToken('a3118d'),
-        };
-        try {
-            delete process.env.OMX_ROOT;
-            delete process.env.OMX_TEAM_STATE_ROOT;
-            delete process.env.OMX_STATE_ROOT;
-            await mkdir(getBaseStateDir(cwd), { recursive: true });
-            const journal = (role, originCwd, claimantToken) => ({
-                role,
-                session_id: scope.sessionId,
-                parent_thread_id: scope.parentThreadId,
-                correlation_token: scope.correlationToken,
-                created_at: new Date(nowMs).toISOString(),
-                expires_at: new Date(nowMs + 60_000).toISOString(),
-                ...(originCwd ? { origin_cwd: originCwd } : {}),
-                ...(claimantToken ? {
-                    binding_state: 'bound',
-                    binding_claimant_token: canonicalClaimantToken(claimantToken),
-                    bound_at: new Date(nowMs).toISOString(),
-                } : {}),
-            });
-            const legacy = journal('architect');
-            const exact = journal('critic', cwd);
-            const writeJournals = async (pendingRoleIntents) => {
-                await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                    schemaVersion: 1,
-                    sessions: {},
-                    pending_role_intents: pendingRoleIntents,
-                })}\n`);
-            };
-            for (const duplicateOrder of [[legacy, exact], [exact, legacy]]) {
-                await writeJournals(duplicateOrder);
-                assert.deepEqual(consumePendingRoleIntent(cwd, { ...scope, nowMs }), {
-                    role: 'critic',
-                    provenanceKind: OMX_ADAPTED_PROVENANCE,
-                });
-                assert.equal(consumePendingRoleIntent(cwd, { ...scope, nowMs }), null);
-                assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, []);
-            }
-            for (const duplicateOrder of [[legacy, exact], [exact, legacy]]) {
-                await writeJournals(duplicateOrder);
-                let boundRole;
-                const binding = bindPendingRoleIntentUnderLock(cwd, { ...scope, nowMs }, (state, intent) => {
-                    boundRole = intent.role;
-                    return state;
-                });
-                assert.equal(binding?.role, 'critic');
-                assert.equal(boundRole, 'critic');
-                assert.ok(binding?.claimantToken);
-                assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents.map((intent) => intent.role), ['critic']);
-                assert.equal(completeAdaptedRoleBinding(cwd, {
-                    ...scope,
-                    claimantToken: binding?.claimantToken,
-                    nowMs,
-                }), 'completed');
-                assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, []);
-            }
-            const legacyBound = journal('architect', undefined, 'legacyclaimant');
-            const exactBound = journal('critic', cwd, 'exactclaimant');
-            for (const duplicateOrder of [[legacyBound, exactBound], [exactBound, legacyBound]]) {
-                await writeJournals(duplicateOrder);
-                assert.equal(completeAdaptedRoleBinding(cwd, {
-                    ...scope,
-                    claimantToken: canonicalClaimantToken('exactclaimant'),
-                    nowMs,
-                }), 'completed');
-                assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, []);
-            }
-            const mixedStates = [
-                {
-                    name: 'exact-bound-with-legacy-pending',
-                    bound: journal('critic', cwd, 'exact-bound-claimant'),
-                    pending: journal('architect'),
-                },
-                {
-                    name: 'legacy-bound-with-exact-pending',
-                    bound: journal('critic', undefined, 'legacy-bound-claimant'),
-                    pending: journal('architect', cwd),
-                },
-            ];
-            for (const { name, bound, pending } of mixedStates) {
-                for (const invocationOrder of [['bind', 'consume'], ['consume', 'bind']]) {
-                    for (const journalOrder of [[bound, pending], [pending, bound]]) {
-                        await writeJournals(journalOrder);
-                        const authorizedRoles = [];
-                        let bindCount = 0;
-                        for (const operation of invocationOrder) {
-                            if (operation === 'bind') {
-                                const binding = bindPendingRoleIntentUnderLock(cwd, { ...scope, nowMs }, (state) => {
-                                    bindCount += 1;
-                                    return state;
-                                });
-                                assert.deepEqual(binding, {
-                                    role: 'critic',
-                                    provenanceKind: OMX_ADAPTED_PROVENANCE,
-                                    claimantToken: undefined,
-                                    alreadyBound: true,
-                                }, `${name}:${invocationOrder.join('-')}:${journalOrder[0]?.role}`);
-                                authorizedRoles.push(binding?.role ?? 'missing');
-                            }
-                            else {
-                                assert.equal(consumePendingRoleIntent(cwd, { ...scope, nowMs }), null, `${name}:${invocationOrder.join('-')}:${journalOrder[0]?.role}`);
-                            }
-                        }
-                        assert.deepEqual(authorizedRoles, ['critic']);
-                        assert.equal(bindCount, 0);
-                        const retained = (await readSubagentTrackingState(cwd)).pending_role_intents;
-                        assert.equal(retained.length, 1);
-                        assert.equal(retained[0]?.role, 'critic');
-                        assert.equal(retained[0]?.binding_state, 'bound');
-                        assert.equal(retained[0]?.correlation_token, scope.correlationToken);
-                    }
-                }
-            }
-        }
-        finally {
-            if (previousOmxRoot === undefined)
-                delete process.env.OMX_ROOT;
-            else
-                process.env.OMX_ROOT = previousOmxRoot;
-            if (previousTeamStateRoot === undefined)
-                delete process.env.OMX_TEAM_STATE_ROOT;
-            else
-                process.env.OMX_TEAM_STATE_ROOT = previousTeamStateRoot;
-            if (previousStateRoot === undefined)
-                delete process.env.OMX_STATE_ROOT;
-            else
-                process.env.OMX_STATE_ROOT = previousStateRoot;
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('consumes a pending role intent exactly once', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_000,
-            }).ok, true);
-            assert.deepEqual(consumePendingRoleIntent(cwd, {
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_001,
-            }), { role: 'architect', provenanceKind: OMX_ADAPTED_PROVENANCE });
-            assert.equal(consumePendingRoleIntent(cwd, {
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_002,
-            }), null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('completes retained adapted bindings only for the claimant that began them', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        const input = {
-            sessionId: 'sess-complete-binding',
-            parentThreadId: 'thread-parent',
-            correlationToken: canonicalCorrelationToken('completetoken'),
-            nowMs: 1_001,
-        };
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: input.sessionId,
-                parentThreadId: input.parentThreadId,
-                correlationToken: input.correlationToken,
-                nowMs: 1_000,
-            }).ok, true);
-            const binding = bindPendingRoleIntentUnderLock(cwd, input, (state) => state);
-            assert.ok(binding?.claimantToken);
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...input, claimantToken: canonicalClaimantToken('wrong-claimant') }), 'claimant_mismatch');
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents.length, 1);
-            // Fail-closed: an OMITTED caller token must not complete a journal that carries a
-            // stored claimant token (prevents unauthenticated completion / successor theft).
-            assert.equal(completeAdaptedRoleBinding(cwd, {
-                sessionId: input.sessionId,
-                parentThreadId: input.parentThreadId,
-                correlationToken: input.correlationToken,
-            }), 'claimant_mismatch');
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents.length, 1);
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...input, claimantToken: binding.claimantToken }), 'completed');
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...input, claimantToken: binding.claimantToken }), 'not_found');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('requires a claimant-less bound journal to receive its durable correlation token before completion', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-claimant-less-'));
-        const nowMs = Date.now();
-        const intent = {
-            role: 'architect',
-            session_id: 'claimant-less-session',
-            parent_thread_id: 'claimant-less-parent',
-            correlation_token: canonicalCorrelationToken('a3118f'),
-            created_at: new Date(nowMs).toISOString(),
-            expires_at: new Date(nowMs + 60_000).toISOString(),
-            binding_state: 'bound',
-            bound_at: new Date(nowMs).toISOString(),
-            origin_cwd: cwd,
-        };
-        try {
-            await mkdir(getBaseStateDir(cwd), { recursive: true });
-            await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                schemaVersion: 1,
-                sessions: {},
-                pending_role_intents: [intent],
-            })}\n`);
-            assert.equal(completeAdaptedRoleBinding(cwd, {
-                sessionId: intent.session_id,
-                parentThreadId: intent.parent_thread_id,
-                nowMs,
-            }), 'claimant_mismatch');
-            assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, [intent]);
-            assert.equal(completeAdaptedRoleBinding(cwd, {
-                sessionId: intent.session_id,
-                parentThreadId: intent.parent_thread_id,
-                correlationToken: intent.correlation_token,
-                nowMs,
-            }), 'completed');
-            assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, []);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('serializes concurrent pending role intent consumes across processes', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: 'sess-role-intent-concurrent-consume',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_000,
-            }).ok, true);
-            const results = await runConcurrentPendingRoleIntentWorkers(cwd, [
-                {
-                    operation: 'consume',
-                    cwd,
-                    sessionId: 'sess-role-intent-concurrent-consume',
-                    parentThreadId: 'thread-parent',
-                    correlationToken: canonicalCorrelationToken('architecttoken'),
-                    nowMs: 1_001,
-                },
-                {
-                    operation: 'consume',
-                    cwd,
-                    sessionId: 'sess-role-intent-concurrent-consume',
-                    parentThreadId: 'thread-parent',
-                    correlationToken: canonicalCorrelationToken('architecttoken'),
-                    nowMs: 1_001,
-                },
-            ]);
-            assert.equal(results.filter(isConsumedRoleIntent).length, 1);
-            assert.equal(results.filter((result) => result === null).length, 1);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('serializes lifecycle tracking writes with pending role intent records and consumes', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        const sessionId = 'sess-role-intent-lifecycle-race';
-        const parentThreadId = 'thread-parent';
-        const correlationToken = canonicalCorrelationToken('architecttoken');
-        try {
-            const recordResults = await runConcurrentPendingRoleIntentWorkers(cwd, [
-                {
-                    operation: 'record',
-                    cwd,
-                    role: 'architect',
-                    sessionId,
-                    parentThreadId,
-                    correlationToken,
-                    nowMs: 1_000,
-                },
-                {
-                    operation: 'record-turn',
-                    cwd,
-                    sessionId,
-                    threadId: 'thread-lifecycle-before-consume',
-                },
-            ]);
-            assert.equal(isSuccessfulRoleIntentRecord(recordResults[0]), true);
-            assert.equal(isSuccessfulRoleIntentRecord(recordResults[1]), true);
-            const recorded = await readSubagentTrackingState(cwd);
-            assert.equal(recorded.pending_role_intents.length, 1);
-            assert.equal(recorded.pending_role_intents[0]?.role, 'architect');
-            assert.equal(recorded.sessions[sessionId]?.threads['thread-lifecycle-before-consume']?.kind, 'leader');
-            const consumeResults = await runConcurrentPendingRoleIntentWorkers(cwd, [
-                {
-                    operation: 'consume',
-                    cwd,
-                    sessionId,
-                    parentThreadId,
-                    correlationToken,
-                    nowMs: 1_001,
-                },
-                {
-                    operation: 'record-turn',
-                    cwd,
-                    sessionId,
-                    threadId: 'thread-lifecycle-after-consume',
-                },
-            ]);
-            assert.equal(isConsumedRoleIntent(consumeResults[0]), true);
-            assert.equal(isSuccessfulRoleIntentRecord(consumeResults[1]), true);
-            const consumed = await readSubagentTrackingState(cwd);
-            assert.deepEqual(consumed.pending_role_intents, []);
-            assert.equal(consumed.sessions[sessionId]?.threads['thread-lifecycle-before-consume']?.kind, 'leader');
-            assert.equal(consumed.sessions[sessionId]?.threads['thread-lifecycle-after-consume']?.kind, 'subagent');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('does not consume expired pending role intents', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-'));
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, {
-                role: 'architect',
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_000,
-                ttlMs: 10,
-            }).ok, true);
-            assert.equal(consumePendingRoleIntent(cwd, {
-                sessionId: 'sess-role-intent',
-                parentThreadId: 'thread-parent',
-                correlationToken: canonicalCorrelationToken('architecttoken'),
-                nowMs: 1_010,
-            }), null);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('retains invalid durable credentials and rejects whitespace callers without fallthrough', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-credentials-'));
-        const nowMs = Date.now();
-        const scope = { session_id: 'credential-session', parent_thread_id: 'credential-parent' };
-        const base = {
-            role: 'architect',
-            ...scope,
-            created_at: new Date(nowMs).toISOString(),
-            expires_at: new Date(nowMs + 60_000).toISOString(),
-            binding_state: 'bound',
-            origin_cwd: cwd,
-        };
-        try {
-            await mkdir(getBaseStateDir(cwd), { recursive: true });
-            await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                schemaVersion: 1,
-                sessions: {},
-                pending_role_intents: [
-                    { ...base, correlation_token: '', binding_claimant_token: canonicalClaimantToken('claimant') },
-                    { ...base, correlation_token: canonicalCorrelationToken('validtoken'), binding_claimant_token: canonicalClaimantToken('claimant') },
-                ],
-            })}\n`);
-            const retained = (await readSubagentTrackingState(cwd)).pending_role_intents;
-            assert.equal(retained[0]?.correlation_token, '');
-            assert.equal(retained[0]?.binding_claimant_token, canonicalClaimantToken('claimant'));
-            assert.equal(completeAdaptedRoleBinding(cwd, {
-                sessionId: scope.session_id, parentThreadId: scope.parent_thread_id,
-                correlationToken: canonicalCorrelationToken('validtoken'), claimantToken: canonicalClaimantToken('claimant'), nowMs,
-            }), 'claimant_mismatch');
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents.length, 2);
-            await writeFile(subagentTrackingPath(cwd), `${JSON.stringify({
-                schemaVersion: 1, sessions: {}, pending_role_intents: [{
-                        ...base, correlation_token: canonicalCorrelationToken('validtoken'), binding_claimant_token: canonicalClaimantToken('claimant'),
-                    }],
-            })}\n`);
-            assert.equal(completeAdaptedRoleBinding(cwd, {
-                sessionId: scope.session_id, parentThreadId: scope.parent_thread_id,
-                correlationToken: ' validtoken ', claimantToken: ' claimant ', nowMs,
-            }), 'claimant_mismatch');
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('rejects noncanonical caller correlation credentials without changing a retained intent', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-caller-credential-'));
-        const correlationToken = canonicalCorrelationToken('caller-correlation');
-        const scope = { sessionId: 'caller-session', parentThreadId: 'caller-parent', correlationToken, nowMs: Date.now() };
-        try {
-            assert.equal(recordPendingRoleIntent(cwd, { role: 'architect', ...scope }).ok, true);
-            for (const invalid of ['', ' ', null, 1, true, [], {}]) {
-                assert.equal(bindPendingRoleIntentUnderLock(cwd, { ...scope, correlationToken: invalid }, (state) => state), null);
-                assert.equal(consumePendingRoleIntent(cwd, { ...scope, correlationToken: invalid }), null);
-                assert.equal(completeAdaptedRoleBinding(cwd, { ...scope, correlationToken: invalid }), 'not_found');
-            }
-            assert.equal((await readSubagentTrackingState(cwd)).pending_role_intents.length, 1);
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('rejects every malformed completion credential without rewriting durable bound journals', async () => {
-        const cwd = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-completion-credentials-'));
-        const nowMs = Date.now();
-        const correlationToken = canonicalCorrelationToken('completion-correlation');
-        const claimantToken = canonicalClaimantToken('completion-claimant');
-        const scope = { sessionId: 'completion-session', parentThreadId: 'completion-parent', nowMs };
-        const base = {
-            role: 'architect',
-            session_id: scope.sessionId,
-            parent_thread_id: scope.parentThreadId,
-            created_at: new Date(nowMs).toISOString(),
-            expires_at: new Date(nowMs + 60_000).toISOString(),
-            binding_state: 'bound',
-            bound_at: new Date(nowMs).toISOString(),
-            origin_cwd: cwd,
-        };
-        const writeJournal = async (journal) => {
-            const raw = `${JSON.stringify({ schemaVersion: 1, sessions: {}, pending_role_intents: [journal] })}\n`;
-            await writeFile(subagentTrackingPath(cwd), raw);
-            return raw;
-        };
-        const assertRetainedMismatch = async (label, journal, input) => {
-            const raw = await writeJournal(journal);
-            assert.equal(completeAdaptedRoleBinding(cwd, input), 'claimant_mismatch', label);
-            assert.equal(readFileSync(subagentTrackingPath(cwd), 'utf-8'), raw, label);
-        };
-        try {
-            await mkdir(getBaseStateDir(cwd), { recursive: true });
-            const claimantLess = { ...base, correlation_token: correlationToken };
-            const claimed = { ...claimantLess, binding_claimant_token: claimantToken };
-            const invalidCorrelations = [
-                ['omitted', undefined], ['empty', ''], ['ascii-whitespace', ' '], ['tab-cr-lf-wrapped', `\t${correlationToken}\r\n`],
-                ['uppercase', correlationToken.toUpperCase()], ['wrong-length', correlationToken.slice(1)], ['non-hex', 'g'.repeat(32)],
-                ['wrong-canonical', canonicalCorrelationToken('other-correlation')], ['null', null], ['number', 1], ['boolean', true], ['array', []], ['object', {}],
-            ];
-            for (const [name, value] of invalidCorrelations) {
-                const input = { ...scope, correlationToken: value, claimantToken };
-                await assertRetainedMismatch(`claimant-less correlation ${name}`, claimantLess, input);
-                await assertRetainedMismatch(`claimed correlation ${name}`, claimed, input);
-            }
-            const invalidClaimants = [
-                ['omitted', undefined], ['empty', ''], ['ascii-whitespace', ' '], ['tab-cr-lf-wrapped', `\t${claimantToken}\r\n`],
-                ['uppercase', claimantToken.toUpperCase()], ['wrong-length', claimantToken.slice(1)], ['non-hex', 'x'.repeat(36)],
-                ['wrong-canonical', canonicalClaimantToken('other-claimant')], ['null', null], ['number', 1], ['boolean', true], ['array', []], ['object', {}],
-            ];
-            for (const [name, value] of invalidClaimants) {
-                await assertRetainedMismatch(`claimed claimant ${name}`, claimed, { ...scope, correlationToken, claimantToken: value });
-            }
-            await writeJournal(claimantLess);
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...scope, correlationToken }), 'completed');
-            assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, []);
-            await writeJournal(claimed);
-            assert.equal(completeAdaptedRoleBinding(cwd, { ...scope, correlationToken, claimantToken }), 'completed');
-            assert.deepEqual((await readSubagentTrackingState(cwd)).pending_role_intents, []);
-            for (const persistedCorrelation of ['', ' ', null, 1, true, [], {}]) {
-                await assertRetainedMismatch('claimed persisted correlation', { ...claimed, correlation_token: persistedCorrelation }, { ...scope, correlationToken, claimantToken });
-                await assertRetainedMismatch('claimant-less persisted correlation', { ...claimantLess, correlation_token: persistedCorrelation }, { ...scope, correlationToken });
-            }
-            for (const persistedClaimant of ['', ' ', null, 1, true, [], {}]) {
-                await assertRetainedMismatch('claimed persisted claimant', { ...claimed, binding_claimant_token: persistedClaimant }, { ...scope, correlationToken, claimantToken });
-            }
-        }
-        finally {
-            await rm(cwd, { recursive: true, force: true });
-        }
-    });
-    it('rejects NUL and ELOOP origins before creating tracking artifacts', async () => {
-        const parent = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-origin-'));
-        const stateRoot = await mkdtemp(join(tmpdir(), 'omx-subagent-tracker-origin-state-'));
-        const loop = join(parent, 'loop');
-        const validCwd = join(parent, 'valid');
-        const previousStateRoot = process.env.OMX_STATE_ROOT;
-        const assertNoArtifacts = () => assert.deepEqual(readdirSync(stateRoot), []);
-        try {
-            process.env.OMX_STATE_ROOT = stateRoot;
-            await symlink(loop, loop);
-            for (const cwd of [`${parent}\u0000suffix`, loop]) {
-                assert.deepEqual(recordPendingRoleIntent(cwd, {
-                    role: 'architect', sessionId: 'origin-session', parentThreadId: 'origin-parent', correlationToken: canonicalCorrelationToken('origintoken'),
-                }), { ok: false, reason: 'invalid_origin' });
-                assertNoArtifacts();
-            }
-            await mkdir(validCwd);
-            const recorded = recordPendingRoleIntent(validCwd, {
-                role: 'architect', sessionId: 'valid-origin-session', parentThreadId: 'valid-origin-parent', correlationToken: canonicalCorrelationToken('validorigintoken'),
-            });
-            assert.equal(recorded.ok, true);
-            assert.equal(recorded.ok && recorded.intent.origin_cwd, canonicalizeOriginCwd(validCwd));
-            const state = await readSubagentTrackingState(validCwd);
-            assert.deepEqual(state.pending_role_intents, recorded.ok ? [recorded.intent] : []);
-            assert.equal(existsSync(subagentTrackingPath(validCwd)), true);
-        }
-        finally {
-            if (previousStateRoot === undefined)
-                delete process.env.OMX_STATE_ROOT;
-            else
-                process.env.OMX_STATE_ROOT = previousStateRoot;
-            await rm(parent, { recursive: true, force: true });
-            await rm(stateRoot, { recursive: true, force: true });
-        }
-    });
 });
 //# sourceMappingURL=tracker.test.js.map