@fitlab-ai/agent-infra 0.9.6 → 0.9.7

package/dist/lib/task/artifact-receipts.js

@@ -0,0 +1,128 @@
+import fs from 'node:fs';
+import { createHash } from 'node:crypto';
+import { extractSection, findSectionHeading, parseTable } from './sections.js';
+const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'];
+const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'];
+const RECEIPT_EVENTS = new Set([
+    'review-analysis.completed',
+    'review-plan.completed',
+    'review-code.completed',
+    'code.completed'
+]);
+const SHA256_RE = /^[a-f0-9]{64}$/;
+const ARTIFACT_NAME_RE = /^(analysis|review-analysis|plan|review-plan|code|review-code|manual-validation|validation-run|pr-review)(?:-r([2-9]|[1-9]\d+))?\.md$/;
+const RECEIPT_SHAPES = {
+    'review-analysis.completed': { output: 'review-analysis', input: 'analysis' },
+    'review-plan.completed': { output: 'review-plan', input: 'plan' },
+    'review-code.completed': { output: 'review-code', input: 'code' },
+    'code.completed': { output: 'code', input: 'plan' }
+};
+class ArtifactReceiptError extends Error {
+    code = 'ARTIFACT_RECEIPT_INVALID';
+    constructor(message) {
+        super(message);
+        this.name = 'ArtifactReceiptError';
+    }
+}
+function sha256Bytes(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function sha256File(filePath) {
+    return sha256Bytes(fs.readFileSync(filePath));
+}
+function parseReceiptArtifactName(name) {
+    const match = ARTIFACT_NAME_RE.exec(name);
+    if (!match)
+        return null;
+    const roundText = match[2];
+    if (roundText !== undefined) {
+        const round = Number(roundText);
+        if (!Number.isSafeInteger(round) || String(round) !== roundText)
+            return null;
+    }
+    return { family: match[1] };
+}
+function validateReceiptShape(event, output, input) {
+    const outputIdentity = parseReceiptArtifactName(output);
+    const inputIdentity = parseReceiptArtifactName(input);
+    if (!outputIdentity || !inputIdentity)
+        throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
+    const shape = RECEIPT_SHAPES[event];
+    if (outputIdentity.family !== shape.output || inputIdentity.family !== shape.input) {
+        throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
+    }
+}
+function parseArtifactReceipts(content) {
+    const section = extractSection(content, [...RECEIPT_SECTION_ALIASES]);
+    if (!section)
+        return { present: false, rows: [] };
+    let table;
+    try {
+        table = parseTable(content, {
+            sectionAliases: [...RECEIPT_SECTION_ALIASES],
+            columns: [...RECEIPT_COLUMNS],
+            keyColumn: 'output'
+        });
+    }
+    catch (error) {
+        throw new ArtifactReceiptError(error instanceof Error ? error.message : String(error));
+    }
+    if (!table)
+        throw new ArtifactReceiptError('receipt section has no receipt table');
+    const rows = table.rows.map((row) => {
+        const event = row.values.event ?? '';
+        const output = row.values.output ?? '';
+        const input = row.values.input ?? '';
+        const inputSha256 = row.values.input_sha256 ?? '';
+        const completedAt = row.values.completed_at ?? '';
+        if (!RECEIPT_EVENTS.has(event))
+            throw new ArtifactReceiptError(`unknown receipt event '${event}'`);
+        if (!output || !input)
+            throw new ArtifactReceiptError('receipt output and input are required');
+        validateReceiptShape(event, output, input);
+        if (!SHA256_RE.test(inputSha256))
+            throw new ArtifactReceiptError(`receipt digest for '${output}' is invalid`);
+        if (!completedAt || Number.isNaN(Date.parse(completedAt.replace(' ', 'T')))) {
+            throw new ArtifactReceiptError(`receipt completion time for '${output}' is invalid`);
+        }
+        return {
+            event: event,
+            output,
+            input,
+            inputSha256,
+            completedAt
+        };
+    });
+    return { present: true, rows };
+}
+function receiptForOutput(content, output) {
+    const parsed = parseArtifactReceipts(content);
+    return parsed.rows.find((row) => row.output === output) ?? null;
+}
+function upsertArtifactReceipt(content, receipt) {
+    if (!RECEIPT_EVENTS.has(receipt.event))
+        throw new ArtifactReceiptError(`unknown receipt event '${receipt.event}'`);
+    if (!receipt.output || !receipt.input)
+        throw new ArtifactReceiptError('receipt output and input are required');
+    validateReceiptShape(receipt.event, receipt.output, receipt.input);
+    if (!SHA256_RE.test(receipt.inputSha256))
+        throw new ArtifactReceiptError(`receipt digest for '${receipt.output}' is invalid`);
+    if (!receipt.completedAt || Number.isNaN(Date.parse(receipt.completedAt.replace(' ', 'T')))) {
+        throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
+    }
+    const existing = parseArtifactReceipts(content).rows;
+    const previous = existing.find((row) => row.output === receipt.output);
+    if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) {
+        throw new ArtifactReceiptError(`receipt for '${receipt.output}' already exists with different evidence`);
+    }
+    const rows = previous ? existing : [...existing, receipt];
+    const heading = findSectionHeading(content, [...RECEIPT_SECTION_ALIASES]);
+    const body = [
+        `| ${RECEIPT_COLUMNS.join(' | ')} |`,
+        `| ${RECEIPT_COLUMNS.map(() => '---').join(' | ')} |`,
+        ...rows.map((row) => `| ${row.event} | ${row.output} | ${row.input} | ${row.inputSha256} | ${row.completedAt} |`)
+    ].join('\n');
+    return { aliases: [...RECEIPT_SECTION_ALIASES], heading, body };
+}
+export { ArtifactReceiptError, RECEIPT_SECTION_ALIASES, parseArtifactReceipts, receiptForOutput, sha256Bytes, sha256File, upsertArtifactReceipt };
+//# sourceMappingURL=artifact-receipts.js.map

