@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/README.md

@@ -182,7 +182,7 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 | `code-task` → `review-code` | Implement and test, then run a structured code review |
 | `commit` → `create-pr` → `complete-task` | Commit, open a PR, and archive the task |
 
-Start with one atomic role policy, for example: `$run-task 42 --executor-model <id> --executor-reasoning-effort <value> --reviewer-model <id> --reviewer-reasoning-effort <value>`. Both roles may use the same model. With no explicit policy, `run-task` reads the current Agent Client's optional `agentClients[].orchestration`; if neither source is complete, it shows the host model-selection guidance before creating any run. Re-entry uses the persisted v2 policy.
+Start with one atomic role policy, for example: `$run-task 42 --executor-model <id> --executor-reasoning-effort <value> --reviewer-model <id> --reviewer-reasoning-effort <value>`. Both roles may use the same model. With no explicit policy, `run-task` reads the current Agent Client's optional `agentClients[].orchestration`; if neither source is complete, it shows the host model-selection guidance before creating any run. Re-entry uses the persisted run policy. Finish or clear active runs before upgrading agent-infra; unsupported disk state fails closed without rewriting.
 
 See the full catalog — task status, release, security, and project-maintenance skills — in [Built-in AI Skills](./docs/en/skills.md).
 

package/README.zh-CN.md

@@ -181,7 +181,7 @@ ai agent-client configure
 | `code-task` → `review-code` | 实现并测试，再执行结构化代码审查 |
 | `commit` → `create-pr` → `complete-task` | 提交、创建 PR、归档任务 |
 
-启动时可提供原子角色策略，例如：`$run-task 42 --executor-model <id> --executor-reasoning-effort <值> --reviewer-model <id> --reviewer-reasoning-effort <值>`。两个角色可以使用同一模型。完全没有显式策略时，`run-task` 读取当前 Agent Client 可选的 `agentClients[].orchestration`；两个来源都不完整时，会在创建任何 run 前展示宿主模型选择指引。重入使用已持久化的 v2 策略。
+启动时可提供原子角色策略，例如：`$run-task 42 --executor-model <id> --executor-reasoning-effort <值> --reviewer-model <id> --reviewer-reasoning-effort <值>`。两个角色可以使用同一模型。完全没有显式策略时，`run-task` 读取当前 Agent Client 可选的 `agentClients[].orchestration`；两个来源都不完整时，会在创建任何 run 前展示宿主模型选择指引。重入使用已持久化的 run 策略。升级 agent-infra 前必须完成或清空 active run；不受支持的磁盘状态会失败关闭且不改写。
 
 完整清单（任务状态、发布、安全、项目维护等 skill）见 [内置 AI Skills](./docs/zh-CN/skills.md)。
 

package/dist/bin/internal-cli.js

@@ -6,7 +6,7 @@ if (major < 22 || (major === 22 && minor < 9)) {
 }
 const command = process.argv[2] || '';
 if (process.env.AGENT_INFRA_CONTROL_TOKEN
-    && (command === 'task-lifecycle' || command === 'task-orchestration')) {
+    && (command === 'task-lifecycle' || command === 'task-orchestration' || command === 'task-finalization')) {
     const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
     await sandboxControl(['client', command, ...process.argv.slice(3)]);
 }
@@ -132,6 +132,16 @@ else
             taskLifecycle(process.argv.slice(3));
             break;
         }
