@fitlab-ai/agent-infra 0.11.5 → 0.11.7

package/lib/sandbox/control/lifecycle.ts

@@ -1298,6 +1298,10 @@ export async function quiesceSandboxControlRoot(
     timeoutMs?: number;
     timing?: SandboxControlTimingPolicy;
     identityProbe?: ProcessIdentityProbe;
+    executionProcessControl?: Readonly<{
+      isAlive: (execution: SandboxControlExecution) => boolean;
+      terminate: (execution: SandboxControlExecution, phase: 'graceful' | 'force') => boolean;
+    }>;
   } = {}
 ): Promise<'missing' | 'stale' | 'stopped'> {
   const resolvedRoot = path.resolve(root);
@@ -1338,58 +1342,63 @@ export async function quiesceSandboxControlRoot(
   if (!manifest && brokerLive) throw new Error('SANDBOX_CONTROL_OWNER_MISMATCH');
 
   const platform = options.platform ?? process.platform;
+  const processControl = options.executionProcessControl ?? {
+    isAlive: (execution: SandboxControlExecution) => executionAlive(execution, platform, identityProbe),
+    terminate: (execution: SandboxControlExecution, phase: 'graceful' | 'force') => phase === 'graceful'
+      ? terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, allowForce: false, identityProbe })
+      : terminateSandboxControlExecution(execution, {
+        platform, timeoutMs: Math.max(0, deadlineAt - Date.now()), deadlineAt, forceAt: Date.now(), identityProbe
+      })
+  };
   let executions = manifest ? readExecutions(manifest) : [];
   const owner: OwnerIdentity | null = brokerLive ? broker : statusLive ? statusOwner : null;
   if (!owner) {
     if (manifest && !broker && !status) throw new Error('SANDBOX_CONTROL_OWNER_EVIDENCE_MISSING');
     for (const execution of executions) {
-      terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, allowForce: false, identityProbe });
+      processControl.terminate(execution, 'graceful');
     }
     const softDeadlineAt = Math.min(forceAt, Date.now() + Math.floor(Math.max(0, forceAt - Date.now()) / 2));
     while (Date.now() < softDeadlineAt) {
-      if (!executions.some((execution) => executionAlive(execution, platform, identityProbe))) break;
+      if (!executions.some((execution) => processControl.isAlive(execution))) break;
       await new Promise((resolve) => setTimeout(resolve, 25));
     }
     if (manifest) executions = mergeExecutions(executions, readExecutions(manifest));
     if (Date.now() >= deadlineAt) throw new Error('SANDBOX_CONTROL_QUIESCE_DEADLINE_EXCEEDED');
     for (const execution of executions) {
-      if (!terminateSandboxControlExecution(execution, {
-        platform, timeoutMs: Math.max(0, deadlineAt - Date.now()), deadlineAt, forceAt: Date.now(), identityProbe
-      })) {
+      if (!processControl.terminate(execution, 'force')) {
         throw new Error(`SANDBOX_CONTROL_EXECUTION_STILL_RUNNING: ${execution.requestId}`);
       }
     }
-    if (executions.some((execution) => executionAlive(execution, platform, identityProbe))) {
+    if (executions.some((execution) => processControl.isAlive(execution))) {
       throw new Error('SANDBOX_CONTROL_EXECUTION_STILL_RUNNING');
     }
     return broker || status ? 'stale' : 'missing';
   }
 
-  const remaining = (): number => Math.max(0, deadlineAt - Date.now());
   signalOwner(owner, platform, false);
   for (const execution of executions) {
-    terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, allowForce: false, identityProbe });
+    processControl.terminate(execution, 'graceful');
   }
   const softDeadlineAt = Math.min(forceAt, Date.now() + Math.floor(Math.max(0, forceAt - Date.now()) / 2));
   while (Date.now() < softDeadlineAt) {
-    if (!ownerLive(owner, identityProbe) && !executions.some((execution) => executionAlive(execution, platform, identityProbe))) break;
+    if (!ownerLive(owner, identityProbe) && !executions.some((execution) => processControl.isAlive(execution))) break;
     await new Promise((resolve) => setTimeout(resolve, 25));
   }
