@fitlab-ai/agent-infra 0.11.3 → 0.11.5

package/dist/lib/task/lifecycle.js

@@ -43,9 +43,6 @@ const lifecycleProducerCatalog = lifecycleFailureCatalog.map((code) => ({
     guardId: 'G-03',
     code
 }));
-function allowsManualOverride(options, code) {
-    return options.manualOverride?.failureId === `lifecycle.apply:${code}`;
-}
 const STEPS = ['task-written', 'directory-moved', 'registry-committed'];
 const DEFAULT_IO = {
     renameSync: (source, target) => fs.renameSync(source, target),
@@ -320,6 +317,49 @@ export function readLifecycleJournalEvidence(repoRoot, taskId) {
         return { exists: true, completedSteps: [], failure: 'SANDBOX_CONTROL_LIFECYCLE_JOURNAL_INVALID' };
     }
 }
+export function inspectTaskLifecycleProgress(repoRoot, taskId, agent) {
+    try {
+        const hot = locateHotTaskDirs(repoRoot, taskId);
+        if (hot.length !== 1 || (hot[0].state !== 'active' && hot[0].state !== 'completed'))
+            return 'unknown';
+        const { state, taskDir } = hot[0];
+        const content = fs.readFileSync(path.join(taskDir, 'task.md'), 'utf8');
+        const frontmatter = parseTypedTaskFrontmatter(content);
+        if (frontmatter.id !== taskId)
+            return 'unknown';
+        const journalPath = path.join(taskDir, '.task-lifecycle.json');
+        if (!fs.existsSync(journalPath)) {
+            if (state === 'active')
+                return frontmatter.status === 'active' ? 'not-started' : 'unknown';
+            return matchingCompletion(content, { taskRef: taskId, intent: 'complete', agent })
+                ? 'started-recoverable' : 'unknown';
+        }
+        const journal = parseJournal(fs.readFileSync(journalPath, 'utf8'));
+        const request = { taskRef: taskId, intent: 'complete', agent };
+        if (journal.taskId !== taskId || journal.intent !== 'complete'
+            || journal.intentDigest !== intentIdentity(request, taskId)
+            || journal.sourceState !== 'active' || journal.targetState !== 'completed')
+            return 'unknown';
+        if (journal.completedSteps.some((step, index) => STEPS[index] !== step))
+            return 'unknown';
+        const directoryMoved = journal.completedSteps.includes('directory-moved');
+        const registryCommitted = journal.completedSteps.includes('registry-committed');
+        const hasShortId = loadShortIdByTaskId(repoRoot).has(taskId);
+        if (state === 'active' && (directoryMoved || !hasShortId))
+            return 'unknown';
+        if (state === 'completed' && (!journal.completedSteps.includes('task-written')
+            || !matchingCompletion(content, request) || (registryCommitted && hasShortId)))
+            return 'unknown';
+        if (frontmatter.status !== state
+            && !(state === 'active' && frontmatter.status === 'completed' && matchingCompletion(content, request))) {
+            return 'unknown';
+        }
+        return 'started-recoverable';
+    }
+    catch {
+        return 'unknown';
+    }
+}
 function directoryManifest(root) {
     const entries = [];
     const visit = (current, relative = '') => {
@@ -440,7 +480,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         }
         return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: `task ${taskId} is already ${spec.target} with a different lifecycle intent` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (!spec.sources.includes(sourceState) && !existingJournal && !allowsManualOverride(options, 'LIFECYCLE_SOURCE_INVALID')) {
+    if (!spec.sources.includes(sourceState) && !existingJournal) {
         return failed(request, { code: 'LIFECYCLE_SOURCE_INVALID', message: `${request.intent} is not allowed from ${sourceState}` }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     if (sourcePath !== targetPath && fs.existsSync(targetPath) && !existingJournal) {
@@ -456,7 +496,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     if (frontmatter.id !== taskId)
         return failed(request, { code: 'LIFECYCLE_IDENTITY_INVALID', message: 'task.md id does not match its lifecycle task id' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
-    if (!locateActivityLog(content) && !allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'))
+    if (!locateActivityLog(content))
         return failed(request, { code: 'LIFECYCLE_LOG_MISSING', message: 'task has no unique Activity Log section' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     if (spec.target === 'active') {
         const contract = validateCurrentTaskContract(content);
@@ -472,10 +512,10 @@ function applyTaskLifecycle(requestInput, options = {}) {
     }
     const registry = JSON.parse(registryRequest.output || '{"version":1,"ids":{}}');
     const registeredKey = Object.entries(registry.ids).find(([, candidate]) => candidate === taskId)?.[0];
-    if (spec.registry === 'release' && sourceState === 'active' && !registeredKey && !allowsManualOverride(options, 'LIFECYCLE_SHORT_ID_PRECONDITION')) {
+    if (spec.registry === 'release' && sourceState === 'active' && !registeredKey) {
         return failed(request, { code: 'LIFECYCLE_SHORT_ID_PRECONDITION', message: 'active source has no short-id registry entry' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
-    if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1 && !allowsManualOverride(options, 'SHORT_ID_CAPACITY_EXCEEDED')) {
+    if (spec.registry === 'alloc' && !registeredKey && Object.keys(registry.ids).length >= 10 ** configuredShortIdLength(repoRoot) - 1) {
         return failed(request, { code: 'SHORT_ID_CAPACITY_EXCEEDED', message: 'short-id registry has no free slot' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
     }
     const digest = intentIdentity(request, taskId);
@@ -499,8 +539,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
                 return failed(request, { code: 'LIFECYCLE_JOURNAL_INVALID', message: 'existing lifecycle journal has no durable failure evidence for a read-only probe' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
             return failed(request, journal.failure, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath, completedSteps: journal.completedSteps, pendingSteps: STEPS.filter((step) => !journal.completedSteps.includes(step)) });
         }
-        const overrideResumesRecordedFailure = journal.failure && allowsManualOverride(options, journal.failure.code);
-        if (journal.intentDigest !== digest && !overrideResumesRecordedFailure)
+        if (journal.intentDigest !== digest)
             return failed(request, { code: 'LIFECYCLE_INTENT_CONFLICT', message: 'an in-progress lifecycle journal belongs to a different request' }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath: initialJournalPath });
     }
     else {
@@ -516,7 +555,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         }
         journal = { version: 1, taskId, intent: request.intent, intentDigest: digest, sourceState, targetState: spec.target, metadata, completedSteps: [] };
         if (request.dryRun) {
-            const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));
+            const plannedMutations = mutationsFor(request, content, metadata, restoredFiles, false);
             if ('code' in plannedMutations)
                 return failed(request, plannedMutations, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath });
             const taskPlan = writeTask({ taskRef: taskId, expectedState: sourceState === 'blocked' ? 'blocked' : 'active', mutations: plannedMutations, dryRun: true }, {
@@ -558,7 +597,7 @@ function applyTaskLifecycle(requestInput, options = {}) {
         completed.add('task-written');
     if (!completed.has('task-written')) {
         const current = io.readFileSync(path.join(sourcePath, 'task.md'));
-        const mutations = mutationsFor(request, current, journal.metadata, restoredFiles, allowsManualOverride(options, 'LIFECYCLE_LOG_MISSING'));
+        const mutations = mutationsFor(request, current, journal.metadata, restoredFiles, false);
         if ('code' in mutations)
             return failed(request, mutations, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, completedSteps: [...completed], changed: completed.size > 0 });
         const writeResult = writeTask({ taskRef: taskId, expectedState: sourceState === 'blocked' ? 'blocked' : 'active', mutations }, {
@@ -578,6 +617,16 @@ function applyTaskLifecycle(requestInput, options = {}) {
             return failed(request, { code: 'LIFECYCLE_JOURNAL_WRITE_FAILED', message: String(error) }, { taskId, sourceState, targetState: spec.target, sourcePath, targetPath, journalPath, task: { operations: taskOperations }, changed: true, completedSteps: [...completed], timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion });
         }
     }
+    if (options.prepareOnly && !completed.has('directory-moved')) {
+        return {
+            ...failed(request, { code: '', message: '' }), status: 'applied', changed: true, error: null,
+            taskId, sourceState, targetState: spec.target, sourcePath, targetPath,
+            task: { operations: taskOperations }, directory: { effect: 'unchanged', changed: false },
+            shortId: { effect: 'unchanged', shortId: null, changed: false },
+            timestamp: journal.metadata.timestamp, agentInfraVersion: journal.metadata.agentInfraVersion,
+            journalPath, completedSteps: [...completed], pendingSteps: STEPS.filter((step) => !completed.has(step))
+        };
+    }
     if (fs.existsSync(targetPath) && !fs.existsSync(sourcePath))
         completed.add('directory-moved');
     if (!completed.has('directory-moved')) {

package/dist/lib/task/local-artifact-finalization.js

@@ -1,12 +1,10 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { inspectDecisionDetailDuplicates } from './decision-details.js';
-import { scanVisibleMarkdown } from './markdown.js';
 import { parseArtifactName } from './artifact-name.js';
-import { hasOpenArtifactRound, } from './artifact-lifecycle.js';
+import { parseLifecyclePathDecision } from './lifecycle-path.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.js';
-import { canonicalSemanticDigest, inspectArtifactPatterns, inspectArtifactStructure, sha256Content } from './artifact-operations.js';
+import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
 import { getArtifactSchema } from './artifact-schema.js';
 const LOCAL_ARTIFACT_REQUIRED_SECTIONS = {
     analysis: getArtifactSchema('analysis').sections.map((section) => section.headings.zh),
@@ -18,59 +16,29 @@ function localDiagnosticCode(code) {
         ARTIFACT_EMPTY: 'LOCAL_ARTIFACT_EMPTY',
         ARTIFACT_MISSING_SECTION: 'LOCAL_ARTIFACT_MISSING_SECTION',
         ARTIFACT_DUPLICATE_SECTION: 'LOCAL_ARTIFACT_DUPLICATE_SECTION',
-        ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION'
+        ARTIFACT_HEADING_TRAILING_PUNCTUATION: 'LOCAL_SECTION_HEADING_TRAILING_PUNCTUATION',
+        ARTIFACT_STATE_CHECK_PATTERN_MISSING: 'LOCAL_STATUS_COMMAND_MISSING',
+        ARTIFACT_REQUIRED_PATTERN_MISSING: 'LOCAL_REQUIRED_PATTERN_MISSING'
     };
     return map[code] ?? 'LOCAL_STRUCTURAL_INVALID';
 }
 function localDiagnostic(item) {
     return { code: localDiagnosticCode(item.code), message: item.message, line: item.line };
 }
-function isStatusPattern(pattern) {
-    return pattern === '^\\$ ';
-}
 function validateLocalArtifact(content, options) {
     const schema = getArtifactSchema(options.family);
     const diagnostics = [];
-    const scanned = scanVisibleMarkdown(content);
-    const structure = inspectArtifactStructure(content, schema);
-    for (const item of structure.diagnostics)
+    const inspection = inspectArtifactContract(content, schema, { scopeStateCheckSection: true });
+    for (const item of inspection.diagnostics)
         diagnostics.push(localDiagnostic(item));
-    const statusSection = schema.sections.find((section) => section.id === 'state-check');
-    if (statusSection) {
-        const statusHeading = scanned.headings.find((heading) => (heading.level === 2 && [statusSection.headings.zh, statusSection.headings.en].some((name) => (heading.text === name || heading.text === `${name}:` || heading.text === `${name}：`))));
-        if (statusHeading) {
-            const next = scanned.headings.find((candidate) => candidate.start > statusHeading.start && candidate.level <= 2);
-            const body = content.slice(statusHeading.end, next?.start ?? content.length);
-            for (const pattern of schema.requiredPatterns.filter(isStatusPattern)) {
-                if (!new RegExp(pattern, 'm').test(body)) {
-                    diagnostics.push({ code: 'LOCAL_STATUS_COMMAND_MISSING', message: `status section '${statusHeading.text}' is missing required command output`, line: content.slice(0, statusHeading.start).split('\n').length });
-                }
-            }
-        }
-    }
-    const patternInspection = inspectArtifactPatterns(content, {
-        ...schema,
-        requiredPatterns: schema.requiredPatterns.filter((item) => !isStatusPattern(item))
-    });
-    for (const item of patternInspection.diagnostics)
-        diagnostics.push({ code: 'LOCAL_REQUIRED_PATTERN_MISSING', message: item.message, line: null });
     const decisionDetails = inspectDecisionDetailDuplicates(content);
     if (!decisionDetails.ok)
         diagnostics.push({ code: 'LOCAL_DECISION_DETAIL_DUPLICATE', message: decisionDetails.message, line: null });
-    if (options.taskContent !== undefined) {
-        const identity = options.artifact ? parseArtifactName(options.artifact) : null;
-        const expected = identity?.family === options.family && hasOpenArtifactRound(options.taskContent, options.family, identity.round)
-            ? expectedQualificationRelations(options.taskContent, options.family)
-            : undefined;
-        if (expected && !expected.ok)
-            diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${expected.code}: ${expected.message}`, line: null });
-        const qualification = validateQualificationAudit(options.taskContent, content, {
-            family: options.family,
-            artifact: options.artifact,
-            expectedUpstreamRelations: expected?.ok ? expected.relations : undefined
-        });
-        if (!qualification.ok)
-            diagnostics.push({ code: 'LOCAL_QUALIFICATION_AUDIT_INVALID', message: `${qualification.code}: ${qualification.message}`, line: null });
+    if (options.family === 'analysis') {
+        const flowDecision = parseLifecyclePathDecision(content);
+        if (flowDecision.status !== 'valid') {
+            diagnostics.push({ code: 'LOCAL_FLOW_DECISION_INVALID', message: flowDecision.message, line: null });
+        }
     }
     return {
         ok: diagnostics.length === 0,
@@ -98,10 +66,8 @@ function prepareLocalArtifact(request, candidate) {
     const parsed = parseArtifactName(request.artifact);
     if (!parsed || parsed.family !== request.family)
         return failed('ARTIFACT_IDENTITY_INVALID', `artifact '${request.artifact}' does not match ${request.family}`);
-    let taskContent;
     let content;
     try {
-        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
         const artifactPath = path.join(resolved.taskDir, request.artifact);
         if (!fs.statSync(artifactPath).isFile())
             return failed('ARTIFACT_NOT_REGULAR', `artifact '${request.artifact}' is not a regular file`);
@@ -114,7 +80,7 @@ function prepareLocalArtifact(request, candidate) {
         return failed('ARTIFACT_IDENTITY_INVALID', 'artifact finalization requires an active task');
     }
     const validation = validateLocalArtifact(content, {
-        family: request.family, requiredSections: request.requiredSections, taskContent, artifact: request.artifact
+        family: request.family, requiredSections: request.requiredSections
     });
     const artifactSha256 = sha256Content(content);
     const result = failedFinalization(request, {

package/dist/lib/task/orchestration.js

@@ -22,6 +22,7 @@ import { buildLifecycleFacts, canStart, recommendNext } from './capabilities.js'
 import { hasOpenLifecycleExecution } from './activity-log.js';
 import { reconcileTaskInvalidation } from './invalidation-command.js';
 import { normalizeAgentToken } from '../agent-clients/tokens.js';
+import { resolveArtifactContext } from './artifact-lifecycle.js';
 function supportsLifecycleDelegation(client) {
     return getAgentClientCapability(client, 'subagents').level !== 'unsupported'
         && getAgentClientCapability(client, 'orchestration').level !== 'unsupported'
@@ -479,17 +480,13 @@ function validateSavedCurrentDiffBase(repoRoot, metadata, taskDir, reviewedHead)
 function routeFromFacts(facts) {
     const recommendation = recommendNext(facts);
     if (!recommendation.action)
-        return { completion: true };
+        return recommendation.reasonCode === 'LIFECYCLE_REVIEWED' ? { completion: true } : null;
     const action = recommendation.action;
     if (action === 'manual-validation' || action === 'validation-run')
         return null;
-    const family = action === 'analysis' ? 'analysis' : action;
-    const round = maxArtifactRound([
-        ...(facts.artifacts[family] ?? []), ...(facts.staleArtifacts?.[family] ?? [])
-    ], family) + 1;
     const command = action === 'analysis' ? 'analyze-task' : action === 'plan' ? 'plan-task' : action === 'code' ? 'code-task' : action;
     const role = action.startsWith('review-') ? 'reviewer' : 'executor';
-    return { action: command, role, stage: action, round, artifact: artifactName(family, round) };
+    return { action: command, role, stage: action };
 }
 function routeOrchestration(taskRef, options = {}) {
     const resolved = resolveTaskRef(taskRef, { repoRoot: options.repoRoot });
@@ -619,8 +616,19 @@ function routeOrchestration(taskRef, options = {}) {
         return { status: 'completed', changed: true, taskId: resolved.taskId, run: completed, next: null, error: null };
     }
     const action = routed.stage;
+    const family = action === 'analysis' ? 'analysis' : action;
+    const artifactContext = resolveArtifactContext(taskRef, family, {
+        repoRoot: resolved.repoRoot
+    });
+    if (artifactContext.status !== 'ready' || !artifactContext.selection) {
+        return failed(artifactContext.error?.code ?? 'ORCHESTRATION_ARTIFACT_SELECTION_FAILED', artifactContext.error?.message ?? 'cannot determine artifact selection', resolved.taskId);
+    }
+    if (artifactContext.selection.disposition === 'reuse') {
+        return failed('ORCHESTRATION_REUSE_STALLED', `lifecycle still routes to ${action} after reusing ${artifactContext.selection.artifact.name}`, resolved.taskId);
+    }
+    const selected = artifactContext.selection.artifact;
     const capability = canStart(action, facts.facts, {
-        initiator: 'orchestrator', requestId: `orchestration:${resolved.taskId}:${routed.stage}:${routed.round}`,
+        initiator: 'orchestrator', requestId: `orchestration:${resolved.taskId}:${routed.stage}:${selected.round}`,
         requestedAction: action, reasonCode: 'user-request', explicitRequest: true
     });
     if (!capability.allowed)
@@ -628,6 +636,8 @@ function routeOrchestration(taskRef, options = {}) {
     const policy = run ? rolePolicy(run, routed.role) : null;
     const next = {
         ...routed,
+        round: selected.round,
+        artifact: selected.name,
         requestedModel: policy?.model ?? null,
         requestedReasoningEffort: policy?.reasoningEffort ?? null
     };

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

@@ -3,8 +3,7 @@ export function parseReviewCommand(args) {
         throw new Error('task ref and a supported review operation are required');
     const values = {};
     const flags = {
-        '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun',
-        '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+        '--stage': 'stage', '--artifact': 'artifact', '--orchestrated': 'orchestrated', '--dry-run': 'dryRun'
     };
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];

package/dist/lib/task/review-finalization.js

@@ -9,10 +9,8 @@ import { inspectDecisionDetailDuplicates } from './decision-details.js';
 import { resolveTaskRef } from './resolve-ref.js';
 import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
-import { allowsManualOverride } from './guard-override.js';
 import { getArtifactSchema } from './artifact-schema.js';
 import { canonicalSemanticDigest, inspectArtifactContract, sha256Content } from './artifact-operations.js';
-import { expectedQualificationRelations, validateQualificationAudit } from './qualification-audit.js';
 const STAGES = {
     analysis: { family: 'review-analysis' },
     plan: { family: 'review-plan' },
@@ -66,10 +64,8 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
     const publicationError = validateArtifactPublication(resolved.taskDir, spec.family, request.artifact);
     if (publicationError)
         return preflightFailed(request, 'REVIEW_ARTIFACT_IDENTITY_INVALID', publicationError.message, resolved.taskId);
-    let taskContent;
     let content;
     try {
-        taskContent = fs.readFileSync(resolved.taskMdPath, 'utf8');
         const validated = validateCompletedArtifact(resolved.taskDir, spec.family, request.artifact);
         if (!validated.ok)
             return preflightFailed(request, validated.error.code === 'ARTIFACT_NOT_REGULAR' ? 'REVIEW_ARTIFACT_NOT_REGULAR' : 'REVIEW_ARTIFACT_IDENTITY_INVALID', validated.error.message, resolved.taskId);
@@ -89,22 +85,12 @@ function preflightReviewSummaryUnlocked(request, options = {}) {
     const semanticDigest = canonicalSemanticDigest(content);
     const detail = inspectDecisionDetailDuplicates(content);
     const structure = inspectArtifactContract(content, getArtifactSchema(spec.family));
-    const expected = expectedQualificationRelations(taskContent, spec.family);
-    if (!expected.ok)
-        return preflightFailed(request, 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', `${expected.code}: ${expected.message}`, resolved.taskId, { artifactSha256, semanticDigest });
-    const qualification = validateQualificationAudit(taskContent, content, {
-        family: spec.family,
-        artifact: request.artifact,
-        expectedUpstreamRelations: expected.relations
-    });
-    const qualificationError = qualification.ok ? null : qualification;
-    if (!detail.ok || !structure.ok || qualificationError) {
+    if (!detail.ok || !structure.ok) {
         const diagnostics = [
             ...(!detail.ok ? [`${detail.code}: ${detail.message}`] : []),
-            ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`),
-            ...(qualificationError ? [`${qualificationError.code}: ${qualificationError.message}`] : [])
+            ...structure.diagnostics.map((item) => `${item.code}: ${item.message}`)
         ].join('; ');
-        return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : !structure.ok ? 'REVIEW_ARTIFACT_STRUCTURE_INVALID' : 'REVIEW_ARTIFACT_QUALIFICATION_INVALID', diagnostics, resolved.taskId, {
+        return preflightFailed(request, !detail.ok ? 'REVIEW_DECISION_DETAIL_INVALID' : 'REVIEW_ARTIFACT_STRUCTURE_INVALID', diagnostics, resolved.taskId, {
             artifactSha256, semanticDigest,
         });
     }
@@ -151,7 +137,7 @@ function prepareReviewSummaryCandidate(request, artifactContent, options = {}) {
     taskId = resolved.taskId ?? null;
     if (!resolved.ok)
         return reject(resolved.code, resolved.message);
-    if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'review-finalization', 'TASK_STATE_MISMATCH')) {
+    if (resolved.state !== 'active') {
         return reject('TASK_STATE_MISMATCH', `task ${taskId} is ${resolved.state}, expected active`);
     }
     const parsed = parseArtifactName(request.artifact);

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

@@ -1,5 +1,9 @@
 const REWORK_INTENT_HEADINGS = ['返工意图', 'Rework Intent'];
 const REWORK_INTENT_COLUMNS = [
+    'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
+    'classification', 'evidence_digest', 'task_fact_digest', 'status', 'declared_at', 'consumed_at'
+];
+const LEGACY_REWORK_INTENT_COLUMNS = [
     'intent_id', 'finding_id', 'source_artifact', 'source_sha256', 'target',
     'status', 'declared_at', 'consumed_at'
 ];
@@ -55,12 +59,16 @@ function parseReworkIntentDocument(content) {
                 throw new Error(`invalid intent id '${row.intent_id}'`);
             if (!/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id))
                 throw new Error(`invalid finding id '${row.finding_id}'`);
-            if (!['analysis', 'plan', 'code'].includes(row.target))
+            if (!['analysis', 'plan', 'code', 'pause'].includes(row.target))
                 throw new Error(`invalid rework target '${row.target}'`);
+            if (!['scope-or-requirement', 'design', 'implementation', 'human-decision', 'insufficient-evidence'].includes(row.classification))
+                throw new Error(`invalid rework classification '${row.classification}'`);
             if (!['pending', 'consumed', 'superseded'].includes(row.status))
                 throw new Error(`invalid rework status '${row.status}'`);
             if (!/^[a-f0-9]{64}$/.test(row.source_sha256))
                 throw new Error(`invalid source hash for '${row.intent_id}'`);
+            if (!/^[a-f0-9]{64}$/.test(row.evidence_digest) || !/^[a-f0-9]{64}$/.test(row.task_fact_digest))
+                throw new Error(`invalid semantic digest for '${row.intent_id}'`);
             if (!row.source_artifact || !row.declared_at)
                 throw new Error(`rework intent '${row.intent_id}' has invalid required fields`);
             const terminal = row.status === 'consumed' || row.status === 'superseded';
@@ -69,6 +77,8 @@ function parseReworkIntentDocument(content) {
             return {
                 intentId: row.intent_id, findingId: row.finding_id, sourceArtifact: row.source_artifact,
                 sourceSha256: row.source_sha256, target: row.target,
+                classification: row.classification,
+                evidenceDigest: row.evidence_digest, taskFactDigest: row.task_fact_digest,
                 status: row.status, declaredAt: row.declared_at, consumedAt: row.consumed_at
             };
         });
@@ -91,7 +101,10 @@ function renderReworkIntents(intents) {
         `| ${REWORK_INTENT_COLUMNS.map(() => '---').join(' | ')} |`,
         ...intents.map((intent) => `| ${[
             intent.intentId, intent.findingId, intent.sourceArtifact, intent.sourceSha256,
-            intent.target, intent.status, intent.declaredAt, intent.consumedAt
+            intent.target, intent.classification ?? (intent.target === 'analysis' ? 'scope-or-requirement' : intent.target === 'plan' ? 'design' : intent.target === 'code' ? 'implementation' : 'insufficient-evidence'),
+            intent.evidenceDigest ?? requireDigest(`${intent.findingId}|${intent.sourceArtifact}|${intent.sourceSha256}`),
+            intent.taskFactDigest ?? requireDigest(`current|${intent.findingId}|${intent.target}`),
+            intent.status, intent.declaredAt, intent.consumedAt
         ].map(escape).join(' | ')} |`)
     ].join('\n');
 }
@@ -99,11 +112,63 @@ function upsertReworkIntent(intents, intent) {
     const existing = intents.find((candidate) => candidate.intentId === intent.intentId);
     if (!existing)
         return { changed: true, intents: [...intents, intent] };
-    const identity = (value) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target];
+    const identity = (value) => [value.intentId, value.findingId, value.sourceArtifact, value.sourceSha256, value.target, value.classification, value.evidenceDigest, value.taskFactDigest];
     if (JSON.stringify(identity(existing)) !== JSON.stringify(identity(intent)))
         throw new Error(`intent '${intent.intentId}' identity conflicts with existing state`);
     return { changed: false, intents };
 }
+function consumeHumanDecisionReworkIntents(intents, findingId, consumedAt) {
+    let changed = false;
+    const next = intents.map((intent) => {
+        if (intent.status !== 'pending' || intent.target !== 'pause' || intent.classification !== 'human-decision' || intent.findingId !== findingId)
+            return intent;
+        changed = true;
+        return { ...intent, status: 'consumed', consumedAt };
+    });
+    return { changed, intents: next };
+}
+function parseLegacyReworkIntentDocument(content) {
+    // TODO(compat): Remove this explicit decoder once no task contains the eight-column rework-intent header.
+    const body = sectionBody(content);
+    if (body === null)
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'legacy rework intent section is missing' };
+    const lines = body.split(/\r?\n/).filter((line) => line.trim());
+    const header = lines[0] ? cells(lines[0]) : null;
+    const separator = lines[1] ? cells(lines[1]) : null;
+    if (!header || !separator || header.length !== LEGACY_REWORK_INTENT_COLUMNS.length || !header.every((value, index) => value === LEGACY_REWORK_INTENT_COLUMNS[index])) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: 'rework intent section is not the known legacy table' };
+    }
+    try {
+        const intents = lines.slice(2).map((line) => {
+            const values = cells(line);
+            if (!values || values.length !== LEGACY_REWORK_INTENT_COLUMNS.length)
+                throw new Error('legacy rework intent row has the wrong column count');
+            const row = Object.fromEntries(LEGACY_REWORK_INTENT_COLUMNS.map((column, index) => [column, values[index]]));
+            if (!/^RI-[1-9]\d*$/.test(row.intent_id) || !/^(AN|PL|CD)-[1-9]\d*$/.test(row.finding_id))
+                throw new Error('legacy rework intent identity is invalid');
+            if (!['analysis', 'plan', 'code'].includes(row.target) || !['pending', 'consumed', 'superseded'].includes(row.status))
+                throw new Error('legacy rework intent state is invalid');
+            if (!/^[a-f0-9]{64}$/.test(row.source_sha256))
+                throw new Error('legacy rework intent source hash is invalid');
+            const legacyDigest = (value) => requireDigest(value);
+            const classification = row.target === 'analysis' ? 'scope-or-requirement' : row.target === 'plan' ? 'design' : 'implementation';
+            return {
+                intentId: row.intent_id, findingId: row.finding_id, sourceArtifact: row.source_artifact, sourceSha256: row.source_sha256,
+                target: row.target, classification,
+                evidenceDigest: legacyDigest(`${row.finding_id}|${row.source_artifact}|${row.source_sha256}`),
+                taskFactDigest: legacyDigest(`legacy|${row.finding_id}|${row.target}`),
+                status: row.status, declaredAt: row.declared_at, consumedAt: row.consumed_at
+            };
+        });
+        return { ok: true, present: true, intents };
+    }
+    catch (error) {
+        return { ok: false, code: 'TASK_REWORK_INTENT_INVALID', message: error instanceof Error ? error.message : String(error) };
+    }
+}
+function requireDigest(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
 function consumeReworkIntents(intents, target, sourceHashes, consumedAt) {
     let changed = false;
     const next = intents.map((intent) => {
@@ -134,5 +199,6 @@ function reworkIntentMutation(content, intents) {
         body: renderReworkIntents(intents)
     };
 }
-export { REWORK_INTENT_COLUMNS, REWORK_INTENT_HEADINGS, parseReworkIntentDocument, renderReworkIntents, reworkIntentMutation, consumeReworkIntents, supersedeReworkIntents, upsertReworkIntent };
+export { REWORK_INTENT_COLUMNS, REWORK_INTENT_HEADINGS, parseReworkIntentDocument, renderReworkIntents, reworkIntentMutation, consumeReworkIntents, supersedeReworkIntents, upsertReworkIntent, consumeHumanDecisionReworkIntents, parseLegacyReworkIntentDocument };
+import { createHash } from 'node:crypto';
 //# sourceMappingURL=rework-intent.js.map

package/dist/lib/task/snapshot.js

@@ -56,25 +56,25 @@ function collectTaskSnapshot(taskRef, options = {}) {
     const observations = [];
     try {
         const output = stripOneTrailingNewline((options.gitStatus ?? defaultGitStatus)(resolved.repoRoot));
-        observations.push({ name: 'git', status: 'ready', command: '$ git status -s', output, error: null });
+        observations.push({ name: 'git', status: 'ready', command: 'git status --short --untracked-files=all', output, error: null });
     }
     catch (error) {
-        return failedSnapshot(resolved, taskRef, observations, 'git', '$ git status -s', 'SNAPSHOT_GIT_FAILED', error);
+        return failedSnapshot(resolved, taskRef, observations, 'git', 'git status --short --untracked-files=all', 'SNAPSHOT_GIT_FAILED', error);
     }
     try {
         const entries = (options.readDirectory ?? ((dir) => fs.readdirSync(dir, { withFileTypes: true })))(resolved.taskDir);
         const output = renderDirectory(entries, resolved.taskDir, options.lstat ?? fs.lstatSync);
-        observations.push({ name: 'task-directory', status: 'ready', command: `$ ls -la ${taskDirPath}/`, output, error: null });
+        observations.push({ name: 'task-directory', status: 'ready', command: `fs.readdirSync ${taskDirPath}/`, output, error: null });
     }
     catch (error) {
-        return failedSnapshot(resolved, taskRef, observations, 'task-directory', `$ ls -la ${taskDirPath}/`, 'SNAPSHOT_DIRECTORY_READ_FAILED', error);
+        return failedSnapshot(resolved, taskRef, observations, 'task-directory', `fs.readdirSync ${taskDirPath}/`, 'SNAPSHOT_DIRECTORY_READ_FAILED', error);
     }
     try {
         const content = (options.readTask ?? ((file) => fs.readFileSync(file, 'utf8')))(resolved.taskMdPath);
-        observations.push({ name: 'task-tail', status: 'ready', command: `$ tail ${taskPath}`, output: renderTail(content), error: null });
+        observations.push({ name: 'task-tail', status: 'ready', command: `fs.readFileSync ${taskPath} (last 10 lines)`, output: renderTail(content), error: null });
     }
     catch (error) {
-        return failedSnapshot(resolved, taskRef, observations, 'task-tail', `$ tail ${taskPath}`, 'SNAPSHOT_TASK_READ_FAILED', error);
+        return failedSnapshot(resolved, taskRef, observations, 'task-tail', `fs.readFileSync ${taskPath} (last 10 lines)`, 'SNAPSHOT_TASK_READ_FAILED', error);
     }
     return {
         status: 'ready', changed: false, requestRef: taskRef, taskId: resolved.taskId,