+        case 'task-finalization': {
+            const { taskFinalization } = await import('../lib/internal/task-finalization.js');
+            taskFinalization(process.argv.slice(3));
+            break;
+        }
+        case 'task-override': {
+            const { taskOverride } = await import('../lib/internal/task-override.js');
+            taskOverride(process.argv.slice(3));
+            break;
+        }
         case 'task-short-id': {
             const { taskShortId } = await import('../lib/internal/task-short-id.js');
             taskShortId(process.argv.slice(3));

package/dist/lib/agent-clients/adapters/claude-code.js

@@ -11,7 +11,7 @@ const claudeCodeAdapter = defineAgentClientAdapter({
         commands: { level: 'integrated' },
         hooks: { level: 'integrated' },
         subagents: { level: 'experimental' },
-        orchestration: { level: 'unsupported' },
+        orchestration: { level: 'experimental' },
         sandbox: { level: 'integrated' },
         verification: { level: 'compatible' }
     },
@@ -21,8 +21,8 @@ const claudeCodeAdapter = defineAgentClientAdapter({
         guidance: 'Use the host model picker for the complete model and reasoning-effort catalog.'
     },
     delegationEvidence: {
-        actualModel: 'unavailable',
-        actualReasoningEffort: 'unavailable'
+        actualModel: 'host-event',
+        actualReasoningEffort: 'spawn-ack'
     },
     project: {
         ownedPathPrefixes: ['.claude/'],

package/dist/lib/agent-clients/adapters/codex-lifecycle/app-server.js

@@ -4,6 +4,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import semver from 'semver';
+import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js';
 const LIFECYCLE_HOOKS = Object.freeze([
     Object.freeze({ event: 'PreToolUse', matcher: '^collaborationspawn_agent$', phase: 'pre-tool' }),
     Object.freeze({ event: 'PostToolUse', matcher: '', phase: 'post-tool' }),
@@ -12,6 +13,10 @@ const LIFECYCLE_HOOKS = Object.freeze([
 ]);
 const DEFAULT_ROLLOUT_READ_ATTEMPTS = 81;
 const DEFAULT_ROLLOUT_RETRY_MS = 100;
+const DEFAULT_THREAD_READ_ATTEMPTS = 21;
+const DEFAULT_THREAD_RETRY_MS = 100;
+const DEFAULT_TERMINAL_READ_ATTEMPTS = 21;
+const DEFAULT_TERMINAL_RETRY_MS = 100;
 function object(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -61,16 +66,20 @@ function resolveCodexSpawnedChild(transcriptPath, expected) {
         throw new Error('Codex parent rollout spawn identity does not match the hook event');
     const activities = records.filter((record) => {
         const payload = object(record?.payload);
+        const item = object(payload?.item);
         return record?.type === 'event_msg'
-            && payload?.type === 'sub_agent_activity'
-            && payload.event_id === expected.toolUseId
-            && payload.kind === 'started'
-            && payload.agent_path === `/root/${expected.taskName}`
-            && nonEmpty(payload.agent_thread_id);
+            && payload?.type === 'item_completed'
+            && payload.thread_id === expected.sessionId
+            && payload.turn_id === expected.turnId
+            && item?.type === 'SubAgentActivity'
+            && item.id === expected.toolUseId
+            && item.kind === 'started'
+            && item.agent_path === `/root/${expected.taskName}`
+            && nonEmpty(item.agent_thread_id);
     });
     if (activities.length !== 1)
         throw new Error('Codex parent rollout child activity was not found uniquely');
-    return nonEmpty(object(activities[0]?.payload)?.agent_thread_id);
+    return nonEmpty(object(object(activities[0]?.payload)?.item)?.agent_thread_id);
 }
 function validateCodexLifecycleHookConfig(value) {
     const hooks = object(object(value)?.hooks);
@@ -85,7 +94,7 @@ function validateCodexLifecycleHookConfig(value) {
             return entry.hooks.some((hookValue) => {
                 const hook = object(hookValue);
                 return hook?.type === 'command'
-                    && hook.timeout === 15
+                    && hook.timeout === 30
                     && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`;
             });
         });
@@ -409,14 +418,26 @@ async function resolveCodexThread(childThreadId, options = {}) {
         const readThread = object(readResult?.thread);
         if (nonEmpty(readThread?.id) !== childThreadId)
             throw new Error('Codex App Server returned the wrong child thread');
-        let resolution;
+        let rolloutRecords;
         try {
-            const rolloutRecords = await resolveCodexRolloutRecords(readResult, childThreadId, options.rolloutReadAttempts ?? DEFAULT_ROLLOUT_READ_ATTEMPTS, options.rolloutRetryMs ?? DEFAULT_ROLLOUT_RETRY_MS);
-            resolution = parseCodexThreadResolution(readResult, rolloutRecords);
+            rolloutRecords = await resolveCodexRolloutRecords(readResult, childThreadId, options.rolloutReadAttempts ?? DEFAULT_ROLLOUT_READ_ATTEMPTS, options.rolloutRetryMs ?? DEFAULT_ROLLOUT_RETRY_MS);
         }
         catch {
             throw new Error('Codex App Server rollout metadata is unavailable');
         }
+        let resolution = parseCodexThreadResolution(readResult, rolloutRecords);
+        const threadReadAttempts = options.threadReadAttempts ?? DEFAULT_THREAD_READ_ATTEMPTS;
+        for (let attempt = 1; resolution.thread.forkedFromId !== null && attempt < threadReadAttempts; attempt += 1) {
+            await new Promise((resolve) => setTimeout(resolve, options.threadRetryMs ?? DEFAULT_THREAD_RETRY_MS));
+            const refreshed = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: false }));
+            if (nonEmpty(object(refreshed?.thread)?.id) !== childThreadId) {
+                throw new Error('Codex App Server returned the wrong child thread');
+            }
+            resolution = parseCodexThreadResolution(refreshed, rolloutRecords);
+        }
+        if (resolution.thread.forkedFromId !== null) {
+            throw new Error('Codex App Server fresh thread metadata is unavailable');
+        }
         const reroutes = transport.notifications
             .filter((entry) => entry.method === 'model/rerouted')
             .map((entry) => parseCodexModelReroute(entry.params))
@@ -433,21 +454,38 @@ async function resolveCodexThread(childThreadId, options = {}) {
         transport.close();
     }
 }
-async function resolveCodexTerminal(childThreadId, options = {}) {
+async function resolveCodexTerminal(childThreadId, expectedTurnIdOrOptions = {}, terminalOptions = {}) {
+    const expectedTurnId = typeof expectedTurnIdOrOptions === 'string' ? expectedTurnIdOrOptions : null;
+    const options = typeof expectedTurnIdOrOptions === 'string' ? terminalOptions : expectedTurnIdOrOptions;
     const transport = new CodexAppServerTransport(options);
     transport.start();
     try {
         await transport.initialize();
-        const result = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: true }));
-        const thread = object(result?.thread);
-        if (nonEmpty(thread?.id) !== childThreadId)
-            throw new Error('Codex App Server returned the wrong child thread');
-        const turns = Array.isArray(thread?.turns) ? thread.turns : [];
-        const turn = turns.at(-1);
-        const turnValue = object(turn);
-        if (!turnValue || turnValue.status === 'inProgress')
-            throw new Error('CODEX_TURN_NOT_TERMINAL');
-        return parseCodexTurnCompleted({ threadId: childThreadId, turn });
+        const attempts = expectedTurnId ? options.terminalReadAttempts ?? DEFAULT_TERMINAL_READ_ATTEMPTS : 1;
+        let abnormal = null;
+        for (let attempt = 0; attempt < attempts; attempt += 1) {
+            const result = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: true }));
+            const thread = object(result?.thread);
+            if (nonEmpty(thread?.id) !== childThreadId)
+                throw new Error('Codex App Server returned the wrong child thread');
+            const turns = Array.isArray(thread?.turns) ? thread.turns : [];
+            const turn = expectedTurnId
+                ? turns.find((candidate) => object(candidate)?.id === expectedTurnId)
+                : turns.at(-1);
+            const turnValue = object(turn);
+            if (turnValue && turnValue.status !== 'inProgress') {
+                const terminal = parseCodexTurnCompleted({ threadId: childThreadId, turn });
+                if (terminal.status === 'completed')
+                    return terminal;
+                abnormal = terminal;
+            }
+            if (attempt + 1 < attempts) {
+                await new Promise((resolve) => setTimeout(resolve, options.terminalRetryMs ?? DEFAULT_TERMINAL_RETRY_MS));
+            }
+        }
+        if (abnormal)
+            return abnormal;
+        throw new Error('CODEX_TURN_NOT_TERMINAL');
     }
     finally {
         transport.close();
@@ -482,7 +520,7 @@ async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtime
         fs.rmSync(schemaDir, { recursive: true, force: true });
     }
     const hookDefinitionHash = crypto.createHash('sha256').update(hooksRaw).digest('hex');
-    const runtimeRoot = path.join(repoRoot, '.agents', 'workspace', '.runtime', 'codex-lifecycle');
+    const runtimeRoot = resolveAgentRuntimeStoreRoot({ repoRoot, store: 'lifecycle' });
     const runtimeLiveness = hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, runtimeIdentity);
     const transport = new CodexAppServerTransport();
     transport.start();

package/dist/lib/agent-clients/adapters/codex-lifecycle/build-identity.js

@@ -2,10 +2,17 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import semver from 'semver';
 const LIFECYCLE_PROTOCOL_VERSION = 3;
 function exactText(value) {
     return typeof value === 'string' && value.trim() === value && value.length > 0;
 }
+function isCanonicalLifecyclePackageVersion(value) {
+    return typeof value === 'string' && semver.valid(value) === value;
+}
+function isLifecycleProtocolVersion(value) {
+    return value === LIFECYCLE_PROTOCOL_VERSION;
+}
 function normalizeRelativePath(value) {
     return value.replaceAll('\\', '/');
 }
@@ -158,5 +165,5 @@ function verifyLifecycleBuildIdentity(expected, actual) {
     }
     return { ok: true, code: null, message: null };
 }
-export { LIFECYCLE_PROTOCOL_VERSION, computeLifecycleBuildIdentity, readLifecycleManifestFiles, resolveLifecycleExecutableFiles, verifyLifecycleBuildIdentity };
+export { LIFECYCLE_PROTOCOL_VERSION, computeLifecycleBuildIdentity, isCanonicalLifecyclePackageVersion, isLifecycleProtocolVersion, readLifecycleManifestFiles, resolveLifecycleExecutableFiles, verifyLifecycleBuildIdentity };
 //# sourceMappingURL=build-identity.js.map

package/dist/lib/agent-clients/adapters/codex-lifecycle/capability-store.js

@@ -1,28 +1,180 @@
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
-import { verifyLifecycleBuildIdentity } from './build-identity.js';
+import { isCanonicalLifecyclePackageVersion, isLifecycleProtocolVersion, LIFECYCLE_PROTOCOL_VERSION, verifyLifecycleBuildIdentity } from './build-identity.js';
+import { resolveAgentRuntimeStoreRoot } from '../../../runtime/agent-runtime.js';
 const DEFAULT_TTL_MS = 30_000;
 const DEFAULT_TOMBSTONE_MS = 86_400_000;
 const DEFAULT_MAX_RECORDS = 128;
 const LOCK_RETRY_MS = 10;
 const LOCK_TIMEOUT_MS = 1_000;
 const LOCK_STALE_MS = 30_000;
+const DETAIL_DOMAIN = 'codex-capability-provenance/v1';
+const TASK_ID_PATTERN = /^TASK-[0-9]{8}-[0-9]{6}$/u;
+const SHA256_PATTERN = /^[0-9a-f]{64}$/u;
+const DIGEST_PREFIX_PATTERN = /^sha256:[0-9a-f]{16}$/u;
 function digest(value) {
     return crypto.createHash('sha256').update(value).digest('hex');
 }
-function capabilityError(code, message) {
+function capabilityError(code, message, detail) {
     const error = new Error(`${code}: ${message}`);
     error.name = code;
+    if (detail)
+        error.detail = detail;
     return error;
 }
+function objectValue(value, key) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    return value[key];
+}
+function digestPrefix(fieldName, value) {
+    return {
+        kind: 'digest-prefix',
+        value: `sha256:${crypto.createHash('sha256')
+            .update(`${DETAIL_DOMAIN}\0${fieldName}\0${value}`)
+            .digest('hex')
+            .slice(0, 16)}`
+    };
+}
+function projectDigest(fieldName, value, pattern) {
+    return typeof value === 'string' && pattern.test(value) ? digestPrefix(fieldName, value) : { kind: 'absent' };
+}
+function projectTaskId(value) {
+    return projectDigest('taskId', value, TASK_ID_PATTERN);
+}
+function projectHash(fieldName, value) {
+    return projectDigest(fieldName, value, SHA256_PATTERN);
+}
+function projectProtocol(value) {
+    return isLifecycleProtocolVersion(value)
+        ? { kind: 'protocol-version', value: LIFECYCLE_PROTOCOL_VERSION }
+        : { kind: 'absent' };
+}
+function projectPackageVersion(value) {
+    return isCanonicalLifecyclePackageVersion(value)
+        ? { kind: 'semver', value }
+        : { kind: 'absent' };
+}
+function projectPresence(value) {
+    return { kind: 'presence', present: Boolean(value && typeof value === 'object') };
+}
+function field(matches, expected, actual) {
+    return { matches, expected, actual };
+}
+function provenanceDetail(record, expected) {
+    const actualBuild = record.buildIdentity;
+    const expectedBuild = expected.buildIdentity;
+    const actualController = record.controller;
+    const expectedController = expected.controller ?? null;
+    return {
+        kind: 'codex-capability-provenance-mismatch',
+        version: 1,
+        fields: {
+            taskId: field(record.taskId === expected.taskId, projectTaskId(expected.taskId), projectTaskId(record.taskId)),
+            hookDefinitionHash: field(record.hookDefinitionHash === expected.hookDefinitionHash, projectHash('hookDefinitionHash', expected.hookDefinitionHash), projectHash('hookDefinitionHash', record.hookDefinitionHash)),
+            buildIdentity: {
+                protocolVersion: field(objectValue(actualBuild, 'protocolVersion') === objectValue(expectedBuild, 'protocolVersion'), projectProtocol(objectValue(expectedBuild, 'protocolVersion')), projectProtocol(objectValue(actualBuild, 'protocolVersion'))),
+                packageVersion: field(objectValue(actualBuild, 'packageVersion') === objectValue(expectedBuild, 'packageVersion'), projectPackageVersion(objectValue(expectedBuild, 'packageVersion')), projectPackageVersion(objectValue(actualBuild, 'packageVersion'))),
+                internalExecutableBuildHash: field(objectValue(actualBuild, 'internalExecutableBuildHash') === objectValue(expectedBuild, 'internalExecutableBuildHash'), projectHash('buildIdentity.internalExecutableBuildHash', objectValue(expectedBuild, 'internalExecutableBuildHash')), projectHash('buildIdentity.internalExecutableBuildHash', objectValue(actualBuild, 'internalExecutableBuildHash'))),
+                lifecycleContractHash: field(objectValue(actualBuild, 'lifecycleContractHash') === objectValue(expectedBuild, 'lifecycleContractHash'), projectHash('buildIdentity.lifecycleContractHash', objectValue(expectedBuild, 'lifecycleContractHash')), projectHash('buildIdentity.lifecycleContractHash', objectValue(actualBuild, 'lifecycleContractHash')))
+            },
+            controller: {
+                instanceDigest: field(sameControllerField(actualController, expectedController, 'instanceDigest'), projectPresence(objectValue(expectedController, 'instanceDigest') === undefined ? null : expectedController), projectPresence(objectValue(actualController, 'instanceDigest') === undefined ? null : actualController)),
+                controlGeneration: field(sameControllerField(actualController, expectedController, 'controlGeneration'), projectPresence(objectValue(expectedController, 'controlGeneration') === undefined ? null : expectedController), projectPresence(objectValue(actualController, 'controlGeneration') === undefined ? null : actualController))
+            }
+        }
+    };
+}
+function exactKeys(value, keys) {
+    return Object.keys(value).length === keys.length && keys.every((key) => Object.hasOwn(value, key));
+}
+function isCodexControllerBinding(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return exactKeys(record, ['instanceDigest', 'controlGeneration'])
+        && typeof record.instanceDigest === 'string'
+        && typeof record.controlGeneration === 'string';
+}
+function isProjection(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    if (record.kind === 'absent')
+        return exactKeys(record, ['kind']);
+    if (record.kind === 'protocol-version') {
+        return exactKeys(record, ['kind', 'value']) && isLifecycleProtocolVersion(record.value);
+    }
+    if (record.kind === 'semver') {
+        return exactKeys(record, ['kind', 'value']) && isCanonicalLifecyclePackageVersion(record.value);
+    }
+    if (record.kind === 'digest-prefix') {
+        return exactKeys(record, ['kind', 'value'])
+            && typeof record.value === 'string'
+            && DIGEST_PREFIX_PATTERN.test(record.value);
+    }
+    if (record.kind === 'presence') {
+        return exactKeys(record, ['kind', 'present']) && typeof record.present === 'boolean';
+    }
+    return false;
+}
+function isProvenanceField(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    return exactKeys(record, ['matches', 'expected', 'actual'])
+        && typeof record.matches === 'boolean'
+        && isProjection(record.expected)
+        && isProjection(record.actual);
+}
+function isCodexCapabilityProvenanceDetail(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const record = value;
+    if (!exactKeys(record, ['kind', 'version', 'fields'])
+        || record.kind !== 'codex-capability-provenance-mismatch'
+        || record.version !== 1
+        || !record.fields || typeof record.fields !== 'object')
+        return false;
+    const fields = record.fields;
+    if (!exactKeys(fields, ['taskId', 'hookDefinitionHash', 'buildIdentity', 'controller'])
+        || !isProvenanceField(fields.taskId)
+        || !isProvenanceField(fields.hookDefinitionHash))
+        return false;
+    const buildIdentity = fields.buildIdentity;
+    const controller = fields.controller;
+    if (!buildIdentity || typeof buildIdentity !== 'object' || !controller || typeof controller !== 'object')
+        return false;
+    const build = buildIdentity;
+    const binding = controller;
+    return exactKeys(build, ['protocolVersion', 'packageVersion', 'internalExecutableBuildHash', 'lifecycleContractHash'])
+        && exactKeys(binding, ['instanceDigest', 'controlGeneration'])
+        && isProvenanceField(build.protocolVersion)
+        && isProvenanceField(build.packageVersion)
+        && isProvenanceField(build.internalExecutableBuildHash)
+        && isProvenanceField(build.lifecycleContractHash)
+        && isProvenanceField(binding.instanceDigest)
+        && isProvenanceField(binding.controlGeneration);
+}
+function sameControllerField(left, right, key) {
+    if (left === null || right === null)
+        return left === null && right === null;
+    return isCodexControllerBinding(left)
+        && isCodexControllerBinding(right)
+        && left[key] === right[key];
+}
 function sameController(left, right) {
-    return left?.instanceDigest === right?.instanceDigest
-        && left?.controlGeneration === right?.controlGeneration;
+    if (left === null || right === null)
+        return left === null && right === null;
+    return isCodexControllerBinding(left)
+        && isCodexControllerBinding(right)
+        && left.instanceDigest === right.instanceDigest
+        && left.controlGeneration === right.controlGeneration;
 }
 function createCodexCapabilityStore(options = {}) {
     const root = options.root
-        ?? path.join(process.cwd(), '.agents', 'workspace', '.runtime', 'codex-capabilities');
+        ?? resolveAgentRuntimeStoreRoot({ store: 'capabilities' });
     const now = options.now ?? Date.now;
     const createToken = options.token ?? (() => crypto.randomBytes(32).toString('base64url'));
     const ttlMs = options.ttlMs ?? DEFAULT_TTL_MS;
@@ -210,22 +362,33 @@ function createCodexCapabilityStore(options = {}) {
         write(file, next, record.revision);
         return next;
     }
-    function consume(token, expected) {
-        sweep();
-        const { file, record } = loadActive(token);
+    function validateRecord(record, expected) {
         if (record.status === 'consumed') {
             throw capabilityError('CODEX_CAPABILITY_REPLAY', 'capability token was already consumed');
         }
         if (record.status !== 'attested') {
             throw capabilityError('CODEX_CAPABILITY_NOT_ATTESTED', 'capability token has no current-session hook attestation');
         }
-        const identity = verifyLifecycleBuildIdentity(record.buildIdentity, expected.buildIdentity);
+        const identity = record.buildIdentity && typeof record.buildIdentity === 'object'
+            ? verifyLifecycleBuildIdentity(record.buildIdentity, expected.buildIdentity)
+            : { ok: false };
         if (!identity.ok
             || record.taskId !== expected.taskId
             || record.hookDefinitionHash !== expected.hookDefinitionHash
             || !sameController(record.controller, expected.controller ?? null)) {
-            throw capabilityError('CODEX_CAPABILITY_PROVENANCE_MISMATCH', 'capability consumption identity does not match');
+            throw capabilityError('CODEX_CAPABILITY_PROVENANCE_MISMATCH', 'capability consumption identity does not match', provenanceDetail(record, expected));
         }
+        return record;
+    }
+    function validate(token, expected) {
+        sweep();
+        const { record } = loadActive(token);
+        return validateRecord(record, expected);
+    }
+    function consume(token, expected) {
+        sweep();
+        const { file, record } = loadActive(token);
+        validateRecord(record, expected);
         const next = Object.freeze({
             ...record,
             revision: record.revision + 1,
@@ -238,7 +401,8 @@ function createCodexCapabilityStore(options = {}) {
     function inspect(token) {
         return loadActive(token).record;
     }
-    return Object.freeze({ arm, attest, consume, inspect, sweep });
+    return Object.freeze({ arm, attest, consume, inspect, validate, sweep });
 }
 export { createCodexCapabilityStore };
+export { isCodexCapabilityProvenanceDetail };
 //# sourceMappingURL=capability-store.js.map

package/dist/lib/agent-clients/adapters/codex-lifecycle/controller-context.js

@@ -0,0 +1,147 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { getProcessIdentityState } from '../../../server/process-state.js';
+import { computeLifecycleBuildIdentity } from './build-identity.js';
+const HEX_256 = /^[a-f0-9]{64}$/u;
+function exactKeys(value, keys) {
+    return Object.keys(value).sort().join(',') === [...keys].sort().join(',');
+}
+function digestProfiles(repoRoot) {
+    const files = [
+        path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-executor.toml'),
+        path.join(repoRoot, '.codex', 'agents', 'agent-infra-lifecycle-reviewer.toml')
+    ];
+    const hash = crypto.createHash('sha256');
+    for (const file of files.sort()) {
+        const stat = fs.lstatSync(file);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
+        hash.update(path.basename(file));
+        hash.update('\0');
+        hash.update(fs.readFileSync(file));
+        hash.update('\0');
+    }
+    return hash.digest('hex');
+}
+function validProcess(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const identity = value;
+    return exactKeys(identity, ['pid', 'startTime'])
+        && Number.isSafeInteger(identity.pid) && identity.pid > 0
+        && Number.isSafeInteger(identity.startTime) && identity.startTime >= 0;
+}
+function validBuildIdentity(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const identity = value;
+    return exactKeys(identity, [
+        'internalExecutableBuildHash', 'lifecycleContractHash', 'packageVersion', 'protocolVersion'
+    ])
+        && identity.protocolVersion === 3
+        && typeof identity.packageVersion === 'string' && identity.packageVersion.length > 0
+        && typeof identity.internalExecutableBuildHash === 'string' && HEX_256.test(identity.internalExecutableBuildHash)
+        && typeof identity.lifecycleContractHash === 'string' && HEX_256.test(identity.lifecycleContractHash);
+}
+function validateContext(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    const context = value;
+    const lease = context.controllerLease;
+    if (!exactKeys(context, [
+        'buildIdentity', 'controlGeneration', 'controllerInstanceDigest', 'controllerLease',
+        'controllerProcess', 'expiresAt', 'hookDefinitionHash', 'issuedAt',
+        'lifecycleProfilesHash', 'taskId', 'version'
+    ])
+        || context.version !== 2
+        || typeof context.taskId !== 'string' || context.taskId.length === 0
+        || typeof context.controlGeneration !== 'string' || context.controlGeneration.length === 0
+        || typeof context.controllerInstanceDigest !== 'string' || !HEX_256.test(context.controllerInstanceDigest)
+        || !validProcess(context.controllerProcess)
+        || !lease || !exactKeys(lease, ['leaseId', 'leaseSecret', 'version'])
+        || lease.version !== 1
+        || typeof lease.leaseId !== 'string' || !HEX_256.test(lease.leaseId)
+        || typeof lease.leaseSecret !== 'string' || !HEX_256.test(lease.leaseSecret)
+        || !Number.isSafeInteger(context.issuedAt)
+        || !Number.isSafeInteger(context.expiresAt)
+        || context.expiresAt <= context.issuedAt
+        || !validBuildIdentity(context.buildIdentity)
+        || typeof context.hookDefinitionHash !== 'string' || !HEX_256.test(context.hookDefinitionHash)
+        || typeof context.lifecycleProfilesHash !== 'string' || !HEX_256.test(context.lifecycleProfilesHash)) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    return context;
+}
+export function contextFromControllerLease(lease, hashes) {
+    return Object.freeze({
+        version: 2,
+        taskId: lease.taskId,
+        controlGeneration: lease.controlGeneration,
+        controllerInstanceDigest: lease.controllerInstanceDigest,
+        controllerProcess: lease.controllerProcess,
+        controllerLease: Object.freeze({ version: 1, leaseId: lease.leaseId, leaseSecret: lease.leaseSecret }),
+        issuedAt: lease.issuedAt,
+        expiresAt: lease.expiresAt,
+        buildIdentity: lease.buildIdentity,
+        hookDefinitionHash: hashes.hookDefinitionHash,
+        lifecycleProfilesHash: hashes.lifecycleProfilesHash
+    });
+}
+export function writeCodexSandboxControllerContext(contextPath, context) {
+    validateContext(context);
+    fs.mkdirSync(path.dirname(contextPath), { recursive: true, mode: 0o700 });
+    const temporary = path.join(path.dirname(contextPath), `.${path.basename(contextPath)}.${process.pid}.${crypto.randomUUID()}.tmp`);
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(context, null, 2)}\n`, { mode: 0o600, flag: 'wx' });
+        fs.chmodSync(temporary, 0o600);
+        fs.renameSync(temporary, contextPath);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
+}
+export function verifyCodexSandboxControllerContext(contextPath, options = {}) {
+    let stat;
+    try {
+        stat = fs.lstatSync(contextPath);
+    }
+    catch {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    if (!stat.isFile() || stat.isSymbolicLink()
+        || (process.platform !== 'win32' && (stat.mode & 0o077) !== 0)) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    let context;
+    try {
+        context = validateContext(JSON.parse(fs.readFileSync(contextPath, 'utf8')));
+    }
+    catch {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    const repoRoot = options.repoRoot ?? process.cwd();
+    const generation = options.generation ?? process.env.AGENT_INFRA_CONTROL_GENERATION;
+    const state = (options.probeProcess ?? getProcessIdentityState)(context.controllerProcess);
+    if (context.controlGeneration !== generation
+        || context.expiresAt <= (options.now ?? Date.now())
+        || state !== 'alive') {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+    }
+    if (JSON.stringify(computeLifecycleBuildIdentity(repoRoot)) !== JSON.stringify(context.buildIdentity)
+        || crypto.createHash('sha256').update(fs.readFileSync(path.join(repoRoot, '.codex', 'hooks.json'))).digest('hex') !== context.hookDefinitionHash
+        || digestProfiles(repoRoot) !== context.lifecycleProfilesHash) {
+        throw new Error('CODEX_SANDBOX_CONTROLLER_BUNDLE_MISMATCH');
+    }
+    return Object.freeze(context);
+}
+export function controllerProofFromContext(context) {
+    return Object.freeze({
+        version: 1,
+        leaseId: context.controllerLease.leaseId,
+        leaseSecret: context.controllerLease.leaseSecret,
+        controllerProcess: context.controllerProcess
+    });
+}
+//# sourceMappingURL=controller-context.js.map

package/dist/lib/agent-clients/adapters/codex-lifecycle/evidence.js

@@ -29,6 +29,12 @@ function invalid(state, code, message) {
 function same(left, right) {
     return JSON.stringify(left) === JSON.stringify(right);
 }
+function sameChildCorrelation(left, right) {
+    return left.sessionId === right.sessionId
+        && left.childThreadId === right.childThreadId
+        && left.parentThreadId === right.parentThreadId
+        && left.nativeAgent === right.nativeAgent;
+}
 function requiredStrings(event) {
     return Object.entries(event).every(([key, value]) => key === 'forkedFromId'
         || (typeof value !== 'string' || value.trim() !== ''));
@@ -152,6 +158,14 @@ function reduceCodexLifecycleEvent(state, event) {
     if (existing) {
         if (same(existing, event))
             return state;
+        if (existing.type === 'hook-child'
+            && event.type === 'hook-child'
+            && sameChildCorrelation(existing, event)
+            && (existing.source === 'parent-rollout') !== (event.source === 'parent-rollout')) {
+            if (existing.source !== 'parent-rollout')
+                return state;
+            return derive(Object.freeze({ ...state, child: Object.freeze({ ...event }) }));
+        }
         return invalid(state, 'CODEX_EVIDENCE_REPLAY_CONFLICT', `conflicting '${event.type}' event`);
     }
     return derive(Object.freeze({ ...state, [key]: Object.freeze({ ...event }) }));