@fitlab-ai/agent-infra 0.12.1 → 0.12.2

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

@@ -1,443 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import crypto from 'node:crypto';
-import fs from 'node:fs';
-import path from 'node:path';
-import { preflightCodexLifecycleEvidence, resolveCodexTerminal, resolveCodexThread } from './app-server.js';
-import { createCodexLifecycleStore } from './store.js';
-import { resolveTaskRef } from '../../../task/resolve-ref.js';
-import { resolveTaskContext } from '../../../task/resolve-ref.js';
-import { hasSealableOrchestrationDelegation, readRun } from '../../../task/orchestration.js';
-import { parseCodexLifecycleBinding, verifyCodexLifecycleTaskBinding } from './binding.js';
-import { activateCodexOrchestrationDelegation, activateCodexSpawnDelegation, reconcileCodexOrchestrationDelegation, sealCodexOrchestrationDelegation, sealCodexParentDelegation } from '../codex-orchestration.js';
-import { ensureInternalHandlerRoute, internalHandlerRoute } from '../../../internal/cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal codex-lifecycle <hook-event|resolve-start|resolve-stop|preflight|consume> [options]\n';
-const MANAGED_AGENT = /^agent-infra-lifecycle-(executor|reviewer)$/;
-function output(value) {
-    process.stdout.write(`${JSON.stringify(value)}\n`);
-}
-function failure(code, message) {
-    output({ status: 'failed', changed: false, evidence: null, diagnostics: [], error: { code, message } });
-    process.exitCode = 1;
-}
-function outputBridgeResult(result) {
-    if (result.error?.code === 'ORCHESTRATION_DELEGATION_MISSING') {
-        output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
-        return;
-    }
-    output(result);
-    if (result.status !== 'running')
-        process.exitCode = 1;
-}
-function parse(args) {
-    if (args[0] === '--help' || args[0] === '-h') {
-        process.stdout.write(USAGE);
-        return null;
-    }
-    const operation = args[0];
-    if (!operation) {
-        failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', 'operation is required');
-        return null;
-    }
-    const allowed = {
-        'hook-event': ['--event', '--bridge'],
-        'resolve-start': ['--child-id'],
-        'resolve-stop': ['--child-id'],
-        preflight: ['--format', '--session-id', '--turn-id', '--tool-use-id'],
-        consume: ['--child-id', '--consumer']
-    }[operation];
-    if (!allowed) {
-        failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', 'unknown operation');
-        return null;
-    }
-    const values = {};
-    for (let index = 1; index < args.length; index += 1) {
-        const flag = args[index];
-        if (!allowed.includes(flag) || Object.hasOwn(values, flag)) {
-            failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', `invalid or duplicate option '${flag}'`);
-            return null;
-        }
-        const value = args[++index];
-        if (!value || value.startsWith('--')) {
-            failure('CODEX_LIFECYCLE_PAYLOAD_INVALID', `option '${flag}' requires a value`);
-            return null;
-        }
-        values[flag] = value;
-    }
-    return Object.freeze({ operation, values: Object.freeze(values) });
-}
-function cliVersion() {
-    const result = spawnSync('codex', ['--version'], { encoding: 'utf8' });
-    const version = /codex-cli\s+(\d+\.\d+\.\d+)/.exec(result.stdout ?? '')?.[1];
-    if (result.status !== 0 || !version)
-        throw new Error('Codex CLI version is unavailable');
-    return version;
-}
-function hookDefinitionHash() {
-    const file = path.join(process.cwd(), '.codex', 'hooks.json');
-    return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
-}
-function resolveLifecycleTaskContext() {
-    const taskId = process.env.AGENT_INFRA_TASK_ID;
-    const context = taskId
-        ? resolveTaskRef(taskId, { repoRoot: process.cwd() })
-        : resolveTaskContext(undefined, { repoRoot: process.cwd() });
-    if (!context.ok)
-        throw new Error(`${context.code}: ${context.message}`);
-    return context;
-}
-function verifyPendingBinding(binding, nativeAgent, expected = {}) {
-    const resolved = resolveLifecycleTaskContext();
-    const run = readRun(resolved.taskDir);
-    if (!run)
-        throw new Error('Codex lifecycle task binding has no current orchestration run');
-    verifyCodexLifecycleTaskBinding(binding, run, nativeAgent, expected);
-    return { resolved, run };
-}
-function verifyStoredBinding(taskId, binding, nativeAgent) {
-    const resolved = resolveTaskRef(taskId, { repoRoot: process.cwd() });
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    const run = readRun(resolved.taskDir);
-    const receipt = run?.pendingDelegation;
-    if (!receipt || run?.status !== 'running'
-        || receipt.id !== binding.receiptId
-        || receipt.runId !== binding.runId
-        || receipt.client !== 'codex'
-        || receipt.role !== nativeRole(nativeAgent)) {
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: stored task receipt is not the current pending lifecycle event');
-    }
-}
-function sameTaskBinding(left, right) {
-    return left?.runId === right.runId && left.receiptId === right.receiptId;
-}
-function nativeRole(nativeAgent) {
-    const match = /^agent-infra-lifecycle-(executor|reviewer)$/u.exec(nativeAgent);
-    return match?.[1] ?? null;
-}
-function taskScopedStore(taskId) {
-    return createCodexLifecycleStore({
-        repoRoot: process.cwd(),
-        taskId,
-        cliVersion: cliVersion()
-    });
-}
-async function readStdin() {
-    let input = '';
-    process.stdin.setEncoding('utf8');
-    for await (const chunk of process.stdin) {
-        input += chunk;
-        if (Buffer.byteLength(input) > 64 * 1024)
-            throw new Error('Codex lifecycle input exceeds 64 KiB');
-    }
-    return JSON.parse(input || '{}');
-}
-function recordFromPayload(phase, payload, taskBinding) {
-    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
-        throw new Error('Codex lifecycle hook payload must be an object');
-    }
-    const value = payload;
-    const text = (key) => typeof value[key] === 'string' ? value[key] : '';
-    if (!MANAGED_AGENT.test(text('nativeAgent')))
-        return null;
-    if (phase === 'pre-tool')
-        return {
-            type: 'hook-spawn',
-            sessionId: text('sessionId'),
-            turnId: text('turnId'),
-            toolUseId: text('toolUseId'),
-            nativeAgent: text('nativeAgent'),
-            ...(text('requestedModel') ? { requestedModel: text('requestedModel') } : {}),
-            ...(text('requestedReasoningEffort') ? { requestedReasoningEffort: text('requestedReasoningEffort') } : {}),
-            hookDefinitionHash: text('hookDefinitionHash'),
-            ...(taskBinding ? { taskBinding } : {})
-        };
-    if (phase === 'subagent-start')
-        return {
-            type: 'hook-child',
-            sessionId: text('sessionId'),
-            turnId: text('turnId'),
-            childThreadId: text('childThreadId'),
-            nativeAgent: text('nativeAgent'),
-            source: 'hook'
-        };
-    if (phase === 'subagent-stop')
-        return {
-            type: 'hook-stop',
-            sessionId: text('sessionId'),
-            turnId: text('turnId'),
-            childThreadId: text('childThreadId'),
-            nativeAgent: text('nativeAgent')
-        };
-    if (phase === 'post-tool')
-        return null;
-    throw new Error(`unknown Codex lifecycle hook phase '${phase}'`);
-}
-function payloadText(payload, key) {
-    return payload && typeof payload === 'object' && !Array.isArray(payload)
-        && typeof payload[key] === 'string'
-        ? payload[key]
-        : '';
-}
-function resolveHookTaskContext(phase, toolName, payload) {
-    const spawnName = payloadText(payload, 'taskName');
-    const needsSpawnBinding = phase === 'pre-tool' || (phase === 'post-tool' && toolName === 'collaborationspawn_agent');
-    const spawnBinding = needsSpawnBinding ? parseCodexLifecycleBinding(spawnName) : null;
-    if (needsSpawnBinding && !spawnBinding) {
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISSING: task_name must carry the prepared task binding');
-    }
-    const nativeAgent = payloadText(payload, 'nativeAgent');
-    const taskContext = spawnBinding
-        ? verifyPendingBinding(spawnBinding.binding, nativeAgent, {
-            requestedModel: payloadText(payload, 'requestedModel') || undefined,
-            requestedReasoningEffort: payloadText(payload, 'requestedReasoningEffort') || undefined
-        }).resolved
-        : resolveLifecycleTaskContext();
-    const store = taskScopedStore(taskContext.taskId);
-    if (spawnBinding)
-        verifyStoredBinding(taskContext.taskId, spawnBinding.binding, nativeAgent);
-    return { spawnBinding, nativeAgent, taskContext, store };
-}
-function currentHookTaskBinding(taskDir, taskId, spawnBinding, nativeAgent) {
-    if (!spawnBinding) {
-        const run = readRun(taskDir);
-        const receipt = run?.pendingDelegation;
-        if (!receipt || receipt.client !== 'codex' || receipt.role !== nativeRole(nativeAgent)) {
-            throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: no matching pending task receipt');
-        }
-        verifyStoredBinding(taskId, { taskId: receipt.taskId, runId: receipt.runId, receiptId: receipt.id }, nativeAgent);
-    }
-    const receipt = readRun(taskDir)?.pendingDelegation;
-    return receipt && { taskId: receipt.taskId, runId: receipt.runId, receiptId: receipt.id };
-}
-function validateHookStopIdentity(store, event, currentBinding) {
-    const record = store.read(event.childThreadId);
-    const child = record.state.child;
-    if (!currentBinding || !sameTaskBinding(record.taskBinding, currentBinding)
-        || !child
-        || child.sessionId !== event.sessionId
-        || child.turnId !== event.turnId
-        || child.childThreadId !== event.childThreadId
-        || child.nativeAgent !== event.nativeAgent) {
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: stop event does not match the current task receipt and child');
-    }
-}
-function matchingHookChildSpawns(store, binding, event) {
-    return binding ? store.findByTaskBinding(binding).filter((record) => record.state.spawn?.sessionId === event.sessionId
-        && record.state.spawn?.nativeAgent === event.nativeAgent) : [];
-}
-async function applyHookChildEvent(event, currentBinding, taskContext, store, bridge, resolved) {
-    const candidates = matchingHookChildSpawns(store, currentBinding, event);
-    if (candidates.length !== 1) {
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: child event has no unique spawn for the current task receipt');
-    }
-    const childResolution = resolved ?? await resolveCodexThread(event.childThreadId);
-    verifyStoredBinding(taskContext.taskId, currentBinding, event.nativeAgent);
-    const latestCandidates = matchingHookChildSpawns(store, currentBinding, event);
-    if (latestCandidates.length !== 1 || latestCandidates[0].revision !== candidates[0].revision) {
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: task receipt spawn became ambiguous during child resolution');
-    }
-    if (childResolution.resolution.thread.childThreadId !== event.childThreadId
-        || childResolution.resolution.thread.parentThreadId !== event.sessionId
-        || childResolution.resolution.thread.nativeAgent !== event.nativeAgent) {
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: resolved child does not match the current spawn');
-    }
-    verifyStoredBinding(taskContext.taskId, currentBinding, event.nativeAgent);
-    const spawn = latestCandidates[0].state.spawn;
-    if (!spawn)
-        throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: current spawn record is missing');
-    const result = store.applyToSpawn({
-        sessionId: spawn.sessionId, turnId: spawn.turnId, toolUseId: spawn.toolUseId, taskBinding: currentBinding
-    }, { ...event, parentThreadId: childResolution.resolution.thread.parentThreadId }, latestCandidates[0].revision);
-    if (bridge) {
-        outputBridgeResult(await activateCodexOrchestrationDelegation(event.childThreadId, {
-            store, orchestrationOptions: { repoRoot: process.cwd(), taskId: taskContext.taskId },
-            resolveThread: async () => childResolution
-        }));
-        return;
-    }
-    output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: childResolution.diagnostics, error: result.state.error });
-    if (result.state.status === 'invalid')
-        process.exitCode = 1;
-}
-async function handleBridgePostTool(toolName, payload, nativeAgent, taskId, store) {
-    const orchestrationOptions = { repoRoot: process.cwd(), taskId };
-    if (toolName === 'collaborationspawn_agent') {
-        if (!MANAGED_AGENT.test(nativeAgent)) {
-            output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
-            return;
-        }
-        const requestedModel = payloadText(payload, 'requestedModel');
-        const requestedReasoningEffort = payloadText(payload, 'requestedReasoningEffort');
-        const bridged = await activateCodexSpawnDelegation({
-            sessionId: payloadText(payload, 'sessionId'), turnId: payloadText(payload, 'turnId'),
-            toolUseId: payloadText(payload, 'toolUseId'), transcriptPath: payloadText(payload, 'transcriptPath'),
-            nativeAgent, taskName: payloadText(payload, 'taskName'),
-            ...(requestedModel ? { requestedModel } : {}),
-            ...(requestedReasoningEffort ? { requestedReasoningEffort } : {})
-        }, { store, orchestrationOptions });
-        outputBridgeResult(bridged);
-        return;
-    }
-    if (toolName === 'collaborationwait_agent') {
-        outputBridgeResult(await sealCodexParentDelegation(payloadText(payload, 'sessionId'), { store, orchestrationOptions }));
-        return;
-    }
-    output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
-}
-async function sealConsumedHookStop(event, store, taskId) {
-    const result = await sealCodexOrchestrationDelegation(event.childThreadId, {
-        store, orchestrationOptions: { repoRoot: process.cwd(), taskId }
-    });
-    outputBridgeResult(result);
-}
-function handleMissingHookEvent(phase, bridge, payload, taskId) {
-    if (phase === 'post-tool' && bridge) {
-        const value = payload;
-        outputBridgeResult(reconcileCodexOrchestrationDelegation(String(value.childThreadId ?? ''), {
-            orchestrationOptions: { repoRoot: process.cwd(), taskId }
-        }));
-        return;
-    }
-    output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
-}
-async function handlePreflight(parsed) {
-    const format = parsed.values['--format'] ?? 'json';
-    if (!['text', 'json'].includes(format))
-        throw new Error("format must be 'text' or 'json'");
-    const runtimeFields = [parsed.values['--session-id'], parsed.values['--turn-id'], parsed.values['--tool-use-id']];
-    if (runtimeFields.some(Boolean) && !runtimeFields.every(Boolean)) {
-        throw new Error('preflight runtime identity requires --session-id, --turn-id, and --tool-use-id together');
-    }
-    const runtimeIdentity = runtimeFields.every(Boolean)
-        ? { sessionId: runtimeFields[0], turnId: runtimeFields[1], toolUseId: runtimeFields[2] }
-        : undefined;
-    const result = await preflightCodexLifecycleEvidence(process.cwd(), runtimeIdentity);
-    if (format === 'text') {
-        process.stdout.write(`Codex lifecycle static preflight: ready\nCLI: ${result.cliVersion}\nRuntime hook liveness: ${result.runtimeLiveness ? 'observed' : 'not-yet-observed'}\n`);
-    }
-    else
-        output({ status: 'ready', changed: false, evidence: result, diagnostics: result.diagnostics, error: null });
-}
-async function codexLifecycle(args = []) {
-    if (!ensureInternalHandlerRoute('codex-lifecycle', args))
-        return;
-    const parsed = parse(args);
-    if (!parsed || process.exitCode)
-        return;
-    try {
-        if (internalHandlerRoute('codex-lifecycle', 'preflight', parsed.operation)) {
-            await handlePreflight(parsed);
-            return;
-        }
-        if (internalHandlerRoute('codex-lifecycle', 'hook-event', parsed.operation)) {
-            const phase = parsed.values['--event'];
-            if (!phase || !['pre-tool', 'subagent-start', 'post-tool', 'subagent-stop'].includes(phase)) {
-                throw new Error('hook-event requires a known --event');
-            }
-            if (parsed.values['--bridge'] !== undefined && parsed.values['--bridge'] !== 'true') {
-                throw new Error("hook-event --bridge must be 'true'");
-            }
-            const payload = await readStdin();
-            const toolName = payloadText(payload, 'toolName');
-            const hookContext = resolveHookTaskContext(phase, toolName, payload);
-            const { spawnBinding, nativeAgent, taskContext, store } = hookContext;
-            if (phase === 'post-tool' && parsed.values['--bridge'] === 'true') {
-                await handleBridgePostTool(toolName, payload, nativeAgent, taskContext.taskId, store);
-                return;
-            }
-            const event = recordFromPayload(phase, payload, spawnBinding?.binding);
-            if (!event) {
-                handleMissingHookEvent(phase, parsed.values['--bridge'] === 'true', payload, taskContext.taskId);
-                return;
-            }
-            const currentBinding = currentHookTaskBinding(taskContext.taskDir, taskContext.taskId, spawnBinding, nativeAgent);
-            if (event.type === 'hook-stop') {
-                validateHookStopIdentity(store, event, currentBinding);
-            }
-            if (parsed.values['--bridge'] === 'true' && event.type === 'hook-stop'
-                && store.read(event.childThreadId).consumer) {
-                await sealConsumedHookStop(event, store, taskContext.taskId);
-                return;
-            }
-            if (event.type === 'hook-child') {
-                await applyHookChildEvent(event, currentBinding, taskContext, store, parsed.values['--bridge'] === 'true');
-                return;
-            }
-            if (!currentBinding)
-                throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISMATCH: current task receipt is missing');
-            verifyStoredBinding(taskContext.taskId, currentBinding, nativeAgent);
-            const result = store.apply(event);
-            if (parsed.values['--bridge'] === 'true' && event.type === 'hook-stop') {
-                if (!hasSealableOrchestrationDelegation('codex', event.childThreadId, { repoRoot: process.cwd(), taskId: taskContext.taskId })) {
-                    output({ status: 'ignored', changed: false, evidence: null, diagnostics: [], error: null });
-                    return;
-                }
-                output({
-                    status: result.state.status,
-                    changed: true,
-                    evidence: result.state,
-                    diagnostics: [],
-                    error: result.state.error
-                });
-                return;
-            }
-            output({ status: result.state.status, changed: true, evidence: result.state, diagnostics: [], error: result.state.error });
-            if (result.state.status === 'invalid')
-                process.exitCode = 1;
-            return;
-        }
-        const childThreadId = parsed.values['--child-id'];
-        if (!childThreadId)
-            throw new Error(`operation '${parsed.operation}' requires --child-id`);
-        const taskContext = resolveLifecycleTaskContext();
-        const store = taskScopedStore(taskContext.taskId);
-        const existing = store.read(childThreadId);
-        if (!existing.taskBinding)
-            throw new Error('CODEX_LIFECYCLE_TASK_BINDING_MISSING: stored lifecycle identity has no task binding');
-        verifyStoredBinding(taskContext.taskId, existing.taskBinding, existing.state.startEvidence?.nativeAgent ?? existing.state.spawn?.nativeAgent ?? '');
-        if (internalHandlerRoute('codex-lifecycle', 'resolve-start', parsed.operation)) {
-            if (store.read(childThreadId).state.spawn?.hookDefinitionHash !== hookDefinitionHash()) {
-                throw new Error('Codex lifecycle hook definition hash is stale');
-            }
-            const resolved = await resolveCodexThread(childThreadId);
-            verifyStoredBinding(taskContext.taskId, existing.taskBinding, existing.state.startEvidence?.nativeAgent ?? existing.state.spawn?.nativeAgent ?? '');
-            let latest = store.apply(resolved.resolution.thread);
-            for (const reroute of resolved.reroutes)
-                latest = store.apply(reroute);
-            latest = store.apply(resolved.resolution.settings);
-            output({ status: latest.state.status, changed: true, evidence: latest.state.startEvidence, diagnostics: resolved.diagnostics, error: latest.state.error });
-            if (latest.state.status !== 'start-ready')
-                process.exitCode = 1;
-            return;
-        }
-        if (internalHandlerRoute('codex-lifecycle', 'resolve-stop', parsed.operation)) {
-            const stopTurnId = store.read(childThreadId).state.stop?.turnId;
-            if (!stopTurnId)
-                throw new Error('Codex lifecycle stop hook is not available');
-            const terminal = await resolveCodexTerminal(childThreadId, stopTurnId);
-            verifyStoredBinding(taskContext.taskId, existing.taskBinding, existing.state.startEvidence?.nativeAgent ?? existing.state.spawn?.nativeAgent ?? '');
-            const latest = store.apply(terminal);
-            if (latest.state.status !== 'stop-ready') {
-                throw new Error(`Codex lifecycle stop evidence is not ready (status=${latest.state.status})`);
-            }
-            output({ status: latest.state.status, changed: true, evidence: latest.state.stopEvidence, diagnostics: [], error: latest.state.error });
-            return;
-        }
-        if (internalHandlerRoute('codex-lifecycle', 'consume', parsed.operation)) {
-            const consumer = parsed.values['--consumer'];
-            if (!consumer)
-                throw new Error('consume requires --consumer');
-            verifyStoredBinding(taskContext.taskId, existing.taskBinding, existing.state.startEvidence?.nativeAgent ?? existing.state.spawn?.nativeAgent ?? '');
-            const consumed = store.consume(childThreadId, consumer, hookDefinitionHash());
-            output({ status: 'consumed', changed: true, evidence: {
-                    start: consumed.state.startEvidence,
-                    stop: consumed.state.stopEvidence
-                }, diagnostics: [], error: null });
-        }
-    }
-    catch (error) {
-        failure('CODEX_LIFECYCLE_FAILED', error instanceof Error ? error.message : String(error));
-    }
-}
-export { codexLifecycle };
-//# sourceMappingURL=cli.js.map

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