-  if (!ownerLive(owner, identityProbe) && !executions.some((execution) => executionAlive(execution, platform, identityProbe))) {
+  if (!ownerLive(owner, identityProbe) && !executions.some((execution) => processControl.isAlive(execution))) {
     return 'stopped';
   }
   if (manifest) executions = mergeExecutions(executions, readExecutions(manifest));
   if (Date.now() >= deadlineAt) throw new Error('SANDBOX_CONTROL_QUIESCE_DEADLINE_EXCEEDED');
   for (const execution of executions) {
-    terminateSandboxControlExecution(execution, { platform, timeoutMs: 0, deadlineAt, forceAt: Date.now(), identityProbe });
+    processControl.terminate(execution, 'force');
   }
   signalOwner(owner, platform, true);
   while (Date.now() < deadlineAt) {
-    if (!ownerLive(owner, identityProbe) && !executions.some((execution) => executionAlive(execution, platform, identityProbe))) return 'stopped';
+    if (!ownerLive(owner, identityProbe) && !executions.some((execution) => processControl.isAlive(execution))) return 'stopped';
     await new Promise((resolve) => setTimeout(resolve, 25));
   }
   if (ownerLive(owner, identityProbe)) throw new Error('SANDBOX_CONTROL_BROKER_STILL_RUNNING');
-  if (executions.some((execution) => executionAlive(execution, platform, identityProbe))) throw new Error('SANDBOX_CONTROL_EXECUTION_STILL_RUNNING');
+  if (executions.some((execution) => processControl.isAlive(execution))) throw new Error('SANDBOX_CONTROL_EXECUTION_STILL_RUNNING');
   return 'stopped';
 }
 

package/lib/sandbox/control/server.ts

