@fitlab-ai/agent-infra 0.9.5 → 0.9.7

package/dist/lib/sandbox/worktree-safety.js

@@ -0,0 +1,196 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { runProbe } from './shell.js';
+function probeText(probe, cwd, args) {
+    const result = probe('git', ['-C', cwd, ...args], { encoding: 'utf8' });
+    if (result.error)
+        throw result.error;
+    if (result.status !== 0) {
+        const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : result.stderr.toString('utf8').trim();
+        throw new Error(stderr || `git ${args[0] ?? 'command'} failed with exit code ${result.status ?? 'unknown'}`);
+    }
+    return typeof result.stdout === 'string' ? result.stdout : result.stdout.toString('utf8');
+}
+function parseStatus(raw) {
+    const records = raw.split('\0');
+    const changes = [];
+    for (let index = 0; index < records.length; index += 1) {
+        const record = records[index] ?? '';
+        if (!record || record.startsWith('# '))
+            continue;
+        if (record.startsWith('? ')) {
+            changes.push({ indexStatus: '?', worktreeStatus: '?', path: record.slice(2) });
+            continue;
+        }
+        if (record.startsWith('1 ')) {
+            const match = /^1 (..) \S+ \S+ \S+ \S+ \S+ \S+ (.*)$/s.exec(record);
+            if (!match)
+                throw new Error('Unable to parse git porcelain v2 ordinary record');
+            changes.push({ indexStatus: match[1][0], worktreeStatus: match[1][1], path: match[2] });
+            continue;
+        }
+        if (record.startsWith('2 ')) {
+            const match = /^2 (..) \S+ \S+ \S+ \S+ \S+ \S+ \S+ (.*)$/s.exec(record);
+            const originalPath = records[++index];
+            if (!match || originalPath === undefined || originalPath === '') {
+                throw new Error('Unable to parse git porcelain v2 rename record');
+            }
+            changes.push({
+                indexStatus: match[1][0],
+                worktreeStatus: match[1][1],
+                path: match[2],
+                originalPath
+            });
+            continue;
+        }
+        if (record.startsWith('u ')) {
+            const match = /^u (..) \S+ \S+ \S+ \S+ \S+ \S+ \S+ \S+ (.*)$/s.exec(record);
+            if (!match)
+                throw new Error('Unable to parse git porcelain v2 unmerged record');
+            changes.push({ indexStatus: match[1][0], worktreeStatus: match[1][1], path: match[2] });
+            continue;
+        }
+        throw new Error(`Unsupported git porcelain v2 record '${record[0] ?? ''}'`);
+    }
+    return changes;
+}
+function updatePart(hash, label, value) {
+    const data = Buffer.isBuffer(value) ? value : Buffer.from(value, 'utf8');
+    hash.update(`${label.length}:${label}:${data.length}:`, 'utf8');
+    hash.update(data);
+}
+function resolveSnapshotPath(worktree, relativePath) {
+    const resolved = path.resolve(worktree, relativePath);
+    const relative = path.relative(worktree, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        throw new Error(`Git reported a path outside the worktree: ${JSON.stringify(relativePath)}`);
+    }
+    return resolved;
+}
+function hashPath(hash, worktree, relativePath, probe) {
+    updatePart(hash, 'path', relativePath);
+    const target = resolveSnapshotPath(worktree, relativePath);
+    let stat;
+    try {
+        stat = fs.lstatSync(target);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            updatePart(hash, 'kind', 'absent');
+            return;
+        }
+        throw error;
+    }
+    updatePart(hash, 'mode', String(stat.mode & 0o7777));
+    if (stat.isFile()) {
+        updatePart(hash, 'kind', 'file');
+        updatePart(hash, 'content', fs.readFileSync(target));
+        return;
+    }
+    if (stat.isSymbolicLink()) {
+        updatePart(hash, 'kind', 'symlink');
+        updatePart(hash, 'target', fs.readlinkSync(target));
+        return;
+    }
+    if (stat.isDirectory()) {
+        updatePart(hash, 'kind', 'git-directory');
+        const nestedHead = probeText(probe, target, ['rev-parse', '--verify', 'HEAD']).trim();
+        const nestedStatus = probeText(probe, target, [
+            'status', '--porcelain=v2', '-z', '--branch', '--untracked-files=all', '--ignore-submodules=none'
+        ]);
+        const nestedIndex = probeText(probe, target, ['ls-files', '--stage', '-z']);
+        updatePart(hash, 'nested-head', nestedHead);
+        updatePart(hash, 'nested-status', nestedStatus);
+        updatePart(hash, 'nested-index', nestedIndex);
+        for (const change of parseStatus(nestedStatus)) {
+            hashPath(hash, target, change.path, probe);
+            if (change.originalPath)
+                hashPath(hash, target, change.originalPath, probe);
+        }
+        return;
+    }
+    throw new Error(`Unsupported file type in dirty snapshot: ${JSON.stringify(relativePath)}`);
+}
+function captureOnce(worktree, probe) {
+    const resolvedWorktree = path.resolve(worktree);
+    const branch = probeText(probe, resolvedWorktree, ['rev-parse', '--abbrev-ref', 'HEAD']).trim();
+    const head = probeText(probe, resolvedWorktree, ['rev-parse', '--verify', 'HEAD']).trim();
+    const status = probeText(probe, resolvedWorktree, [
+        'status', '--porcelain=v2', '-z', '--branch', '--untracked-files=all', '--ignore-submodules=none'
+    ]);
+    const index = probeText(probe, resolvedWorktree, ['ls-files', '--stage', '-z']);
+    if (!branch)
+        throw new Error('Unable to determine worktree branch');
+    if (!head)
+        throw new Error('Unable to determine worktree HEAD');
+    const changes = parseStatus(status);
+    const hash = createHash('sha256');
+    updatePart(hash, 'worktree', resolvedWorktree);
+    updatePart(hash, 'branch', branch);
+    updatePart(hash, 'head', head);
+    updatePart(hash, 'status', status);
+    updatePart(hash, 'index', index);
+    for (const change of changes) {
+        hashPath(hash, resolvedWorktree, change.path, probe);
+        if (change.originalPath)
+            hashPath(hash, resolvedWorktree, change.originalPath, probe);
+    }
+    return { worktree: resolvedWorktree, branch, head, changes, identity: hash.digest('hex') };
+}
+function inspectWorktree(worktree, { probe = runProbe } = {}) {
+    const resolvedWorktree = path.resolve(worktree);
+    try {
+        const first = captureOnce(resolvedWorktree, probe);
+        const second = captureOnce(resolvedWorktree, probe);
+        if (first.identity !== second.identity) {
+            return { status: 'failed', worktree: resolvedWorktree, message: 'Snapshot changed while inspecting worktree' };
+        }
+        return { status: second.changes.length === 0 ? 'clean' : 'dirty', snapshot: second };
+    }
+    catch (error) {
+        return {
+            status: 'failed',
+            worktree: resolvedWorktree,
+            message: error instanceof Error ? error.message : String(error)
+        };
+    }
+}
+function inspectWorktrees(worktrees) {
+    return [...new Set(worktrees.map((worktree) => path.resolve(worktree)))].sort()
+        .map((worktree) => inspectWorktree(worktree));
+}
+function createCleanPermit(snapshot) {
+    if (snapshot.changes.length > 0)
+        throw new Error('Cannot create a clean permit for a dirty worktree');
+    return { mode: 'clean', snapshot };
+}
+function createDiscardPermit(snapshot) {
+    if (snapshot.changes.length === 0)
+        throw new Error('Cannot create a discard permit for a clean worktree');
+    return { mode: 'discard', snapshot };
+}
+function verifyWorktreePermit(permit, options = {}) {
+    const current = inspectWorktree(permit.snapshot.worktree, options);
+    if (current.status === 'failed')
+        throw new Error(`Unable to verify worktree permit: ${current.message}`);
+    if (current.snapshot.identity !== permit.snapshot.identity || (permit.mode === 'clean' && current.status !== 'clean')) {
+        throw new Error(`Worktree changed after authorization: ${permit.snapshot.worktree}`);
+    }
+    return current.snapshot;
+}
+function formatWorktreeSnapshot(snapshot) {
+    const lines = snapshot.changes.map((change) => {
+        const rename = change.originalPath ? ` <- ${JSON.stringify(change.originalPath)}` : '';
+        return `  ${change.indexStatus}${change.worktreeStatus} ${JSON.stringify(change.path)}${rename}`;
+    });
+    return [
+        `Worktree: ${JSON.stringify(snapshot.worktree)}`,
+        `Branch: ${snapshot.branch}`,
+        `HEAD: ${snapshot.head}`,
+        ...lines,
+        `Snapshot identity: ${snapshot.identity}`
+    ].join('\n');
+}
+export { createCleanPermit, createDiscardPermit, formatWorktreeSnapshot, inspectWorktree, inspectWorktrees, verifyWorktreePermit };
+//# sourceMappingURL=worktree-safety.js.map

