@fitlab-ai/agent-infra 0.9.4 → 0.9.5

package/README.md

@@ -176,7 +176,7 @@ The most-used lifecycle commands, in delivery order. The command prefix varies b
 | Command | Purpose |
 |---------|---------|
 | `create-task` / `import-issue` | Start a task from a description or a GitHub Issue |
-| `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; current built-in clients, including Claude Code and Codex, fail closed before delegation because their native start events do not expose all required evidence |
+| `run-task` | Resume the lifecycle with fresh isolated executors/reviewers when the selected client exposes verified actual model/effort evidence; Codex now has an experimental Hooks + App Server evidence channel, but orchestration remains disabled until that channel is connected to delegation receipts |
 | `analyze-task` → `review-analysis` | Capture scope and risks, then review the analysis |
 | `plan-task` → `review-plan` | Design the approach, then review the plan |
 | `code-task` → `review-code` | Implement and test, then run a structured code review |

package/README.zh-CN.md

@@ -175,7 +175,7 @@ ai agent-client configure
 | 命令 | 用途 |
 |------|------|
 | `create-task` / `import-issue` | 从描述或 GitHub Issue 创建任务 |
-| `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；当前内建客户端（含 Claude Code 与 Codex）因原生 start 事件未暴露全部必需证据，会在委派前失败关闭 |
+| `run-task` | 当所选客户端能提供已验证的 actual model/effort 证据时，用 fresh 隔离 executor/reviewer 续跑生命周期；Codex 现已具备实验性的 Hooks + App Server 证据通道，但在该通道接入 delegation receipt 前仍不会启用 orchestration |
 | `analyze-task` → `review-analysis` | 明确范围与风险，再审查分析 |
 | `plan-task` → `review-plan` | 设计实现路径，再审查方案 |
 | `code-task` → `review-code` | 实现并测试，再执行结构化代码审查 |

package/dist/bin/internal-cli.js

