@fitlab-ai/agent-infra 0.9.5 → 0.9.7

package/dist/lib/task/commit-finalization.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { locateActivityLog, appendActivityEntry, pairEntries, parseCommitAttemptStarted } from './activity-log.js';
 import { commitIntentPath, digest, readCommitIntent } from './commit-intent.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
-import { parseReviewSummary } from './review-artifacts.js';
+import { artifactName, maxRound, parseReviewSummary } from './review-artifacts.js';
 import { extractReviewBaseline, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, parseReviewedGitTree } from './review-fingerprint.js';
 const SHA_RE = /^[a-f0-9]{40,64}$/;
 function git(repoRoot, args) {
@@ -26,6 +26,22 @@ function isAncestor(repoRoot, ancestor, descendant) {
         stdio: 'ignore'
     }).status === 0;
 }
+function hasMatchingApprovedReview(taskDir, beforeRound, baseline, tree) {
+    const entries = fs.readdirSync(taskDir);
+    for (let round = Math.min(beforeRound - 1, maxRound(entries, 'review-code')); round >= 1; round -= 1) {
+        const file = path.join(taskDir, artifactName('review-code', round));
+        if (!fs.existsSync(file))
+            continue;
+        const content = fs.readFileSync(file, 'utf8');
+        const summary = parseReviewSummary(content);
+        if (summary.ok
+            && summary.summary.verdict === 'Approved'
+            && extractReviewBaseline(content) === baseline
+            && extractReviewedSnapshotTree(content) === tree)
+            return true;
+    }
+    return false;
+}
 function outcome(disposition, overrides = {}) {
     return {
         disposition,
@@ -34,6 +50,7 @@ function outcome(disposition, overrides = {}) {
         currentHead: '',
         committedHead: null,
         commitNote: null,
+        activityNote: null,
         needsAnchor: false,
         needsLog: false,
         intent: null,
@@ -130,6 +147,12 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
             message: 'repository HEAD or ancestry conflicts with the commit intent'
         });
     }
+    const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
+    const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
+    const pushOnlyRetry = intent.phase === 'pushed'
+        && intent.baselineHead === intent.committedHead
+        && matchingDone.length === 1
+        && openRows.length === 1;
     const review = findAuthoritativeReviewCodeArtifact(taskDir);
     let needsAnchor = false;
     if (review.ok && review.path) {
@@ -147,7 +170,9 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
             return invalid('authoritative review-code evidence is not a valid approved snapshot', currentHead, 'COMMIT_FINALIZATION_EVIDENCE_INVALID', shared);
         }
         const committedTree = git(repoRoot, ['rev-parse', `${intent.committedHead}^{tree}`]);