package/dist/lib/task/codex-orchestration.js

@@ -1,6 +1,11 @@
+import fs from 'node:fs';
 import { preflightCodexLifecycleEvidence, resolveCodexSpawnedChild, resolveCodexTerminal, resolveCodexThread } from '../agent-clients/adapters/codex-lifecycle/app-server.js';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.js';
-import { activateMatchingOrchestrationDelegation, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
+import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.js';
+import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.js';
+import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.js';
+import { resolveTaskRef } from './resolve-ref.js';
+import { activateMatchingOrchestrationDelegation, hasActivatableOrchestrationDelegation, hasSealableOrchestrationDelegation, pauseMatchingOrchestrationDelegation, prepareOrchestrationDelegation, reconcileMatchingOrchestrationDelegation, sealMatchingOrchestrationDelegationWithHostEvidence } from './orchestration.js';
 function coreOptions(options) {
     return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
@@ -21,19 +26,61 @@ function requiredStore(options) {
         throw new Error('Codex lifecycle store is required for orchestration bridge events');
     return options.store;
 }
+function controllerContext(taskId, repoRoot) {
+    const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+    return contextPath
+        ? verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot })
+        : null;
+}
 async function prepareCodexOrchestrationDelegation(taskRef, input, options = {}) {
     if (input.client !== 'codex')
         return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
     try {
-        await (options.preflight ?? preflightCodexLifecycleEvidence)(options.repoRoot ?? process.cwd());
+        const repoRoot = options.repoRoot ?? process.cwd();
+        const resolved = resolveTaskRef(taskRef, { repoRoot });
+        if (!resolved.ok)
+            return bridgeFailure(resolved.code, resolved.message);
+        const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot);
+        if (!input.capabilityToken) {
+            return bridgeFailure('ORCHESTRATION_CODEX_CAPABILITY_REQUIRED', 'Codex prepare requires a current-session capability token');
+        }
+        const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+        const controller = controllerContext(resolved.taskId, repoRoot);
+        const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
+        const consumed = capabilityStore.consume(input.capabilityToken, {
+            taskId: resolved.taskId,
+            hookDefinitionHash: preflight.hookDefinitionHash,
+            buildIdentity,
+            ...(controller ? { controller: {
+                    instanceDigest: controller.controllerInstanceDigest,
+                    controlGeneration: controller.controlGeneration
+                } } : {})
+        });
+        return prepareOrchestrationDelegation(taskRef, {
+            ...input,
+            lifecycleProvenance: {
+                ...consumed.buildIdentity,
+                hookDefinitionHash: preflight.hookDefinitionHash,
+                ...preflight.hookProvenance,
+                capabilitySessionId: consumed.sessionId,
+                capabilityTurnId: consumed.turnId,
+                capabilityToolUseId: consumed.toolUseId,
+                controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+                controlGeneration: controller?.controlGeneration ?? null
+            }
+        }, coreOptions(options));
     }
     catch (error) {
-        return bridgeFailure('ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
+        return bridgeFailure(error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
+            ? error.name
+            : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED', error instanceof Error ? error.message : String(error));
     }
-    return prepareOrchestrationDelegation(taskRef, input, coreOptions(options));
 }
 async function activateCodexOrchestrationDelegation(childThreadId, options = {}) {
     try {
+        if (!hasActivatableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+            return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+        }
         const store = requiredStore(options);
         const resolved = await (options.resolveThread ?? resolveCodexThread)(childThreadId);
         store.apply(resolved.resolution.thread);
@@ -45,6 +92,23 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
         if (record.state.status !== 'start-ready' || !evidence) {
             return pauseBridge('ORCHESTRATION_CODEX_START_EVIDENCE_INVALID', 'Codex lifecycle start evidence is not ready', options);
         }
+        const repoRoot = options.repoRoot ?? process.cwd();
+        const preflight = await (options.preflight ?? preflightCodexLifecycleEvidence)(repoRoot, {
+            sessionId: evidence.parentThreadId,
+            turnId: evidence.parentTurnId,
+            toolUseId: evidence.spawnToolUseId
+        });
+        const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
+        const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+        const contextTaskId = contextPath
+            ? JSON.parse(fs.readFileSync(contextPath, 'utf8')).taskId
+            : null;
+        if (contextPath && typeof contextTaskId !== 'string') {
+            throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
+        }
+        const controller = contextPath
+            ? verifyCodexSandboxControllerContext(contextPath, contextTaskId, { repoRoot })
+            : null;
         return activateMatchingOrchestrationDelegation('codex', {
             nativeAgent: evidence.nativeAgent,
             childId: evidence.childThreadId,
@@ -57,9 +121,17 @@ async function activateCodexOrchestrationDelegation(childThreadId, options = {})
                 ? { reasoningEffortFallbackReason: evidence.reasoningEffortFallbackReason }
                 : {}),
             hostEvidence: {
-                kind: 'codex-lifecycle-v1',
+                kind: 'codex-lifecycle-v2',
                 hookDefinitionHash: evidence.hookDefinitionHash,
-                startRevision: record.revision
+                startRevision: record.revision,
+                ...buildIdentity,
+                ...preflight.hookProvenance,
+                capabilitySessionId: evidence.parentThreadId,
+                capabilityTurnId: evidence.parentTurnId,
+                spawnToolUseId: evidence.spawnToolUseId,
+                spawnObservedAt: record.spawnObservedAt ?? undefined,
+                controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
+                controlGeneration: controller?.controlGeneration ?? null
             }
         }, coreOptions(options));
     }
@@ -93,6 +165,9 @@ async function activateCodexSpawnDelegation(spawn, options = {}) {
 }
 async function sealCodexOrchestrationDelegation(childThreadId, options = {}) {
     try {
+        if (!hasSealableOrchestrationDelegation('codex', childThreadId, coreOptions(options))) {
+            return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'No matching Codex delegation is active');
+        }
         const store = requiredStore(options);
         const existing = store.read(childThreadId);
         if (!existing.consumer) {

package/dist/lib/task/commands/validate.js

@@ -168,7 +168,7 @@ function inplaceValidation(config, target, options) {
     const nonce = randomUUID();
     const issuedAt = Date.now();
     const lease = {
-        version: 1, generation: manifest.generation, nonce,
+        version: 2, generation: manifest.generation, nonce,
         owner: { pid: process.pid, startTime }, issuedAt,
         expiresAt: issuedAt + Math.min(options.timeoutMs + RECOVERY_GRACE_MS, MAX_TIMEOUT_MS + RECOVERY_GRACE_MS),
         taskId: target.workspace.mode === 'task-bound' ? target.workspace.taskId : null,

package/dist/lib/task/create.js

@@ -181,6 +181,13 @@ function assertRealDirectory(directory, code) {
     if (!stat.isDirectory() || stat.isSymbolicLink())
         throw new Error(code);
 }
+function ensureRealDirectory(directory, code) {
+    if (fs.existsSync(directory)) {
+        assertRealDirectory(directory, code);
+        return;
+    }
+    fs.mkdirSync(directory, { mode: 0o700 });
+}
 function withCreateLock(repoRoot, workspaceRoot, operation) {
     const lockRoot = path.join(workspaceRoot, '.task-create.lock');
     fs.mkdirSync(lockRoot, { recursive: true, mode: 0o700 });
@@ -254,8 +261,9 @@ function createLocalTask(value, options) {
     const repoRoot = fs.realpathSync.native(options.repoRoot);
     const workspaceRoot = path.join(repoRoot, '.agents', 'workspace');
     const activeRoot = path.join(workspaceRoot, 'active');
-    assertRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
-    assertRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+    ensureRealDirectory(path.join(repoRoot, '.agents'), 'TASK_CREATE_WORKSPACE_INVALID');
+    ensureRealDirectory(workspaceRoot, 'TASK_CREATE_WORKSPACE_INVALID');
+    ensureRealDirectory(activeRoot, 'TASK_CREATE_WORKSPACE_INVALID');
     const project = readProject(repoRoot);
     const canonical = canonicalTaskCreateCandidate(candidate);
     const candidateDigest = sha256(canonical);

package/dist/lib/task/delegation-receipts.js

@@ -11,6 +11,7 @@ function fail(code, message) {
     return { ok: false, code, message };
 }
 function prepareDelegation(input, options = {}) {
+    const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
     return Object.freeze({
         ...input,
         id: (options.id ?? randomUUID)(),
@@ -27,17 +28,55 @@ function prepareDelegation(input, options = {}) {
         afterFingerprint: null,
         changedPaths: Object.freeze([]),
         createdAt: (options.now ?? (() => new Date().toISOString()))(),
+        preparedMonotonicMs: monotonic,
+        spawnDispatchMonotonicMs: null,
+        activationDeadlineMonotonicMs: null,
+        spawnDispatchedAt: null,
+        activationDeadlineAt: null,
+        startEvidenceMonotonicMs: null,
+        activatedMonotonicMs: null,
         activatedAt: null,
         sealedAt: null,
         consumedAt: null
     });
 }
+function dispatchDelegation(receipt, options = {}) {
+    if (receipt.status !== 'prepared') {
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    }
+    if (receipt.spawnDispatchMonotonicMs != null || receipt.spawnDispatchedAt != null) {
+        return fail('DELEGATION_DISPATCH_REPLAY', `delegation ${receipt.id} was already dispatched`);
+    }
+    const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
+    const dispatchedAt = (options.now ?? (() => new Date().toISOString()))();
+    const window = options.activationWindowMs ?? 15_000;
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            spawnDispatchMonotonicMs: monotonic,
+            activationDeadlineMonotonicMs: monotonic + window,
+            spawnDispatchedAt: dispatchedAt,
+            activationDeadlineAt: new Date(Date.parse(dispatchedAt) + window).toISOString()
+        }) };
+}
 function activateDelegation(receipt, event, options = {}) {
     const managedRole = managedDelegationRole(event.nativeAgent);
     if (!managedRole)
         return fail('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
     if (receipt.status !== 'prepared')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    if (receipt.spawnDispatchMonotonicMs == null
+        || receipt.spawnDispatchedAt == null
+        || receipt.activationDeadlineAt == null
+        || receipt.activationDeadlineMonotonicMs == null
+        || !Number.isFinite(Date.parse(receipt.spawnDispatchedAt))
+        || !Number.isFinite(Date.parse(receipt.activationDeadlineAt))) {
+        return fail('DELEGATION_NOT_DISPATCHED', `delegation ${receipt.id} has not reached the native spawn dispatch boundary`);
+    }
+    const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
+    const wallNow = Date.parse((options.now ?? (() => new Date().toISOString()))());
+    if (wallNow > Date.parse(receipt.activationDeadlineAt)) {
+        return fail('DELEGATION_ACTIVATION_TIMEOUT', `delegation ${receipt.id} activation evidence arrived after its deadline`);
+    }
     if (managedRole !== receipt.role)
         return fail('DELEGATION_ROLE_MISMATCH', `managed role ${managedRole} does not match ${receipt.role}`);
     if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
@@ -56,6 +95,9 @@ function activateDelegation(receipt, event, options = {}) {
     if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
         return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
     }
+    if (receipt.client === 'codex'
+        && event.hostEvidence?.kind !== 'codex-lifecycle-v2')
+        return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex activation requires trusted lifecycle-v2 host evidence');
     if (actualReasoningEffort !== receipt.requestedReasoningEffort
         && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
         return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
@@ -72,6 +114,32 @@ function activateDelegation(receipt, event, options = {}) {
             || !Number.isSafeInteger(event.hostEvidence.startRevision)
             || event.hostEvidence.startRevision < 1))
         return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence reference is invalid');
+    if (event.hostEvidence?.kind === 'codex-lifecycle-v2') {
+        const expected = receipt.lifecycleProvenance;
+        const spawnObservedAt = Date.parse(event.hostEvidence.spawnObservedAt ?? '');
+        const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt);
+        const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt);
+        if (!expected
+            || event.hostEvidence.protocolVersion !== expected.protocolVersion
+            || event.hostEvidence.packageVersion !== expected.packageVersion
+            || event.hostEvidence.internalExecutableBuildHash !== expected.internalExecutableBuildHash
+            || event.hostEvidence.lifecycleContractHash !== expected.lifecycleContractHash
+            || event.hostEvidence.hookDefinitionHash !== expected.hookDefinitionHash
+            || event.hostEvidence.hookSource !== expected.hookSource
+            || event.hostEvidence.hookSourcePathDigest !== expected.hookSourcePathDigest
+            || event.hostEvidence.hookSourceHash !== expected.hookSourceHash
+            || event.hostEvidence.capabilitySessionId !== expected.capabilitySessionId
+            || event.hostEvidence.capabilityTurnId !== expected.capabilityTurnId
+            || !event.hostEvidence.spawnToolUseId?.trim()
+            || event.hostEvidence.spawnToolUseId === expected.capabilityToolUseId
+            || !Number.isFinite(spawnObservedAt)
+            || spawnObservedAt < spawnDispatchedAt
+            || spawnObservedAt > activationDeadlineAt
+            || event.parentId !== expected.capabilitySessionId
+            || (event.hostEvidence.controllerInstanceDigest ?? null) !== expected.controllerInstanceDigest
+            || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration)
+            return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex lifecycle provenance does not match the prepared receipt');
+    }
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             status: 'activated',
@@ -88,9 +156,20 @@ function activateDelegation(receipt, event, options = {}) {
                 consumer: null,
                 consumedAt: null
             }) : receipt.hostEvidence ?? null,
-            activatedAt: (options.now ?? (() => new Date().toISOString()))()
+            startEvidenceMonotonicMs: monotonic,
+            activatedMonotonicMs: (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))(),
+            activatedAt: new Date(wallNow).toISOString()
         }) };
 }