@@ -12,6 +12,11 @@ if (process.env.AGENT_INFRA_CONTROL_TOKEN
 }
 else
     switch (command) {
+        case 'task-create': {
+            const { taskCreate } = await import('../lib/internal/task-create.js');
+            taskCreate(process.argv.slice(3));
+            break;
+        }
         case 'sandbox-control': {
             const { sandboxControl } = await import('../lib/internal/sandbox-control.js');
             sandboxControl(process.argv.slice(3));
@@ -22,6 +27,11 @@ else
             agentClient(process.argv.slice(3));
             break;
         }
+        case 'codex-lifecycle': {
+            const { codexLifecycle } = await import('../lib/internal/codex-lifecycle.js');
+            await codexLifecycle(process.argv.slice(3));
+            break;
+        }
         case 'git-workflow': {
             const { gitWorkflow } = await import('../lib/internal/git-workflow.js');
             gitWorkflow(process.argv.slice(3));

package/dist/lib/agent-clients/adapter.js

@@ -190,8 +190,8 @@ function defineAgentClientAdapter(candidate) {
     }
     const evidence = candidate.delegationEvidence;
     if (!evidence
-        || !['host-event', 'unavailable'].includes(evidence.actualModel)
-        || !['host-event', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)) {
+        || !['host-event', 'app-server', 'unavailable'].includes(evidence.actualModel)
+        || !['host-event', 'app-server', 'spawn-ack', 'unavailable'].includes(evidence.actualReasoningEffort)) {
         throw new Error(`Agent Client '${candidate.id}' has invalid delegation evidence`);
     }
     if (typeof candidate.project !== 'object'

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

@@ -0,0 +1,382 @@
+import { spawn, spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import semver from 'semver';
+const LIFECYCLE_HOOKS = Object.freeze([
+    Object.freeze({ event: 'PreToolUse', matcher: '^collaborationspawn_agent$', phase: 'pre-tool' }),
+    Object.freeze({ event: 'PostToolUse', matcher: '^collaborationspawn_agent$', phase: 'post-tool' }),
+    Object.freeze({ event: 'SubagentStart', matcher: '^agent-infra-lifecycle-(executor|reviewer)$', phase: 'subagent-start' }),
+    Object.freeze({ event: 'SubagentStop', matcher: '^agent-infra-lifecycle-(executor|reviewer)$', phase: 'subagent-stop' })
+]);
+function object(value) {
+    return value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function validateCodexLifecycleHookConfig(value) {
+    const hooks = object(object(value)?.hooks);
+    const valid = hooks && LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => {
+        const entries = hooks[event];
+        if (!Array.isArray(entries))
+            return false;
+        return entries.some((entryValue) => {
+            const entry = object(entryValue);
+            if (entry?.matcher !== matcher || !Array.isArray(entry.hooks))
+                return false;
+            return entry.hooks.some((hookValue) => {
+                const hook = object(hookValue);
+                return hook?.type === 'command'
+                    && hook.timeout === 5
+                    && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`;
+            });
+        });
+    });
+    if (!valid)
+        throw new Error('CODEX_PREFLIGHT_HOOKS_INVALID: lifecycle hooks are invalid');
+}
+function parseCodexHooksList(value, repoRoot) {
+    const root = object(value);
+    const entries = Array.isArray(root?.data) ? root.data : [];
+    const entry = entries.map(object).find((candidate) => candidate?.cwd === repoRoot);
+    const errors = Array.isArray(entry?.errors) ? entry.errors : [];
+    if (errors.length)
+        throw new Error(`CODEX_PREFLIGHT_HOOK_DISCOVERY_FAILED: ${errors.map(String).join('; ')}`);
+    const hooks = (Array.isArray(entry?.hooks) ? entry.hooks : [])
+        .map(object)
+        .filter((hook) => hook !== null)
+        .map((hook) => Object.freeze({
+        eventName: String(hook.eventName ?? ''),
+        matcher: typeof hook.matcher === 'string' ? hook.matcher : null,
+        command: String(hook.command ?? ''),
+        enabled: hook.enabled === true
+    }));
+    const valid = LIFECYCLE_HOOKS.every(({ event, matcher, phase }) => hooks.some((hook) => hook.eventName === event.replace(/^./, (character) => character.toLowerCase())
+        && hook.matcher === matcher
+        && hook.command === `node "$(git rev-parse --show-toplevel)/.agents/hooks/lifecycle-delegation.js" --client codex --event ${phase}`
+        && hook.enabled));
+    if (!valid)
+        throw new Error('CODEX_PREFLIGHT_HOOKS_NOT_LOADED: lifecycle hooks are not loaded for this workspace');
+    return Object.freeze(hooks);
+}
+function hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, identity) {
+    if (!identity || !fs.existsSync(runtimeRoot))
+        return false;
+    return fs.readdirSync(runtimeRoot)
+        .filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+        .some((name) => {
+        try {
+            const record = object(JSON.parse(fs.readFileSync(path.join(runtimeRoot, name), 'utf8')));
+            const state = object(record?.state);
+            const spawnEvent = object(state?.spawn);
+            return !['invalid', 'expired'].includes(String(state?.status))
+                && spawnEvent?.hookDefinitionHash === hookDefinitionHash
+                && spawnEvent.sessionId === identity.sessionId
+                && spawnEvent.turnId === identity.turnId
+                && spawnEvent.toolUseId === identity.toolUseId;
+        }
+        catch {
+            return false;
+        }
+    });
+}
+function parseCodexThreadResolution(readValue, resumeValue) {
+    const readRoot = object(readValue);
+    const resumeRoot = object(resumeValue);
+    const thread = object(readRoot?.thread);
+    const resumedThread = object(resumeRoot?.thread);
+    const source = object(thread?.source);
+    const subAgent = object(source?.subAgent);
+    const threadSpawn = object(subAgent?.thread_spawn);
+    const childThreadId = nonEmpty(thread?.id);
+    const parentThreadId = nonEmpty(thread?.parentThreadId);
+    const sourceParentThreadId = nonEmpty(threadSpawn?.parent_thread_id);
+    const resumedChildThreadId = nonEmpty(resumedThread?.id);
+    const model = nonEmpty(resumeRoot?.model);
+    const reasoningEffort = nonEmpty(resumeRoot?.reasoningEffort ?? object(resumeRoot?.settings)?.effort);
+    const forkedFromId = thread?.forkedFromId;
+    if (!childThreadId
+        || resumedChildThreadId !== childThreadId
+        || !parentThreadId
+        || !sourceParentThreadId
+        || !model
+        || !reasoningEffort
+        || (forkedFromId !== null && typeof forkedFromId !== 'string')) {
+        throw new Error('Codex App Server thread resolution is invalid');
+    }
+    return Object.freeze({
+        thread: Object.freeze({
+            type: 'app-thread',
+            childThreadId,
+            parentThreadId,
+            forkedFromId,
+            sourceParentThreadId
+        }),
+        settings: Object.freeze({
+            type: 'app-settings',
+            childThreadId,
+            model,
+            reasoningEffort
+        })
+    });
+}
+function parseCodexTurnCompleted(value) {
+    const root = object(value);
+    const turn = object(root?.turn);
+    const childThreadId = nonEmpty(root?.threadId);
+    const turnId = nonEmpty(turn?.id);
+    const status = turn?.status;
+    if (!childThreadId || !turnId || !['completed', 'interrupted', 'failed'].includes(String(status))) {
+        throw new Error('Codex App Server turn completion is invalid');
+    }
+    return Object.freeze({
+        type: 'app-terminal',
+        childThreadId,
+        turnId,
+        status: status
+    });
+}
+function parseCodexModelReroute(value) {
+    const root = object(value);
+    const childThreadId = nonEmpty(root?.threadId);
+    const turnId = nonEmpty(root?.turnId);
+    const fromModel = nonEmpty(root?.fromModel);
+    const toModel = nonEmpty(root?.toModel);
+    const reasonValue = root?.reason;
+    const reason = nonEmpty(reasonValue) ?? (object(reasonValue) ? JSON.stringify(reasonValue) : null);
+    if (!childThreadId || !turnId || !fromModel || !toModel || !reason) {
+        throw new Error('Codex App Server model reroute is invalid');
+    }
+    return Object.freeze({ type: 'app-reroute', childThreadId, turnId, fromModel, toModel, reason });
+}
+class CodexAppServerTransport {
+    #options;
+    #child = null;
+    #buffer = '';
+    #stderr = '';
+    #nextId = 1;
+    #pending = new Map();
+    #notifications = [];
+    constructor(options = {}) {
+        this.#options = {
+            ...options,
+            command: options.command ?? 'codex',
+            args: options.args ?? ['app-server', '--stdio'],
+            timeoutMs: options.timeoutMs ?? 5_000
+        };
+    }
+    get diagnostics() {
+        return Object.freeze(this.#stderr.split(/\r?\n/).filter(Boolean));
+    }
+    get notifications() {
+        return Object.freeze([...this.#notifications]);
+    }
+    start() {
+        if (this.#child)
+            throw new Error('Codex App Server transport is already started');
+        const child = spawn(this.#options.command, [...this.#options.args], {
+            cwd: this.#options.cwd,
+            env: this.#options.env,
+            stdio: ['pipe', 'pipe', 'pipe']
+        });
+        this.#child = child;
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (chunk) => this.#onData(chunk));
+        child.stderr.on('data', (chunk) => {
+            this.#stderr = `${this.#stderr}${chunk}`.slice(-32 * 1024);
+        });
+        child.on('error', (error) => this.#rejectAll(error));
+        child.on('exit', (code, signal) => {
+            if (this.#pending.size) {
+                this.#rejectAll(new Error(`Codex App Server exited before responding (code=${code}, signal=${signal})`));
+            }
+        });
+    }
+    #onData(chunk) {
+        this.#buffer += chunk;
+        for (;;) {
+            const newline = this.#buffer.indexOf('\n');
+            if (newline < 0)
+                return;
+            const line = this.#buffer.slice(0, newline).trim();
+            this.#buffer = this.#buffer.slice(newline + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                const parsed = object(JSON.parse(line));
+                if (!parsed)
+                    throw new Error('message is not an object');
+                message = parsed;
+            }
+            catch (error) {
+                this.#rejectAll(new Error(`Codex App Server returned invalid JSON: ${String(error)}`));
+                continue;
+            }
+            if (typeof message.id === 'number') {
+                const pending = this.#pending.get(message.id);
+                if (!pending)
+                    continue;
+                clearTimeout(pending.timer);
+                this.#pending.delete(message.id);
+                if (message.error)
+                    pending.reject(new Error(`Codex App Server request failed: ${JSON.stringify(message.error)}`));
+                else
+                    pending.resolve(message.result);
+            }
+            else if (typeof message.method === 'string') {
+                this.#notifications.push(Object.freeze({ method: message.method, params: message.params }));
+            }
+        }
+    }
+    #rejectAll(error) {
+        for (const [id, pending] of this.#pending) {
+            clearTimeout(pending.timer);
+            this.#pending.delete(id);
+            pending.reject(error);
+        }
+    }
+    request(method, params) {
+        if (!this.#child || !this.#child.stdin.writable) {
+            return Promise.reject(new Error('Codex App Server transport is not running'));
+        }
+        const id = this.#nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.#pending.delete(id);
+                reject(new Error(`Codex App Server request '${method}' timed out`));
+            }, this.#options.timeoutMs);
+            this.#pending.set(id, { resolve, reject, timer });
+            this.#child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+        });
+    }
+    notify(method, params = {}) {
+        if (!this.#child || !this.#child.stdin.writable)
+            throw new Error('Codex App Server transport is not running');
+        this.#child.stdin.write(`${JSON.stringify({ method, params })}\n`);
+    }
+    async initialize() {
+        const result = await this.request('initialize', {
+            clientInfo: { name: 'agent-infra', title: 'agent-infra', version: '0.9.5' },
+            capabilities: null
+        });
+        this.notify('initialized');
+        return result;
+    }
+    close() {
+        if (!this.#child)
+            return;
+        this.#child.stdin.end();
+        this.#child.kill();
+        this.#child = null;
+    }
+}
+async function resolveCodexThread(childThreadId, options = {}) {
+    if (!nonEmpty(childThreadId))
+        throw new Error('Codex child thread id is required');
+    const transport = new CodexAppServerTransport(options);
+    transport.start();
+    try {
+        await transport.initialize();
+        const readResult = object(await transport.request('thread/read', { threadId: childThreadId, includeTurns: false }));
+        const readThread = object(readResult?.thread);
+        if (nonEmpty(readThread?.id) !== childThreadId)
+            throw new Error('Codex App Server returned the wrong child thread');
+        const resumeResult = await transport.request('thread/resume', { threadId: childThreadId });
+        let resolution;
+        try {
+            resolution = parseCodexThreadResolution(readResult, resumeResult);
+        }
+        catch {
+            throw new Error('Codex App Server resumed settings are unavailable');
+        }
+        const reroutes = transport.notifications
+            .filter((entry) => entry.method === 'model/rerouted')
+            .map((entry) => parseCodexModelReroute(entry.params))
+            .filter((event) => event.childThreadId === childThreadId);
+        return Object.freeze({ resolution, reroutes: Object.freeze(reroutes), diagnostics: transport.diagnostics });
+    }
+    finally {
+        try {
+            await transport.request('thread/unsubscribe', { threadId: childThreadId });
+        }
+        catch {
+            // Closing the short-lived transport still removes the subscription.
+        }
+        transport.close();
+    }
+}
+async function resolveCodexTerminal(childThreadId, options = {}) {
+    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);
+        return parseCodexTurnCompleted({ threadId: childThreadId, turn });
+    }
+    finally {
+        transport.close();
+    }
+}
+async function preflightCodexLifecycleEvidence(repoRoot = process.cwd(), runtimeIdentity) {
+    const versionRun = spawnSync('codex', ['--version'], { encoding: 'utf8' });
+    const match = /codex-cli\s+(\d+\.\d+\.\d+)/.exec(versionRun.stdout ?? '');
+    if (versionRun.status !== 0 || !match?.[1] || !semver.gte(match[1], '0.147.0')) {
+        throw new Error('CODEX_PREFLIGHT_VERSION_UNSUPPORTED');
+    }
+    const featuresRun = spawnSync('codex', ['features', 'list'], { encoding: 'utf8' });
+    if (featuresRun.status !== 0
+        || !/^hooks\s+\S+\s+true$/m.test(featuresRun.stdout)
+        || !/^multi_agent\s+\S+\s+true$/m.test(featuresRun.stdout))
+        throw new Error('CODEX_PREFLIGHT_FEATURE_DISABLED');
+    const hooksPath = path.join(repoRoot, '.codex', 'hooks.json');
+    const hooksRaw = fs.readFileSync(hooksPath, 'utf8');
+    validateCodexLifecycleHookConfig(JSON.parse(hooksRaw));
+    const schemaDir = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-infra-codex-schema-'));
+    try {
+        const schemaRun = spawnSync('codex', ['app-server', 'generate-json-schema', '--out', schemaDir], { encoding: 'utf8' });
+        if (schemaRun.status !== 0)
+            throw new Error('CODEX_PREFLIGHT_SCHEMA_UNAVAILABLE');
+        const schema = fs.readFileSync(path.join(schemaDir, 'codex_app_server_protocol.v2.schemas.json'), 'utf8');
+        for (const field of ['parentThreadId', 'forkedFromId', 'ThreadSettings', 'turn/completed', 'model/rerouted']) {
+            if (!schema.includes(field))
+                throw new Error(`CODEX_PREFLIGHT_SCHEMA_MISSING:${field}`);
+        }
+    }
+    finally {
+        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 runtimeLiveness = hasCodexRuntimeLiveness(runtimeRoot, hookDefinitionHash, runtimeIdentity);
+    const transport = new CodexAppServerTransport();
+    transport.start();
+    let discoveredHooks;
+    try {
+        await transport.initialize();
+        discoveredHooks = parseCodexHooksList(await transport.request('hooks/list', { cwds: [repoRoot] }), repoRoot);
+    }
+    finally {
+        transport.close();
+    }
+    return Object.freeze({
+        cliVersion: match[1],
+        hookDefinitionHash,
+        staticReady: true,
+        discoveredHooks,
+        runtimeLiveness,
+        diagnostics: transport.diagnostics
+    });
+}
+export { CodexAppServerTransport, hasCodexRuntimeLiveness, parseCodexModelReroute, parseCodexHooksList, parseCodexThreadResolution, parseCodexTurnCompleted, preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread, validateCodexLifecycleHookConfig };
+//# sourceMappingURL=app-server.js.map

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

@@ -0,0 +1,163 @@
+function createCodexLifecycleState(cliVersion) {
+    if (!cliVersion.trim())
+        throw new Error('Codex CLI version is required');
+    return Object.freeze({
+        schemaVersion: 1,
+        cliVersion,
+        status: 'empty',
+        spawn: null,
+        child: null,
+        thread: null,
+        settings: null,
+        reroute: null,
+        terminal: null,
+        stop: null,
+        startEvidence: null,
+        stopEvidence: null,
+        error: null
+    });
+}
+function invalid(state, code, message) {
+    return Object.freeze({
+        ...state,
+        status: 'invalid',
+        startEvidence: null,
+        stopEvidence: null,
+        error: Object.freeze({ code, message })
+    });
+}
+function same(left, right) {
+    return JSON.stringify(left) === JSON.stringify(right);
+}
+function requiredStrings(event) {
+    return Object.entries(event).every(([key, value]) => key === 'forkedFromId'
+        || (typeof value !== 'string' || value.trim() !== ''));
+}
+function derive(state) {
+    const { spawn, child, thread, settings, reroute, terminal, stop } = state;
+    if (spawn && child && (spawn.sessionId !== child.sessionId
+        || spawn.nativeAgent !== child.nativeAgent)) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook spawn and child identity do not match');
+    }
+    if (child && thread && child.childThreadId !== thread.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server child identity do not match');
+    }
+    if (spawn && thread && (thread.parentThreadId !== spawn.sessionId
+        || thread.sourceParentThreadId !== spawn.sessionId)) {
+        return invalid(state, 'CODEX_EVIDENCE_PARENT_MISMATCH', 'App Server parent identity does not match the spawning session');
+    }
+    if (thread?.forkedFromId !== null && thread?.forkedFromId !== undefined) {
+        return invalid(state, 'CODEX_EVIDENCE_FORK_FORBIDDEN', 'forked child threads are not fresh lifecycle evidence');
+    }
+    if (settings && child && settings.childThreadId !== child.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'resolved settings belong to a different child');
+    }
+    if (reroute && child && reroute.childThreadId !== child.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'model reroute belongs to a different child');
+    }
+    if (spawn?.requestedModel && settings && spawn.requestedModel !== settings.model) {
+        if (!reroute
+            || reroute.fromModel !== spawn.requestedModel
+            || reroute.toModel !== settings.model
+            || !reroute.reason.trim()) {
+            return invalid(state, 'CODEX_EVIDENCE_MODEL_UNEXPLAINED', 'resolved model differs without a matching host reroute');
+        }
+    }
+    if (spawn?.requestedReasoningEffort
+        && settings
+        && spawn.requestedReasoningEffort !== settings.reasoningEffort) {
+        return invalid(state, 'CODEX_EVIDENCE_EFFORT_UNEXPLAINED', 'resolved reasoning effort differs without structured host evidence');
+    }
+    if (terminal && terminal.status !== 'completed') {
+        return invalid(state, 'CODEX_EVIDENCE_TERMINAL_INVALID', `child turn ended as '${terminal.status}'`);
+    }
+    if (terminal && child && terminal.childThreadId !== child.childThreadId) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'terminal event belongs to a different child');
+    }
+    if (stop && child && (stop.sessionId !== child.sessionId
+        || stop.turnId !== child.turnId
+        || stop.childThreadId !== child.childThreadId
+        || stop.nativeAgent !== child.nativeAgent)) {
+        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook stop identity does not match the child');
+    }
+    let startEvidence = null;
+    if (spawn && child && thread && settings) {
+        startEvidence = Object.freeze({
+            schemaVersion: 1,
+            cliVersion: state.cliVersion,
+            parentThreadId: spawn.sessionId,
+            parentTurnId: spawn.turnId,
+            spawnToolUseId: spawn.toolUseId,
+            childThreadId: child.childThreadId,
+            nativeAgent: child.nativeAgent,
+            spawnMode: 'fresh',
+            actualModel: Object.freeze({ value: settings.model, source: 'codex-app-server-settings' }),
+            actualReasoningEffort: Object.freeze({ value: settings.reasoningEffort, source: 'codex-app-server-settings' }),
+            modelFallbackReason: reroute?.reason ?? null,
+            reasoningEffortFallbackReason: null,
+            hookDefinitionHash: spawn.hookDefinitionHash
+        });
+    }
+    let stopEvidence = null;
+    if (startEvidence && terminal?.status === 'completed' && stop) {
+        stopEvidence = Object.freeze({
+            schemaVersion: 1,
+            childThreadId: startEvidence.childThreadId,
+            turnId: terminal.turnId,
+            terminalStatus: 'completed',
+            hookStopObserved: true
+        });
+    }
+    const status = stopEvidence
+        ? 'stop-ready'
+        : terminal
+            ? 'observed-terminal'
+            : startEvidence
+                ? 'start-ready'
+                : child
+                    ? 'observed-child'
+                    : spawn
+                        ? 'observed-spawn'
+                        : 'empty';
+    return Object.freeze({ ...state, status, startEvidence, stopEvidence, error: null });
+}
+function reduceCodexLifecycleEvent(state, event) {
+    if (state.status === 'invalid' || state.status === 'expired')
+        return state;
+    if (!requiredStrings(event)) {
+        return invalid(state, 'CODEX_EVIDENCE_FIELD_MISSING', 'lifecycle event contains an empty required field');
+    }
+    const key = {
+        'hook-spawn': 'spawn',
+        'hook-child': 'child',
+        'app-thread': 'thread',
+        'app-settings': 'settings',
+        'app-reroute': 'reroute',
+        'app-terminal': 'terminal',
+        'hook-stop': 'stop'
+    }[event.type];
+    const existing = state[key];
+    if (existing) {
+        if (same(existing, event))
+            return state;
+        return invalid(state, 'CODEX_EVIDENCE_REPLAY_CONFLICT', `conflicting '${event.type}' event`);
+    }
+    return derive(Object.freeze({ ...state, [key]: Object.freeze({ ...event }) }));
+}
+function expireCodexLifecycleState(state) {
+    if (!['observed-spawn', 'observed-child', 'start-ready', 'observed-terminal'].includes(state.status)) {
+        return state;
+    }
+    return Object.freeze({
+        ...state,
+        status: 'expired',
+        startEvidence: null,
+        stopEvidence: null,
+        error: Object.freeze({
+            code: 'CODEX_EVIDENCE_EXPIRED',
+            message: 'Codex lifecycle evidence expired before completion'
+        })
+    });
+}
+export { createCodexLifecycleState, expireCodexLifecycleState, reduceCodexLifecycleEvent };
+//# sourceMappingURL=evidence.js.map