package/dist/lib/server/daemon.js

@@ -110,7 +110,7 @@ export async function runDaemon() {
             logger.close();
             if (ownStartTime !== null) {
                 removePidRecordIfMatches(config.pidFile, {
-                    version: 1,
+                    version: 2,
                     pid: process.pid,
                     startTime: ownStartTime
                 });

package/dist/lib/server/process-control.js

@@ -4,6 +4,12 @@ import { loadServerConfig } from './config.js';
 import { runDaemon } from './daemon.js';
 import { getProcessStartTime, isProcessAlive, processIdentityMatches, readProcessState, removePidFileIfMatches, writePidRecord } from './process-state.js';
 export { isProcessAlive } from './process-state.js';
+export function buildProcessTreeStopCommand(pid, platform) {
+    if (platform === 'win32') {
+        return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };
+    }
+    return { kind: 'group-signal', pid: -pid, signal: 'SIGTERM' };
+}
 export function buildStopCommand(pid, platform) {
     if (platform === 'win32') {
         return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };
@@ -20,7 +26,7 @@ async function waitForProcessIdentity(pid, timeoutMs = 2000) {
     while (Date.now() < deadline) {
         const startTime = getProcessStartTime(pid);
         if (startTime !== null)
-            return { version: 1, pid, startTime };
+            return { version: 2, pid, startTime };
         await delay(25);
     }
     return null;
@@ -52,6 +58,9 @@ export async function start({ foreground = false } = {}) {
         process.stdout.write(`server already running (pid ${existing.record.pid})\n`);
         return;
     }
+    if (existing.kind === 'legacy-json' || existing.kind === 'legacy-pid-only' || existing.kind === 'legacy-unknown') {
+        throw new Error('server: legacy pid record requires the matching previous version to stop it before starting');
+    }
     if (existing.kind !== 'missing') {
         removePidFileIfMatches(pidPath, existing.snapshot);
     }
@@ -98,6 +107,9 @@ export async function stop() {
         return;
     }
     if (state.kind !== 'running') {
+        if (state.kind === 'legacy-json' || state.kind === 'legacy-pid-only' || state.kind === 'legacy-unknown') {
+            throw new Error('server: legacy pid record requires the matching previous version to stop it');
+        }
         removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server is not running (removed stale pid file)\n');
         return;
@@ -129,6 +141,10 @@ export function status() {
     const config = loadServerConfig();
     const state = readProcessState(config.pidFile);
     if (state.kind !== 'running') {
+        if (state.kind === 'legacy-json' || state.kind === 'legacy-pid-only' || state.kind === 'legacy-unknown') {
+            process.stdout.write('server: legacy pid record requires the matching previous version to stop it\n');
+            return;
+        }
         if (state.kind !== 'missing')
             removePidFileIfMatches(config.pidFile, state.snapshot);
         process.stdout.write('server: stopped\n');

package/dist/lib/server/process-state.js

@@ -11,7 +11,10 @@ export function parseLinuxProcessStat(raw) {
     if (typeof state !== 'string' || state.length !== 1 || !/^\d+$/.test(startTime ?? '')) {
         return null;
     }
-    return { state, startTime: startTime };
+    const numericStartTime = Number(startTime);
+    if (!Number.isSafeInteger(numericStartTime))
+        return null;
+    return { state, startTime: numericStartTime };
 }
 export function buildProcessStartTimeQuery(pid, platform) {
     if (platform === 'darwin') {
@@ -47,6 +50,17 @@ export function isProcessAlive(pid, platform = process.platform) {
         return error.code === 'EPERM';
     }
 }
+function parseDarwinStartTime(output) {
+    const match = output.trim().match(/^(?:Sun|Mon|Tue|Wed|Thu|Fri|Sat) ([A-Z][a-z]{2}) (\d{1,2}) (\d{2}):(\d{2}):(\d{2}) (\d{4})$/);
+    if (!match)
+        return null;
+    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+    const month = months.indexOf(match[1]);
+    if (month < 0)
+        return null;
+    const timestamp = Date.UTC(Number(match[6]), month, Number(match[2]), Number(match[3]), Number(match[4]), Number(match[5]));
+    return Number.isNaN(timestamp) ? null : timestamp;
+}
 export function getProcessStartTime(pid, platform = process.platform) {
     if (!Number.isInteger(pid) || pid <= 0)
         return null;
@@ -65,14 +79,19 @@ export function getProcessStartTime(pid, platform = process.platform) {
     if (query === null)
         return null;
     try {
-        const output = execFileSync(query.command, query.args, { encoding: 'utf8' }).trim();
+        const output = execFileSync(query.command, query.args, {
+            encoding: 'utf8',
+            env: platform === 'darwin' ? { ...process.env, LC_ALL: 'C', LANG: 'C', TZ: 'UTC' } : process.env
+        }).trim();
         if (output.length === 0)
             return null;
         if (platform === 'win32') {
             const timestamp = new Date(output);
-            return Number.isNaN(timestamp.getTime()) ? null : timestamp.toISOString();
+            return Number.isNaN(timestamp.getTime()) ? null : timestamp.getTime();
         }
-        return output;
+        if (platform === 'darwin')
+            return parseDarwinStartTime(output);
+        return null;
     }
     catch {
         return null;
@@ -82,26 +101,42 @@ function parsePidRecord(raw) {
     const trimmed = raw.trim();
     if (/^[1-9]\d*$/.test(trimmed)) {
         const pid = Number(trimmed);
-        return Number.isSafeInteger(pid) ? { kind: 'legacy', pid } : { kind: 'invalid' };
+        return Number.isSafeInteger(pid)
+            ? { kind: 'legacy-pid-only', legacy: { pid, raw, format: 'pid-only' } }
+            : { kind: 'legacy-unknown', legacy: { raw, format: 'malformed' }, reason: 'pid is not a safe integer' };
     }
     try {
         const value = JSON.parse(trimmed);
+        const pidValue = value?.pid;
+        const startTimeValue = value?.startTime;
         if (value !== null &&
-            value.version === 1 &&
-            Number.isSafeInteger(value.pid) &&
-            (value.pid ?? 0) > 0 &&
-            typeof value.startTime === 'string' &&
-            value.startTime.length > 0) {
+            value.version === 2 &&
+            typeof pidValue === 'number' &&
+            Number.isSafeInteger(pidValue) &&
+            pidValue > 0 &&
+            typeof startTimeValue === 'number' &&
+            Number.isSafeInteger(startTimeValue) &&
+            startTimeValue >= 0) {
+            const startTime = startTimeValue;
             return {
                 kind: 'record',
-                record: { version: 1, pid: value.pid, startTime: value.startTime }
+                record: { version: 2, pid: pidValue, startTime }
             };
         }
+        if (value !== null &&
+            value.version === 1 &&
+            typeof pidValue === 'number' &&
+            Number.isSafeInteger(pidValue) &&
+            pidValue > 0 &&
+            typeof value.startTime === 'string' &&
+            value.startTime.length > 0) {
+            return { kind: 'legacy-json', legacy: { pid: pidValue, raw, format: 'json-v1' } };
+        }
+        return { kind: 'legacy-unknown', legacy: { raw, format: 'malformed' }, reason: 'unsupported PID record schema' };
     }
     catch {
-        // Invalid JSON is an invalid PID record.
+        return { kind: 'legacy-unknown', legacy: { raw, format: 'malformed' }, reason: 'invalid PID record JSON' };
     }
-    return { kind: 'invalid' };
 }
 export function readProcessState(pidFile) {
     let snapshot;
@@ -111,13 +146,15 @@ export function readProcessState(pidFile) {
     catch (error) {
         if (error.code === 'ENOENT')
             return { kind: 'missing', snapshot: null };
-        return { kind: 'invalid', snapshot: '' };
+        return { kind: 'legacy-unknown', snapshot: '', legacy: { raw: '', format: 'malformed' }, reason: 'PID record cannot be read' };
     }
     const parsed = parsePidRecord(snapshot);
-    if (parsed.kind === 'invalid')
-        return { kind: 'invalid', snapshot };
-    if (parsed.kind === 'legacy')
-        return { kind: 'legacy', snapshot, pid: parsed.pid };
+    if (parsed.kind === 'legacy-json')
+        return { kind: parsed.kind, snapshot, legacy: parsed.legacy };
+    if (parsed.kind === 'legacy-pid-only')
+        return { kind: parsed.kind, snapshot, legacy: parsed.legacy };
+    if (parsed.kind === 'legacy-unknown')
+        return { kind: parsed.kind, snapshot, legacy: parsed.legacy, reason: parsed.reason };
     const currentStartTime = getProcessStartTime(parsed.record.pid);
     if (currentStartTime === null || currentStartTime !== parsed.record.startTime) {
         return { kind: 'stale', snapshot, record: parsed.record };
@@ -162,7 +199,7 @@ export function removePidRecordIfMatches(pidFile, expected) {
         return false;
     return removePidFileIfMatches(pidFile, state.snapshot);
 }
-export function processIdentityMatches(record) {
-    return getProcessStartTime(record.pid) === record.startTime;
+export function processIdentityMatches(identity) {
+    return getProcessStartTime(identity.pid) === identity.startTime;
 }
 //# sourceMappingURL=process-state.js.map

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

@@ -5,6 +5,7 @@ import { locateActivityLog } from './activity-log.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
+import { receiptForOutput, sha256File } from './artifact-receipts.js';
 const artifactFamilyCatalog = [
     { family: 'analysis', sectionAliases: ['分析', 'Analysis'], heading: '分析', labels: ['需求分析报告', 'Requirements Analysis'] },
     { family: 'review-analysis', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['需求分析审查', 'Analysis Review'] },
@@ -13,6 +14,7 @@ const artifactFamilyCatalog = [
     { family: 'code', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['实现报告', 'Implementation Report'] },
     { family: 'review-code', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['代码审查', 'Code Review'] },
     { family: 'manual-validation', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['人工验证', 'Manual Validation'] },
+    { family: 'validation-run', sectionAliases: ['实现备注', 'Implementation Notes'], heading: '实现备注', labels: ['验证运行证据', 'Validation Run Evidence'] },
     { family: 'pr-review', sectionAliases: ['审查反馈', 'Review Feedback'], heading: '审查反馈', labels: ['PR 审查报告', 'PR Review Report'] }
 ];
 const FAMILY_SET = new Set(artifactFamilyCatalog.map((item) => item.family));
@@ -150,11 +152,7 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, String(error)));
         return null;
     }
-    const lines = content.split(/\r?\n/);
-    const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
-    const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
-    const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]);
-    const parsed = candidates.map((name) => parseArtifactName(name)).find((item) => item?.family === expectedFamily);
+    const parsed = parseReviewedInputReference(content, expectedFamily);
     if (!parsed) {
         diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${review.name} does not reference a canonical ${expectedFamily} artifact`));
         return null;
@@ -164,9 +162,17 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         const stat = fs.lstatSync(abs);
         if (!stat.isFile() || stat.isSymbolicLink())
             throw new Error('referenced input is not a regular file');
-        if (stat.mtimeMs > review.mtimeMs) {
-            diagnostics.push(diagnostic('BROKEN_REFERENCE', review.family, review.name, `${parsed.name} is newer than ${review.name}`));
-            return null;
+        const taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const receipt = receiptForOutput(taskContent, review.name);
+        if (!receipt)
+            throw new Error(`receipt for ${review.name} is missing`);
+        const expectedEvent = reviewEventName(review.family);
+        if (receipt.event !== expectedEvent || receipt.input !== parsed.name) {
+            throw new Error(`receipt for ${review.name} does not match ${parsed.name}`);
+        }
+        const actualSha256 = sha256File(abs);
+        if (actualSha256 !== receipt.inputSha256) {
+            throw new Error(`${parsed.name} content digest does not match receipt`);
         }
         return { ...parsed, path: abs, size: stat.size, mtimeMs: stat.mtimeMs };
     }
@@ -175,6 +181,64 @@ function resolveReviewedInput(taskDir, review, expectedFamily, diagnostics) {
         return null;
     }
 }
+function parseReviewedInputReference(content, expectedFamily) {
+    const lines = content.split(/\r?\n/);
+    const header = lines.findIndex((line) => /\*\*(?:审查输入|Review Input)\*\*[:：]/.test(line));
+    const referenceBlock = header >= 0 ? lines.slice(header, header + 12).join('\n') : '';
+    const candidates = [...referenceBlock.matchAll(/`([^`]+\.md)`/g)].map((match) => match[1]);
+    return candidates
+        .map((name) => parseArtifactName(name))
+        .find((item) => item?.family === expectedFamily) ?? null;
+}
+function parseCodePlanInputReference(content) {
+    const lines = content.split(/\r?\n/);
+    const sectionStart = lines.findIndex((line) => /^##\s+(?:实现输入|Implementation Input)\s*$/.test(line.trim()));
+    if (sectionStart < 0)
+        return null;
+    const bodyLines = lines.slice(sectionStart + 1);
+    const nextSection = bodyLines.findIndex((line) => /^##\s+/.test(line.trim()));
+    const body = (nextSection < 0 ? bodyLines : bodyLines.slice(0, nextSection)).join('\n');
+    const match = body.match(/\*\*(?:方案输入|Plan Input)\*\*[:：]\s*`([^`]+\.md)`/);
+    if (!match)
+        return null;
+    const parsed = parseArtifactName(match[1]);
+    return parsed?.family === 'plan' ? { ...parsed, family: 'plan' } : null;
+}
+function reviewEventName(family) {
+    if (family === 'review-analysis')
+        return 'review-analysis.completed';
+    if (family === 'review-plan')
+        return 'review-plan.completed';
+    if (family === 'review-code')
+        return 'review-code.completed';
+    throw new Error(`unsupported review family '${family}'`);
+}
+function resolveCodeInputReceipt(taskDir, code) {
+    let taskContent;
+    try {
+        taskContent = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    }
+    catch {
+        return null;
+    }
+    let receipt;
+    try {
+        receipt = receiptForOutput(taskContent, code.name);
+    }
+    catch {
+        return null;
+    }
+    if (!receipt || receipt.event !== 'code.completed')
+        return null;
+    const plan = inspectArtifactDirectory(taskDir, 'plan');
+    if (plan.status !== 'ready')
+        return null;
+    const input = plan.artifacts.find((artifact) => artifact.name === receipt.input);
+    return input ? { input, inputSha256: receipt.inputSha256 } : null;
+}
+function resolveCodePlanInput(taskDir, code) {
+    return resolveCodeInputReceipt(taskDir, code);
+}
 function assertWritableInventory(inventory) {
     if (inventory.status === 'failed')
         return inventory.error;
@@ -191,7 +255,8 @@ const OPTIONAL_CONTEXT = {
     analysis: { family: 'review-analysis', requireReference: true },
     plan: { family: 'review-plan', requireReference: true },
     'review-code': { family: 'review-plan' },
-    'manual-validation': { family: 'review-code' }
+    'manual-validation': { family: 'review-code' },
+    'validation-run': { family: 'review-code' }
 };
 function resolveArtifactContext(taskRef, family, options = {}) {
     const inventory = inspectTaskArtifacts(taskRef, family, options);
@@ -246,10 +311,18 @@ function resolveCodeContext(inventory, options) {
         }
         return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, null, null, 'No prior code artifact. Starting initial implementation (round 1 -> code.md).');
     }
+    const codePlanInput = resolveCodePlanInput(inventory.taskDir, latestCode);
+    if (!codePlanInput) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `code completion receipt for ${latestCode.name} is missing or does not match the current plan`, latestCode.name);
+    }
+    if (reviewPlan.latest && !reviewPlan.reviewedInput) {
+        return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `${reviewPlan.latest.name} has no valid reviewed input`, reviewPlan.latest.name);
+    }
     if (reviewPlan.latest && reviewPlan.reviewedInput?.name === plan.latest.name) {
         const verdict = parseVerdict(reviewPlan.latest.path);
-        if (verdict.ok && verdict.verdict === 'Approved' && reviewPlan.latest.mtimeMs > latestCode.mtimeMs) {
-            return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} is approved and newer than the latest code artifact. Entering replan-driven init.`);
+        const reviewedPlanSha256 = sha256File(reviewPlan.reviewedInput.path);
+        if (verdict.ok && verdict.verdict === 'Approved' && (codePlanInput.input.name !== plan.latest.name || codePlanInput.inputSha256 !== reviewedPlanSha256)) {
+            return withCodeMode(inventory, inputs, 'ready', 'init', codeMax, reviewMax, verdict.verdict, reviewPlan.latest.name, `Latest ${reviewPlan.latest.name} approves plan content not captured by the latest code input receipt. Entering replan-driven init.`);
         }
     }
     if (reviewMax < codeMax) {
@@ -306,12 +379,11 @@ function resolveDecisionImplementationInput(inventory, review) {
     const activity = locateActivityLog(content);
     if (!activity)
         return { error: 'task has no unique Activity Log section' };
-    const reviewEntries = activity.entries.filter((entry) => /^Review Code \(Round \d+\)$/.test(entry.step) && entry.note.includes(`→ ${review.name}`));
-    const completed = reviewEntries.at(-1);
+    const completed = activity.entries.some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step) && entry.note.includes(`→ ${review.name}`));
     if (!completed)
         return { error: `cannot find completed Activity Log identity for ${review.name}` };
     try {
-        return { input: selectPendingImplementationInput(rows, completed.time) };
+        return { input: selectPendingImplementationInput(rows) };
     }
     catch (error) {
         return { error: error instanceof Error ? error.message : String(error) };
@@ -376,5 +448,5 @@ function buildArtifactLinkSection(content, artifact) {
     body = lines.join('\n').replace(/^\n+|\n+$/g, '');
     return { aliases, heading, body };
 }
-export { artifactFamilyCatalog, artifactName, parseArtifactName, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
+export { artifactFamilyCatalog, artifactName, parseArtifactName, familySpec, inspectTaskArtifacts, inspectArtifactDirectory, resolveArtifactContext, parseReviewedInputReference, parseCodePlanInputReference, resolveCodePlanInput, reviewEventName, assertWritableInventory, validateCompletedArtifact, buildArtifactLinkSection };
 //# sourceMappingURL=artifact-lifecycle.js.map