@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/sandbox/shell.ts

@@ -1,7 +1,7 @@
 import { execFileSync, spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import type { ExecFileSyncOptions, StdioOptions, SpawnSyncOptions, SpawnSyncReturns } from 'node:child_process';
+import type { ExecFileSyncOptions, StdioOptions, SpawnSyncReturns } from 'node:child_process';
 import { getAdapter } from './engines/index.ts';
 
 const DEFAULT_TIMEOUT_MS = 60 * 60 * 1000;

package/lib/sandbox/task-resolver.ts

@@ -1,11 +1,8 @@
-import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { isRemovedHashShortIdInput } from '../task/short-id.ts';
 import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.ts';
 
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
-const SHORT_ID_RE = /^\d+$/;
 export const TASK_WORKSPACE_STATES = ['active', 'completed', 'blocked', 'archive'] as const;
 export type TaskWorkspaceState = typeof TASK_WORKSPACE_STATES[number];
 export type TaskWorkspace = Readonly<{
@@ -15,39 +12,10 @@ export type TaskWorkspace = Readonly<{
   taskMd: string;
 }>;
 
-function resolveShortIdStrict(arg: string, repoRoot: string): string {
-  const scriptPath = path.join(repoRoot, '.agents', 'scripts', 'task-short-id.js');
-  if (!fs.existsSync(scriptPath)) {
-    throw new Error(
-      `Short id '${arg}' provided but task-short-id.js script is missing at ${scriptPath}`
-    );
-  }
-  const result = spawnSync('node', [scriptPath, 'resolve', arg], { encoding: 'utf8', cwd: repoRoot });
-  if (result.status !== 0) {
-    throw new Error(
-      `Short id '${arg}' not found in active task registry: ${(result.stderr || '').trim()}`
-    );
-  }
-  return result.stdout.trim();
-}
-
 function stripQuotes(value: string): string {
   return value.replace(/^(["'])(.*)\1$/, '$2');
 }
 
-function readTaskContent(repoRoot: string, taskId: string): { content: string; state: TaskWorkspaceState; taskMd: string } {
-  const taskRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
-  for (const state of TASK_WORKSPACE_STATES) {
-    const taskPath = state === 'archive'
-      ? path.join(taskRoot, state, ...findArchiveTaskParts(repoRoot, taskId), 'local', 'task.md')
-      : path.join(taskRoot, state, taskId, 'task.md');
-    if (fs.existsSync(taskPath)) {
-      return { content: fs.readFileSync(taskPath, 'utf8'), state, taskMd: taskPath };
-    }
-  }
-  throw new Error(`Task not found: ${taskId}`);
-}
-
 function taskWorkspaceCandidates(repoRoot: string, taskId: string): TaskWorkspace[] {
   const taskRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
   const hot = TASK_WORKSPACE_STATES.filter((state) => state !== 'archive').flatMap((state) => {
@@ -103,22 +71,6 @@ function resolveBranchFromTaskContent(content: string, taskId: string): string {
   throw new Error(`Task ${taskId} has no branch field in task.md`);
 }
 
-export function resolveTaskBranch(arg: string, repoRoot: string): string {
-  if (isRemovedHashShortIdInput(arg)) {
-    throw new Error(`Invalid task short id '${arg}': task short ids must use bare digits`);
-  }
-  if (SHORT_ID_RE.test(arg)) {
-    const taskId = resolveShortIdStrict(arg, repoRoot);
-    const { content } = readTaskContent(repoRoot, taskId);
-    return resolveBranchFromTaskContent(content, taskId);
-  }
-  if (!TASK_ID_RE.test(arg)) {
-    return arg;
-  }
-  const { content } = readTaskContent(repoRoot, arg);
-  return resolveBranchFromTaskContent(content, arg);
-}
-
 export function resolveTaskWorkspace(taskId: string, repoRoot: string): TaskWorkspace {
   if (!TASK_ID_RE.test(taskId)) throw new Error(`Invalid task id: ${taskId}`);
   const matches = taskWorkspaceCandidates(repoRoot, taskId);

package/lib/sandbox/tools.ts

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { createSandboxCapabilityPlan } from './agent-client-reconciler.ts';
-import { safeNameCandidates, sanitizeBranchName } from './constants.ts';
+import { safeNameCandidates } from './constants.ts';
 import { hostJoin } from './engines/wsl2-paths.ts';
 import type { SandboxTool, SandboxToolInstall } from './tool-types.ts';
 
@@ -287,10 +287,6 @@ export function resolveTools(config: ToolsConfig): SandboxTool[] {
   return [...createSandboxCapabilityPlan(config).tools];
 }
 
-export function toolConfigDir(tool: SandboxTool, project: string, branch: string): string {
-  return hostJoin(tool.sandboxBase, project, sanitizeBranchName(branch));
-}
-
 export function toolConfigDirCandidates(tool: SandboxTool, project: string, branch: string): string[] {
   return safeNameCandidates(branch).map((name) => hostJoin(tool.sandboxBase, project, name));
 }

package/lib/sandbox/workspace-view.ts

@@ -59,7 +59,7 @@ export type SandboxControlSetup = Readonly<{
   controlRootId: string;
 }>;
 
-export type SandboxControlManifestDraft = Readonly<Omit<SandboxControlManifest, 'containerIdentity' | 'engine' | 'authorityEvidence'> & {
+export type SandboxControlManifestDraft = Readonly<Omit<SandboxControlManifest, 'containerIdentity' | 'engine'> & {
   engine: string;
 }>;
 
@@ -355,15 +355,13 @@ export function finalizeSandboxControlManifest(
     engine: string;
     id: string;
     labels: Readonly<Record<string, string>>;
-    authorityEvidence: SandboxControlManifest['authorityEvidence'];
   }>
 ): SandboxControlManifest {
   if (!identity.engine || !identity.id) throw new Error('SANDBOX_CONTROL_CONTAINER_ID_INVALID');
   const manifest: SandboxControlManifest = {
     ...setup.manifestDraft,
     engine: identity.engine,
-    containerIdentity: { id: identity.id, labels: { ...identity.labels } },
-    authorityEvidence: identity.authorityEvidence
+    containerIdentity: { id: identity.id, labels: { ...identity.labels } }
   };
   const persistedManifest = {
     ...manifest,

package/lib/server/display.ts

@@ -32,10 +32,6 @@ export function markdownMessage(markdown: string): DisplayMessage {
   return { kind: 'markdown', markdown };
 }
 
-export function tableMessage(columns: string[], rows: string[][], title?: string): DisplayMessage {
-  return { kind: 'table', title, columns, rows };
-}
-
 export function statusCard(
   title: string,
   tone: DisplayTone,
@@ -59,16 +55,6 @@ export function streamEvent(
   return message;
 }
 
-export function commandResult(
-  title: string,
-  exitCode: number | null,
-  signal: NodeJS.Signals | null,
-  stdout?: string,
-  stderr?: string
-): DisplayMessage {
-  return { kind: 'command-result', title, exitCode, signal, stdout, stderr };
-}
-
 export function normalizeOutbound(message: OutboundMessage): DisplayMessage {
   return typeof message === 'string' ? textMessage(message) : message;
 }

package/lib/server/process-control.ts

@@ -12,7 +12,7 @@ import {
   removePidFileIfMatches,
   writePidRecord
 } from './process-state.ts';
-import type { PidRecord, ProcessIdentity, ProcessState } from './process-state.ts';
+import type { PidRecord, ProcessIdentity } from './process-state.ts';
 
 export { isProcessAlive } from './process-state.ts';
 

package/lib/task/activity-intent.ts

@@ -2,7 +2,8 @@ import fs from 'node:fs';
 
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
-import { locateActivityLog, appendActivityEntry } from './activity-log.ts';
+import { locateActivityLog, appendActivityEntry, inspectActivityLog } from './activity-log.ts';
+import { lifecycleExecutions, prReviewExecution, serializeLifecycleExecution } from './lifecycle-execution.ts';
 import {
   assertWritableInventory,
   buildArtifactLinkSection,
@@ -82,6 +83,7 @@ export type PrReviewActivityResult = {
   artifact: string | null;
   operations: readonly TaskOperationSummary[];
   error: { code: string; message: string } | null;
+  warnings?: readonly { code: string; message: string }[];
 };
 
 export type PrReviewInspectionResult = {
@@ -102,7 +104,6 @@ type RoundState = ArtifactRecord & {
 };
 
 const HEAD_RE = /^[0-9a-f]{40}$/;
-const REVIEW_ACTION_RE = /^Review PR \(Round ([1-9]\d*)\)( \[started\])?$/;
 const VERDICTS: ReadonlySet<string> = new Set(['approved', 'changes-requested', 'commented']);
 const OUTCOMES: ReadonlySet<string> = new Set(['aborted', 'superseded']);
 const SUCCESS_STATUSES: ReadonlySet<PrReviewArtifactStatus> = new Set(['applied', 'no-op']);
@@ -181,48 +182,28 @@ function readSnapshot(taskRef: string, repoRoot?: string):
   } catch (error) {
     return { ok: false, code: 'TASK_READ_FAILED', message: error instanceof Error ? error.message : String(error), taskId: resolved.taskId };
   }
-  const activity = locateActivityLog(content);
-  if (!activity) return { ok: false, code: 'ACTIVITY_SECTION_MISSING', message: 'task has no unique Activity Log section', taskId: resolved.taskId };
-
-  const knownRounds = new Set(inventory.artifacts.map((artifact) => artifact.round));
-  for (const entry of activity.entries) {
-    const match = REVIEW_ACTION_RE.exec(entry.step);
-    if (match && !knownRounds.has(Number(match[1]))) {
-      return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: `Activity Log round ${match[1]} has no canonical pr-review artifact`, taskId: resolved.taskId };
-    }
-  }
-
+  let pr;
+  try { pr = prReviewExecution(content); }
+  catch (error) { return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: String(error), taskId: resolved.taskId }; }
   const states: RoundState[] = [];
   for (const identity of inventory.artifacts) {
     const parsed = parseArtifactRecord(identity);
     if ('code' in parsed) return { ok: false, ...parsed, taskId: resolved.taskId };
-    const base = `Review PR (Round ${identity.round})`;
-    const started = activity.entries.filter((entry) => entry.step === `${base} [started]`);
-    const terminal = activity.entries.filter((entry) => entry.step === base);
-    if (started.length > 1 || terminal.length > 1) {
-      return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: `${base} has duplicate started or terminal rows`, taskId: resolved.taskId };
-    }
-    if (terminal.length === 1 && started.length === 0 && !terminal[0]!.note.startsWith('receipt ')) {
-      return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: `${base} has a terminal row without a matching started row`, taskId: resolved.taskId };
+    const started = pr.open?.artifact === identity.name ? pr.open : null;
+    const terminals = pr.terminals.filter((entry) => entry.artifact === identity.name);
+    if (terminals.length > 1) return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: `duplicate PR review terminal for ${identity.name}`, taskId: resolved.taskId };
+    const terminal = terminals[0];
+    if (terminal) {
+      const matches = (terminal.note.startsWith('Verdict: ') && LOCAL_COMPLETION_STATUSES.has(parsed.status))
+        || (terminal.note.startsWith('Outcome: Aborted, ') && parsed.status === 'aborted')
+        || (terminal.note.startsWith('Outcome: Superseded, ') && parsed.status === 'superseded')
+        || (terminal.note.startsWith('receipt ') && SUCCESS_STATUSES.has(parsed.status));
+      if (!matches) return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: `terminal note conflicts with artifact status ${parsed.status}`, taskId: resolved.taskId };
     }
-    if (terminal.length === 1) {
-      const note = terminal[0]!.note;
-      const terminalMatchesStatus =
-        (note.startsWith('Verdict: ') && LOCAL_COMPLETION_STATUSES.has(parsed.status))
-        || (note.startsWith('Outcome: Aborted, ') && parsed.status === 'aborted')
-        || (note.startsWith('Outcome: Superseded, ') && parsed.status === 'superseded')
-        || (note.startsWith('receipt ') && SUCCESS_STATUSES.has(parsed.status));
-      if (!terminalMatchesStatus) {
-        return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: `${base} terminal note conflicts with artifact status ${parsed.status}`, taskId: resolved.taskId };
-      }
-    }
-    states.push({
-      ...parsed,
-      startedAgent: started[0]?.agent ?? null,
-      terminalAgent: terminal[0]?.agent ?? null,
-      terminalNote: terminal[0]?.note ?? null
-    });
+    if ((started && started.head !== parsed.head) || (terminal && terminal.head !== parsed.head)) return { ok: false, code: 'ACTIVITY_IDENTITY_MISMATCH', message: `head does not match ${identity.name}`, taskId: resolved.taskId };
+    states.push({ ...parsed, startedAgent: started?.agent ?? null, terminalAgent: terminal?.agent ?? null, terminalNote: terminal?.note ?? null });
   }
+  if ((pr.open && !states.some((state) => state.identity.name === pr.open!.artifact)) || pr.terminals.some((entry) => !states.some((state) => state.identity.name === entry.artifact))) return { ok: false, code: 'ACTIVITY_STATE_CONFLICT', message: 'PR review execution references a missing artifact', taskId: resolved.taskId };
 
   const openStates = states.filter((state) => state.startedAgent !== null && state.terminalNote === null);
   const preparedStates = states.filter((state) => state.status === 'pending' && state.startedAgent === null && state.terminalNote === null);
@@ -353,11 +334,15 @@ function applyActivityIntent(intent: PrReviewActivityIntent, normalizedAgent: st
   } catch (error) {
     return failed(intent, 'METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), state.taskId);
   }
-  const section = locateActivityLog(state.content)!;
-  const mutations: TaskMutation[] = [{
-    kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading,
-    body: appendActivityEntry(section, { time: metadata.timestamp, step, agent: normalizedAgent, note })
-  }];
+  const section = locateActivityLog(state.content);
+  const pr = prReviewExecution(state.content);
+  if (intent.kind === 'pr-review-start') pr.open = { artifact: intent.artifact, head: intent.head, agent: normalizedAgent, startedAt: metadata.timestamp };
+  else {
+    pr.open = null;
+    pr.terminals.push({ artifact: intent.artifact, head: intent.head, agent: normalizedAgent, note });
+  }
+  const mutations: TaskMutation[] = [{ kind: 'frontmatter', lifecycleExecutionDomain: 'pr-review', set: { lifecycle_execution: serializeLifecycleExecution(lifecycleExecutions(state.content), state.content, pr) } }];
+  if (section) mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body: appendActivityEntry(section, { time: metadata.timestamp, step, agent: normalizedAgent, note }) });
   if (linkArtifact) {
     const link = buildArtifactLinkSection(state.content, roundState.identity);
     mutations.push({ kind: 'section', aliases: link.aliases, heading: link.heading, body: link.body });
@@ -399,7 +384,14 @@ export function applyPrReviewActivityIntent(intent: PrReviewActivityIntent, opti
   if (resolved.state !== 'active') {
     return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   }
-  return applyActivityIntent(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
+  let warnings: { code: string; message: string }[] = [];
+  try {
+    const inspected = inspectActivityLog(fs.readFileSync(resolved.taskMdPath, 'utf8'));
+    warnings = !inspected.section ? [{ code: 'ACTIVITY_LOG_UNAVAILABLE', message: 'Activity Log is missing or ambiguous' }] : inspected.invalidEntries.length ? [{ code: 'ACTIVITY_LOG_INVALID_ENTRIES', message: 'Activity Log contains malformed entries' }] : [];
+  } catch { /* The operation reports read errors. */ }
+  const result = applyActivityIntent(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
+  if (result.status === 'failed') return result;
+  return warnings.length ? { ...result, warnings } : result;
 }
 
 export type { ActivityIntentOptions };

package/lib/task/activity-log.ts

@@ -3,13 +3,10 @@ const ENTRY_RE = /^- (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}[+-]\d{2}:\d{2}) — \*
 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-]+)$/;
-const LIFECYCLE_STEP_RE = /^(?:Complete Manual Validation|(?:Analyze Task|Review Analysis|Plan Task|Review Plan|Code Task|Review Code|Run Manual Validation) \(Round [1-9]\d*(?:(?:, fix for review-code(?:-r[2-9]|-r[1-9]\d+)?\.md)|(?:, decision II-[1-9]\d*))?\))$/;
 
 type LogEntry = { time: string; step: string; agent: 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,6 +34,13 @@ function inspectActivityLog(content: string): { section: ActivityLogSection | nu
   return { section: { heading: heading.text, body, entries }, invalidEntries };
 }
 
+function activityWarnings(content: string): { code: string; message: string }[] {
+  const inspected = inspectActivityLog(content);
+  if (!inspected.section) return [{ code: 'ACTIVITY_LOG_UNAVAILABLE', message: 'Activity Log is missing or ambiguous; repair the section to resume logging' }];
+  if (inspected.invalidEntries.length) return [{ code: 'ACTIVITY_LOG_INVALID_ENTRIES', message: 'Activity Log contains malformed entries; repair the entries' }];
+  return [];
+}
+
 function locateActivityLog(content: string): ActivityLogSection | null {
   const { section } = inspectActivityLog(content);
   if (!section) return null;
@@ -53,15 +57,6 @@ 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[]>();
@@ -101,22 +96,14 @@ function startedBackedRows(rows: StepRow[]): StepRow[] {
   return rows.filter((row) => row.started !== '');
 }
 
-function hasOpenLifecycleExecution(content: string): boolean {
-  const section = locateActivityLog(content);
-  if (!section) return false;
-  return pairEntries(section.entries).some((row) => row.done === '' && LIFECYCLE_STEP_RE.test(row.step));
-}
-
 export {
   activityAttempt,
+  activityWarnings,
   appendActivityEntry,
-  hasOpenLifecycleExecution,
-  commitAttemptStartedNote,
   inspectActivityLog,
   locateActivityLog,
   pairEntries,
   parseActivityLog,
-  parseCommitAttemptStarted,
   startedBackedRows
 };
-export type { ActivityLogSection, CommitAttempt, LogEntry, StepRow };
+export type { ActivityLogSection, LogEntry, StepRow };

package/lib/task/artifact-command.ts

@@ -98,7 +98,7 @@ export function executeArtifactCommand(
       matchingInitializedSkeleton = existing.includes(`<!-- artifact-context:${resolved.taskId}:${family}:${parsed.round} -->`);
     } catch { /* an absent candidate is created only for the selected identity */ }
     if ((context.status !== 'ready' && !matchingInitializedSkeleton) || (context.next?.name !== artifact
-      && !hasOpenArtifactRound(fs.readFileSync(resolved.taskMdPath, 'utf8'), family, parsed.round)
+      && !hasOpenArtifactRound(taskDir, fs.readFileSync(resolved.taskMdPath, 'utf8'), family, parsed.round)
       && !matchingInitializedSkeleton)) {
       return fail('ARTIFACT_INIT_CONTEXT_INVALID', context.error?.message ?? `artifact '${artifact}' is not the next ${family} artifact`);
     }

package/lib/task/artifact-lifecycle.ts

@@ -4,13 +4,13 @@ import path from 'node:path';
 import { ARTIFACT_FAMILY_CATALOG, artifactName, parseArtifactName } from './artifact-name.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import type { ResolveTaskRefErrorCode, TaskWorkspaceState } from './resolve-ref.ts';
-import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.ts';
+import { lifecycleExecutions } from './lifecycle-execution.ts';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 import { parseVerdict } from './review-artifacts.ts';
 import { extractSection, findSectionHeading } from './sections.ts';
 import { receiptForOutput, receiptsForOutput, sha256File } from './artifact-receipts.ts';
-import { artifactCompletionOrder, hasArtifactCompletionFact, hasArtifactCompletionLog, parseCompletionFacts } from './completion-facts.ts';
+import { hasArtifactCompletionRecord, hasValidArtifactCompletion } from './completion-facts.ts';
 import { inspectReviewIdentity } from './review-identity.ts';
 import type { ArtifactFamily, ArtifactFamilySpec } from './artifact-name.ts';
 import { parseLifecyclePathDecision } from './lifecycle-path.ts';
@@ -21,35 +21,29 @@ import type { ArtifactSelection } from './artifact-selection.ts';
 import { executionInputsMatchLatest } from './execution-inputs.ts';
 
 const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
-const ARTIFACT_STEPS: Readonly<Record<string, string>> = {
-  analysis: 'Analyze Task', 'review-analysis': 'Review Analysis',
-  plan: 'Plan Task', 'review-plan': 'Review Plan',
-  code: 'Code Task', 'review-code': 'Review Code'
-};
-
 /** Init, repair and finalization share the same authoritative round identity. */
-export function hasOpenArtifactRound(content: string, family: string, round: number): boolean {
-  return openArtifactRounds(content, family).includes(round);
+export function hasOpenArtifactRound(taskDir: string, content: string, family: ArtifactFamily, round: number): boolean {
+  return openArtifactRounds(taskDir, content, family).includes(round);
 }
 
-function openArtifactRounds(content: string, family: string): number[] {
-  const activity = locateActivityLog(content);
-  const step = ARTIFACT_STEPS[family];
-  if (!activity || !step) return [];
-  const qualifier = family === 'code'
-    ? '(?:, (?:fix for review-code(?:-r(?:[2-9]|[1-9]\\d+))?\\.md|decision II-[1-9]\\d*))?'
-    : '';
-  const expected = new RegExp(`^${step} \\(Round ([1-9]\\d*)${qualifier}\\)$`);
-  return [...new Set(startedBackedRows(pairEntries(activity.entries))
-    .filter((row) => expected.test(row.step) && !row.done)
-    .map((row) => Number(expected.exec(row.step)?.[1])))].sort((left, right) => left - right);
+function openArtifactRounds(taskDir: string, content: string, family: ArtifactFamily): number[] {
+  const executionFamily = family === 'analysis' ? 'analyze' : family;
+  const event = completionEvent(family);
+  return [...new Set(lifecycleExecutions(content)
+    .filter((item) => item.family === executionFamily && item.round !== undefined)
+    .flatMap((item) => {
+      const round = item.round!;
+      const name = artifactName(family, round);
+      if (!event || !hasArtifactCompletionRecord(content, name, event)) return [round];
+      if (!hasValidArtifactCompletion(content, taskDir, name, event)) throw new Error(`completion evidence for started ${family} Round ${round} is invalid`);
+      return [];
+    }))].sort((left, right) => left - right);
 }
 
-function hasCompletedArtifactRound(content: string, family: string, round: number, name: string): boolean {
+function hasCompletedArtifactRound(taskDir: string, content: string, family: string, round: number, name: string): boolean {
   const event = completionEvent(family);
   return Boolean(event && parseArtifactName(name)?.round === round
-    && artifactCompletionOrder(content, name, event) !== null
-    && hasArtifactCompletionFact(content, name, event));
+    && hasValidArtifactCompletion(content, taskDir, name, event));
 }
 
 function completionEvent(family: string): string | null {
@@ -238,7 +232,14 @@ function inspectArtifactDirectory(
   }
   artifacts.sort((left, right) => left.round - right.round);
   knownArtifacts.sort((left, right) => left.round - right.round);
-  const openRounds = openArtifactRounds(taskContent, family);
+  let openRounds: number[];
+  try { openRounds = openArtifactRounds(taskDir, taskContent, family); }
+  catch (error) {
+    return failure(requestRef, family, {
+      code: 'ARTIFACT_SELECTION_INDETERMINATE',
+      message: error instanceof Error ? error.message : String(error)
+    }, { taskId: identity.taskId ?? null, taskDir, taskState: identity.taskState ?? null });
+  }
   const knownRounds = new Set(knownArtifacts.map((item) => item.round));
   for (const round of openRounds) knownRounds.add(round);
   const max = Math.max(...knownRounds, 0);
@@ -248,11 +249,8 @@ function inspectArtifactDirectory(
   }
   const event = completionEvent(family);
   const completed = event
-    ? artifacts.flatMap((artifact) => {
-      const order = artifactCompletionOrder(taskContent, artifact.name, event);
-      return order !== null && hasArtifactCompletionFact(taskContent, artifact.path, event)
-        ? [{ artifact, order }] : [];
-    }).sort((left, right) => left.order - right.order).map(({ artifact }) => artifact)
+    ? artifacts.filter((artifact) => hasValidArtifactCompletion(taskContent, taskDir, artifact.name, event))
+      .sort((left, right) => left.round - right.round)
     : [];
   if (openRounds.length > 1) diagnostics.push(diagnostic('MULTIPLE_OPEN_ROUNDS', family, null, `multiple incomplete ${family} rounds are open: ${openRounds.join(', ')}`));
   const latest = completed.at(-1) ?? null;
@@ -387,8 +385,8 @@ function hasSelectionEvidence(
         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');
+          || !context.taskDir
+          || !hasValidArtifactCompletion(content, context.taskDir, context.latest.name, 'review-code.completed');
       } catch {
         return true;
       }
@@ -428,13 +426,10 @@ function attachArtifactSelection(
     ...context, status: 'failed', selection: null, error: { code, message }
   });
   if (!context.next) return fail('ARTIFACT_SELECTION_INDETERMINATE', 'artifact inventory did not provide a writable identity');
-  let taskContent: string;
-  try {
-    taskContent = fs.readFileSync(path.join(context.taskDir, 'task.md'), 'utf8');
-  } catch (error) {
-    return fail('ARTIFACT_SELECTION_INDETERMINATE', error instanceof Error ? error.message : String(error));
-  }
-  const openRounds = openArtifactRounds(taskContent, family);
+  const state = readArtifactSelectionState(context.taskDir, family);
+  if (!state.ok) return fail('ARTIFACT_SELECTION_INDETERMINATE', state.message);
+  const taskContent = state.content;
+  const openRounds = state.openRounds;
   if (openRounds.length > 1) return fail('ARTIFACT_TOPOLOGY_CONFLICT', `multiple incomplete ${family} rounds are open: ${openRounds.join(', ')}`);
   const openRound = openRounds[0] ?? null;
   const selectedIdentity = openRound === null ? context.next : {
@@ -459,6 +454,17 @@ function attachArtifactSelection(
   }
 }
 
+function readArtifactSelectionState(taskDir: string, family: ArtifactFamily):
+  | { ok: true; content: string; openRounds: number[] }
+  | { ok: false; message: string } {
+  try {
+    const content = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+    return { ok: true, content, openRounds: openArtifactRounds(taskDir, content, family) };
+  } catch (error) {
+    return { ok: false, message: error instanceof Error ? error.message : String(error) };
+  }
+}
+
 function resolveArtifactContextFromTask(
   taskRef: string,
   family: string,
@@ -531,14 +537,6 @@ function resolveArtifactContext(taskRef: string, family: string, options: Inspec
   return resolveArtifactContextFromTask(taskRef, family, options);
 }
 
-export function resolveArtifactContextForResolvedTask(
-  resolvedTask: ResolvedTaskRef,
-  family: string,
-  options: InspectOptions = {}
-): ArtifactContextResult {
-  return resolveArtifactContextFromTask(resolvedTask.taskId, family, options, resolvedTask);
-}
-
 function resolveCodeContext(
   inventory: ArtifactInventoryResult,
   options: InspectOptions,
@@ -555,8 +553,7 @@ function resolveCodeContext(
     const taskContent = fs.readFileSync(path.join(inventory.taskDir!, 'task.md'), 'utf8');
     const hasPendingImplementation = parseImplementationInputs(taskContent).rows.some((input) => input.needsImplementation && input.status === 'pending');
     if (hasPendingImplementation && !reviewCode.latest) {
-      const candidate = reviewCode.artifacts.at(-1)?.name ?? 'review-code.md';
-      return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', `cannot find completed Activity Log identity for ${candidate}`);
+      return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', 'no valid review-code completion fact is available for pending implementation inputs');
     }
   } catch (error) {
     return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', error instanceof Error ? error.message : String(error));
@@ -575,12 +572,10 @@ function resolveCodeContext(
         const review = reviewCode.latest;
         const openInputs = review ? [...inputs, review] : inputs;
         const openVerdict = review ? parseVerdict(review.path) : null;
-        const openRow = locateActivityLog(taskContent)
-          ? startedBackedRows(pairEntries(locateActivityLog(taskContent)!.entries))
-            .find((row) => row.step.startsWith(`Code Task (Round ${openRound}`) && !row.done)
-          : null;
-        const decisionInput = /, decision (II-[1-9]\d*)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
-        const fixInput = /, fix for (review-code(?:-r\d+)?\.md)\)$/u.exec(openRow?.step ?? '')?.[1] ?? null;
+        const openRow = lifecycleExecutions(taskContent)
+          .find((row) => row.family === 'code' && row.round === openRound);
+        const decisionInput = openRow?.implementationInput ?? null;
+        const fixInput = openRow?.fixFor ?? null;
         const mode = decisionInput ? 'decision'
           : fixInput || (openVerdict?.ok && openVerdict.verdict === 'Changes Requested') ? 'fix'
             : 'init';
@@ -617,7 +612,7 @@ function resolveCodeContext(
   if (!review) return contextFailure(inventory, 'ARTIFACT_INPUT_MISSING', 'latest review-code artifact is required');
   const verdict = parseVerdict(review.path);
   if (!verdict.ok) return contextFailure(inventory, 'ARTIFACT_VERDICT_INVALID', `${verdict.code}: ${verdict.message}`, review.name);
-  const decision = resolveDecisionImplementationInput(inventory, review);
+  const decision = resolveDecisionImplementationInput(reviewCode, review);
   if ('error' in decision) return contextFailure(inventory, 'ARTIFACT_REFERENCE_INVALID', decision.error, review.name);
   if (decision.input) {
     return withCodeMode(
@@ -680,12 +675,10 @@ function resolveDecisionImplementationInput(
   catch (error) { return { error: error instanceof Error ? error.message : String(error) }; }
   const pending = rows.filter((row) => row.needsImplementation && row.status === 'pending');
   if (pending.length === 0) return { input: null };
-  const activity = locateActivityLog(content);
-  if (!activity) return { error: 'task has no unique Activity Log section' };
-  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}` };
+  if (inventory.latest?.name !== review.name
+    || !inventory.completed.some((artifact) => artifact.name === review.name)) {
+    return { error: `Review Code completion facts do not validate ${review.name}` };
+  }
   try { return { input: selectPendingImplementationInput(rows) }; }
   catch (error) { return { error: error instanceof Error ? error.message : String(error) }; }
 }
@@ -720,14 +713,12 @@ export function validateArtifactPublication(taskDir: string, family: ArtifactFam
   if (existing) {
     try {
       const task = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
-      if (hasCompletedArtifactRound(task, family, existing.round, name)) {
+      if (hasCompletedArtifactRound(taskDir, task, family, existing.round, name)) {
         return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completed artifact '${name}' is immutable` };
       }
       const event = completionEvent(family);
-      const frontmatter = parseTypedTaskFrontmatter(task);
-      const completionFactExists = event !== null && parseCompletionFacts(frontmatter.completion_facts)
-        .some((fact) => fact.event === event && fact.output === name);
-      if (event && completionFactExists && artifactCompletionOrder(task, name, event) !== null) {
+      const completionFactExists = event !== null && hasArtifactCompletionRecord(task, name, event);
+      if (event && completionFactExists) {
         return { code: 'ARTIFACT_IDENTITY_INVALID', message: `completion evidence for '${name}' does not match its current content` };
       }
     } catch (error) {

package/lib/task/artifact-name.ts

@@ -44,12 +44,5 @@ export function parseArtifactName(name: string): { family: ArtifactFamily; round
   return { family: match[1] as ArtifactFamily, round, name };
 }
 
-export function maxArtifactRound(names: readonly string[], family: string): number {
-  return names.reduce((max, name) => {
-    const identity = parseArtifactName(name);
-    return identity?.family === family ? Math.max(max, identity.round) : max;
-  }, 0);
-}
-
 export { ARTIFACT_FAMILY_CATALOG };
 export type { ArtifactFamily, ArtifactFamilySpec };