@@ -1,236 +0,0 @@
-function isCodexLifecycleActivationEvidence(value, parentId) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const state = value;
-    const evidence = state.activationEvidence;
-    if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence))
-        return false;
-    const activation = evidence;
-    return activation.kind === 'codex-lifecycle-v2'
-        && typeof activation.hookDefinitionHash === 'string'
-        && activation.hookDefinitionHash.trim() !== ''
-        && Number.isSafeInteger(activation.startRevision)
-        && activation.startRevision >= 1
-        && activation.capabilitySessionId === parentId;
-}
-function isCodexDelegationReceiptEvidence(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value))
-        return false;
-    const receipt = value;
-    if (receipt.client !== 'codex' || typeof receipt.id !== 'string')
-        return false;
-    const status = receipt.status;
-    if (!['activated', 'stage-completed', 'sealed', 'consumed', 'aborted'].includes(status))
-        return true;
-    const adapterEvidence = receipt.adapterEvidence;
-    if (!adapterEvidence || typeof adapterEvidence !== 'object' || Array.isArray(adapterEvidence))
-        return false;
-    const codex = adapterEvidence.codex;
-    if (!codex || typeof codex !== 'object' || Array.isArray(codex))
-        return false;
-    const state = codex;
-    if (!isCodexLifecycleActivationEvidence(state, String(receipt.parentId ?? '')))
-        return false;
-    if (!['sealed', 'consumed', 'aborted'].includes(status))
-        return true;
-    const records = state.records;
-    if (!records || typeof records !== 'object' || Array.isArray(records))
-        return false;
-    return Object.values(records).some((record) => {
-        if (!record || typeof record !== 'object' || Array.isArray(record))
-            return false;
-        const evidence = record;
-        return evidence.consumer === receipt.id
-            && typeof evidence.consumedAt === 'string'
-            && evidence.consumedAt.trim() !== '';
-    });
-}
-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 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() !== ''));
-}
-function derive(state) {
-    const { spawn, child, thread, settings, reroute, terminal, stop } = state;
-    if (spawn && child && (spawn.sessionId !== child.parentThreadId
-        || spawn.nativeAgent !== child.nativeAgent)) {
-        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook spawn and child identity do not match');
-    }
-    if (child && child.sessionId !== child.parentThreadId) {
-        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'child event session does not match the parent thread');
-    }
-    if (child && thread && child.childThreadId !== thread.childThreadId) {
-        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server child identity do not match');
-    }
-    if (child && thread && child.nativeAgent !== thread.nativeAgent) {
-        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'hook and App Server agent roles do not match');
-    }
-    if (child && thread && child.parentThreadId !== thread.parentThreadId) {
-        return invalid(state, 'CODEX_EVIDENCE_PARENT_MISMATCH', 'hook and App Server parent 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 (spawn && thread && spawn.nativeAgent !== thread.nativeAgent) {
-        return invalid(state, 'CODEX_EVIDENCE_IDENTITY_MISMATCH', 'spawn and App Server agent roles do not match');
-    }
-    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: stop.source !== 'parent-rollout'
-        });
-    }
-    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;
-        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 }) }));
-}
-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, isCodexLifecycleActivationEvidence, isCodexDelegationReceiptEvidence, reduceCodexLifecycleEvent };
-//# sourceMappingURL=evidence.js.map