@fitlab-ai/agent-infra 0.12.0 → 0.12.2

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

package/dist/lib/task/commit-operation.js

@@ -7,12 +7,12 @@ import { checkpointCommitMatches } from './commit-identity.js';
 import { resolveTaskContext, resolveTaskRef } from './resolve-ref.js';
 import { commitPushDecision } from './commit-policy.js';
 import { mergeOperationWarnings } from './operation-outcome.js';
-import { appendActivityEntry, locateActivityLog } from './activity-log.js';
+import { activityWarnings, appendActivityEntry, locateActivityLog } from './activity-log.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
 import { checkpointIntentDigest, readCheckpointIntent, removeCheckpointIntent, sameCheckpointIntent, updateCheckpointIntent, writeCheckpointIntent } from './commit-intent.js';
 const HEAD_REF = /^refs\/heads\/(.+)$/;
 function isCommitExecutionMode(value) {
-    return value === 'direct' || value === 'orchestrated';
+    return value === 'direct';
 }
 function gitText(repoRoot, args) {
     return execFileSync('git', [...args], {
@@ -117,50 +117,43 @@ function validateCommon(input, branch) {
     }
     return null;
 }
-function syncTaskCommit(input, task, committedHead) {
+// Log presentation only; checkpoint identity and recovery never depend on this projection.
+function commitLogProjection(activity, timestamp, agent, commitNote) {
+    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, task, committedHead, writeOptions = {}) {
     let content;
     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 = [];
-        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 = {
             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, true, 'task', 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', error instanceof Error ? error.message : String(error), true, 'task', task.taskId, 'ACTION_REQUIRED');
@@ -183,12 +176,10 @@ function checkpointIdentity(input, task, delivery) {
 function checkpointTimestamp() {
     return new Date().toISOString();
 }
-function executeCommitOperationCore(input, task, mode) {
+function executeCommitOperationCore(input, task, mode, writeOptions) {
     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)
@@ -380,13 +371,13 @@ function executeCommitOperationCore(input, task, mode) {
     }
     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()
             });
@@ -406,7 +397,7 @@ function executeCommitOperationCore(input, task, mode) {
         error: null
     };
 }
-function executeCommitOperation(input) {
+function executeCommitOperation(input, writeOptions = {}) {
     if (input.mode !== undefined && !isCommitExecutionMode(input.mode))
         return {
             status: 'blocked',
@@ -417,7 +408,7 @@ function executeCommitOperation(input) {
             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 = input.mode ?? 'direct';
     let normalizedInput;
@@ -431,10 +422,8 @@ function executeCommitOperation(input) {
     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';

package/dist/lib/task/completion-facts.js

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { canonicalSemanticDigest } from './artifact-operations.js';
-import { inspectActivityLog, pairEntries } from './activity-log.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { parseArtifactName } from './artifact-name.js';
 import { sha256File } from './artifact-receipts.js';
@@ -23,56 +23,69 @@ export function parseCompletionFacts(value) {
         return [];
     }
 }
-export function hasArtifactCompletionFact(taskContent, artifactPath, event) {
+function completionEvent(family) {
+    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, taskDir, artifact, event) {
     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, artifact, event) {
-    return artifactCompletionOrder(taskContent, artifact, event) !== null;
+/** Distinguishes an invalidated completion fact from a round that has never completed. */
+export function hasArtifactCompletionRecord(taskContent, artifact, event) {
+    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 = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return true;
+        return parsed.some((fact) => fact && typeof fact === 'object' && !Array.isArray(fact)
+            && fact.event === event
+            && fact.output === artifact);
+    }
+    catch {
+        return true;
+    }
 }
-/** Returns the stable Activity Log position of a paired completion row. */
-export function artifactCompletionOrder(taskContent, artifact, event) {
+function findCompletionFact(taskContent, artifact, event) {
     const identity = parseArtifactName(artifact);
-    if (!identity)
+    if (!identity || completionEvent(identity.family) !== event)
         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;
+    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, artifact, fact) {
+    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;
 }
 //# sourceMappingURL=completion-facts.js.map