-        if (reviewBaseline !== intent.baselineHead || reviewTree !== committedTree) {
+        const matchingCurrentReview = reviewBaseline === intent.baselineHead && reviewTree === committedTree;
+        if (!matchingCurrentReview
+            && !hasMatchingApprovedReview(taskDir, review.round, intent.baselineHead, committedTree)) {
             return outcome('conflict', {
                 ...shared,
                 code: 'COMMIT_FINALIZATION_CONFLICT',
@@ -155,18 +180,16 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
             });
         }
         const anchor = String(metadata.last_reviewed_commit ?? '').trim();
-        if (anchor && anchor !== intent.committedHead) {
+        if (anchor && anchor !== intent.committedHead && anchor !== intent.baselineHead) {
             return outcome('conflict', {
                 ...shared,
                 code: 'COMMIT_FINALIZATION_CONFLICT',
                 message: 'task review anchor conflicts with the committed intent'
             });
         }
-        needsAnchor = anchor === '';
+        needsAnchor = anchor !== intent.committedHead;
     }
-    const commitNote = git(repoRoot, ['show', '-s', '--format=%h%x20%s', intent.committedHead]);
-    const matchingDone = commitRows.filter((row) => row.done !== '' && row.note === commitNote);
-    const needsLog = matchingDone.length === 0 && openRows.length === 1;
+    const needsLog = (matchingDone.length === 0 && openRows.length === 1) || pushOnlyRetry;
     if (!(needsLog || (matchingDone.length === 1 && openRows.length === 0))) {
         return outcome('conflict', {
             ...shared,
@@ -179,12 +202,16 @@ function inspectCommitFinalization(taskDir, repoRoot, taskId) {
         ...shared,
         message: 'commit finalization can be recovered',
         commitNote,
+        activityNote: pushOnlyRetry ? `Pushed ${commitNote}` : commitNote,
         needsAnchor,
         needsLog
     });
 }
 function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
-    if (inspection.disposition !== 'recoverable' || !inspection.committedHead || !inspection.commitNote) {
+    if (inspection.disposition !== 'recoverable'
+        || !inspection.committedHead
+        || !inspection.commitNote
+        || !inspection.activityNote) {
         throw new Error('commit finalization task mutations require a recoverable inspection');
     }
     const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
@@ -207,7 +234,7 @@ function planCommitTaskFinalization(taskDir, inspection, agent, timestamp) {
                 time: timestamp,
                 step: 'Commit',
                 agent,
-                note: inspection.commitNote
+                note: inspection.activityNote
             })
         });
     }

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)(),
@@ -23,20 +24,59 @@ function prepareDelegation(input, options = {}) {
         spawnMode: null,
         agent: null,
         status: 'prepared',
+        hostEvidence: null,
         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) {
@@ -55,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');
@@ -65,6 +108,38 @@ function activateDelegation(receipt, event, options = {}) {
     if (actualReasoningEffort === receipt.requestedReasoningEffort && event.reasoningEffortFallbackReason) {
         return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
     }
+    if (event.hostEvidence
+        && (receipt.client !== 'codex'
+            || !event.hostEvidence.hookDefinitionHash.trim()
+            || !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',
@@ -75,9 +150,26 @@ function activateDelegation(receipt, event, options = {}) {
             actualReasoningEffort,
             modelFallbackReason: event.modelFallbackReason ?? null,
             reasoningEffortFallbackReason: event.reasoningEffortFallbackReason ?? null,
-            activatedAt: (options.now ?? (() => new Date().toISOString()))()
+            hostEvidence: event.hostEvidence ? Object.freeze({
+                ...event.hostEvidence,
+                stopRevision: null,
+                consumer: null,
+                consumedAt: null
+            }) : receipt.hostEvidence ?? null,
+            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`);
@@ -92,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') {
@@ -105,11 +200,23 @@ function sealDelegation(receipt, event, options = {}) {
         if (disallowed)
             return fail('DELEGATION_REVIEWER_WRITE_FORBIDDEN', `reviewer changed forbidden path '${disallowed}'`);
     }
+    if (event.hostEvidence) {
+        if (!receipt.hostEvidence
+            || !Number.isSafeInteger(event.hostEvidence.stopRevision)
+            || event.hostEvidence.stopRevision <= receipt.hostEvidence.startRevision
+            || event.hostEvidence.consumer !== receipt.id
+            || !event.hostEvidence.consumedAt.trim())
+            return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex stop evidence reference is invalid');
+    }
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             status: 'sealed',
             afterFingerprint: event.afterFingerprint,
             changedPaths: Object.freeze([...event.changedPaths]),
+            hostEvidence: event.hostEvidence && receipt.hostEvidence ? Object.freeze({
+                ...receipt.hostEvidence,
+                ...event.hostEvidence
+            }) : receipt.hostEvidence ?? null,
             sealedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }
@@ -124,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';
@@ -18,7 +19,8 @@ const eventCatalog = [
     'review-plan.started', 'review-plan.completed',
     'code.started', 'code.completed',
     'review-code.started', 'review-code.completed',
-    'manual-validation.started', 'manual-validation.completed'
+    'manual-validation.started', 'manual-validation.completed',
+    'validation-run.started', 'validation-run.completed'
 ];
 const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun']);
 const SCHEMAS = {
@@ -36,7 +38,9 @@ const SCHEMAS = {
     'review-code.started': { optional: ['round'] },
     'review-code.completed': { required: ['artifact', 'verdict', 'blockers', 'major', 'minor', 'manualValidation'], optional: ['round', 'orchestrated'] },
     'manual-validation.started': { optional: ['round'] },
-    'manual-validation.completed': { required: ['artifact', 'summaryResult'], optional: ['round'] }
+    'manual-validation.completed': { required: ['artifact', 'summaryResult'], optional: ['round'] },
+    'validation-run.started': { optional: ['round'] },
+    'validation-run.completed': { required: ['artifact'], optional: ['round'] }
 };
 function validateTaskEventRequest(request) {
     if (!eventCatalog.includes(request.event))
@@ -84,7 +88,8 @@ const FAMILY = {
     'review-plan': { artifact: 'review-plan', started: ['technical-design', 'technical-design-review'], completed: ['technical-design', 'technical-design-review'], target: 'technical-design-review', label: 'Review Plan' },
     code: { artifact: 'code', started: ['technical-design-review', 'code-review'], completed: ['technical-design-review', 'code-review'], target: 'code', label: 'Code Task' },
     'review-code': { artifact: 'review-code', started: ['code', 'code-review', 'commit'], completed: ['code', 'code-review', 'commit'], target: 'code-review', label: 'Review Code' },
-    'manual-validation': { artifact: 'manual-validation', started: ['code-review', 'commit'], completed: ['code-review', 'commit'], target: null, label: 'Complete Manual Validation' }
+    'manual-validation': { artifact: 'manual-validation', started: ['code-review', 'commit'], completed: ['code-review', 'commit'], target: null, label: 'Complete Manual Validation' },
+    'validation-run': { artifact: 'validation-run', started: ['code-review', 'commit'], completed: ['code-review', 'commit'], target: null, label: 'Run Manual Validation' }
 };
 const REVIEW_LEDGER_STAGES = {
     'review-analysis': 'analysis',
@@ -180,6 +185,8 @@ function identity(request) {
         note = `Fixed ${request.blockers} blockers, ${request.major} major, ${request.minor} minor issues${request.manualValidation ? `, skipped ${request.manualValidation} manual-validation` : ''} → ${request.artifact}`;
     else if (family === 'code')
         note = `Code implemented, ${request.filesModified} files modified, ${request.testsPassed} tests passed → ${request.artifact}`;
+    else if (family === 'validation-run')
+        note = `Validation evidence recorded → ${request.artifact}`;
     else {
         const verdict = request.verdict === 'approved' ? 'Approved' : request.verdict === 'changes-requested' ? 'Changes Requested' : 'Rejected';
         note = `Verdict: ${verdict}, blockers: ${request.blockers}, major: ${request.major}, minor: ${request.minor}, Manual-validation: ${request.manualValidation} → ${request.artifact}`;
@@ -231,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)
@@ -329,7 +422,7 @@ function applyTaskEventUnlocked(request, options = {}) {
     if (findingCountError)
         return failed(normalized, findingCountError, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     let orchestrationCompletion = null;
-    if (eventIdentity.phase === 'completed' && eventIdentity.family !== 'manual-validation') {
+    if (eventIdentity.phase === 'completed' && eventIdentity.family !== 'manual-validation' && eventIdentity.family !== 'validation-run') {
         const orchestrationStage = eventIdentity.family === 'analyze' ? 'analysis' : eventIdentity.family;
         const execution = validateLifecycleExecution(normalized.taskRef, {
             mode: normalized.orchestrated ? 'orchestrated' : 'standalone',
@@ -357,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/finalization-artifacts.js

@@ -6,7 +6,8 @@ const COMPLETION_BACKFILL_FAMILIES = [
     'review-plan',
     'code',
     'review-code',
-    'manual-validation'
+    'manual-validation',
+    'validation-run'
 ];
 function inspectCompletionArtifacts(taskRef, options = {}) {
     const artifacts = [];

package/dist/lib/task/implementation-inputs.js

@@ -114,14 +114,8 @@ function finalizeImplementationInput(rows, id, decisionEvidence, decidedAt) {
     next.forEach(validateInput);
     return next;
 }
-function selectPendingImplementationInput(rows, reviewCompletedAt) {
-    const reviewEpoch = Date.parse(reviewCompletedAt.replace(' ', 'T'));
-    if (!Number.isFinite(reviewEpoch))
-        throw new Error('latest review completion time is invalid');
+function selectPendingImplementationInput(rows) {
     const pending = rows.filter((row) => row.needsImplementation && row.status === 'pending');
-    const stale = pending.find((row) => Date.parse(row.decidedAt.replace(' ', 'T')) <= reviewEpoch);
-    if (stale)
-        throw new Error(`implementation input ${stale.id} is not later than the latest approved review`);
     return [...pending].sort((left, right) => {
         const time = Date.parse(left.decidedAt.replace(' ', 'T')) - Date.parse(right.decidedAt.replace(' ', 'T'));
         return time || Number.parseInt(left.id.slice(3), 10) - Number.parseInt(right.id.slice(3), 10);

package/dist/lib/task/index.js

@@ -10,6 +10,7 @@ Commands:
   ls [--all | --blocked | --completed]   List tasks (default: active)
   show [--task <ref>]                    Print a task.md
   status [--task <ref>]                  Aggregated status view (metadata / artifacts / git / platform)
+  validate <ref> [options] -- <command>  Run host validation in snapshot or inplace scope
 
 Examples:
   ai task cat 11 analysis
@@ -29,6 +30,7 @@ Examples:
   ai task show 11
   ai task show TASK-20260612-162737
   ai task status 11
+  ai task validate 11 -- npm test
 
 Run 'ai task <command> --help' for details.`;
 export async function runTask(args) {
@@ -89,6 +91,13 @@ export async function runTask(args) {
             status(rest);
             break;
         }
+        case 'validate': {
+            const { validate } = await import('./commands/validate.js');
+            const exitCode = await validate(rest);
+            if (exitCode !== 0)
+                process.exitCode = exitCode;
+            break;
+        }
         default:
             process.stderr.write(`Unknown task command: ${subcommand}\n\n`);
             process.stdout.write(`${USAGE}\n`);

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))