@fitlab-ai/agent-infra 0.12.1 → 0.12.2

package/lib/task/artifact-operations.ts

@@ -124,7 +124,7 @@ function diagnostic(
   return { code, message, sectionId, line };
 }
 
-function sectionHeadings(schema: ArtifactSchema, section: ArtifactSection): readonly string[] {
+function sectionHeadings(section: ArtifactSection): readonly string[] {
   return [section.headings.zh, section.headings.en];
 }
 
@@ -152,7 +152,7 @@ function inspectArtifactStructure(
 
   const headingsBySection = new Map<string, typeof scanned.headings>();
   for (const section of schema.sections) {
-    const aliases = sectionHeadings(schema, section);
+    const aliases = sectionHeadings(section);
     const exact = scanned.headings.filter((heading) => heading.level === 2 && aliases.includes(heading.text));
     const punctuated = scanned.headings.filter((heading) => heading.level === 2 && aliases.some((alias) => heading.text === `${alias}:` || heading.text === `${alias}：`));
     headingsBySection.set(section.id, exact.length > 0 ? exact : punctuated);
@@ -283,7 +283,7 @@ function inspectArtifactStateCheck(
 
   const scanned = scanVisibleMarkdown(content);
   const headings = scanned.headings.filter((heading) => (
-    heading.level === 2 && sectionHeadings(schema, stateCheck).includes(heading.text)
+    heading.level === 2 && sectionHeadings(stateCheck).includes(heading.text)
   ));
   if (headings.length !== 1) {
     return { ok: true, family: schema.family, semanticDigest: canonicalSemanticDigest(content), diagnostics: [] };

package/lib/task/capabilities.ts

@@ -9,13 +9,13 @@ import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.
 import { parseReworkIntentDocument } from './rework-intent.ts';
 import type { ReworkIntent, ReworkTarget } from './rework-intent.ts';
 import { sha256File } from './artifact-receipts.ts';
-import { hasOpenLifecycleExecution } from './activity-log.ts';
+import { lifecycleExecutions } from './lifecycle-execution.ts';
 import { parseQualificationAudit, parseTaskQualification } from './qualification-audit.ts';
 import type { QualificationAudit, TaskQualification } from './qualification-audit.ts';
 import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.ts';
 import type { LifecyclePathState } from './lifecycle-path.ts';
 import { parseImplementationInputs } from './implementation-inputs.ts';
-import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.ts';
+import { hasValidArtifactCompletion } from './completion-facts.ts';
 import { inspectReviewIdentity } from './review-identity.ts';
 import { inspectArtifactDirectory } from './artifact-lifecycle.ts';
 import { executionInputsMatchLatest as executionReceiptsMatchLatest } from './execution-inputs.ts';
@@ -25,7 +25,7 @@ const ARTIFACT_AUDIT_FAMILIES = new Set(['analysis', 'review-analysis', 'plan',
 type LifecycleAction =
   | 'analysis' | 'review-analysis' | 'plan' | 'review-plan'
   | 'code' | 'review-code' | 'manual-validation' | 'validation-run';
-type TriggerInitiator = 'human' | 'model' | 'orchestrator';
+type TriggerInitiator = 'human' | 'model';
 type TriggerReason = 'user-request' | 'new-requirement' | 'upstream-fact-doubt' | 'review-finding' | 'manual-review-supplement' | 'retry' | 'validation-rerun';
 type ExplicitTrigger = {
   initiator: TriggerInitiator;
@@ -395,8 +395,7 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
       if (family === 'review-code') {
         const identity = inspectReviewIdentity(taskDir, reviewContent, repositoryRoot);
         reviewCodeIdentityValid = identity.status === 'matched'
-          && hasArtifactCompletionFact(content, path.join(taskDir, latest), 'review-code.completed')
-          && hasArtifactCompletionLog(content, latest, 'review-code.completed');
+          && hasValidArtifactCompletion(content, taskDir, latest, 'review-code.completed');
       }
       const parsed = parseReviewSummary(reviewContent);
       if (!parsed.ok) continue;
@@ -455,7 +454,7 @@ function buildLifecycleFacts(taskDir: string, content: string, taskState = 'acti
       reviewedInputs, executionInputs, artifactHashes,
       reworkIntents: rework.intents,
       unresolvedLedger,
-      executionBusy: executionBusy || hasOpenLifecycleExecution(content),
+      executionBusy: lifecycleExecutions(content).some((item) => item.family !== 'other') || executionBusy,
       recommendedAction: null,
       qualificationStale: qualificationStaleArtifacts.length > 0,
       qualificationStaleArtifacts

package/lib/task/commands/log.ts

@@ -91,13 +91,6 @@ function isHumanCountField(field: string): boolean {
   return fieldNumber(field, 'manual-validation') !== undefined || fieldNumber(field, 'human-decision') !== undefined;
 }
 
-// A step is human-executed when its agent token is not a known AI token.
-// Known long names classify as AI; empty or unknown tokens classify as non-AI
-// (human).
-export function isHumanAgent(agent: string): boolean {
-  return classifyAgent(agent).status !== 'ai';
-}
-
 // Fold the two human counts into a review row's verdict NOTE: comma-joined, right
 // after the blockers/major/minor list and before the ` → artifact` link, mirroring
 // the review count line. Review done notes already carry `Manual-validation` as a

package/lib/task/commands/status.ts

@@ -9,8 +9,8 @@ import { parseTaskFrontmatter, extractTitle, type Frontmatter } from '../frontma
 import { loadShortIdByTaskId } from '../short-id.ts';
 import { getOpenWorkflowWarnings, formatWorkflowWarningSummary, type WorkflowWarning } from '../workflow-warnings.ts';
 import { parseActivityLog, pairEntries, startedBackedRows } from '../activity-log.ts';
-import { readRun, type OrchestrationRun } from '../orchestration.ts';
-import type { DelegationReceipt } from '../delegation-receipts.ts';
+import { lifecycleExecutions } from '../lifecycle-execution.ts';
+import { parseTypedTaskFrontmatter } from '../frontmatter.ts';
 import { statusCard, type DisplayMessage } from '../../server/display.ts';
 import { buildLifecycleFacts, recommendNext } from '../capabilities.ts';
 
@@ -181,6 +181,15 @@ function parseActivityTime(value: string): number {
   return Number.isFinite(epoch) ? epoch : Number.NaN;
 }
 
+function collectStructuredWorkflow(content: string, now: Date): WorkflowInfo {
+    try {
+      const current = lifecycleExecutions(content).filter((row) => row.family !== 'other').at(-1);
+      if (!current) return { state: 'idle', step: DASH, agent: DASH, startedAt: DASH, doneAt: DASH, stale: DASH };
+      const started = parseActivityTime(current.startedAt);
+      return { state: 'in-progress', step: current.family, agent: current.agent, startedAt: current.startedAt, doneAt: DASH, stale: Number.isFinite(started) ? (now.getTime() - started > STALE_MS ? 'yes' : 'no') : 'unknown' };
+    } catch { return { state: 'unknown', step: DASH, agent: DASH, startedAt: DASH, doneAt: DASH, stale: DASH }; }
+}
+
 function collectWorkflow(content: string, now: Date = new Date()): WorkflowInfo {
   const parsed = parseActivityLog(content);
   if (!parsed.sectionFound || parsed.entries.length === 0) {
@@ -222,19 +231,6 @@ type RuntimeInfo = {
   log: string;
 };
 
-type PendingDelegationInfo = Readonly<Pick<
-  DelegationReceipt,
-  'id' | 'role' | 'stage' | 'round' | 'artifact' | 'client' | 'status'
->>;
-
-type OrchestrationInfo = Readonly<{
-  status: 'absent' | OrchestrationRun['status'];
-  runId: string;
-  nextStage: string;
-  pause: Readonly<{ code: string; message: string; recoverable: boolean }> | null;
-  pendingDelegation: PendingDelegationInfo | null;
-}>;
-
 type ManagedRunRecord = {
   run_id: string;
   engine: string;
@@ -339,39 +335,6 @@ function collectRuntime(taskDir: string, workflow: WorkflowInfo, run: Runner): R
   };
 }
 
-function pendingDelegationInfo(receipt: DelegationReceipt | null): PendingDelegationInfo | null {
-  if (!receipt) return null;
-  return {
-    id: receipt.id,
-    role: receipt.role,
-    stage: receipt.stage,
-    round: receipt.round,
-    artifact: receipt.artifact,
-    client: receipt.client,
-    status: receipt.status
-  };
-}
-
-function collectOrchestration(taskDir: string): OrchestrationInfo {
-  const run = readRun(taskDir);
-  if (!run) {
-    return {
-      status: 'absent',
-      runId: DASH,
-      nextStage: DASH,
-      pause: null,
-      pendingDelegation: null
-    };
-  }
-  return {
-    status: run.status,
-    runId: run.runId,
-    nextStage: run.nextStage ?? DASH,
-    pause: run.pause,
-    pendingDelegation: pendingDelegationInfo(run.pendingDelegation)
-  };
-}
-
 type StatusModel = {
   taskId: string;
   shortId: string;
@@ -381,7 +344,6 @@ type StatusModel = {
   artifacts: { count: number; groups: { stage: string; files: string[] }[] };
   workflow: WorkflowInfo;
   runtime: RuntimeInfo;
-  orchestration: OrchestrationInfo;
   recommendation?: string;
   recommendationReason?: string;
   lifecyclePath?: string;
@@ -439,26 +401,6 @@ function renderStatus(model: StatusModel): string[] {
     ['reason', model.recommendationReason ?? DASH]
   ]));
 
-  lines.push(
-    '',
-    'Orchestration',
-    ...renderPairs([
-      ['status', model.orchestration.status],
-      ['run_id', model.orchestration.runId],
-      ['next_stage', model.orchestration.nextStage],
-      ['pause_code', model.orchestration.pause?.code ?? DASH],
-      ['pause_message', model.orchestration.pause?.message ?? DASH],
-      ['recoverable', model.orchestration.pause ? String(model.orchestration.pause.recoverable) : DASH],
-      ['pending_id', model.orchestration.pendingDelegation?.id ?? DASH],
-      ['pending_role', model.orchestration.pendingDelegation?.role ?? DASH],
-      ['pending_stage', model.orchestration.pendingDelegation?.stage ?? DASH],
-      ['pending_round', model.orchestration.pendingDelegation ? String(model.orchestration.pendingDelegation.round) : DASH],
-      ['pending_artifact', model.orchestration.pendingDelegation?.artifact ?? DASH],
-      ['pending_client', model.orchestration.pendingDelegation?.client ?? DASH],
-      ['pending_status', model.orchestration.pendingDelegation?.status ?? DASH]
-    ])
-  );
-
   lines.push(
     '',
     'Workflow',
@@ -504,9 +446,6 @@ function renderStatus(model: StatusModel): string[] {
 }
 
 function modelTone(model: StatusModel): 'info' | 'success' | 'warning' | 'danger' | 'running' {
-  if (model.orchestration.status === 'paused') return 'warning';
-  if (model.orchestration.status === 'running') return 'running';
-  if (model.orchestration.status === 'completed') return 'success';
   if (model.workflow.state === 'in-progress') return model.workflow.stale === 'yes' ? 'warning' : 'running';
   if (model.metadata.some(([key, value]) => key === 'status' && value === 'completed')) return 'success';
   if (model.metadata.some(([key, value]) => key === 'status' && (value === 'blocked' || value === 'cancelled'))) {
@@ -520,7 +459,8 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
   const fm = parseTaskFrontmatter(content);
   const run = input.run ?? makeRunner(input.repoRoot);
   const artifacts = enumerateArtifacts(input.taskDir);
-  const workflow = collectWorkflow(content, input.now);
+  const workflow = parseTypedTaskFrontmatter(content).lifecycle_execution !== undefined
+    ? collectStructuredWorkflow(content, input.now ?? new Date()) : collectWorkflow(content, input.now);
   const facts = buildLifecycleFacts(input.taskDir, content, fm.status ?? 'active', false, input.repoRoot);
   const next = facts.ok ? recommendNext(facts.facts) : null;
   const recommendation = next?.action ?? DASH;
@@ -534,7 +474,6 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
     artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
     workflow,
     runtime: collectRuntime(input.taskDir, workflow, run),
-    orchestration: collectOrchestration(input.taskDir),
     recommendation,
     recommendationReason: next?.reasonCode ?? 'TASK_CAPABILITY_FACTS_INVALID',
     lifecyclePath: facts.ok && facts.facts.pathState?.status === 'valid' ? facts.facts.pathState.decision.path : facts.ok ? facts.facts.pathState?.status ?? DASH : DASH,
@@ -572,9 +511,6 @@ function statusModelToDisplay(model: StatusModel): DisplayMessage {
     `Task ${model.taskId} (${model.shortId})`,
     modelTone(model),
     [
-      ['orchestration', model.orchestration.status],
-      ['run', model.orchestration.runId],
-      ['next', model.orchestration.nextStage],
       ['workflow', model.workflow.state],
       ['step', model.workflow.step],
       ['runtime', model.runtime.status],
@@ -622,9 +558,8 @@ export {
   collectGit,
   collectWorkflow,
   collectRuntime,
-  collectOrchestration,
   renderStatus,
   statusModelToDisplay,
   METADATA_KEYS
 };
-export type { Runner, GitInfo, WorkflowInfo, RuntimeInfo, OrchestrationInfo, PendingDelegationInfo, StatusModel, BuildStatusModelInput };
+export type { Runner, GitInfo, WorkflowInfo, RuntimeInfo, StatusModel, BuildStatusModelInput };

package/lib/task/commit-operation.ts

@@ -8,9 +8,9 @@ import { checkpointCommitMatches } from './commit-identity.ts';
 import { resolveTaskContext, resolveTaskRef } from './resolve-ref.ts';
 import { commitPushDecision } from './commit-policy.ts';
 import { mergeOperationWarnings, type OperationWarning } from './operation-outcome.ts';
-import { appendActivityEntry, locateActivityLog } from './activity-log.ts';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
-import type { TaskMutation } from './write.ts';
+import type { TaskMutation, TaskWriteOptions } from './write.ts';
 import {
   checkpointIntentDigest,
   readCheckpointIntent,
@@ -20,7 +20,7 @@ import {
   writeCheckpointIntent
 } from './commit-intent.ts';
 
-type CommitExecutionMode = 'direct' | 'orchestrated';
+type CommitExecutionMode = 'direct';
 
 type CommitOperationInput = Readonly<{
   cwd: string;
@@ -68,7 +68,7 @@ const HEAD_REF = /^refs\/heads\/(.+)$/;
 type CommitDelivery = Readonly<{ mode: 'local' } | { mode: 'push'; remote: string; refs: readonly string[] }>;
 
 function isCommitExecutionMode(value: unknown): value is CommitExecutionMode {
-  return value === 'direct' || value === 'orchestrated';
+  return value === 'direct';
 }
 
 function gitText(repoRoot: string, args: readonly string[]): string {
@@ -193,55 +193,42 @@ function validateCommon(input: CommitOperationInput, branch: string | null): Rea
   return null;
 }
 
+// Log presentation only; checkpoint identity and recovery never depend on this projection.
+function commitLogProjection(activity: ReturnType<typeof locateActivityLog>, timestamp: string, agent: string, commitNote: string): TaskMutation[] {
+  if (!activity) return [];
+  let lastCommit = -1;
+  for (const [index, entry] of activity.entries.entries()) {
+    if (entry.step === 'Commit' && entry.note === commitNote) lastCommit = index;
+  }
+  const reviewedAfter = activity.entries.slice(lastCommit + 1).some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
+  if (lastCommit >= 0 && !reviewedAfter) return [];
+  return [{ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: activity.heading,
+    body: appendActivityEntry(activity, { time: timestamp, step: 'Commit', agent, note: commitNote }) }];
+}
+
 function syncTaskCommit(
   input: CommitOperationInput,
   task: BoundTask,
-  committedHead: string
+  committedHead: string,
+  writeOptions: TaskWriteOptions = {}
 ): OperationWarning | null {
   let content: string;
   try {
     content = fs.readFileSync(task.taskMdPath, 'utf8');
     const activity = locateActivityLog(content);
-    if (!activity) return warning(
-      'TASK_STATUS_SYNC_FAILED',
-      'task has no unique Activity Log section',
-      true,
-      'task',
-      task.taskId,
-      'ACTION_REQUIRED'
-    );
     const metadata = captureTaskWriteMetadata();
     const commitNote = gitText(task.repoRoot, ['show', '-s', '--format=%h %s', committedHead]);
-    let matchingCommitIndex = -1;
-    for (let index = activity.entries.length - 1; index >= 0; index -= 1) {
-      const entry = activity.entries[index]!;
-      if (entry.step === 'Commit' && entry.note === commitNote) {
-        matchingCommitIndex = index;
-        break;
-      }
-    }
-    const reviewedAfterCommit = matchingCommitIndex >= 0 && activity.entries
-      .slice(matchingCommitIndex + 1)
-      .some((entry) => /^Review Code \(Round \d+\)$/.test(entry.step));
-    const alreadyLogged = matchingCommitIndex >= 0 && !reviewedAfterCommit;
-    const mutations: TaskMutation[] = [];
-    if (!alreadyLogged) mutations.push({
-      kind: 'section',
-      aliases: ['活动日志', 'Activity Log'],
-      heading: activity.heading,
-      body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Commit', agent: input.agent!, note: commitNote })
-    });
+    const mutations = commitLogProjection(activity, metadata.timestamp, input.agent!, commitNote);
     const frontmatter: Record<string, string> = {
       assigned_to: input.agent!,
       checkpoint_commit: committedHead
     };
     mutations.push({ kind: 'frontmatter', set: frontmatter });
-    if (mutations.length === 0) return null;
     const written = writeTask({
       taskRef: task.taskId,
       expectedState: 'active',
       mutations
-    }, { repoRoot: task.repoRoot, metadataProvider: () => metadata });
+    }, { ...writeOptions, repoRoot: task.repoRoot, metadataProvider: () => metadata });
     if (written.status === 'failed') return warning(
       'TASK_STATUS_SYNC_FAILED',
       written.error.message,
@@ -250,7 +237,8 @@ function syncTaskCommit(
       task.taskId,
       'ACTION_REQUIRED'
     );
-    return null;
+    const logWarning = activityWarnings(content)[0];
+    return logWarning ? warning(logWarning.code, logWarning.message, true, 'task', task.taskId, 'IMPORTANT') : null;
   } catch (error) {
     return warning(
       'TASK_STATUS_SYNC_FAILED',
@@ -281,18 +269,9 @@ function checkpointTimestamp(): string {
   return new Date().toISOString();
 }
 
-function executeCommitOperationCore(input: CommitOperationInput, task: BoundTask | null, mode: CommitExecutionMode): CommitOperationResult {
+function executeCommitOperationCore(input: CommitOperationInput, task: BoundTask | null, mode: CommitExecutionMode, writeOptions: TaskWriteOptions): CommitOperationResult {
   const inspected = inspectGitWorkflow(input.cwd);
   if (!inspected.snapshot) return failure(input, mode, task?.taskId ?? null, 'GIT_INSPECT_FAILED', 'Unable to inspect Git repository');
-  if (mode === 'orchestrated') return failure(
-    input,
-    mode,
-    task?.taskId ?? null,
-    'ORCHESTRATED_COMMIT_REMOVED',
-    'Orchestrated commit is no longer a lifecycle stage; use local checkpoint delivery from code-task',
-    'blocked',
-    inspected.snapshot
-  );
   const branch = inspected.snapshot.branch;
   const commonError = validateCommon(input, branch);
   if (commonError) return failure(input, mode, task?.taskId ?? null, commonError.code, commonError.message, 'blocked', inspected.snapshot);
@@ -466,13 +445,13 @@ function executeCommitOperationCore(input: CommitOperationInput, task: BoundTask
   }
   if (task && (committed.status === 'applied' || committed.status === 'no-op')) {
     const committedHead = checkpointCommittedHead ?? committed.snapshot?.head ?? gitText(task.repoRoot, ['rev-parse', 'HEAD']);
-    const taskWarning = syncTaskCommit(input, task, committedHead);
+    const taskWarning = syncTaskCommit(input, task, committedHead, writeOptions);
     if (taskWarning) {
       warnings.push(taskWarning);
       status = 'applied';
       result = 'committed_with_warnings';
     }
-    if (delivery.mode === 'local' && !taskWarning && pendingIntent && checkpointCommittedHead) {
+    if (delivery.mode === 'local' && taskWarning?.code !== 'TASK_STATUS_SYNC_FAILED' && pendingIntent && checkpointCommittedHead) {
       const synced = updateCheckpointIntent(pendingIntent, {
         state: 'synced', committedHead: checkpointCommittedHead, updatedAt: checkpointTimestamp()
       });
@@ -493,7 +472,7 @@ function executeCommitOperationCore(input: CommitOperationInput, task: BoundTask
   };
 }
 
-function executeCommitOperation(input: CommitOperationInput): CommitOperationResult {
+function executeCommitOperation(input: CommitOperationInput, writeOptions: TaskWriteOptions = {}): CommitOperationResult {
   if (input.mode !== undefined && !isCommitExecutionMode(input.mode)) return {
     status: 'blocked',
     changed: false,
@@ -503,7 +482,7 @@ function executeCommitOperation(input: CommitOperationInput): CommitOperationRes
     warnings: [],
     snapshot: null,
     operations: [],
-    error: { code: 'COMMIT_MODE_INVALID', message: 'commit mode must be direct or orchestrated' }
+    error: { code: 'COMMIT_MODE_INVALID', message: 'commit mode must be direct' }
   };
   const mode: CommitExecutionMode = input.mode ?? 'direct';
   let normalizedInput: CommitOperationInput;
@@ -515,9 +494,8 @@ function executeCommitOperation(input: CommitOperationInput): CommitOperationRes
   const resolved = resolveBoundTask(normalizedInput);
   if (resolved.kind === 'error') return resolved.result;
   const task = resolved.kind === 'bound' ? resolved.task : null;
-  if (mode === 'orchestrated' && !task) return failure(normalizedInput, mode, null, 'ORCHESTRATION_TASK_REQUIRED', 'orchestrated commit requires a task context', 'blocked');
   try {
-    return executeCommitOperationCore(normalizedInput, task, mode);
+    return executeCommitOperationCore(normalizedInput, task, mode, writeOptions);
   } catch (error) {
     const code = 'COMMIT_OPERATION_FAILED';
     return failure(normalizedInput, mode, task?.taskId ?? null, code, error instanceof Error ? error.message : String(error), 'blocked');

package/lib/task/completion-facts.ts

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
+import path from 'node:path';
 
 import { canonicalSemanticDigest } from './artifact-operations.ts';
-import { inspectActivityLog, pairEntries } from './activity-log.ts';
 import { parseTypedTaskFrontmatter } from './frontmatter.ts';
 import { parseArtifactName } from './artifact-name.ts';
 import { sha256File } from './artifact-receipts.ts';
@@ -35,54 +35,57 @@ export function parseCompletionFacts(value: unknown): CompletionFact[] {
   }
 }
 
-export function hasArtifactCompletionFact(taskContent: string, artifactPath: string, event: string): boolean {
+function completionEvent(family: string): string | null {
+  if (family === 'validation-run') return 'validation-run.completed';
+  if (family === 'analysis') return 'analyze.completed';
+  if (family === 'review-analysis') return 'review-analysis.completed';
+  if (family === 'plan') return 'plan.completed';
+  if (family === 'review-plan') return 'review-plan.completed';
+  if (family === 'code') return 'code.completed';
+  if (family === 'review-code') return 'review-code.completed';
+  return null;
+}
+
+/** Validates an artifact's own completion fact and output evidence. */
+export function hasValidArtifactCompletion(taskContent: string, taskDir: string, artifact: string, event: string): boolean {
   try {
-    const frontmatter = parseTypedTaskFrontmatter(taskContent);
-    const output = artifactPath.split(/[\\/]/u).at(-1) ?? '';
-    const content = fs.readFileSync(artifactPath, 'utf8');
-    const outputSha256 = sha256File(artifactPath);
-    const semanticDigest = canonicalSemanticDigest(content);
-    return parseCompletionFacts(frontmatter.completion_facts).some((fact) =>
-      fact.event === event && fact.output === output
-      && fact.outputSha256 === outputSha256 && fact.semanticDigest === semanticDigest
-      && fact.requestId.length > 0
-    );
+    const fact = findCompletionFact(taskContent, artifact, event);
+    return Boolean(fact && validateOutput(taskDir, artifact, fact));
   } catch {
     return false;
   }
 }
 
-export function hasArtifactCompletionLog(taskContent: string, artifact: string, event: string): boolean {
-  return artifactCompletionOrder(taskContent, artifact, event) !== null;
+/** Distinguishes an invalidated completion fact from a round that has never completed. */
+export function hasArtifactCompletionRecord(taskContent: string, artifact: string, event: string): boolean {
+  try {
+    const raw = parseTypedTaskFrontmatter(taskContent).completion_facts;
+    if (raw === undefined) return false;
+    if (typeof raw !== 'string') return true;
+    if (raw.trim() === '') return false;
+    const parsed: unknown = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return true;
+    return parsed.some((fact) => fact && typeof fact === 'object' && !Array.isArray(fact)
+      && (fact as { event?: unknown }).event === event
+      && (fact as { output?: unknown }).output === artifact);
+  } catch {
+    return true;
+  }
 }
 
-/** Returns the stable Activity Log position of a paired completion row. */
-export function artifactCompletionOrder(taskContent: string, artifact: string, event: string): number | null {
+function findCompletionFact(taskContent: string, artifact: string, event: string): CompletionFact | null {
   const identity = parseArtifactName(artifact);
-  if (!identity) return null;
-  const family = event === 'analysis.completed' || event === 'analyze.completed' ? 'analysis'
-    : event === 'review-analysis.completed' ? 'review-analysis'
-      : event === 'plan.completed' ? 'plan'
-        : event === 'review-plan.completed' ? 'review-plan'
-          : event === 'code.completed' ? 'code'
-            : event === 'review-code.completed' ? 'review-code' : null;
-  if (!family || family !== identity.family) return null;
-  const action = family === 'analysis' ? 'Analyze Task'
-    : family === 'review-analysis' ? 'Review Analysis'
-      : family === 'plan' ? 'Plan Task'
-        : family === 'review-plan' ? 'Review Plan'
-          : family === 'code' ? 'Code Task' : 'Review Code';
-  const { section, invalidEntries } = inspectActivityLog(taskContent);
-  if (!section || invalidEntries.length > 0) return null;
-  const ordered = section.entries.map((entry, sourceOrder) => ({ entry, sourceOrder }))
-    .sort((left, right) => Date.parse(left.entry.time.replace(' ', 'T')) - Date.parse(right.entry.time.replace(' ', 'T')) || left.sourceOrder - right.sourceOrder);
-  const entries = ordered.map(({ entry }) => entry);
-  const roundPattern = new RegExp(`^${action} \\(Round ${identity.round}(?:, [^)]+)?\\)$`);
-  const row = pairEntries(entries).find((candidate) => candidate.started !== ''
-    && candidate.done !== '' && roundPattern.test(candidate.step)
-    && candidate.note.includes(`→ ${artifact}`));
-  if (!row) return null;
-  const doneIndex = ordered.findIndex(({ entry }) => entry.time === row.done
-    && entry.step === row.step && entry.note === row.note);
-  return doneIndex < 0 ? null : doneIndex;
+  if (!identity || completionEvent(identity.family) !== event) return null;
+  const fact = parseCompletionFacts(parseTypedTaskFrontmatter(taskContent).completion_facts)
+    .find((candidate) => candidate.event === event && candidate.output === artifact);
+  return fact && fact.requestId.length > 0 ? fact : null;
+}
+
+function validateOutput(taskDir: string, artifact: string, fact: CompletionFact): boolean {
+  const outputPath = path.join(taskDir, artifact);
+  const stat = fs.lstatSync(outputPath);
+  if (!stat.isFile() || stat.isSymbolicLink()) return false;
+  const content = fs.readFileSync(outputPath, 'utf8');
+  return sha256File(outputPath) === fact.outputSha256
+    && canonicalSemanticDigest(content) === fact.semanticDigest;
 }