@fitlab-ai/agent-infra 0.9.4 → 0.9.6

package/lib/sandbox/workspace-view.ts

@@ -9,6 +9,23 @@ export type SandboxWorkspaceView = Readonly<{
   taskMountPath: string | null;
 }>;
 
+export const SANDBOX_WORKSPACE_VIEW_STATES = Object.freeze([
+  'active',
+  'completed',
+  'blocked',
+  'archive'
+] as const);
+
+export function sandboxWorkspaceViewStatePaths(root: string): ReadonlyArray<Readonly<{
+  state: typeof SANDBOX_WORKSPACE_VIEW_STATES[number];
+  hostPath: string;
+}>> {
+  return SANDBOX_WORKSPACE_VIEW_STATES.map((state) => ({
+    state,
+    hostPath: path.join(root, state)
+  }));
+}
+
 export function sandboxWorkspaceViewPaths(params: Readonly<{
   base: string;
   project: string;
@@ -31,8 +48,10 @@ export function sandboxWorkspaceViewPaths(params: Readonly<{
 
 export type SandboxControlSetup = Readonly<{
   channelDir: string;
+  statusDir: string;
   manifestPath: string;
   token: string;
+  generation: string;
 }>;
 
 export function sandboxControlPaths(params: Readonly<{
@@ -40,13 +59,19 @@ export function sandboxControlPaths(params: Readonly<{
   project: string;
   container: string;
   identity: SandboxWorkspaceIdentity;
-}>): Readonly<{ root: string; channelDir: string; manifestPath: string }> {
+}>): Readonly<{ root: string; channelDir: string; statusDir: string; processingDir: string; manifestPath: string }> {
   const identityKey = params.identity.mode === 'task-bound'
     ? `task-bound:${params.identity.taskId}`
     : 'branch-only';
   const digest = createHash('sha256').update(identityKey).digest('hex').slice(0, 16);
   const root = path.resolve(params.base, params.project, params.container, digest);
-  return { root, channelDir: path.join(root, 'channel'), manifestPath: path.join(root, 'manifest.json') };
+  return {
+    root,
+    channelDir: path.join(root, 'channel'),
+    statusDir: path.join(root, 'public'),
+    processingDir: path.join(root, 'processing'),
+    manifestPath: path.join(root, 'manifest.json')
+  };
 }
 
 function assertSafeDirectory(directory: string, expectedBase: string): void {
@@ -59,6 +84,44 @@ function assertSafeDirectory(directory: string, expectedBase: string): void {
   }
 }
 
+function assertSafeMountTargetPath(target: string, worktreeRoot: string, canonicalWorktreeRoot: string): void {
+  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 as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+    }
+  }
+}
+
+export function prepareSandboxWorkspaceMountTargets(worktreeRoot: string): void {
+  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: string, taskId: string): string {
   if (!/^TASK-\d{8}-\d{6}$/.test(taskId)) throw new Error('SANDBOX_TASK_SOURCE_INVALID');
   const activeRoot = fs.realpathSync.native(path.join(repoRoot, '.agents', 'workspace', 'active'));
@@ -85,11 +148,10 @@ export function materializeSandboxWorkspaceView(params: Readonly<{
   assertSafeDirectory(projectRoot, path.resolve(params.base));
   assertSafeDirectory(root, projectRoot);
   fs.mkdirSync(root, { recursive: true, mode: 0o700 });
-  for (const state of ['active', 'completed', 'blocked', 'archive']) {
-    const stateDir = path.join(root, state);
-    assertSafeDirectory(stateDir, root);
-    fs.rmSync(stateDir, { recursive: true, force: true });
-    fs.mkdirSync(stateDir, { recursive: true, mode: 0o700 });
+  for (const { hostPath } of sandboxWorkspaceViewStatePaths(root)) {
+    assertSafeDirectory(hostPath, root);
+    fs.rmSync(hostPath, { recursive: true, force: true });
+    fs.mkdirSync(hostPath, { recursive: true, mode: 0o700 });
   }
 
   const active = path.join(root, 'active');
@@ -113,13 +175,22 @@ export function materializeSandboxWorkspaceView(params: Readonly<{
 export function materializeSandboxControl(params: Readonly<{
   base: string;
   repoRoot: string;
+  worktreeRoot: string;
   project: string;
   container: string;
   branch: string;
   identity: SandboxWorkspaceIdentity;
 }>): SandboxControlSetup {
-  const { root, channelDir, manifestPath } = sandboxControlPaths(params);
+  const { root, channelDir, statusDir, processingDir, manifestPath } = sandboxControlPaths(params);
   assertSafeDirectory(root, path.resolve(params.base));
+  const consumedDir = path.join(root, 'consumed');
+  assertSafeDirectory(consumedDir, root);
+  fs.rmSync(consumedDir, { recursive: true, force: true });
+  fs.mkdirSync(consumedDir, { recursive: true, mode: 0o700 });
+  for (const directory of [statusDir, processingDir]) {
+    assertSafeDirectory(directory, root);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+  }
   for (const queue of ['requests', 'responses']) {
     const directory = path.join(channelDir, queue);
     assertSafeDirectory(directory, root);
@@ -127,17 +198,23 @@ export function materializeSandboxControl(params: Readonly<{
     fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
   }
   const token = randomBytes(32).toString('hex');
+  const generation = randomBytes(16).toString('hex');
+  const repoRoot = fs.realpathSync.native(params.repoRoot);
   const manifest: SandboxControlManifest = {
-    version: 1,
-    repoRoot: fs.realpathSync.native(params.repoRoot),
+    version: 3,
+    repoRoot,
+    worktreeRoot: fs.realpathSync.native(params.worktreeRoot),
     project: params.project,
     container: params.container,
     branch: params.branch,
     mode: params.identity.mode,
     taskId: params.identity.mode === 'task-bound' ? params.identity.taskId : null,
     token,
-    channelDir
+    generation,
+    channelDir,
+    publicStatusDir: statusDir,
+    processingDir
   };
   fs.writeFileSync(manifestPath, `${JSON.stringify(manifest)}\n`, { mode: 0o600 });
-  return { channelDir, manifestPath, token };
+  return { channelDir, statusDir, manifestPath, token, generation };
 }

package/lib/sandbox/worktree-safety.ts

@@ -0,0 +1,234 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { runProbe } from './shell.ts';
+
+type WorktreeChange = {
+  indexStatus: string;
+  worktreeStatus: string;
+  path: string;
+  originalPath?: string;
+};
+
+type WorktreeSnapshot = {
+  worktree: string;
+  branch: string;
+  head: string;
+  changes: readonly WorktreeChange[];
+  identity: string;
+};
+
+type WorktreeInspection =
+  | { status: 'clean'; snapshot: WorktreeSnapshot }
+  | { status: 'dirty'; snapshot: WorktreeSnapshot }
+  | { status: 'failed'; worktree: string; message: string };
+
+type WorktreeRemovalPermit = {
+  mode: 'clean' | 'discard';
+  snapshot: WorktreeSnapshot;
+};
+
+type Probe = typeof runProbe;
+
+function probeText(probe: Probe, cwd: string, args: string[]): string {
+  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: string): WorktreeChange[] {
+  const records = raw.split('\0');
+  const changes: WorktreeChange[] = [];
+  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: ReturnType<typeof createHash>, label: string, value: string | Buffer): void {
+  const data = Buffer.isBuffer(value) ? value : Buffer.from(value, 'utf8');
+  hash.update(`${label.length}:${label}:${data.length}:`, 'utf8');
+  hash.update(data);
+}
+
+function resolveSnapshotPath(worktree: string, relativePath: string): string {
+  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: ReturnType<typeof createHash>, worktree: string, relativePath: string, probe: Probe): void {
+  updatePart(hash, 'path', relativePath);
+  const target = resolveSnapshotPath(worktree, relativePath);
+  let stat: fs.Stats;
+  try {
+    stat = fs.lstatSync(target);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).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: string, probe: Probe): WorktreeSnapshot {
+  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: string, { probe = runProbe }: { probe?: Probe } = {}): WorktreeInspection {
+  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: readonly string[]): WorktreeInspection[] {
+  return [...new Set(worktrees.map((worktree) => path.resolve(worktree)))].sort()
+    .map((worktree) => inspectWorktree(worktree));
+}
+
+function createCleanPermit(snapshot: WorktreeSnapshot): WorktreeRemovalPermit {
+  if (snapshot.changes.length > 0) throw new Error('Cannot create a clean permit for a dirty worktree');
+  return { mode: 'clean', snapshot };
+}
+
+function createDiscardPermit(snapshot: WorktreeSnapshot): WorktreeRemovalPermit {
+  if (snapshot.changes.length === 0) throw new Error('Cannot create a discard permit for a clean worktree');
+  return { mode: 'discard', snapshot };
+}
+
+function verifyWorktreePermit(
+  permit: WorktreeRemovalPermit,
+  options: { probe?: Probe } = {}
+): WorktreeSnapshot {
+  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: WorktreeSnapshot): string {
+  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
+};
+export type { WorktreeChange, WorktreeInspection, WorktreeRemovalPermit, WorktreeSnapshot };

package/lib/server/process-control.ts

@@ -24,6 +24,17 @@ export type StopCommand =
   | { kind: 'signal'; signal: NodeJS.Signals }
   | { kind: 'exec'; command: string; args: string[] };
 
+export type ProcessTreeStopCommand =
+  | { kind: 'group-signal'; pid: number; signal: NodeJS.Signals }
+  | { kind: 'exec'; command: string; args: string[] };
+
+export function buildProcessTreeStopCommand(pid: number, platform: NodeJS.Platform): ProcessTreeStopCommand {
+  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: number, platform: NodeJS.Platform): StopCommand {
   if (platform === 'win32') {
     return { kind: 'exec', command: 'taskkill', args: ['/PID', String(pid), '/T', '/F'] };

package/lib/task/activity-log.ts

@@ -2,10 +2,14 @@ const HEADING_RE = /^##\s+(活动日志|Activity Log)\s*$/;
 const NEXT_H2_RE = /^##\s/;
 const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*\*(.+?)\*\* by (.+?) — (.*)$/;
 const STARTED_SUFFIX_RE = /\s*\[started\]\s*$/;
+const ABORTED_SUFFIX_RE = /\s*\[aborted\]\s*$/;
+const ATTEMPT_RE = /(?:^|;\s*)attempt=([A-Za-z0-9-]{8,64})(?:;|$)/;
+const COMMIT_STARTED_RE = /^started; attempt=([A-Za-z0-9-]{8,64}); baseline=([a-f0-9]{40,64}); agent=([a-z-]+)$/;
 
 type LogEntry = { time: string; step: string; agent: string; note: string };
-type StepRow = { step: string; agent: string; started: string; done: string; note: string };
+type StepRow = { step: string; agent: string; started: string; done: string; note: string; attempt?: string };
 type ActivityLogSection = { heading: string; body: string; entries: LogEntry[] };
+type CommitAttempt = Readonly<{ attempt: string; baseline: string; agent: string }>;
 
 function parseActivityLog(content: string): { sectionFound: boolean; entries: LogEntry[] } {
   const section = locateActivityLog(content);
@@ -37,26 +41,61 @@ function appendActivityEntry(section: ActivityLogSection, entry: LogEntry): stri
   return section.body ? `${section.body}\n${line}` : line;
 }
 
+function activityAttempt(note: string): string | null {
+  return ATTEMPT_RE.exec(note)?.[1] ?? null;
+}
+
+function parseCommitAttemptStarted(note: string): CommitAttempt | null {
+  const match = COMMIT_STARTED_RE.exec(note);
+  return match ? { attempt: match[1]!, baseline: match[2]!, agent: match[3]! } : null;
+}
+
+function commitAttemptStartedNote(attempt: CommitAttempt): string {
+  return `started; attempt=${attempt.attempt}; baseline=${attempt.baseline}; agent=${attempt.agent}`;
+}
+
 function pairEntries(entries: LogEntry[]): StepRow[] {
   const rows: StepRow[] = [];
   const open = new Map<string, StepRow[]>();
   for (const entry of entries) {
     const started = STARTED_SUFFIX_RE.test(entry.step);
-    const base = entry.step.replace(STARTED_SUFFIX_RE, '');
+    const aborted = ABORTED_SUFFIX_RE.test(entry.step);
+    const base = entry.step.replace(STARTED_SUFFIX_RE, '').replace(ABORTED_SUFFIX_RE, '');
     if (started) {
-      const row = { step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note };
+      const attempt = activityAttempt(entry.note);
+      const row: StepRow = {
+        step: base, agent: entry.agent, started: entry.time, done: '', note: entry.note,
+        ...(attempt ? { attempt } : {})
+      };
       rows.push(row);
       const queue = open.get(base) ?? [];
       queue.push(row);
       open.set(base, queue);
     } else {
-      const pending = open.get(base)?.shift();
+      const queue = open.get(base) ?? [];
+      const terminalAttempt = aborted ? activityAttempt(entry.note) : null;
+      const pendingIndex = terminalAttempt === null
+        ? 0
+        : queue.findIndex((row) => row.attempt === terminalAttempt);
+      const pending = pendingIndex >= 0 ? queue.splice(pendingIndex, 1)[0] : undefined;
       if (pending) Object.assign(pending, { done: entry.time, agent: entry.agent, note: entry.note });
-      else rows.push({ step: base, agent: entry.agent, started: '', done: entry.time, note: entry.note });
+      else rows.push({
+        step: aborted ? entry.step : base,
+        agent: entry.agent, started: '', done: entry.time, note: entry.note,
+        ...(terminalAttempt ? { attempt: terminalAttempt } : {})
+      });
     }
   }
   return rows;
 }
 
-export { parseActivityLog, locateActivityLog, appendActivityEntry, pairEntries };
-export type { LogEntry, StepRow, ActivityLogSection };
+export {
+  activityAttempt,
+  appendActivityEntry,
+  commitAttemptStartedNote,
+  locateActivityLog,
+  pairEntries,
+  parseActivityLog,
+  parseCommitAttemptStarted
+};
+export type { ActivityLogSection, CommitAttempt, LogEntry, StepRow };

package/lib/task/artifact-lifecycle.ts

@@ -16,6 +16,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'] }
 ] as const;
 
@@ -257,7 +258,8 @@ const OPTIONAL_CONTEXT: Partial<Record<ArtifactFamily, { family: ArtifactFamily;
   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: string, family: string, options: InspectOptions = {}): ArtifactContextResult {
@@ -376,12 +378,11 @@ function resolveDecisionImplementationInput(
   if (pending.length === 0) return { input: null };
   const activity = locateActivityLog(content);
   if (!activity) return { error: 'task has no unique Activity Log section' };
-  const reviewEntries = activity.entries.filter((entry) =>
+  const completed = activity.entries.some((entry) =>
     /^Review Code \(Round \d+\)$/.test(entry.step) && entry.note.includes(`→ ${review.name}`)
   );
-  const completed = reviewEntries.at(-1);
   if (!completed) return { error: `cannot find completed Activity Log identity for ${review.name}` };
-  try { return { input: selectPendingImplementationInput(rows, completed.time) }; }
+  try { return { input: selectPendingImplementationInput(rows) }; }
   catch (error) { return { error: error instanceof Error ? error.message : String(error) }; }
 }