@fitlab-ai/agent-infra 0.12.1 → 0.12.2

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

@@ -1,292 +0,0 @@
-import fs from 'node:fs';
-import { createCodexLifecycleStore, readCodexLifecycleActivationEvidence } from './store.js';
-import { managedDelegationRole } from '../../../task/delegation-receipts.js';
-import { normalizeAgentToken } from '../../tokens.js';
-import { locateActivityLog, pairEntries, appendActivityEntry } from '../../../task/activity-log.js';
-import { captureTaskWriteMetadata, writeTask } from '../../../task/write.js';
-import { parseTypedTaskFrontmatter } from '../../../task/frontmatter.js';
-import { resolveTaskRef } from '../../../task/resolve-ref.js';
-import { recoverActivatedOrchestrationDelegation, readRun } from '../../../task/orchestration.js';
-const ACTIONS = {
-    analysis: 'Analyze Task',
-    'review-analysis': 'Review Analysis',
-    plan: 'Plan Task',
-    'review-plan': 'Review Plan',
-    code: 'Code Task',
-    'review-code': 'Review Code'
-};
-function result(request, status, extra = {}) {
-    return {
-        status,
-        changed: status === 'applied',
-        targetState: 'active',
-        requestRef: request.taskRef,
-        intent: 'recover-started',
-        taskId: null,
-        receiptId: null,
-        childId: null,
-        error: null,
-        ...extra
-    };
-}
-function failure(request, status, code, message, extra = {}) {
-    return result(request, status, { error: { code, message }, ...extra });
-}
-function actionPattern(receipt) {
-    const action = ACTIONS[receipt.stage];
-    if (!action)
-        return null;
-    const escaped = action.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
-    return new RegExp(`^${escaped} \\(Round ${receipt.round}(?:, (?:fix for review-code(?:-r[2-9]|-r[1-9]\\d+)?.md|decision II-[1-9]\\d*))?\\)$`, 'u');
-}
-function openRows(section) {
-    return pairEntries([...section.entries]).filter((row) => row.started !== '' && row.done === '');
-}
-function rowForReceipt(rows, receipt) {
-    const pattern = actionPattern(receipt);
-    return pattern ? rows.filter((row) => pattern.test(row.step)) : [];
-}
-function readLifecycleStore(options, repoRoot, taskId) {
-    return options.lifecycleStore ?? createCodexLifecycleStore({
-        repoRoot,
-        taskId,
-        cliVersion: 'recovery',
-        now: options.now
-    });
-}
-function readStoredEvidence(store, childId) {
-    try {
-        return store.read(childId);
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        if (message.includes('was not found uniquely'))
-            return { missing: true };
-        return { error: error instanceof Error ? error : new Error(message) };
-    }
-}
-function validateStopRecord(record, receipt) {
-    if (!stopRecordMatchesReceipt(record, receipt)) {
-        return { ok: false, code: 'RECOVERY_TASK_BINDING_MISMATCH', message: 'lifecycle evidence belongs to a different task receipt' };
-    }
-    if (!stopEvidenceMatchesReceipt(record, receipt)) {
-        return { ok: false, code: 'RECOVERY_STOP_EVIDENCE_INVALID', message: 'Codex stop evidence does not match the activated receipt' };
-    }
-    if (record.consumer !== null && record.consumer !== receipt.id) {
-        return { ok: false, code: 'RECOVERY_CONSUMER_CONFLICT', message: `Codex lifecycle evidence was consumed by '${record.consumer}'` };
-    }
-    return { ok: true };
-}
-function stopRecordMatchesReceipt(record, receipt) {
-    return record.taskBinding?.runId === receipt.runId
-        && record.taskBinding.receiptId === receipt.id;
-}
-function stopEvidenceMatchesReceipt(record, receipt) {
-    const start = record.state.startEvidence;
-    const stop = record.state.stopEvidence;
-    const host = readCodexLifecycleActivationEvidence(receipt);
-    if (!stopRecordHasRequiredEvidence(record, receipt, start, stop, host))
-        return false;
-    return spawnMatchesReceipt(record, receipt, host, start)
-        && childMatchesReceipt(record, receipt, start, stop)
-        && hostEvidenceMatches(record, receipt, host, start);
-}
-function stopRecordHasRequiredEvidence(record, receipt, start, stop, host) {
-    return receipt.client === 'codex'
-        && host?.kind === 'codex-lifecycle-v2'
-        && Boolean(start && stop && record.state.spawn && record.state.child && record.state.stop)
-        && record.state.status === 'stop-ready'
-        && stop?.terminalStatus === 'completed'
-        && stop.hookStopObserved === true;
-}
-function spawnMatchesReceipt(record, receipt, host, start) {
-    const spawn = record.state.spawn;
-    return Boolean(spawn)
-        && spawn.sessionId === start.parentThreadId
-        && spawn.turnId === host.capabilityTurnId
-        && spawn.toolUseId === host.spawnToolUseId
-        && spawn.nativeAgent === start.nativeAgent
-        && spawn.hookDefinitionHash === host.hookDefinitionHash
-        && spawn.requestedModel === receipt.requestedModel
-        && spawn.requestedReasoningEffort === receipt.requestedReasoningEffort
-        && spawn.taskBinding?.runId === receipt.runId
-        && spawn.taskBinding.receiptId === receipt.id;
-}
-function childMatchesReceipt(record, receipt, start, stop) {
-    const child = record.state.child;
-    const stopState = record.state.stop;
-    return Boolean(child && stopState)
-        && child.sessionId === start.parentThreadId
-        && stopState.turnId === child.turnId
-        && (stopState.source === 'parent-rollout'
-            ? stop.turnId === record.state.terminal?.turnId
-            : child.turnId === stop.turnId)
-        && child.childThreadId === receipt.childId
-        && child.nativeAgent === start.nativeAgent
-        && stopState.childThreadId === receipt.childId
-        && stopState.nativeAgent === start.nativeAgent
-        && start.childThreadId === receipt.childId
-        && start.parentThreadId === receipt.parentId
-        && managedDelegationRole(start.nativeAgent) === receipt.role;
-}
-function hostEvidenceMatches(record, receipt, host, start) {
-    return start.hookDefinitionHash === host.hookDefinitionHash
-        && host.capabilitySessionId === start.parentThreadId
-        && host.capabilityTurnId === record.state.spawn?.turnId
-        && host.spawnToolUseId === start.spawnToolUseId
-        && Boolean(host.spawnObservedAt)
-        && host.spawnObservedAt === record.spawnObservedAt
-        && hostRevisionMatches(record, receipt, host);
-}
-function hostRevisionMatches(record, receipt, host) {
-    return host.startRevision >= 1
-        && record.revision > host.startRevision
-        && record.state.child?.childThreadId === receipt.childId
-        && record.state.stop?.childThreadId === receipt.childId;
-}
-function abortedCandidates(run, rows) {
-    const candidates = run.receipts.flatMap((receipt) => {
-        if (receipt.status !== 'aborted' || receipt.activatedAt === null || receipt.client !== 'codex')
-            return [];
-        const matches = rowForReceipt(rows, receipt);
-        return matches.length === 1 ? [{ receipt, row: matches[0] }] : [];
-    });
-    return candidates;
-}
-function appendRecoveryLog(request, taskId, section, candidate, repoRoot, writer) {
-    const metadata = captureTaskWriteMetadata();
-    const body = appendActivityEntry(section, {
-        time: metadata.timestamp,
-        step: `${candidate.row.step} [aborted]`,
-        agent: request.agent,
-        note: `terminated Codex delegation; receipt=${candidate.receipt.id}; child=${candidate.receipt.childId}`
-    });
-    const written = writer({
-        taskRef: taskId,
-        expectedState: 'active',
-        mutations: [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body }]
-    }, { repoRoot, metadataProvider: () => metadata });
-    if (written.status === 'failed') {
-        return failure(request, 'owner-unknown', 'RECOVERY_LOG_WRITE_FAILED', written.error.message, {
-            taskId, receiptId: candidate.receipt.id, childId: candidate.receipt.childId
-        });
-    }
-    return result(request, 'applied', {
-        taskId, receiptId: candidate.receipt.id, childId: candidate.receipt.childId
-    });
-}
-function recoverStartedLifecycle(request, options = {}) {
-    if (!request || request.intent !== 'recover-started' || request.auto !== true || normalizeAgentToken(request.agent) !== 'codex') {
-        return failure(request, 'conflict', 'RECOVERY_PAYLOAD_INVALID', 'automatic recovery requires a task and the Codex agent');
-    }
-    const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
-    if (!resolved.ok)
-        return failure(request, 'conflict', resolved.code, resolved.message);
-    const taskId = resolved.taskId;
-    let content;
-    try {
-        content = fs.readFileSync(resolved.taskMdPath, 'utf8');
-        parseTypedTaskFrontmatter(content);
-    }
-    catch (error) {
-        return failure(request, 'conflict', 'RECOVERY_TASK_INVALID', error instanceof Error ? error.message : String(error), { taskId });
-    }
-    const section = locateActivityLog(content);
-    if (!section)
-        return failure(request, 'conflict', 'RECOVERY_LOG_INVALID', 'task has no unique Activity Log section', { taskId });
-    let run;
-    try {
-        run = readRun(resolved.taskDir, options.orchestration);
-    }
-    catch (error) {
-        return failure(request, 'owner-unknown', 'RECOVERY_ORCHESTRATION_UNKNOWN', error instanceof Error ? error.message : String(error), { taskId });
-    }
-    if (!run)
-        return result(request, 'no-op', { taskId });
-    const rows = openRows(section);
-    const pending = run.pendingDelegation;
-    if (!pending)
-        return recoverAbortedLifecycle(request, taskId, section, resolved.repoRoot, run, rows, options);
-    return recoverActiveLifecycle(request, taskId, section, resolved.repoRoot, run, rows, pending, options);
-}
-function recoverAbortedLifecycle(request, taskId, section, repoRoot, run, rows, options) {
-    const candidates = abortedCandidates(run, rows);
-    if (candidates.length === 0)
-        return result(request, 'no-op', { taskId });
-    if (candidates.length > 1) {
-        return failure(request, 'conflict', 'RECOVERY_CANDIDATE_AMBIGUOUS', 'more than one aborted delegation has an open lifecycle row', { taskId });
-    }
-    return appendRecoveryLog(request, taskId, section, candidates[0], repoRoot, options.writeTask ?? writeTask);
-}
-function recoverActiveLifecycle(request, taskId, section, repoRoot, run, rows, pending, options) {
-    if (pending.status !== 'activated')
-        return result(request, 'no-op', { taskId });
-    if (pending.client !== 'codex' || run.status !== 'running' || run.pause !== null) {
-        return failure(request, 'conflict', 'RECOVERY_ORCHESTRATION_INVALID', 'activated recovery requires one running Codex delegation', {
-            taskId, receiptId: pending.id, childId: pending.childId
-        });
-    }
-    const rowResult = matchingActiveRecoveryRow(request, taskId, rows, pending);
-    if ('result' in rowResult)
-        return rowResult.result;
-    const evidenceResult = consumeRecoveryEvidence(request, taskId, repoRoot, pending, options);
-    if ('result' in evidenceResult)
-        return evidenceResult.result;
-    return finishActiveRecovery(request, taskId, section, repoRoot, pending, rowResult.row, options);
-}
-function matchingActiveRecoveryRow(request, taskId, rows, pending) {
-    const matchingRows = rowForReceipt(rows, pending);
-    if (matchingRows.length !== 1 || normalizeAgentToken(matchingRows[0].agent) !== 'codex' || matchingRows[0].note !== 'started') {
-        return { result: failure(request, 'conflict', 'RECOVERY_LOG_CONFLICT', 'activated delegation does not have one matching open lifecycle row', {
-                taskId, receiptId: pending.id, childId: pending.childId
-            }) };
-    }
-    if (!pending.childId) {
-        return { result: failure(request, 'conflict', 'RECOVERY_DELEGATION_INVALID', 'activated delegation has no child identity', { taskId, receiptId: pending.id }) };
-    }
-    return { row: matchingRows[0] };
-}
-function consumeRecoveryEvidence(request, taskId, repoRoot, pending, options) {
-    const store = readLifecycleStore(options, repoRoot, taskId);
-    const stored = readStoredEvidence(store, pending.childId);
-    if ('error' in stored)
-        return { result: failure(request, 'owner-unknown', 'RECOVERY_STORE_UNKNOWN', stored.error.message, { taskId, receiptId: pending.id, childId: pending.childId }) };
-    if ('missing' in stored)
-        return { result: failure(request, 'owner-unknown', 'RECOVERY_STOP_EVIDENCE_MISSING', 'matching Codex lifecycle stop evidence is missing', { taskId, receiptId: pending.id, childId: pending.childId }) };
-    const evidence = validateStopRecord(stored, pending);
-    if (!evidence.ok)
-        return { result: failure(request, evidence.code === 'RECOVERY_CONSUMER_CONFLICT' ? 'conflict' : 'owner-unknown', evidence.code, evidence.message, { taskId, receiptId: pending.id, childId: pending.childId }) };
-    let consumed = stored;
-    if (stored.consumer === null) {
-        try {
-            consumed = store.consume(pending.childId, pending.id, stored.state.startEvidence?.hookDefinitionHash, {
-                taskId: pending.taskId, runId: pending.runId, receiptId: pending.id
-            });
-        }
-        catch (error) {
-            return { result: failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_CONSUME_FAILED', error instanceof Error ? error.message : String(error), { taskId, receiptId: pending.id, childId: pending.childId }) };
-        }
-    }
-    return consumed.consumedAt
-        ? { consumed }
-        : { result: failure(request, 'owner-unknown', 'RECOVERY_EVIDENCE_INVALID', 'consumed stop evidence has no timestamp', { taskId, receiptId: pending.id, childId: pending.childId }) };
-}
-function finishActiveRecovery(request, taskId, section, repoRoot, pending, row, options) {
-    const recovered = recoverActivatedOrchestrationDelegation(taskId, {
-        receiptId: pending.id,
-        stage: pending.stage,
-        round: pending.round,
-        artifact: pending.artifact,
-        startedAgent: request.agent,
-        childId: pending.childId
-    }, { ...options.orchestration, repoRoot, now: options.now });
-    if (recovered.status === 'failed' || !recovered.run) {
-        return failure(request, 'owner-unknown', recovered.error?.code ?? 'RECOVERY_ORCHESTRATION_FAILED', recovered.error?.message ?? 'orchestration recovery failed', { taskId, receiptId: pending.id, childId: pending.childId });
-    }
-    return appendRecoveryLog(request, taskId, section, { receipt: recovered.run.receipts.at(-1), row }, repoRoot, options.writeTask ?? writeTask);
-}
-function recoverStartedLifecycleFromAdapter(request, options = {}) {
-    return recoverStartedLifecycle(request, options);
-}
-export { recoverStartedLifecycle, recoverStartedLifecycleFromAdapter };
-//# sourceMappingURL=recovery.js.map

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

@@ -1,267 +0,0 @@
-import crypto from 'node:crypto';
-import path from 'node:path';
-import { mutateDelegationAdapterEvidence, readRun } from '../../../task/orchestration.js';
-import { resolveTaskRef } from '../../../task/resolve-ref.js';
-import { createCodexLifecycleState, expireCodexLifecycleState, reduceCodexLifecycleEvent } from './evidence.js';
-function readCodexLifecycleActivationEvidence(receipt) {
-    const state = storedEvidence(receipt.adapterEvidence?.codex);
-    return state.activationEvidence && typeof state.activationEvidence === 'object'
-        ? state.activationEvidence
-        : null;
-}
-const NON_PERSISTENT_FAILURES = new Set([
-    'CODEX_EVIDENCE_IDENTITY_MISMATCH',
-    'CODEX_EVIDENCE_PARENT_MISMATCH',
-    'CODEX_EVIDENCE_REPLAY_CONFLICT'
-]);
-function recordKey(sessionId, turnId, toolUseId) {
-    return crypto.createHash('sha256').update(`${sessionId}\0${turnId}\0${toolUseId}`).digest('hex');
-}
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function storedEvidence(value) {
-    if (!isRecord(value) || !isRecord(value.records))
-        return Object.freeze({ records: Object.freeze({}) });
-    return value;
-}
-function receipts(taskDir) {
-    const run = readRun(taskDir);
-    return run ? Object.freeze([...run.receipts, ...(run.pendingDelegation ? [run.pendingDelegation] : [])]) : [];
-}
-function allRecords(taskDir) {
-    return Object.freeze(receipts(taskDir).flatMap((receipt) => {
-        const state = storedEvidence(receipt.adapterEvidence?.codex);
-        return Object.values(state.records);
-    }));
-}
-function lifecyclePath(taskDir) {
-    return path.join(taskDir, '.runtime', 'orchestration.json');
-}
-function assertCurrentCanApply(current, binding) {
-    if (current.revision > 0 && binding && JSON.stringify(current.taskBinding) !== JSON.stringify(binding)) {
-        throw new Error('Codex lifecycle task binding does not match the stored spawn');
-    }
-    if (current.consumer)
-        throw new Error(`Codex lifecycle evidence was already consumed by '${current.consumer}'`);
-}
-function hasActiveCodexLifecycleEvidence(taskDir, query) {
-    return allRecords(taskDir).some((record) => {
-        return record.consumer === null
-            && !['invalid', 'expired'].includes(record.state.status)
-            && record.state.spawn?.hookDefinitionHash === query.hookDefinitionHash
-            && (!query.identity || record.state.spawn?.sessionId === query.identity.sessionId
-                && record.state.spawn.turnId === query.identity.turnId
-                && record.state.spawn.toolUseId === query.identity.toolUseId);
-    });
-}
-function createCodexLifecycleStore(options) {
-    if (!/^TASK-[0-9]{8}-[0-9]{6}$/u.test(options.taskId)) {
-        throw new Error('Codex lifecycle store task id is invalid');
-    }
-    const repoRoot = options.repoRoot ?? process.cwd();
-    const resolved = resolveTaskRef(options.taskId, { repoRoot });
-    if (!resolved.ok)
-        throw new Error(`${resolved.code}: ${resolved.message}`);
-    const taskDir = resolved.taskDir;
-    const now = options.now ?? (() => new Date().toISOString());
-    function currentBinding() {
-        const run = readRun(taskDir);
-        const receipt = run?.pendingDelegation;
-        if (!run || !receipt || receipt.client !== 'codex') {
-            throw new Error('Codex lifecycle evidence has no current task delegation');
-        }
-        return Object.freeze({ taskId: receipt.taskId, runId: receipt.runId, receiptId: receipt.id });
-    }
-    function findByChild(childThreadId) {
-        return allRecords(taskDir).filter((record) => record.state.child?.childThreadId === childThreadId);
-    }
-    function locate(event) {
-        if (event.type === 'hook-spawn') {
-            const key = recordKey(event.sessionId, event.turnId, event.toolUseId);
-            const existing = allRecords(taskDir).find((record) => record.spawnObservedAt && record.state.spawn
-                && recordKey(record.state.spawn.sessionId, record.state.spawn.turnId, record.state.spawn.toolUseId) === key);
-            return existing ?? Object.freeze({
-                schemaVersion: 2,
-                revision: 0,
-                taskBinding: event.taskBinding ?? null,
-                state: createCodexLifecycleState(options.cliVersion),
-                consumer: null,
-                consumedAt: null,
-                spawnObservedAt: null,
-                updatedAt: now()
-            });
-        }
-        if (event.type === 'hook-child') {
-            const matches = allRecords(taskDir).filter((record) => record.state.spawn?.sessionId === event.parentThreadId
-                && record.state.spawn.nativeAgent === event.nativeAgent
-                && (!record.state.child || record.state.child.childThreadId === event.childThreadId));
-            if (matches.length !== 1) {
-                throw new Error(matches.length === 0
-                    ? 'Codex lifecycle parent session and agent correlation was not found'
-                    : 'Codex lifecycle parent session and agent correlation is ambiguous');
-            }
-            return matches[0];
-        }
-        const matches = findByChild(event.childThreadId);
-        if (matches.length !== 1) {
-            throw new Error(matches.length === 0
-                ? `Codex lifecycle child '${event.childThreadId}' was not found`
-                : `Codex lifecycle child '${event.childThreadId}' is ambiguous`);
-        }
-        return matches[0];
-    }
-    function update(binding, key, mutate) {
-        let result = null;
-        mutateDelegationAdapterEvidence(options.taskId, binding.receiptId, 'codex', (value) => {
-            const currentState = storedEvidence(value);
-            const current = currentState.records[key] ?? null;
-            result = mutate(current);
-            return Object.freeze({
-                ...currentState,
-                records: Object.freeze({ ...currentState.records, [key]: result })
-            });
-        }, { repoRoot, now });
-        if (!result)
-            throw new Error('Codex lifecycle record was not updated');
-        return result;
-    }
-    function apply(event) {
-        const existing = event.type === 'hook-spawn' ? null : locate(event);
-        const binding = event.type === 'hook-spawn' ? event.taskBinding ?? currentBinding() : existing?.taskBinding;
-        if (!binding)
-            throw new Error('Codex lifecycle event has no task receipt binding');
-        const key = event.type === 'hook-spawn'
-            ? recordKey(event.sessionId, event.turnId, event.toolUseId)
-            : existing?.state.spawn
-                ? recordKey(existing.state.spawn.sessionId, existing.state.spawn.turnId, existing.state.spawn.toolUseId)
-                : '';
-        const observedAt = now();
-        const next = update(binding, key, (current) => {
-            const base = current ?? Object.freeze({
-                schemaVersion: 2,
-                revision: 0,
-                taskBinding: binding,
-                state: createCodexLifecycleState(options.cliVersion),
-                consumer: null,
-                consumedAt: null,
-                spawnObservedAt: null,
-                updatedAt: observedAt
-            });
-            assertCurrentCanApply(base, binding);
-            const state = reduceCodexLifecycleEvent(base.state, event);
-            if (state === base.state)
-                return base;
-            if (state.status === 'invalid' && state.error && NON_PERSISTENT_FAILURES.has(state.error.code)) {
-                throw new Error(`${state.error.code}: ${state.error.message}`);
-            }
-            return Object.freeze({
-                ...base,
-                revision: base.revision + 1,
-                state,
-                spawnObservedAt: event.type === 'hook-spawn' && base.revision === 0 ? observedAt : base.spawnObservedAt,
-                updatedAt: observedAt
-            });
-        });
-        return Object.freeze({ path: lifecyclePath(taskDir), revision: next.revision, state: next.state });
-    }
-    function applyToSpawn(identity, event, expectedRevision) {
-        const key = recordKey(identity.sessionId, identity.turnId, identity.toolUseId);
-        const current = allRecords(taskDir).find((record) => record.state.spawn
-            && recordKey(record.state.spawn.sessionId, record.state.spawn.turnId, record.state.spawn.toolUseId) === key);
-        if (!current)
-            throw new Error('Codex lifecycle spawn identity was not found');
-        const next = update(identity.taskBinding, key, (latest) => {
-            if (!latest || JSON.stringify(latest.taskBinding) !== JSON.stringify(identity.taskBinding)) {
-                throw new Error('Codex lifecycle task binding does not match the stored spawn');
-            }
-            if (latest.revision !== expectedRevision) {
-                throw new Error(`Codex lifecycle revision changed from ${expectedRevision} to ${latest.revision}`);
-            }
-            if (latest.consumer)
-                throw new Error(`Codex lifecycle evidence was already consumed by '${latest.consumer}'`);
-            if (latest.state.spawn?.sessionId !== identity.sessionId
-                || latest.state.spawn.turnId !== identity.turnId
-                || latest.state.spawn.toolUseId !== identity.toolUseId
-                || latest.state.spawn.nativeAgent !== event.nativeAgent
-                || event.sessionId !== identity.sessionId
-                || event.parentThreadId !== identity.sessionId) {
-                throw new Error('Codex lifecycle spawn identity does not match the stored event');
-            }
-            const state = reduceCodexLifecycleEvent(latest.state, event);
-            if (state.status === 'invalid' && state.error && NON_PERSISTENT_FAILURES.has(state.error.code)) {
-                throw new Error(`${state.error.code}: ${state.error.message}`);
-            }
-            return state === latest.state ? latest : Object.freeze({ ...latest, revision: latest.revision + 1, state, updatedAt: now() });
-        });
-        return Object.freeze({ path: lifecyclePath(taskDir), revision: next.revision, state: next.state });
-    }
-    function findByParent(parentThreadId) {
-        const matches = allRecords(taskDir).filter((record) => record.state.startEvidence?.parentThreadId === parentThreadId
-            && ['start-ready', 'observed-terminal', 'stop-ready'].includes(record.state.status));
-        const unconsumed = matches.filter((record) => !record.consumer);
-        if (unconsumed.length > 1)
-            throw new Error(`Codex lifecycle parent '${parentThreadId}' has ambiguous active children`);
-        return Object.freeze(unconsumed.length === 1 ? unconsumed : matches.filter((record) => record.consumer));
-    }
-    function findByTaskBinding(binding) {
-        return Object.freeze(allRecords(taskDir).filter((record) => record.taskBinding?.runId === binding.runId
-            && record.taskBinding.receiptId === binding.receiptId));
-    }
-    function read(childThreadId) {
-        const matches = findByChild(childThreadId);
-        if (matches.length !== 1)
-            throw new Error(`Codex lifecycle child '${childThreadId}' was not found uniquely`);
-        return matches[0];
-    }
-    function consume(childThreadId, consumer, expectedHookDefinitionHash, expectedTaskBinding) {
-        if (!consumer.trim())
-            throw new Error('Codex lifecycle consumer is required');
-        const current = read(childThreadId);
-        const binding = expectedTaskBinding ?? current.taskBinding;
-        if (!binding)
-            throw new Error('Codex lifecycle task receipt binding is missing');
-        const spawn = current.state.spawn;
-        if (!spawn)
-            throw new Error('Codex lifecycle spawn evidence is missing');
-        const key = recordKey(spawn.sessionId, spawn.turnId, spawn.toolUseId);
-        return update(binding, key, (latest) => {
-            if (!latest || expectedTaskBinding && JSON.stringify(latest.taskBinding) !== JSON.stringify(expectedTaskBinding)) {
-                throw new Error('Codex lifecycle task binding does not match the expected receipt');
-            }
-            if (latest.consumer && latest.consumer !== consumer) {
-                throw new Error(`Codex lifecycle evidence was already consumed by '${latest.consumer}'`);
-            }
-            if (latest.state.status !== 'stop-ready')
-                throw new Error('Codex lifecycle evidence is not stop-ready');
-            if (expectedHookDefinitionHash && latest.state.startEvidence?.hookDefinitionHash !== expectedHookDefinitionHash) {
-                throw new Error('Codex lifecycle hook definition hash is stale');
-            }
-            if (latest.consumer)
-                return latest;
-            return Object.freeze({ ...latest, revision: latest.revision + 1, consumer, consumedAt: now(), updatedAt: now() });
-        });
-    }
-    function expireBefore(cutoff) {
-        let changed = 0;
-        for (const record of allRecords(taskDir)) {
-            if (record.updatedAt >= cutoff || !record.taskBinding?.receiptId || !record.state.spawn)
-                continue;
-            const key = recordKey(record.state.spawn.sessionId, record.state.spawn.turnId, record.state.spawn.toolUseId);
-            update(record.taskBinding, key, (latest) => {
-                if (!latest || latest.updatedAt >= cutoff || latest.consumer
-                    || ['invalid', 'expired', 'stop-ready'].includes(latest.state.status))
-                    return latest ?? record;
-                const state = expireCodexLifecycleState(latest.state);
-                if (state === latest.state)
-                    return latest;
-                changed += 1;
-                return Object.freeze({ ...latest, revision: latest.revision + 1, state, updatedAt: now() });
-            });
-        }
-        return changed;
-    }
-    return Object.freeze({ taskId: options.taskId, root: path.join(taskDir, '.runtime'), apply, applyToSpawn, consume, expireBefore, findByParent, findByTaskBinding, read });
-}
-export { createCodexLifecycleStore, hasActiveCodexLifecycleEvidence, readCodexLifecycleActivationEvidence };
-//# sourceMappingURL=store.js.map