@@ -272,12 +272,15 @@ function taskCreateDomainEvidence(
     ? output.task as Record<string, unknown> : null;
   const taskId = typeof task?.id === 'string' ? task.id : null;
   const shortId = typeof task?.shortId === 'string' ? task.shortId : null;
-  if (!taskId || !shortId) return { consistent: false };
+  const state = task?.state;
+  if (!taskId || !['active', 'blocked', 'completed', 'archive'].includes(String(state))) return { consistent: false };
+  if (state === 'active' ? !shortId : output.status !== 'no-op' || shortId !== null) return { consistent: false };
   try {
     const resolved = resolveTaskRef(taskId, { repoRoot: manifest.repoRoot });
     const shortIds = loadShortIdByTaskId(manifest.repoRoot);
     return {
-      consistent: resolved.ok && resolved.taskId === taskId && resolved.state === 'active' && shortIds.get(taskId) === shortId,
+      consistent: resolved.ok && resolved.taskId === taskId && resolved.state === state
+        && (state === 'active' ? shortIds.get(taskId) === shortId : !shortIds.has(taskId)),
       taskId,
       shortId
     };

package/lib/sandbox/task-resolver.ts

@@ -36,7 +36,9 @@ function stripQuotes(value: string): string {
 
 function readTaskContent(repoRoot: string, taskId: string): { content: string; state: TaskWorkspaceState; taskMd: string } {
   for (const state of TASK_WORKSPACE_STATES) {
-    const taskPath = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
+    const taskPath = state === 'archive'
+      ? path.join(repoRoot, '.agents', 'workspace', state, ...findArchiveTaskParts(repoRoot, taskId), 'local', 'task.md')
+      : path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
     if (fs.existsSync(taskPath)) {
       return { content: fs.readFileSync(taskPath, 'utf8'), state, taskMd: taskPath };
     }
@@ -45,7 +47,7 @@ function readTaskContent(repoRoot: string, taskId: string): { content: string; s
 }
 
 function taskWorkspaceCandidates(repoRoot: string, taskId: string): TaskWorkspace[] {
-  return TASK_WORKSPACE_STATES.flatMap((state) => {
+  const hot = TASK_WORKSPACE_STATES.filter((state) => state !== 'archive').flatMap((state) => {
     const taskMd = path.join(repoRoot, '.agents', 'workspace', state, taskId, 'task.md');
     if (!fs.existsSync(taskMd)) return [];
     const content = fs.readFileSync(taskMd, 'utf8');
@@ -56,6 +58,32 @@ function taskWorkspaceCandidates(repoRoot: string, taskId: string): TaskWorkspac
       taskMd
     }];
   });
+  const parts = findArchiveTaskParts(repoRoot, taskId);
+  if (parts.length === 0) return hot;
+  const taskMd = path.join(repoRoot, '.agents', 'workspace', 'archive', ...parts, 'local', 'task.md');
+  if (!fs.existsSync(taskMd)) return hot;
+  const content = fs.readFileSync(taskMd, 'utf8');
+  return [...hot, {
+    taskId,
+    branch: resolveBranchFromTaskContent(content, taskId),
+    state: 'archive',
+    taskMd
+  }];
+}
+
+function findArchiveTaskParts(repoRoot: string, taskId: string): string[] {
+  const archiveRoot = path.join(repoRoot, '.agents', 'workspace', 'archive');
+  if (!fs.existsSync(archiveRoot)) return [];
+  for (const year of fs.readdirSync(archiveRoot).sort().reverse()) {
+    if (!/^\d{4}$/.test(year)) continue;
+    for (const month of fs.readdirSync(path.join(archiveRoot, year)).sort().reverse()) {
+      if (!/^\d{2}$/.test(month)) continue;
+      for (const day of fs.readdirSync(path.join(archiveRoot, year, month)).sort().reverse()) {
+        if (/^\d{2}$/.test(day) && fs.existsSync(path.join(archiveRoot, year, month, day, taskId, 'local', 'task.md'))) return [year, month, day, taskId];
+      }
+    }
+  }
+  return [];
 }
 
 function resolveBranchFromTaskContent(content: string, taskId: string): string {
@@ -102,6 +130,27 @@ export function resolveTaskWorkspace(taskId: string, repoRoot: string): TaskWork
 
 export function listTaskWorkspaces(repoRoot: string, state: TaskWorkspaceState): TaskWorkspace[] {
   const stateRoot = path.join(repoRoot, '.agents', 'workspace', state);
+  if (state === 'archive') {
+    if (!fs.existsSync(stateRoot)) return [];
+    const rows: TaskWorkspace[] = [];
+    for (const year of fs.readdirSync(stateRoot).sort()) {
+      if (!/^\d{4}$/.test(year)) continue;
+      for (const month of fs.readdirSync(path.join(stateRoot, year)).sort()) {
+        if (!/^\d{2}$/.test(month)) continue;
+        for (const day of fs.readdirSync(path.join(stateRoot, year, month)).sort()) {
+          if (!/^\d{2}$/.test(day)) continue;
+          for (const taskId of fs.readdirSync(path.join(stateRoot, year, month, day)).sort()) {
+            if (!TASK_ID_RE.test(taskId)) continue;
+            const taskMd = path.join(stateRoot, year, month, day, taskId, 'local', 'task.md');
+            if (!fs.existsSync(taskMd)) continue;
+            const content = fs.readFileSync(taskMd, 'utf8');
+            rows.push({ taskId, branch: resolveBranchFromTaskContent(content, taskId), state, taskMd });
+          }
+        }
+      }
+    }
+    return rows;
+  }
   if (!fs.existsSync(stateRoot)) return [];
   return fs.readdirSync(stateRoot, { withFileTypes: true })
     .filter((entry) => entry.isDirectory() && TASK_ID_RE.test(entry.name))

package/lib/server/config.ts

@@ -1,8 +1,8 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { homedir } from 'node:os';
-import { createHash } from 'node:crypto';
 import { execFileSync } from 'node:child_process';
+import { resolvePrimaryWorktreeRoot } from '../git/primary-worktree.ts';
 
 export type ServerLogConfig = {
   path: string;
@@ -52,17 +52,7 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 
-// Daemon runtime state (log + PID) lives OUTSIDE the repo, under the user's home
-// directory, keyed by the .airc.json "project" AND a stable hash of the repo
-// root path:
-//   ~/.agent-infra/logs/<project>/<repo-hash>/server.log
-//   ~/.agent-infra/run/<project>/<repo-hash>/server.pid
-// The <project> segment groups a project's checkouts for readability; the
-// <repo-hash> segment guarantees that two checkouts/worktrees of the same
-// project (same "project" but different absolute path) get ISOLATED runtime
-// dirs, so they never read/control each other's daemon. Using os.homedir() +
-// path.join keeps this correct on Windows too (C:\Users\<name>\.agent-infra\...).
-// An explicit log.path in server.json/.local/env still overrides the log default.
+// Runtime state is shared by all worktrees through the primary checkout.
 function resolveProjectKey(repoRoot: string): string {
   try {
     const airc = JSON.parse(
@@ -77,13 +67,8 @@ function resolveProjectKey(repoRoot: string): string {
   return path.basename(repoRoot);
 }
 
-// Short, stable, filesystem-safe discriminator for a checkout's absolute path.
-function repoKey(repoRoot: string): string {
-  return createHash('sha256').update(repoRoot).digest('hex').slice(0, 12);
-}
-
-function runtimePath(repoRoot: string, projectKey: string, kind: 'logs' | 'run', file: string): string {
-  return path.join(homedir(), '.agent-infra', kind, projectKey, repoKey(repoRoot), file);
+function runtimePath(projectKey: string, kind: 'logs' | 'run', file: string): string {
+  return path.join(homedir(), '.agent-infra', kind, projectKey, file);
 }
 
 function detectRepoRoot(): string {
@@ -185,7 +170,7 @@ export function validateServerConfig(committed: Record<string, unknown>): Server
 }
 
 export function loadServerConfig({ rootDir }: { rootDir?: string } = {}): ServerConfig {
-  const repoRoot = rootDir ?? detectRepoRoot();
+  const repoRoot = resolvePrimaryWorktreeRoot(rootDir ?? detectRepoRoot());
   const agentsDir = path.join(repoRoot, '.agents');
 
   const committed = readJsonIfPresent(path.join(agentsDir, 'server.json'));
@@ -205,18 +190,11 @@ export function loadServerConfig({ rootDir }: { rootDir?: string } = {}): Server
   const projectKey = resolveProjectKey(repoRoot);
 
   const log = isPlainObject(merged.log) ? merged.log : {};
-  // No explicit log.path → default under ~/.agent-infra/logs/<project>/.
-  // Explicit relative path resolves against the repo root; absolute is used as-is.
-  const explicitPath = typeof log.path === 'string' ? log.path : null;
-  const resolvedLogPath = explicitPath === null
-    ? runtimePath(repoRoot, projectKey, 'logs', 'server.log')
-    : (path.isAbsolute(explicitPath) ? explicitPath : path.join(repoRoot, explicitPath));
-
   return {
     repoRoot,
-    pidFile: runtimePath(repoRoot, projectKey, 'run', 'server.pid'),
+    pidFile: runtimePath(projectKey, 'run', 'server.pid'),
     log: {
-      path: resolvedLogPath,
+      path: runtimePath(projectKey, 'logs', 'server.log'),
       rotateAtBytes: typeof log.rotateAtBytes === 'number' ? log.rotateAtBytes : DEFAULT_ROTATE_BYTES
     },
     heartbeatMs: typeof merged.heartbeatMs === 'number' ? merged.heartbeatMs : DEFAULT_SERVER_CONFIG.heartbeatMs,

package/lib/server/daemon.ts

@@ -83,7 +83,7 @@ export function createMessageDispatcher(options: MessageDispatcherOptions): (mes
           chunkChars: typeof options.config.stream?.chunkChars === 'number' ? options.config.stream.chunkChars : 4000,
           throttleMs: typeof options.config.stream?.throttleMs === 'number' ? options.config.stream.throttleMs : 1500
         },
-        (emit) => runAiImpl(plan.argv, { onChunk: emit }),
+        (emit) => runAiImpl(plan.argv, { onChunk: emit, cwd: options.config.repoRoot }),
         (outbound) => replyOutbound(message, outbound)
       );
     }
@@ -100,15 +100,17 @@ export function createMessageDispatcher(options: MessageDispatcherOptions): (mes
 //   - runDaemon() awaits a shutdown promise that only resolves once a
 //     SIGINT/SIGTERM handler has finished graceful cleanup. We never unref()
 //     the only keep-alive timer (that would let the process exit immediately).
-export async function runDaemon(): Promise<void> {
+export async function runDaemon({ rootDir }: { rootDir?: string } = {}): Promise<void> {
   let config;
   try {
-    config = loadServerConfig();
+    config = loadServerConfig({ rootDir });
   } catch (error) {
     process.stderr.write(`${errorMessage(error)}\n`);
     process.exit(1);
   }
 
+  process.chdir(config.repoRoot);
+
   const logger = createLogger(config.log);
   logger.info(`daemon starting agent-infra ${VERSION} pid=${process.pid}`);
   const ownStartTime = getProcessStartTime(process.pid);

package/lib/server/process-control.ts

@@ -1,4 +1,5 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { spawn, execFileSync } from 'node:child_process';
 import { loadServerConfig } from './config.ts';
 import type { ServerConfig } from './config.ts';
@@ -91,7 +92,7 @@ export async function start({ foreground = false }: StartOptions = {}): Promise<
   }
 
   if (foreground) {
-    await runDaemon();
+    await runDaemon({ rootDir: config.repoRoot });
     return;
   }
 
@@ -103,8 +104,9 @@ export async function start({ foreground = false }: StartOptions = {}): Promise<
   // Re-spawn ourselves detached. process.execArgv is forwarded so the dev path
   // (node --experimental-strip-types ./bin/cli.ts) and the built path
   // (node dist/bin/cli.js) both work.
-  const child = spawn(process.execPath, [...process.execArgv, cliEntry, 'server', '__daemon'], {
+  const child = spawn(process.execPath, [...process.execArgv, path.resolve(cliEntry), 'server', '__daemon'], {
     detached: true,
+    cwd: config.repoRoot,
     stdio: 'ignore'
   });
   child.unref();

package/lib/server/runner.ts

@@ -10,8 +10,9 @@ export type RunnerResult = {
 };
 
 export type RunnerOptions = {
-  spawn?: (file: string, args: string[], onChunk?: (chunk: string) => void | Promise<void>) => Promise<RunnerResult>;
+  spawn?: (file: string, args: string[], onChunk?: (chunk: string) => void | Promise<void>, cwd?: string) => Promise<RunnerResult>;
   onChunk?: (chunk: string) => void | Promise<void>;
+  cwd?: string;
 };
 
 function resolveCommand(file: string): string {
@@ -40,13 +41,15 @@ function needsShell(file: string): boolean {
 function spawnCapture(
   file: string,
   args: string[],
-  onChunk?: (chunk: string) => void | Promise<void>
+  onChunk?: (chunk: string) => void | Promise<void>,
+  cwd?: string
 ): Promise<RunnerResult> {
   return new Promise((resolve, reject) => {
     const resolvedFile = resolveCommand(file);
     const child = spawn(resolvedFile, args, {
       stdio: ['ignore', 'pipe', 'pipe'],
-      shell: needsShell(resolvedFile)
+      shell: needsShell(resolvedFile),
+      ...(cwd === undefined ? {} : { cwd })
     });
     let stdout = '';
     let stderr = '';
@@ -91,5 +94,5 @@ function spawnCapture(
 }
 
 export async function runAi(args: string[], options: RunnerOptions = {}): Promise<RunnerResult> {
-  return (options.spawn ?? spawnCapture)('ai', args, options.onChunk);
+  return (options.spawn ?? spawnCapture)('ai', args, options.onChunk, options.cwd);
 }

package/lib/server/server.schema.json

@@ -13,10 +13,6 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "path": {
-          "type": "string",
-          "description": "Log file path. Defaults to ~/.agent-infra/logs/<project>/<repo-hash>/server.log (outside the repo; the repo-hash isolates checkouts that share a project). Relative paths resolve against the repo root; absolute paths are used as-is."
-        },
         "rotateAtBytes": {
           "type": "integer",
           "minimum": 0,

package/lib/task/artifact-lifecycle.ts

@@ -9,6 +9,8 @@ import { parseImplementationInputs, selectPendingImplementationInput } from './i
 import { parseVerdict } from './review-artifacts.ts';
 import { extractSection, findSectionHeading } from './sections.ts';
 import { receiptForOutput, sha256File } from './artifact-receipts.ts';
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.ts';
+import { inspectReviewIdentity } from './review-identity.ts';
 import { isArtifactInvalidated, parseInvalidationDocument } from './invalidation.ts';
 import type { InvalidationDocument } from './invalidation.ts';
 import type { ArtifactFamily, ArtifactFamilySpec } from './artifact-name.ts';
@@ -228,7 +230,12 @@ function inspectArtifactDirectory(
     if (!knownRounds.has(round)) diagnostics.push(diagnostic('ROUND_GAP', family, null, `${artifactName(family, round)} is missing`));
   }
   const latest = artifacts.at(-1) ?? null;
-  const reviewedInput = family.startsWith('review-') && latest
+  let hasReviewCodeReceipt = false;
+  if (family === 'review-code' && latest) {
+    try { hasReviewCodeReceipt = Boolean(receiptForOutput(fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8'), latest.name)); }
+    catch { hasReviewCodeReceipt = false; }
+  }
+  const reviewedInput = family.startsWith('review-') && latest && (family !== 'review-code' || hasReviewCodeReceipt)
     ? resolveReviewedInput(taskDir, latest, family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code', diagnostics)
     : null;
   return {
@@ -316,14 +323,16 @@ function assertWritableInventory(inventory: ArtifactInventoryResult): ArtifactEr
 }
 
 const REQUIRED_INPUT: Partial<Record<ArtifactFamily, ArtifactFamily>> = {
-  'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan', 'review-code': 'code'
+  'review-analysis': 'analysis', plan: 'analysis', 'review-plan': 'plan'
 };
-const OPTIONAL_CONTEXT: Partial<Record<ArtifactFamily, { family: ArtifactFamily }>> = {
-  analysis: { family: 'review-analysis' },
-  plan: { family: 'review-plan' },
-  'review-code': { family: 'review-plan' },
-  'manual-validation': { family: 'review-code' },
-  'validation-run': { family: 'review-code' }
+const OPTIONAL_CONTEXT: Partial<Record<ArtifactFamily, readonly ArtifactFamily[]>> = {
+  analysis: ['review-analysis'],
+  plan: ['review-analysis', 'review-plan'],
+  'review-plan': ['review-analysis'],
+  code: ['review-plan'],
+  'review-code': ['code', 'plan', 'review-plan'],
+  'manual-validation': ['review-code'],
+  'validation-run': ['review-code']
 };
 function hasSelectionEvidence(
   content: string,
@@ -336,6 +345,18 @@ function hasSelectionEvidence(
   if (family.startsWith('review-')) {
     const reviewedFamily = family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
     const currentInput = context.inputs.find((input) => input.family === reviewedFamily);
+    if (family === 'review-code') {
+      if (!context.latest) return false;
+      try {
+        const reportContent = fs.readFileSync(context.latest.path, 'utf8');
+        const identity = inspectReviewIdentity(context.taskDir!, reportContent, options.repoRoot);
+        return identity.status !== 'matched'
+          || !hasArtifactCompletionFact(content, context.latest.path, 'review-code.completed')
+          || !hasArtifactCompletionLog(content, context.latest.name, 'review-code.completed');
+      } catch {
+        return true;
+      }
+    }
     if (currentInput && context.reviewedInput?.name !== currentInput.name) return true;
   }
   const target = family === 'analysis' ? 'analysis' : family === 'plan' ? 'plan' : family === 'code' ? 'code' : null;
@@ -450,9 +471,9 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
   }
   const optional = OPTIONAL_CONTEXT[inventory.family as ArtifactFamily];
   if (optional) {
-    const context = inspectTaskArtifacts(taskRef, optional.family, options);
-    if (context.status === 'ready' && context.latest) {
-      inputs.push(context.latest);
+    for (const family of optional) {
+      const context = inspectTaskArtifacts(taskRef, family, options);
+      if (context.status === 'ready' && context.latest) inputs.push(context.latest);
     }
   }
   if (inventory.family === 'manual-validation' || inventory.family === 'validation-run') {
@@ -473,6 +494,9 @@ function resolveCodeContext(inventory: ArtifactInventoryResult, options: Inspect
   const codeMax = latestCode?.round ?? 0;
   const reviewMax = reviewCode.latest?.round ?? 0;
   const inputs = [source.latest];
+  const sourceReviewFamily = inputFamily === 'analysis' ? 'review-analysis' : 'review-plan';
+  const sourceReview = inspectTaskArtifacts(taskRef, sourceReviewFamily, options);
+  if (sourceReview.status === 'ready' && sourceReview.latest && sourceReview.reviewedInput?.name === source.latest.name) inputs.push(sourceReview.latest);
   if (latestCode) {
     try {
       const taskContent = fs.readFileSync(path.join(inventory.taskDir!, 'task.md'), 'utf8');

package/lib/task/artifact-receipts.ts

@@ -7,24 +7,30 @@ import { extractSection, findSectionHeading, parseTable } from './sections.ts';
 const RECEIPT_SECTION_ALIASES = ['产物生命周期收据', 'Artifact Lifecycle Receipts'] as const;
 const RECEIPT_COLUMNS = ['event', 'output', 'input', 'input_sha256', 'completed_at'] as const;
 const RECEIPT_EVENTS = new Set([
+  'analysis.completed',
+  'plan.completed',
   'review-analysis.completed',
   'review-plan.completed',
+  'code.completed',
   'review-code.completed',
-  'code.completed'
 ]);
 const SHA256_RE = /^[a-f0-9]{64}$/;
 const RECEIPT_SHAPES = {
+  'analysis.completed': { output: 'analysis', input: 'review-analysis' },
+  'plan.completed': { output: 'plan', input: 'analysis' },
   'review-analysis.completed': { output: 'review-analysis', input: 'analysis' },
   'review-plan.completed': { output: 'review-plan', input: 'plan' },
-  'review-code.completed': { output: 'review-code', input: 'code' },
-  'code.completed': { output: 'code', input: 'plan' }
+  'code.completed': { output: 'code', input: 'plan' },
+  'review-code.completed': { output: 'review-code', input: 'code' }
 } as const;
 
 type ArtifactReceiptEvent =
+  | 'analysis.completed'
+  | 'plan.completed'
   | 'review-analysis.completed'
   | 'review-plan.completed'
-  | 'review-code.completed'
-  | 'code.completed';
+  | 'code.completed'
+  | 'review-code.completed';
 type ArtifactReceipt = {
   event: ArtifactReceiptEvent;
   output: string;
@@ -65,8 +71,16 @@ function validateReceiptShape(event: ArtifactReceiptEvent, output: string, input
   if (!outputIdentity || !inputIdentity) throw new ArtifactReceiptError(`receipt artifact identity is invalid: ${output} -> ${input}`);
   const shape = RECEIPT_SHAPES[event];
   const inputMatches = event === 'code.completed'
-    ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan'
-    : inputIdentity.family === shape.input;
+    ? inputIdentity.family === 'analysis' || inputIdentity.family === 'plan' || inputIdentity.family === 'review-analysis' || inputIdentity.family === 'review-plan' || inputIdentity.family === 'review-code'
+    : event === 'plan.completed'
+      ? inputIdentity.family === 'analysis' || inputIdentity.family === 'review-analysis' || inputIdentity.family === 'review-plan'
+      : event === 'analysis.completed'
+        ? inputIdentity.family === 'review-analysis'
+        : event === 'review-plan.completed'
+          ? inputIdentity.family === 'plan' || inputIdentity.family === 'review-analysis'
+          : event === 'review-code.completed'
+            ? inputIdentity.family === 'code' || inputIdentity.family === 'plan' || inputIdentity.family === 'review-plan'
+        : inputIdentity.family === shape.input;
   if (outputIdentity.family !== shape.output || !inputMatches) {
     throw new ArtifactReceiptError(`receipt event '${event}' does not match ${output} -> ${input}`);
   }
@@ -81,7 +95,9 @@ function parseArtifactReceipts(content: string): ArtifactReceiptParseResult {
     table = parseTable(content, {
       sectionAliases: [...RECEIPT_SECTION_ALIASES],
       columns: [...RECEIPT_COLUMNS],
-      keyColumn: 'output'
+      // A completed artifact can have multiple lifecycle inputs. Pair
+      // uniqueness is checked below because the table parser supports one key.
+      keyColumn: null
     });
   } catch (error) {
     throw new ArtifactReceiptError(error instanceof Error ? error.message : String(error));
@@ -109,15 +125,31 @@ function parseArtifactReceipts(content: string): ArtifactReceiptParseResult {
       completedAt
     };
   });
+  const edges = new Set<string>();
+  for (const row of rows) {
+    const edge = `${row.output}\0${row.input}`;
+    if (edges.has(edge)) throw new ArtifactReceiptError(`duplicate receipt edge '${row.output}' <- '${row.input}'`);
+    edges.add(edge);
+  }
   return { present: true, rows };
 }
 
+function receiptsForOutput(content: string, output: string): readonly ArtifactReceipt[] {
+  return parseArtifactReceipts(content).rows.filter((row) => row.output === output);
+}
+
 function receiptForOutput(content: string, output: string): ArtifactReceipt | null {
-  const parsed = parseArtifactReceipts(content);
-  return parsed.rows.find((row) => row.output === output) ?? null;
+  return receiptsForOutput(content, output)[0] ?? null;
 }
 
 function upsertArtifactReceipt(content: string, receipt: ArtifactReceipt): ReceiptSectionMutation {
+  return upsertArtifactReceipts(content, [receipt]);
+}
+
+function upsertArtifactReceipts(content: string, receiptsToAdd: readonly ArtifactReceipt[]): ReceiptSectionMutation {
+  if (receiptsToAdd.length === 0) throw new ArtifactReceiptError('at least one receipt is required');
+  const additions = new Map<string, ArtifactReceipt>();
+  for (const receipt of receiptsToAdd) {
   if (!RECEIPT_EVENTS.has(receipt.event)) throw new ArtifactReceiptError(`unknown receipt event '${receipt.event}'`);
   if (!receipt.output || !receipt.input) throw new ArtifactReceiptError('receipt output and input are required');
   validateReceiptShape(receipt.event, receipt.output, receipt.input);
@@ -126,12 +158,18 @@ function upsertArtifactReceipt(content: string, receipt: ArtifactReceipt): Recei
     throw new ArtifactReceiptError(`receipt completion time for '${receipt.output}' is invalid`);
   }
 
+    const key = `${receipt.output}\0${receipt.input}`;
+    const duplicate = additions.get(key);
+    if (duplicate && JSON.stringify(duplicate) !== JSON.stringify(receipt)) throw new ArtifactReceiptError(`receipt for '${receipt.output}' from '${receipt.input}' has conflicting evidence`);
+    additions.set(key, receipt);
+  }
   const existing = parseArtifactReceipts(content).rows;
-  const previous = existing.find((row) => row.output === receipt.output);
-  if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) {
-    throw new ArtifactReceiptError(`receipt for '${receipt.output}' already exists with different evidence`);
+  for (const receipt of additions.values()) {
+    const previous = existing.find((row) => row.output === receipt.output && row.input === receipt.input);
+    if (previous && JSON.stringify(previous) !== JSON.stringify(receipt)) throw new ArtifactReceiptError(`receipt for '${receipt.output}' from '${receipt.input}' already exists with different evidence`);
   }
-  const rows = previous ? existing : [...existing, receipt];
+  const rows = [...existing];
+  for (const receipt of additions.values()) if (!rows.some((row) => row.output === receipt.output && row.input === receipt.input)) rows.push(receipt);
   const heading = findSectionHeading(content, [...RECEIPT_SECTION_ALIASES]);
   const body = [
     `| ${RECEIPT_COLUMNS.join(' | ')} |`,
@@ -146,8 +184,10 @@ export {
   RECEIPT_SECTION_ALIASES,
   parseArtifactReceipts,
   receiptForOutput,
+  receiptsForOutput,
   sha256Bytes,
   sha256File,
-  upsertArtifactReceipt
+  upsertArtifactReceipt,
+  upsertArtifactReceipts
 };
 export type { ArtifactReceipt, ArtifactReceiptEvent, ArtifactReceiptParseResult, ReceiptSectionMutation };