@fitlab-ai/agent-infra 0.9.6 → 0.9.7

package/dist/lib/sandbox/recovery.js

@@ -11,13 +11,28 @@ import { sandboxCoreBindMounts } from './mounts.js';
 import { assertSandboxTaskSource, sandboxControlPaths, sandboxWorkspaceViewPaths } from './workspace-view.js';
 import { parseSandboxWorkspaceIdentity, sameSandboxWorkspaceIdentity } from './workspace-identity.js';
 import { inspectWorktree } from './worktree-safety.js';
-import { runEngine, runOkEngine, runVerboseEngine } from './shell.js';
+import { commandForEngine, runEngine, runOkEngine, runProbe, runVerboseEngine } from './shell.js';
 import { declaredTmpfsSeedEntries, resolveTools, toolConfigDirCandidates } from './tools.js';
 import { fetchSandboxRows, selectSandboxContainer, startSandboxContainer } from './commands/list-running.js';
 import { getProcessStartTime, processIdentityMatches, removePidFileIfMatches } from '../server/process-state.js';
-import { acquireSandboxControlBrokerStartup, isSandboxControlRootQuiescing } from './control/lifecycle.js';
+import { acquireSandboxControlBrokerStartup, garbageCollectSandboxControlRoot, isSandboxControlRootQuiescing, readSandboxControlManifest } from './control/lifecycle.js';
 import { appendSandboxControlAudit, readSandboxControlStatus } from './control/state.js';
+import { inspectSandboxControlContainer } from './control/container-identity.js';
 import { SANDBOX_CONTROL_FUTURE_SKEW_MS, SANDBOX_CONTROL_STATUS_STALE_MS } from './control/protocol.js';
