@fitlab-ai/agent-infra 0.12.0 → 0.12.2

package/dist/lib/sandbox/task-resolver.js

@@ -1,37 +1,11 @@
-import { spawnSync } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
-import { isRemovedHashShortIdInput } from '../task/short-id.js';
 import { resolveProjectTaskWorkspaceRoot } from '../task/workspace-root.js';
 const TASK_ID_RE = /^TASK-\d{8}-\d{6}$/;
-const SHORT_ID_RE = /^\d+$/;
 export const TASK_WORKSPACE_STATES = ['active', 'completed', 'blocked', 'archive'];
-function resolveShortIdStrict(arg, repoRoot) {
-    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) {
     return value.replace(/^(["'])(.*)\1$/, '$2');
 }
-function readTaskContent(repoRoot, taskId) {
-    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, taskId) {
     const taskRoot = resolveProjectTaskWorkspaceRoot(repoRoot);
     const hot = TASK_WORKSPACE_STATES.filter((state) => state !== 'archive').flatMap((state) => {
@@ -89,21 +63,6 @@ function resolveBranchFromTaskContent(content, taskId) {
     }
     throw new Error(`Task ${taskId} has no branch field in task.md`);
 }
-export function resolveTaskBranch(arg, repoRoot) {
-    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, repoRoot) {
     if (!TASK_ID_RE.test(taskId))
         throw new Error(`Invalid task id: ${taskId}`);

package/dist/lib/sandbox/tools.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { createSandboxCapabilityPlan } from './agent-client-reconciler.js';
-import { safeNameCandidates, sanitizeBranchName } from './constants.js';
+import { safeNameCandidates } from './constants.js';
 import { hostJoin } from './engines/wsl2-paths.js';
 export function tmpfsSeedStagingPath(toolId, index) {
     return `/run/agent-infra/tmpfs-seeds/${toolId}/${index}`;
@@ -233,9 +233,6 @@ export function parseCustomTools(value, options) {
 export function resolveTools(config) {
     return [...createSandboxCapabilityPlan(config).tools];
 }
-export function toolConfigDir(tool, project, branch) {
-    return hostJoin(tool.sandboxBase, project, sanitizeBranchName(branch));
-}
 export function toolConfigDirCandidates(tool, project, branch) {
     return safeNameCandidates(branch).map((name) => hostJoin(tool.sandboxBase, project, name));
 }

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

@@ -295,8 +295,7 @@ export function finalizeSandboxControlManifest(setup, identity) {
     const manifest = {
         ...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/dist/lib/server/display.js

@@ -4,9 +4,6 @@ export function textMessage(text) {
 export function markdownMessage(markdown) {
     return { kind: 'markdown', markdown };
 }
-export function tableMessage(columns, rows, title) {
-    return { kind: 'table', title, columns, rows };
-}
 export function statusCard(title, tone, fields, body) {
     return { kind: 'status-card', title, tone, fields, body };
 }
@@ -20,9 +17,6 @@ export function streamEvent(title, phase, text, exitCode, signal) {
         message.signal = signal;
     return message;
 }
-export function commandResult(title, exitCode, signal, stdout, stderr) {
-    return { kind: 'command-result', title, exitCode, signal, stdout, stderr };
-}
 export function normalizeOutbound(message) {
     return typeof message === 'string' ? textMessage(message) : message;
 }

package/dist/lib/task/activity-intent.js

@@ -1,12 +1,12 @@
 import fs from 'node:fs';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { locateActivityLog, appendActivityEntry } from './activity-log.js';
+import { locateActivityLog, appendActivityEntry, inspectActivityLog } from './activity-log.js';
+import { lifecycleExecutions, prReviewExecution, serializeLifecycleExecution } from './lifecycle-execution.js';
 import { assertWritableInventory, buildArtifactLinkSection, inspectTaskArtifacts } from './artifact-lifecycle.js';
 import { parseArtifactName } from './artifact-name.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 const HEAD_RE = /^[0-9a-f]{40}$/;
-const REVIEW_ACTION_RE = /^Review PR \(Round ([1-9]\d*)\)( \[started\])?$/;
 const VERDICTS = new Set(['approved', 'changes-requested', 'commented']);
 const OUTCOMES = new Set(['aborted', 'superseded']);
 const SUCCESS_STATUSES = new Set(['applied', 'no-op']);
@@ -76,47 +76,37 @@ function readSnapshot(taskRef, repoRoot) {
     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 = [];
     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);
     if (openStates.length > 1 || preparedStates.length > 1) {
@@ -250,10 +240,16 @@ function applyActivityIntent(intent, normalizedAgent, options) {
         return failed(intent, 'METADATA_CAPTURE_FAILED', error instanceof Error ? error.message : String(error), state.taskId);
     }
     const section = locateActivityLog(state.content);
-    const mutations = [{
-            kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading,
-            body: appendActivityEntry(section, { time: metadata.timestamp, step, agent: normalizedAgent, note })
-        }];
+    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 = [{ 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 });
@@ -296,6 +292,15 @@ export function applyPrReviewActivityIntent(intent, options = {}) {
     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 = [];
+    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;
 }
 //# sourceMappingURL=activity-intent.js.map

package/dist/lib/task/activity-log.js

@@ -3,8 +3,6 @@ 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*))?\))$/;
 function parseActivityLog(content) {
     const section = locateActivityLog(content);
     return section ? { sectionFound: true, entries: section.entries } : { sectionFound: false, entries: [] };
@@ -33,6 +31,14 @@ function inspectActivityLog(content) {
     const body = content.slice(heading.end + 1, end).replace(/\r\n/g, '\n').replace(/^\n+|\n+$/g, '');
     return { section: { heading: heading.text, body, entries }, invalidEntries };
 }
+function activityWarnings(content) {
+    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) {
     const { section } = inspectActivityLog(content);
     if (!section)
@@ -47,13 +53,6 @@ function appendActivityEntry(section, entry) {
 function activityAttempt(note) {
     return ATTEMPT_RE.exec(note)?.[1] ?? null;
 }
-function parseCommitAttemptStarted(note) {
-    const match = COMMIT_STARTED_RE.exec(note);
-    return match ? { attempt: match[1], baseline: match[2], agent: match[3] } : null;
-}
-function commitAttemptStartedNote(attempt) {
-    return `started; attempt=${attempt.attempt}; baseline=${attempt.baseline}; agent=${attempt.agent}`;
-}
 function pairEntries(entries) {
     const rows = [];
     const open = new Map();
@@ -94,11 +93,5 @@ function pairEntries(entries) {
 function startedBackedRows(rows) {
     return rows.filter((row) => row.started !== '');
 }
-function hasOpenLifecycleExecution(content) {
-    const section = locateActivityLog(content);
-    if (!section)
-        return false;
-    return pairEntries(section.entries).some((row) => row.done === '' && LIFECYCLE_STEP_RE.test(row.step));
-}
-export { activityAttempt, appendActivityEntry, hasOpenLifecycleExecution, commitAttemptStartedNote, inspectActivityLog, locateActivityLog, pairEntries, parseActivityLog, parseCommitAttemptStarted, startedBackedRows };
+export { activityAttempt, activityWarnings, appendActivityEntry, inspectActivityLog, locateActivityLog, pairEntries, parseActivityLog, startedBackedRows };
 //# sourceMappingURL=activity-log.js.map

package/dist/lib/task/artifact-command.js

@@ -88,7 +88,7 @@ export function executeArtifactCommand(command, options = {}) {
         }
         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/dist/lib/task/artifact-lifecycle.js

@@ -2,46 +2,42 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { ARTIFACT_FAMILY_CATALOG, artifactName, parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { locateActivityLog, pairEntries, startedBackedRows } from './activity-log.js';
+import { lifecycleExecutions } from './lifecycle-execution.js';
 import { parseImplementationInputs, selectPendingImplementationInput } from './implementation-inputs.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseVerdict } from './review-artifacts.js';
 import { extractSection, findSectionHeading } from './sections.js';
 import { receiptForOutput, receiptsForOutput, sha256File } from './artifact-receipts.js';
-import { artifactCompletionOrder, hasArtifactCompletionFact, hasArtifactCompletionLog, parseCompletionFacts } from './completion-facts.js';
+import { hasArtifactCompletionRecord, hasValidArtifactCompletion } from './completion-facts.js';
 import { inspectReviewIdentity } from './review-identity.js';
 import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { parseReworkIntentDocument } from './rework-intent.js';
 import { selectArtifactDisposition } from './artifact-selection.js';
 import { executionInputsMatchLatest } from './execution-inputs.js';
 const artifactFamilyCatalog = ARTIFACT_FAMILY_CATALOG;
-const ARTIFACT_STEPS = {
-    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, family, round) {
-    return openArtifactRounds(content, family).includes(round);
+export function hasOpenArtifactRound(taskDir, content, family, round) {
+    return openArtifactRounds(taskDir, content, family).includes(round);
 }
-function openArtifactRounds(content, family) {
-    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, content, family) {
+    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, family, round, name) {
+function hasCompletedArtifactRound(taskDir, content, family, round, name) {
     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) {
     if (family === 'analysis')
@@ -153,7 +149,16 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
     }
     artifacts.sort((left, right) => left.round - right.round);
     knownArtifacts.sort((left, right) => left.round - right.round);
-    const openRounds = openArtifactRounds(taskContent, family);
+    let openRounds;
+    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);
@@ -166,11 +171,8 @@ function inspectArtifactDirectory(taskDir, family, identity = {}) {
     }
     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(', ')}`));
@@ -321,8 +323,8 @@ function hasSelectionEvidence(content, family, options, context, pathState) {
                 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;
@@ -366,14 +368,11 @@ function attachArtifactSelection(context, pathState, options) {
     });
     if (!context.next)
         return fail('ARTIFACT_SELECTION_INDETERMINATE', 'artifact inventory did not provide a writable identity');
-    let taskContent;
-    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;
@@ -399,6 +398,15 @@ function attachArtifactSelection(context, pathState, options) {
         return fail('ARTIFACT_SELECTION_INDETERMINATE', error instanceof Error ? error.message : String(error));
     }
 }
+function readArtifactSelectionState(taskDir, family) {
+    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, family, options, resolvedTask) {
     const inventory = inspectTaskArtifacts(taskRef, family, options, resolvedTask);
     if (inventory.status === 'failed')
@@ -469,9 +477,6 @@ function resolveArtifactContextFromTask(taskRef, family, options, resolvedTask)
 function resolveArtifactContext(taskRef, family, options = {}) {
     return resolveArtifactContextFromTask(taskRef, family, options);
 }
-export function resolveArtifactContextForResolvedTask(resolvedTask, family, options = {}) {
-    return resolveArtifactContextFromTask(resolvedTask.taskId, family, options, resolvedTask);
-}
 function resolveCodeContext(inventory, options, resolvedTask) {
     const taskRef = inventory.requestRef;
     const pathState = lifecyclePathState(inventory.taskDir);
@@ -486,8 +491,7 @@ function resolveCodeContext(inventory, options, resolvedTask) {
         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) {
@@ -508,12 +512,10 @@ function resolveCodeContext(inventory, options, resolvedTask) {
             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';
@@ -544,7 +546,7 @@ function resolveCodeContext(inventory, options, resolvedTask) {
     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) {
@@ -598,12 +600,10 @@ function resolveDecisionImplementationInput(inventory, review) {
     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) };
     }
@@ -653,14 +653,12 @@ export function validateArtifactPublication(taskDir, family, name) {
     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` };
             }
         }

package/dist/lib/task/artifact-name.js

@@ -26,11 +26,5 @@ export function parseArtifactName(name) {
         return null;
     return { family: match[1], round, name };
 }
-export function maxArtifactRound(names, family) {
-    return names.reduce((max, name) => {
-        const identity = parseArtifactName(name);
-        return identity?.family === family ? Math.max(max, identity.round) : max;
-    }, 0);
-}
 export { ARTIFACT_FAMILY_CATALOG };
 //# sourceMappingURL=artifact-name.js.map

package/dist/lib/task/artifact-operations.js

@@ -59,7 +59,7 @@ function stripHtmlComments(content) {
 function diagnostic(code, message, sectionId, line) {
     return { code, message, sectionId, line };
 }
-function sectionHeadings(schema, section) {
+function sectionHeadings(section) {
     return [section.headings.zh, section.headings.en];
 }
 function canonicalContent(content) {
@@ -82,7 +82,7 @@ function inspectArtifactStructure(content, schema) {
         diagnostics.push(diagnostic('ARTIFACT_UNCLOSED_FENCE', 'artifact contains an unclosed Markdown fence', null, null));
     const headingsBySection = new Map();
     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);
@@ -182,7 +182,7 @@ function inspectArtifactStateCheck(content, schema, scopeToStateCheckSection) {
         };
     }
     const scanned = scanVisibleMarkdown(content);
-    const headings = scanned.headings.filter((heading) => (heading.level === 2 && sectionHeadings(schema, stateCheck).includes(heading.text)));
+    const headings = scanned.headings.filter((heading) => (heading.level === 2 && sectionHeadings(stateCheck).includes(heading.text)));
     if (headings.length !== 1) {
         return { ok: true, family: schema.family, semanticDigest: canonicalSemanticDigest(content), diagnostics: [] };
     }

package/dist/lib/task/capabilities.js

@@ -7,11 +7,11 @@ import { parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '.
 import { parseReviewSummary, resolveCanonicalVerdict } from './review-artifacts.js';
 import { parseReworkIntentDocument } from './rework-intent.js';
 import { sha256File } from './artifact-receipts.js';
-import { hasOpenLifecycleExecution } from './activity-log.js';
+import { lifecycleExecutions } from './lifecycle-execution.js';
 import { parseQualificationAudit, parseTaskQualification } from './qualification-audit.js';
 import { parseLifecyclePathDecision, pathIncludes } from './lifecycle-path.js';
 import { parseImplementationInputs } from './implementation-inputs.js';
-import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { hasValidArtifactCompletion } from './completion-facts.js';
 import { inspectReviewIdentity } from './review-identity.js';
 import { inspectArtifactDirectory } from './artifact-lifecycle.js';
 import { executionInputsMatchLatest as executionReceiptsMatchLatest } from './execution-inputs.js';
@@ -389,8 +389,7 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             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)
@@ -455,7 +454,7 @@ function buildLifecycleFacts(taskDir, content, taskState = 'active', executionBu
             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/dist/lib/task/commands/log.js

@@ -84,12 +84,6 @@ function humanValidationCount(note) {
 function isHumanCountField(field) {
     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) {
-    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