@fitlab-ai/agent-infra 0.12.1 → 0.12.2

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

package/dist/lib/task/commands/status.js

@@ -9,7 +9,8 @@ import { parseTaskFrontmatter, extractTitle } from '../frontmatter.js';
 import { loadShortIdByTaskId } from '../short-id.js';
 import { getOpenWorkflowWarnings, formatWorkflowWarningSummary } from '../workflow-warnings.js';
 import { parseActivityLog, pairEntries, startedBackedRows } from '../activity-log.js';
-import { readRun } from '../orchestration.js';
+import { lifecycleExecutions } from '../lifecycle-execution.js';
+import { parseTypedTaskFrontmatter } from '../frontmatter.js';
 import { statusCard } from '../../server/display.js';
 import { buildLifecycleFacts, recommendNext } from '../capabilities.js';
 const USAGE = `Usage: ai task status [--task <ref> | -t <ref>]
@@ -151,6 +152,18 @@ function parseActivityTime(value) {
     const epoch = Date.parse(value.replace(' ', 'T'));
     return Number.isFinite(epoch) ? epoch : Number.NaN;
 }
+function collectStructuredWorkflow(content, now) {
+    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, now = new Date()) {
     const parsed = parseActivityLog(content);
     if (!parsed.sectionFound || parsed.entries.length === 0) {
@@ -264,38 +277,6 @@ function collectRuntime(taskDir, workflow, run) {
         log: record.log_file
     };
 }
-function pendingDelegationInfo(receipt) {
-    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) {
-    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)
-    };
-}
 // Indent each label/value pair by two spaces and pad labels to a common width so
 // every section reads as an aligned "key   value" block.
 function renderPairs(rows) {
@@ -323,21 +304,6 @@ function renderStatus(model) {
         ['action', model.recommendation ?? DASH],
         ['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', ...renderPairs([
         ['state', model.workflow.state],
         ['step', model.workflow.step],
@@ -367,12 +333,6 @@ function renderStatus(model) {
     return lines;
 }
 function modelTone(model) {
-    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'))
@@ -387,7 +347,8 @@ function buildFromResolved(input) {
     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;
@@ -400,7 +361,6 @@ function buildFromResolved(input) {
         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,
@@ -426,9 +386,6 @@ function buildStatusModel(refOrInput, options = {}) {
 }
 function statusModelToDisplay(model) {
     return statusCard(`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],
@@ -463,5 +420,5 @@ function status(args = []) {
         process.stdout.write(`${line}\n`);
     }
 }
-export { status, makeRunner, buildStatusModel, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, collectOrchestration, renderStatus, statusModelToDisplay, METADATA_KEYS };
+export { status, makeRunner, buildStatusModel, collectMetadata, groupArtifacts, collectGit, collectWorkflow, collectRuntime, renderStatus, statusModelToDisplay, METADATA_KEYS };
 //# sourceMappingURL=status.js.map