+export function worktreeProbeForEngine(engine, probe = runProbe) {
+    return (cmd, args, opts = {}) => {
+        const engineArgs = [...args];
+        if (engine === 'wsl2' && cmd === 'git') {
+            for (let index = 0; index < engineArgs.length - 1; index += 1) {
+                if (engineArgs[index] === '-C') {
+                    engineArgs[index + 1] = toEnginePath(engine, engineArgs[index + 1]);
+                }
+            }
+        }
+        const command = commandForEngine(engine, cmd, engineArgs);
+        return probe(command.cmd, command.args, opts);
+    };
+}
 async function waitForSandboxControlBrokerStatus(params, timeoutMs = 5_000) {
     const deadline = Date.now() + timeoutMs;
     while (Date.now() < deadline) {
@@ -42,7 +57,7 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
     const directory = path.dirname(fileURLToPath(import.meta.url));
     const extension = path.extname(fileURLToPath(import.meta.url));
     const internalCli = path.resolve(directory, '..', '..', 'bin', `internal-cli${extension}`);
-    const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+    const manifest = readSandboxControlManifest(manifestPath);
     const root = path.dirname(manifestPath);
     if (isSandboxControlRootQuiescing(root))
         throw new Error('SANDBOX_CONTROL_QUIESCING');
@@ -64,14 +79,21 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
         catch {
             // Malformed owner records are stale and replaced below.
         }
-        const owner = broker !== null && typeof broker.pid === 'number' && typeof broker.startTime === 'string'
-            ? { version: 1, pid: broker.pid, startTime: broker.startTime }
+        const owner = broker !== null && broker.version === 3 && typeof broker.pid === 'number'
+            && Number.isSafeInteger(broker.pid) && broker.pid > 0 && typeof broker.startTime === 'number'
+            && Number.isSafeInteger(broker.startTime) && typeof broker.brokerId === 'string'
+            && broker.brokerId.length > 0 && typeof broker.token === 'string'
+            && typeof broker.generation === 'string'
+            ? broker
             : null;
-        const live = owner !== null && processIdentityMatches(owner);
+        if (broker === null || broker.version !== 3 || owner === null) {
+            throw new Error('SANDBOX_CONTROL_BROKER_VERSION_INVALID: rebuild the sandbox container before starting a new broker');
+        }
+        const live = owner !== null && processIdentityMatches({ pid: owner.pid, startTime: owner.startTime });
         if (live
             && owner !== null
             && broker !== null
-            && broker.version === 2
+            && broker.version === 3
             && broker.token === manifest.token
             && broker.generation === manifest.generation) {
             await waitForSandboxControlBrokerStatus({
@@ -83,28 +105,6 @@ export async function startSandboxControlBroker(repoRoot, manifestPath) {
             });
             return;
         }
-        if (live && owner) {
-            const deadline = Date.now() + 5_000;
-            while (Date.now() < deadline) {
-                await new Promise((resolve) => setTimeout(resolve, 25));
-                try {
-                    if (fs.readFileSync(brokerPath, 'utf8') !== brokerSnapshot) {
-                        return startSandboxControlBroker(repoRoot, manifestPath);
-                    }
-                }
-                catch (error) {
-                    if (error.code === 'ENOENT') {
-                        return startSandboxControlBroker(repoRoot, manifestPath);
-                    }
-                    throw error;
-                }
-                if (!processIdentityMatches(owner)) {
-                    removePidFileIfMatches(brokerPath, brokerSnapshot);
-                    return startSandboxControlBroker(repoRoot, manifestPath);
-                }
-            }
-            throw new Error('SANDBOX_CONTROL_BROKER_OWNER_ACTIVE');
-        }
     }
     const startupStartTime = getProcessStartTime(process.pid);
     if (!startupStartTime)
@@ -162,22 +162,33 @@ async function ensureSandboxControlBroker(params) {
     });
     if (!fs.existsSync(control.manifestPath))
         return;
-    const manifest = JSON.parse(fs.readFileSync(control.manifestPath, 'utf8'));
-    if (manifest.version !== 3) {
-        throw new Error('SANDBOX_CONTROL_MANIFEST_VERSION_INVALID: expected version 3; container-only recreation is required');
+    const validatedManifest = readSandboxControlManifest(control.manifestPath);
+    const containerObservation = await inspectSandboxControlContainer(validatedManifest);
+    if (containerObservation.state === 'unknown') {
+        throw new Error(`SANDBOX_CONTROL_CONTAINER_UNKNOWN: ${containerObservation.reason}`);
+    }
+    if (containerObservation.state === 'absent') {
+        await garbageCollectSandboxControlRoot(control.root, {
+            inspectContainer: (timeoutMs) => inspectSandboxControlContainer(validatedManifest, { timeoutMs })
+        });
+        throw new Error('SANDBOX_CONTROL_CONTAINER_ABSENT: recreate the sandbox container before broker recovery');
     }
     const brokerPath = path.join(control.root, 'broker.json');
     try {
         const broker = JSON.parse(fs.readFileSync(brokerPath, 'utf8'));
-        if (broker.version === 2
+        if (broker.version === 3
             && typeof broker.pid === 'number'
-            && typeof broker.startTime === 'string'
-            && broker.token === manifest.token
-            && broker.generation === manifest.generation
-            && processIdentityMatches({ version: 1, pid: broker.pid, startTime: broker.startTime })) {
+            && Number.isSafeInteger(broker.pid)
+            && typeof broker.startTime === 'number'
+            && Number.isSafeInteger(broker.startTime)
+            && typeof broker.brokerId === 'string'
+            && broker.brokerId.length > 0
+            && broker.token === validatedManifest.token
+            && broker.generation === validatedManifest.generation
+            && processIdentityMatches({ pid: broker.pid, startTime: broker.startTime })) {
             try {
                 const status = readSandboxControlStatus(control.statusDir);
-                if (status.generation === manifest.generation && status.broker.pid === broker.pid
+                if (status.generation === validatedManifest.generation && status.broker.pid === broker.pid
                     && status.broker.startTime === broker.startTime
                     && Date.now() - status.updatedAt <= SANDBOX_CONTROL_STATUS_STALE_MS
                     && status.updatedAt <= Date.now() + SANDBOX_CONTROL_FUTURE_SKEW_MS)
@@ -189,7 +200,7 @@ async function ensureSandboxControlBroker(params) {
             await waitForSandboxControlBrokerStatus({
                 root: control.root,
                 statusDir: control.statusDir,
-                generation: manifest.generation,
+                generation: validatedManifest.generation,
                 pid: broker.pid,
                 startTime: broker.startTime
             });
@@ -729,6 +740,9 @@ export async function ensureSandboxReady(params) {
                 workspace: params.workspace ?? { mode: 'branch-only' }
             });
         }
+        if (params.forceRecreate) {
+            throw new Error('Explicit container recreation requested.');
+        }
         if (!params.row.running) {
             startFn(params.engine, params.row.name);
             const initial = assess({
@@ -862,7 +876,8 @@ export async function ensureSandboxReady(params) {
                 + 'keep the worktree in use, remove the stale directory, then retry.';
         throw new Error(`SANDBOX_RECOVERY_WORKTREE_SNAPSHOT_INVALID: expected exactly one existing worktree for '${params.branch}', found ${existingWorktrees.length}. ${remediation}`);
     }
-    const beforeInspection = inspectWorktree(existingWorktrees[0]);
+    const worktreeProbe = worktreeProbeForEngine(params.engine, deps?.probe);
+    const beforeInspection = inspectWorktree(existingWorktrees[0], { probe: worktreeProbe });
     if (beforeInspection.status === 'failed') {
         throw new Error(`SANDBOX_RECOVERY_WORKTREE_SNAPSHOT_INVALID: ${beforeInspection.message}`);
     }
@@ -871,7 +886,9 @@ export async function ensureSandboxReady(params) {
         throw new Error(`SANDBOX_RECOVERY_WORKTREE_SNAPSHOT_INVALID: expected branch '${params.branch}', found '${before.branch}'. `
             + `Run 'git -C ${JSON.stringify(before.worktree)} checkout ${params.branch}' to restore the expected branch, then retry.`);
     }
-    const warning = `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
+    const warning = params.forceRecreate
+        ? `Explicit sandbox recreation requested. Replacing only the container. ${dataBoundary}`
+        : `Sandbox recovery failed in place. Replacing only the container. ${dataBoundary}`;
     warnings.push(warning);
     (params.writeWarning ?? ((message) => process.stderr.write(`${message}\n`)))(warning);
     const runVerboseFn = deps?.runVerbose ?? runVerboseEngine;
@@ -904,7 +921,7 @@ export async function ensureSandboxReady(params) {
     catch (error) {
         replacementFailure = error;
     }
-    const afterInspection = inspectWorktree(before.worktree);
+    const afterInspection = inspectWorktree(before.worktree, { probe: worktreeProbe });
     if (afterInspection.status === 'failed' || afterInspection.snapshot.identity !== before.identity) {
         const detail = afterInspection.status === 'failed'
             ? afterInspection.message

package/dist/lib/sandbox/workspace-view.js

@@ -50,44 +50,6 @@ function assertSafeDirectory(directory, expectedBase) {
         throw new Error(`Sandbox workspace view must not be a symbolic link: ${directory}`);
     }
 }
-function assertSafeMountTargetPath(target, worktreeRoot, canonicalWorktreeRoot) {
-    const relative = path.relative(worktreeRoot, target);
-    if (relative.startsWith('..') || path.isAbsolute(relative)) {
-        throw new Error(`Sandbox workspace mount target escapes its worktree: ${target}`);
-    }
-    let current = worktreeRoot;
-    for (const segment of ['', ...relative.split(path.sep).filter(Boolean)]) {
-        current = segment ? path.join(current, segment) : current;
-        try {
-            if (fs.lstatSync(current).isSymbolicLink()) {
-                throw new Error(`Sandbox workspace mount target must not contain a symbolic link: ${current}`);
-            }
-            const canonicalRelative = path.relative(canonicalWorktreeRoot, fs.realpathSync.native(current));
-            if (canonicalRelative.startsWith('..') || path.isAbsolute(canonicalRelative)) {
-                throw new Error(`Sandbox workspace mount target escapes its real worktree: ${current}`);
-            }
-        }
-        catch (error) {
-            if (error.code !== 'ENOENT')
-                throw error;
-        }
-    }
-}
-export function prepareSandboxWorkspaceMountTargets(worktreeRoot) {
-    const resolvedWorktreeRoot = path.resolve(worktreeRoot);
-    const canonicalWorktreeRoot = fs.realpathSync.native(resolvedWorktreeRoot);
-    const workspaceRoot = path.resolve(resolvedWorktreeRoot, '.agents', 'workspace');
-    const statePaths = sandboxWorkspaceViewStatePaths(workspaceRoot);
-    const registryTarget = path.join(workspaceRoot, 'active', '.short-ids.json');
-    for (const target of [workspaceRoot, ...statePaths.map(({ hostPath }) => hostPath), registryTarget]) {
-        assertSafeMountTargetPath(target, resolvedWorktreeRoot, canonicalWorktreeRoot);
-    }
-    fs.mkdirSync(workspaceRoot, { recursive: true, mode: 0o700 });
-    for (const { hostPath } of statePaths) {
-        fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
-    }
-    fs.closeSync(fs.openSync(registryTarget, 'a', 0o600));
-}
 export function assertSandboxTaskSource(repoRoot, taskId) {
     if (!/^TASK-\d{8}-\d{6}$/.test(taskId))
         throw new Error('SANDBOX_TASK_SOURCE_INVALID');
@@ -103,6 +65,43 @@ export function assertSandboxTaskSource(repoRoot, taskId) {
     }
     return canonical;
 }
+export function prepareSandboxWorkspaceMountTarget(worktreeRoot) {
+    const worktree = path.resolve(worktreeRoot);
+    const canonicalWorktree = fs.realpathSync.native(worktree);
+    const agentsRoot = path.join(worktree, '.agents');
+    if (fs.existsSync(agentsRoot)) {
+        const agentsStat = fs.lstatSync(agentsRoot);
+        if (!agentsStat.isDirectory() || agentsStat.isSymbolicLink()) {
+            throw new Error(`Sandbox workspace mount ancestor must be a real directory: ${agentsRoot}`);
+        }
+    }
+    else {
+        fs.mkdirSync(agentsRoot, { mode: 0o700 });
+    }
+    const canonicalAgents = fs.realpathSync.native(agentsRoot);
+    if (path.dirname(canonicalAgents) !== canonicalWorktree) {
+        throw new Error(`Sandbox workspace mount ancestor escapes the worktree: ${agentsRoot}`);
+    }
+    const target = path.join(agentsRoot, 'workspace');
+    if (fs.existsSync(target)) {
+        const stat = fs.lstatSync(target);
+        if (stat.isSymbolicLink()) {
+            throw new Error(`Sandbox workspace mount target must not be a symbolic link: ${target}`);
+        }
+        if (!stat.isDirectory()) {
+            throw new Error(`Sandbox workspace mount target must be a directory: ${target}`);
+        }
+        if (path.dirname(fs.realpathSync.native(target)) !== canonicalAgents) {
+            throw new Error(`Sandbox workspace mount target escapes the worktree: ${target}`);
+        }
+    }
+    else {
+        fs.mkdirSync(target, { mode: 0o700 });
+    }
+    fs.chmodSync(target, 0o700);
+    fs.accessSync(target, fs.constants.W_OK);
+    return target;
+}
 export function materializeSandboxWorkspaceView(params) {
     const projectRoot = path.resolve(params.base, params.project);
     const { root, taskMountPath } = sandboxWorkspaceViewPaths(params);
@@ -152,11 +151,13 @@ export function materializeSandboxControl(params) {
     const generation = randomBytes(16).toString('hex');
     const repoRoot = fs.realpathSync.native(params.repoRoot);
     const manifest = {
-        version: 3,
+        version: 4,
+        engine: params.engine ?? 'docker',
         repoRoot,
         worktreeRoot: fs.realpathSync.native(params.worktreeRoot),
         project: params.project,
         container: params.container,
+        containerIdentity: { id: '', labels: {} },
         branch: params.branch,
         mode: params.identity.mode,
         taskId: params.identity.mode === 'task-bound' ? params.identity.taskId : null,
@@ -167,6 +168,22 @@ export function materializeSandboxControl(params) {
         processingDir
     };
     fs.writeFileSync(manifestPath, `${JSON.stringify(manifest)}\n`, { mode: 0o600 });
-    return { channelDir, statusDir, manifestPath, token, generation };
+    return { root, channelDir, statusDir, manifestPath, token, generation };
+}
+export function finalizeSandboxControlManifest(setup, identity) {
+    if (!identity.engine || !identity.id)
+        throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
+    const manifest = JSON.parse(fs.readFileSync(setup.manifestPath, 'utf8'));
+    manifest.version = 4;
+    manifest.engine = identity.engine;
+    manifest.containerIdentity = { id: identity.id, labels: { ...identity.labels } };
+    const temporary = `${setup.manifestPath}.${process.pid}.${randomBytes(8).toString('hex')}.tmp`;
+    try {
+        fs.writeFileSync(temporary, `${JSON.stringify(manifest)}\n`, { mode: 0o600, flag: 'wx' });
+        fs.renameSync(temporary, setup.manifestPath);
+    }
+    finally {
+        fs.rmSync(temporary, { force: true });
+    }
 }
 //# sourceMappingURL=workspace-view.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

@@ -26,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;
@@ -58,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);
     }
@@ -104,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;
@@ -135,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'] },
@@ -151,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;
@@ -165,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 };
     }
@@ -176,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;
@@ -248,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) {
@@ -377,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