+function abortPreparedDelegation(receipt) {
+    if (receipt.status !== 'prepared') {
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    }
+    return {
+        ok: true,
+        receipt: Object.freeze({ ...receipt, status: 'aborted' })
+    };
+}
 function completeDelegationStage(receipt, event) {
     if (receipt.status !== 'activated')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
@@ -105,6 +184,9 @@ function completeDelegationStage(receipt, event) {
 function sealDelegation(receipt, event, options = {}) {
     if (receipt.status !== 'stage-completed')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+    if (receipt.client === 'codex' && options.requireHostEvidence !== false && !event.hostEvidence) {
+        return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex sealing requires consumed lifecycle-v2 host evidence');
+    }
     if (event.childId !== receipt.childId || event.exitCode !== 0)
         return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
     if (receipt.role === 'reviewer') {
@@ -149,5 +231,5 @@ function consumeDelegation(receipt, options = {}) {
             consumedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }
-export { activateDelegation, completeDelegationStage, consumeDelegation, managedDelegationRole, prepareDelegation, sealDelegation };
+export { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, managedDelegationRole, prepareDelegation, sealDelegation };
 //# sourceMappingURL=delegation-receipts.js.map

package/dist/lib/task/events.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { appendActivityEntry, locateActivityLog, pairEntries } from './activity-log.js';
-import { buildArtifactLinkSection, artifactName, parseArtifactName, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { buildArtifactLinkSection, artifactName, inspectArtifactDirectory, parseReviewedInputReference, parseCodePlanInputReference, parseArtifactName, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { ArtifactReceiptError, sha256File, upsertArtifactReceipt } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { consumeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
 import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
@@ -237,6 +238,92 @@ function openStartedIdentity(rows, family) {
     });
     return matches.length === 1 ? matches[0] : matches.length > 1 ? { conflict: true } : null;
 }
+function reviewInputFamily(family) {
+    return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
+}
+function buildCompletionReceipt(taskDir, family, artifact, completedAt, frontmatter) {
+    if (family === 'code') {
+        let content;
+        try {
+            content = fs.readFileSync(artifact.path, 'utf8');
+        }
+        catch (error) {
+            return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` };
+        }
+        const input = parseCodePlanInputReference(content);
+        if (!input)
+            return { ok: false, message: `${artifact.name} does not reference a canonical plan artifact` };
+        const startedInput = typeof frontmatter.code_input_artifact === 'string' ? frontmatter.code_input_artifact : '';
+        const startedSha256 = typeof frontmatter.code_input_sha256 === 'string' ? frontmatter.code_input_sha256 : '';
+        if (!startedInput || !startedSha256)
+            return { ok: false, message: 'code.started plan input context is missing' };
+        if (input.name !== startedInput)
+            return { ok: false, message: `${artifact.name} plan input '${input.name}' does not match code.started input '${startedInput}'` };
+        const plan = inspectArtifactDirectory(taskDir, 'plan');
+        if (plan.status !== 'ready' || !plan.latest || plan.latest.name !== input.name) {
+            return { ok: false, message: `code input '${input.name}' is not the latest plan artifact` };
+        }
+        try {
+            const inputSha256 = sha256File(plan.latest.path);
+            if (inputSha256 !== startedSha256)
+                return { ok: false, message: `code input ${input.name} changed after code.started` };
+            return {
+                ok: true,
+                receipt: {
+                    event: 'code.completed', output: artifact.name, input: input.name,
+                    inputSha256, completedAt
+                }
+            };
+        }
+        catch (error) {
+            return { ok: false, message: `cannot hash code input plan: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    if (!family.startsWith('review-'))
+        return null;
+    const expectedFamily = reviewInputFamily(family);
+    let content;
+    try {
+        content = fs.readFileSync(artifact.path, 'utf8');
+    }
+    catch (error) {
+        return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` };
+    }
+    const input = parseReviewedInputReference(content, expectedFamily);
+    if (!input)
+        return { ok: false, message: `${artifact.name} does not reference a canonical ${expectedFamily} artifact` };
+    const startedInput = typeof frontmatter.review_input_artifact === 'string' ? frontmatter.review_input_artifact : '';
+    const startedSha256 = typeof frontmatter.review_input_sha256 === 'string' ? frontmatter.review_input_sha256 : '';
+    if (!startedInput || !startedSha256)
+        return { ok: false, message: 'review started input context is missing' };
+    if (input.name !== startedInput)
+        return { ok: false, message: `${artifact.name} input '${input.name}' does not match review.started input '${startedInput}'` };
+    const current = inspectArtifactDirectory(taskDir, expectedFamily);
+    if (current.status !== 'ready' || !current.latest || current.latest.name !== input.name) {
+        return { ok: false, message: `review input '${input.name}' is not the latest ${expectedFamily} artifact` };
+    }
+    const event = family === 'review-analysis'
+        ? 'review-analysis.completed'
+        : family === 'review-plan' ? 'review-plan.completed' : 'review-code.completed';
+    try {
+        const stat = fs.lstatSync(current.latest.path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error('review input is not a regular file');
+        const inputSha256 = sha256File(current.latest.path);
+        if (inputSha256 !== startedSha256)
+            return { ok: false, message: `review input ${input.name} changed after review.started` };
+        return {
+            ok: true,
+            receipt: {
+                event, output: artifact.name, input: input.name,
+                inputSha256, completedAt
+            }
+        };
+    }
+    catch (error) {
+        return { ok: false, message: `cannot hash review input ${input.name}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
 function applyTaskEventUnlocked(request, options = {}) {
     const invalid = validateTaskEventRequest(request);
     if (invalid)
@@ -363,19 +450,69 @@ function applyTaskEventUnlocked(request, options = {}) {
     catch (error) {
         return failed(normalized, { code: 'METADATA_CAPTURE_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     }
+    let completionReceipt = null;
+    if (eventIdentity.phase === 'completed' && completedArtifact) {
+        const receipt = buildCompletionReceipt(resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter);
+        if (receipt && !receipt.ok) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: receipt.message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        }
+        completionReceipt = receipt?.receipt ?? null;
+    }
     const step = eventIdentity.phase === 'started' || eventIdentity.target === null ? currentStep : eventIdentity.target;
     const logStep = eventIdentity.phase === 'started' ? `${eventIdentity.action} [started]` : eventIdentity.action;
     const body = appendActivityEntry(section, { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
     const frontmatterSet = { current_step: step, assigned_to: normalized.agent };
+    let frontmatterRemove;
+    if (eventIdentity.phase === 'started' && eventIdentity.family === 'code') {
+        const planInput = artifactContext?.inputs.find((input) => input.family === 'plan');
+        if (!planInput)
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'code.started plan input context is unavailable' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        try {
+            frontmatterSet.code_input_artifact = planInput.name;
+            frontmatterSet.code_input_sha256 = sha256File(planInput.path);
+        }
+        catch (error) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot hash code.started plan input: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        }
+    }
+    else if (eventIdentity.phase === 'completed' && eventIdentity.family === 'code') {
+        frontmatterRemove = ['code_input_artifact', 'code_input_sha256'];
+    }
+    else if (eventIdentity.phase === 'started' && eventIdentity.family.startsWith('review-')) {
+        const expectedFamily = reviewInputFamily(eventIdentity.family);
+        const input = artifactContext?.inputs.find((candidate) => candidate.family === expectedFamily);
+        if (!input)
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `review.started ${expectedFamily} input context is unavailable` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        try {
+            frontmatterSet.review_input_artifact = input.name;
+            frontmatterSet.review_input_sha256 = sha256File(input.path);
+        }
+        catch (error) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot hash review.started input: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        }
+    }
+    else if (eventIdentity.phase === 'completed' && eventIdentity.family.startsWith('review-')) {
+        frontmatterRemove = ['review_input_artifact', 'review_input_sha256'];
+    }
     if (eventIdentity.phase === 'started' && normalized.implementationInput)
         frontmatterSet.last_reviewed_commit = '';
     const mutations = [
-        { kind: 'frontmatter', set: frontmatterSet }
+        { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove }
     ];
     if (completedArtifact) {
         const link = buildArtifactLinkSection(content, completedArtifact);
         mutations.push({ kind: 'section', aliases: link.aliases, heading: link.heading, body: link.body });
     }
+    if (completionReceipt) {
+        try {
+            const receiptSection = upsertArtifactReceipt(content, completionReceipt);
+            mutations.push({ kind: 'section', aliases: receiptSection.aliases, heading: receiptSection.heading, body: receiptSection.body });
+        }
+        catch (error) {
+            const message = error instanceof ArtifactReceiptError ? error.message : String(error);
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        }
+    }
     if (eventIdentity.phase === 'completed' && normalized.implementationInput) {
         let implementationRows;
         try {

package/dist/lib/task/ledger.js

@@ -31,8 +31,20 @@ function validateLedgerRows(rows) {
         if (seen.has(row.id))
             return { code: 'LEDGER_DUPLICATE_ID', message: `duplicate ledger id '${row.id}'` };
         seen.add(row.id);
-        if (/^PRC-[1-9]\d*$/.test(row.id))
+        if (/^PRC-[1-9]\d*$/.test(row.id)) {
+            if (row.stage !== 'post-review-commit' ||
+                row.round !== '-' ||
+                row.severity !== '-' ||
+                row.status !== 'human-decided' ||
+                row.evidence === '' ||
+                /[\r\n]/.test(row.evidence)) {
+                return { code: 'LEDGER_DOCUMENT_INVALID', message: `post-review exemption row '${row.id}' is invalid` };
+            }
             continue;
+        }
+        if (row.stage === 'post-review-commit') {
+            return { code: 'LEDGER_DOCUMENT_INVALID', message: `post-review exemption row '${row.id}' must use a PRC id` };
+        }
         if (!/^(AN|PL|CD|HD)-[1-9]\d*$/.test(row.id))
             return { code: 'LEDGER_ID_INVALID', message: `ledger id '${row.id}' is invalid` };
         if (!['analysis', 'plan', 'code', 'post-review-commit'].includes(row.stage))