@fitlab-ai/agent-infra 0.9.6 → 0.9.8

package/dist/lib/task/decision-intents.js

@@ -6,6 +6,7 @@ import { LEDGER_COLUMNS, LEDGER_HEADINGS, parseLedger } from './ledger.js';
 import { resolveTaskContext } from './resolve-ref.js';
 import { extractSection, extractSubSection, findSectionHeading } from './sections.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { allowsManualOverride } from './guard-override.js';
 const DECISION_ALIASES = ['人工裁决', 'Human Rulings', 'Human Decisions', 'Human Decision'];
 const ACTIVITY_ALIASES = ['活动日志', 'Activity Log'];
 function failed(code, message, taskId = null, ledgerId = null) {
@@ -56,7 +57,8 @@ function applyHumanDecision(request, options = {}) {
     const resolved = resolveTaskContext(request.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(resolved.code, resolved.message, resolved.taskId);
-    if (resolved.state !== 'active')
+    const stateOverride = allowsManualOverride(options.manualOverride, 'decision-intent', 'TASK_STATE_MISMATCH');
+    if (resolved.state !== 'active' && !stateOverride)
         return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     let content;
     let rows;
@@ -155,7 +157,7 @@ function applyHumanDecision(request, options = {}) {
         kind: 'section', aliases: ACTIVITY_ALIASES, heading: activity.heading,
         body: appendActivityEntry(activity, { time: metadata.timestamp, step: 'Human Decision', agent: 'human', note: `${row.id} decided → ${recordId}` })
     });
-    const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, {
+    const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
         ...options,
         taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
         metadataProvider: () => metadata

package/dist/lib/task/delegation-receipts.js

@@ -10,7 +10,12 @@ function managedDelegationRole(nativeAgent) {
 function fail(code, message) {
     return { ok: false, code, message };
 }
+// 空白串折叠为 null，保持"缺失即 null"的单一表示（Start/Stop 两处共用，避免任一入口把 "   " 当成已观察到的值入账）
+function foldBlankToNull(value) {
+    return value?.trim() ? value : null;
+}
 function prepareDelegation(input, options = {}) {
+    const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
     return Object.freeze({
         ...input,
         id: (options.id ?? randomUUID)(),
@@ -27,43 +32,97 @@ function prepareDelegation(input, options = {}) {
         afterFingerprint: null,
         changedPaths: Object.freeze([]),
         createdAt: (options.now ?? (() => new Date().toISOString()))(),
+        preparedMonotonicMs: monotonic,
+        spawnDispatchMonotonicMs: null,
+        activationDeadlineMonotonicMs: null,
+        spawnDispatchedAt: null,
+        activationDeadlineAt: null,
+        startEvidenceMonotonicMs: null,
+        activatedMonotonicMs: null,
         activatedAt: null,
         sealedAt: null,
         consumedAt: null
     });
 }
+function dispatchDelegation(receipt, options = {}) {
+    if (receipt.status !== 'prepared') {
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    }
+    if (receipt.spawnDispatchMonotonicMs != null || receipt.spawnDispatchedAt != null) {
+        return fail('DELEGATION_DISPATCH_REPLAY', `delegation ${receipt.id} was already dispatched`);
+    }
+    const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
+    const dispatchedAt = (options.now ?? (() => new Date().toISOString()))();
+    const window = options.activationWindowMs ?? 15_000;
+    return { ok: true, receipt: Object.freeze({
+            ...receipt,
+            spawnDispatchMonotonicMs: monotonic,
+            activationDeadlineMonotonicMs: monotonic + window,
+            spawnDispatchedAt: dispatchedAt,
+            activationDeadlineAt: new Date(Date.parse(dispatchedAt) + window).toISOString()
+        }) };
+}
 function activateDelegation(receipt, event, options = {}) {
     const managedRole = managedDelegationRole(event.nativeAgent);
     if (!managedRole)
         return fail('DELEGATION_IGNORED', `subagent '${event.nativeAgent}' is not lifecycle-managed`);
     if (receipt.status !== 'prepared')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    if (receipt.spawnDispatchMonotonicMs == null
+        || receipt.spawnDispatchedAt == null
+        || receipt.activationDeadlineAt == null
+        || receipt.activationDeadlineMonotonicMs == null
+        || !Number.isFinite(Date.parse(receipt.spawnDispatchedAt))
+        || !Number.isFinite(Date.parse(receipt.activationDeadlineAt))) {
+        return fail('DELEGATION_NOT_DISPATCHED', `delegation ${receipt.id} has not reached the native spawn dispatch boundary`);
+    }
+    const monotonic = (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))();
+    const wallNow = Date.parse((options.now ?? (() => new Date().toISOString()))());
+    if (wallNow > Date.parse(receipt.activationDeadlineAt)) {
+        return fail('DELEGATION_ACTIVATION_TIMEOUT', `delegation ${receipt.id} activation evidence arrived after its deadline`);
+    }
     if (managedRole !== receipt.role)
         return fail('DELEGATION_ROLE_MISMATCH', `managed role ${managedRole} does not match ${receipt.role}`);
     if (!event.parentId || (receipt.parentId !== null && event.parentId !== receipt.parentId) || !event.childId || event.childId === event.parentId) {
         return fail('DELEGATION_IDENTITY_INVALID', 'native parent/child identity does not match the prepared delegation');
     }
-    if (event.spawnMode !== 'fresh')
+    // spawnMode 的必需性按 client 判断：claude-code 宿主结构上不提供该字段，跳过；其余 client 维持硬校验
+    if (receipt.client !== 'claude-code' && event.spawnMode !== 'fresh') {
         return fail('DELEGATION_FORK_FORBIDDEN', `spawn mode '${event.spawnMode}' is not fresh`);
-    const actualModel = event.actualModel;
-    if (!actualModel || actualModel.trim() !== actualModel) {
-        return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
     }
-    if (actualModel !== receipt.requestedModel && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
-        return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+    // model/effort 维度：claude-code 如实记录、不做门禁；其余 client 维持现状硬校验（HDR-2）
+    const actualModel = foldBlankToNull(event.actualModel);
+    const actualReasoningEffort = foldBlankToNull(event.actualReasoningEffort);
+    if (receipt.client !== 'claude-code') {
+        if (!actualModel || actualModel.trim() !== actualModel) {
+            return fail('DELEGATION_MODEL_IDENTITY_MISSING', 'native start event must provide a non-empty actual model identity');
+        }
     }
-    const actualReasoningEffort = event.actualReasoningEffort;
-    if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
-        return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
+    if (actualModel !== null && actualModel !== receipt.requestedModel) {
+        if (receipt.client !== 'claude-code' && (!event.modelFallbackReason || event.modelFallbackReason.trim() === '')) {
+            return fail('DELEGATION_MODEL_FALLBACK_UNRECORDED', 'actual model differs from requested model without a fallback reason');
+        }
     }
-    if (actualReasoningEffort !== receipt.requestedReasoningEffort
-        && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
-        return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+    if (receipt.client !== 'claude-code') {
+        if (!actualReasoningEffort || actualReasoningEffort.trim() !== actualReasoningEffort) {
+            return fail('DELEGATION_REASONING_EFFORT_MISSING', 'native start event must provide a non-empty actual reasoning effort');
+        }
     }
-    if (actualModel === receipt.requestedModel && event.modelFallbackReason) {
+    if (receipt.client === 'codex'
+        && event.hostEvidence?.kind !== 'codex-lifecycle-v2')
+        return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex activation requires trusted lifecycle-v2 host evidence');
+    if (actualReasoningEffort !== null && actualReasoningEffort !== receipt.requestedReasoningEffort) {
+        if (receipt.client !== 'claude-code' && (!event.reasoningEffortFallbackReason || event.reasoningEffortFallbackReason.trim() === '')) {
+            return fail('DELEGATION_REASONING_EFFORT_FALLBACK_UNRECORDED', 'actual reasoning effort differs from requested effort without a fallback reason');
+        }
+    }
+    // "无关 fallback 理由"检查对所有 client 保持不变——防止编造理由的红线，不属于 HDR-2 放宽范围
+    // actualModel/actualReasoningEffort 为 null（未观察到）时同样没有"实际不同"这回事，理由一样是无关的
+    if ((actualModel === null || actualModel === receipt.requestedModel) && event.modelFallbackReason) {
         return fail('DELEGATION_MODEL_FALLBACK_INVALID', 'model fallback reason is only valid when actual model differs');
     }
-    if (actualReasoningEffort === receipt.requestedReasoningEffort && event.reasoningEffortFallbackReason) {
+    if ((actualReasoningEffort === null || actualReasoningEffort === receipt.requestedReasoningEffort)
+        && event.reasoningEffortFallbackReason) {
         return fail('DELEGATION_REASONING_EFFORT_FALLBACK_INVALID', 'reasoning-effort fallback reason is only valid when actual effort differs');
     }
     if (event.hostEvidence
@@ -72,12 +131,38 @@ function activateDelegation(receipt, event, options = {}) {
             || !Number.isSafeInteger(event.hostEvidence.startRevision)
             || event.hostEvidence.startRevision < 1))
         return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex start evidence reference is invalid');
+    if (event.hostEvidence?.kind === 'codex-lifecycle-v2') {
+        const expected = receipt.lifecycleProvenance;
+        const spawnObservedAt = Date.parse(event.hostEvidence.spawnObservedAt ?? '');
+        const spawnDispatchedAt = Date.parse(receipt.spawnDispatchedAt);
+        const activationDeadlineAt = Date.parse(receipt.activationDeadlineAt);
+        if (!expected
+            || event.hostEvidence.protocolVersion !== expected.protocolVersion
+            || event.hostEvidence.packageVersion !== expected.packageVersion
+            || event.hostEvidence.internalExecutableBuildHash !== expected.internalExecutableBuildHash
+            || event.hostEvidence.lifecycleContractHash !== expected.lifecycleContractHash
+            || event.hostEvidence.hookDefinitionHash !== expected.hookDefinitionHash
+            || event.hostEvidence.hookSource !== expected.hookSource
+            || event.hostEvidence.hookSourcePathDigest !== expected.hookSourcePathDigest
+            || event.hostEvidence.hookSourceHash !== expected.hookSourceHash
+            || event.hostEvidence.capabilitySessionId !== expected.capabilitySessionId
+            || event.hostEvidence.capabilityTurnId !== expected.capabilityTurnId
+            || !event.hostEvidence.spawnToolUseId?.trim()
+            || event.hostEvidence.spawnToolUseId === expected.capabilityToolUseId
+            || !Number.isFinite(spawnObservedAt)
+            || spawnObservedAt < spawnDispatchedAt
+            || spawnObservedAt > activationDeadlineAt
+            || event.parentId !== expected.capabilitySessionId
+            || (event.hostEvidence.controllerInstanceDigest ?? null) !== expected.controllerInstanceDigest
+            || (event.hostEvidence.controlGeneration ?? null) !== expected.controlGeneration)
+            return fail('DELEGATION_HOST_EVIDENCE_INVALID', 'Codex lifecycle provenance does not match the prepared receipt');
+    }
     return { ok: true, receipt: Object.freeze({
             ...receipt,
             status: 'activated',
             parentId: event.parentId,
             childId: event.childId,
-            spawnMode: event.spawnMode,
+            spawnMode: event.spawnMode ?? null,
             actualModel,
             actualReasoningEffort,
             modelFallbackReason: event.modelFallbackReason ?? null,
@@ -88,9 +173,20 @@ function activateDelegation(receipt, event, options = {}) {
                 consumer: null,
                 consumedAt: null
             }) : receipt.hostEvidence ?? null,
-            activatedAt: (options.now ?? (() => new Date().toISOString()))()
+            startEvidenceMonotonicMs: monotonic,
+            activatedMonotonicMs: (options.monotonicNow ?? (() => Number(process.hrtime.bigint() / 1000000n)))(),
+            activatedAt: new Date(wallNow).toISOString()
         }) };
 }
+function abortPreparedDelegation(receipt) {
+    if (receipt.status !== 'prepared') {
+        return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected prepared`);
+    }
+    return {
+        ok: true,
+        receipt: Object.freeze({ ...receipt, status: 'aborted' })
+    };
+}
 function completeDelegationStage(receipt, event) {
     if (receipt.status !== 'activated')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected activated`);
@@ -105,6 +201,9 @@ function completeDelegationStage(receipt, event) {
 function sealDelegation(receipt, event, options = {}) {
     if (receipt.status !== 'stage-completed')
         return fail('DELEGATION_STATE_INVALID', `delegation ${receipt.id} is ${receipt.status}, expected stage-completed`);
+    if (receipt.client === 'codex' && options.requireHostEvidence !== false && !event.hostEvidence) {
+        return fail('DELEGATION_HOST_EVIDENCE_REQUIRED', 'Codex sealing requires consumed lifecycle-v2 host evidence');
+    }
     if (event.childId !== receipt.childId || event.exitCode !== 0)
         return fail('DELEGATION_STOP_INVALID', 'native stop identity or exit status is invalid');
     if (receipt.role === 'reviewer') {
@@ -131,6 +230,10 @@ function sealDelegation(receipt, event, options = {}) {
             status: 'sealed',
             afterFingerprint: event.afterFingerprint,
             changedPaths: Object.freeze([...event.changedPaths]),
+            actualModel: receipt.actualModel ?? foldBlankToNull(event.actualModel),
+            actualReasoningEffort: receipt.actualReasoningEffort ?? foldBlankToNull(event.actualReasoningEffort),
+            modelFallbackReason: receipt.modelFallbackReason ?? event.modelFallbackReason ?? null,
+            reasoningEffortFallbackReason: receipt.reasoningEffortFallbackReason ?? event.reasoningEffortFallbackReason ?? null,
             hostEvidence: event.hostEvidence && receipt.hostEvidence ? Object.freeze({
                 ...receipt.hostEvidence,
                 ...event.hostEvidence
@@ -149,5 +252,5 @@ function consumeDelegation(receipt, options = {}) {
             consumedAt: (options.now ?? (() => new Date().toISOString()))()
         }) };
 }
-export { activateDelegation, completeDelegationStage, consumeDelegation, managedDelegationRole, prepareDelegation, sealDelegation };
+export { activateDelegation, abortPreparedDelegation, completeDelegationStage, consumeDelegation, dispatchDelegation, foldBlankToNull, managedDelegationRole, prepareDelegation, sealDelegation };
 //# sourceMappingURL=delegation-receipts.js.map

package/dist/lib/task/events.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import { appendActivityEntry, locateActivityLog, pairEntries } from './activity-log.js';
-import { buildArtifactLinkSection, artifactName, parseArtifactName, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { buildArtifactLinkSection, artifactName, inspectArtifactDirectory, parseReviewedInputReference, parseCodePlanInputReference, parseArtifactName, resolveArtifactContext, validateCompletedArtifact } from './artifact-lifecycle.js';
+import { ArtifactReceiptError, sha256File, upsertArtifactReceipt } from './artifact-receipts.js';
 import { parseTypedTaskFrontmatter } from './frontmatter.js';
 import { consumeImplementationInput, IMPLEMENTATION_INPUT_ALIASES, parseImplementationInputs, renderImplementationInputs } from './implementation-inputs.js';
 import { parseLedger, summarizeLedgerStage, validateLedgerRows } from './ledger.js';
@@ -11,6 +12,7 @@ import { validateLifecycleExecution } from './lifecycle-execution.js';
 import { commitOrchestrationStageCompletion } from './orchestration.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
+import { allowsManualOverride } from './guard-override.js';
 const eventCatalog = [
     'analyze.started', 'analyze.awaiting-input', 'analyze.completed',
     'review-analysis.started', 'review-analysis.completed',
@@ -21,7 +23,7 @@ const eventCatalog = [
     'manual-validation.started', 'manual-validation.completed',
     'validation-run.started', 'validation-run.completed'
 ];
-const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun']);
+const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope']);
 const SCHEMAS = {
     'analyze.started': { optional: ['round'] },
     'analyze.awaiting-input': { required: ['question'] },
@@ -237,6 +239,92 @@ function openStartedIdentity(rows, family) {
     });
     return matches.length === 1 ? matches[0] : matches.length > 1 ? { conflict: true } : null;
 }
+function reviewInputFamily(family) {
+    return family === 'review-analysis' ? 'analysis' : family === 'review-plan' ? 'plan' : 'code';
+}
+function buildCompletionReceipt(taskDir, family, artifact, completedAt, frontmatter) {
+    if (family === 'code') {
+        let content;
+        try {
+            content = fs.readFileSync(artifact.path, 'utf8');
+        }
+        catch (error) {
+            return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` };
+        }
+        const input = parseCodePlanInputReference(content);
+        if (!input)
+            return { ok: false, message: `${artifact.name} does not reference a canonical plan artifact` };
+        const startedInput = typeof frontmatter.code_input_artifact === 'string' ? frontmatter.code_input_artifact : '';
+        const startedSha256 = typeof frontmatter.code_input_sha256 === 'string' ? frontmatter.code_input_sha256 : '';
+        if (!startedInput || !startedSha256)
+            return { ok: false, message: 'code.started plan input context is missing' };
+        if (input.name !== startedInput)
+            return { ok: false, message: `${artifact.name} plan input '${input.name}' does not match code.started input '${startedInput}'` };
+        const plan = inspectArtifactDirectory(taskDir, 'plan');
+        if (plan.status !== 'ready' || !plan.latest || plan.latest.name !== input.name) {
+            return { ok: false, message: `code input '${input.name}' is not the latest plan artifact` };
+        }
+        try {
+            const inputSha256 = sha256File(plan.latest.path);
+            if (inputSha256 !== startedSha256)
+                return { ok: false, message: `code input ${input.name} changed after code.started` };
+            return {
+                ok: true,
+                receipt: {
+                    event: 'code.completed', output: artifact.name, input: input.name,
+                    inputSha256, completedAt
+                }
+            };
+        }
+        catch (error) {
+            return { ok: false, message: `cannot hash code input plan: ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    if (!family.startsWith('review-'))
+        return null;
+    const expectedFamily = reviewInputFamily(family);
+    let content;
+    try {
+        content = fs.readFileSync(artifact.path, 'utf8');
+    }
+    catch (error) {
+        return { ok: false, message: `cannot read ${artifact.name}: ${String(error)}` };
+    }
+    const input = parseReviewedInputReference(content, expectedFamily);
+    if (!input)
+        return { ok: false, message: `${artifact.name} does not reference a canonical ${expectedFamily} artifact` };
+    const startedInput = typeof frontmatter.review_input_artifact === 'string' ? frontmatter.review_input_artifact : '';
+    const startedSha256 = typeof frontmatter.review_input_sha256 === 'string' ? frontmatter.review_input_sha256 : '';
+    if (!startedInput || !startedSha256)
+        return { ok: false, message: 'review started input context is missing' };
+    if (input.name !== startedInput)
+        return { ok: false, message: `${artifact.name} input '${input.name}' does not match review.started input '${startedInput}'` };
+    const current = inspectArtifactDirectory(taskDir, expectedFamily);
+    if (current.status !== 'ready' || !current.latest || current.latest.name !== input.name) {
+        return { ok: false, message: `review input '${input.name}' is not the latest ${expectedFamily} artifact` };
+    }
+    const event = family === 'review-analysis'
+        ? 'review-analysis.completed'
+        : family === 'review-plan' ? 'review-plan.completed' : 'review-code.completed';
+    try {
+        const stat = fs.lstatSync(current.latest.path);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            throw new Error('review input is not a regular file');
+        const inputSha256 = sha256File(current.latest.path);
+        if (inputSha256 !== startedSha256)
+            return { ok: false, message: `review input ${input.name} changed after review.started` };
+        return {
+            ok: true,
+            receipt: {
+                event, output: artifact.name, input: input.name,
+                inputSha256, completedAt
+            }
+        };
+    }
+    catch (error) {
+        return { ok: false, message: `cannot hash review input ${input.name}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+}
 function applyTaskEventUnlocked(request, options = {}) {
     const invalid = validateTaskEventRequest(request);
     if (invalid)
@@ -244,7 +332,8 @@ function applyTaskEventUnlocked(request, options = {}) {
     const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(request, { code: resolved.code, message: resolved.message }, { taskId: resolved.taskId });
-    if (resolved.state !== 'active')
+    const stateOverride = allowsManualOverride(options.manualOverride, 'task-event', 'TASK_STATE_MISMATCH');
+    if (resolved.state !== 'active' && !stateOverride)
         return failed(request, { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected active` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     let content;
     try {
@@ -316,7 +405,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, done.done, frontmatter, artifactContext);
     if (eventIdentity.phase === 'completed' && completedRows.length > 0 && openRows.length === 0)
         return failed(normalized, { code: 'EVENT_LOG_CONFLICT', message: 'event identity is already completed with a different payload' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
-    if (eventIdentity.phase === 'completed' && !row?.started)
+    if (eventIdentity.phase === 'completed' && !row?.started && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING'))
         return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires one open matching started event' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     if (eventIdentity.phase === 'completed') {
         const validated = validateCompletedArtifact(resolved.taskDir, FAMILY[eventIdentity.family].artifact, normalized.artifact, normalized.round);
@@ -329,7 +418,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, existing.time, frontmatter, artifactContext);
     }
     const allowed = FAMILY[eventIdentity.family][eventIdentity.phase === 'started' ? 'started' : 'completed'];
-    if (!allowed.includes(currentStep))
+    if (!allowed.includes(currentStep) && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_TRANSITION_INVALID'))
         return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${normalized.event} is not allowed from '${currentStep}'` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     const findingCountError = validateReviewFindingCounts(normalized, content, eventIdentity.family, completedArtifact?.path ?? null);
     if (findingCountError)
@@ -363,19 +452,69 @@ function applyTaskEventUnlocked(request, options = {}) {
     catch (error) {
         return failed(normalized, { code: 'METADATA_CAPTURE_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
     }
+    let completionReceipt = null;
+    if (eventIdentity.phase === 'completed' && completedArtifact) {
+        const receipt = buildCompletionReceipt(resolved.taskDir, eventIdentity.family, completedArtifact, metadata.timestamp, frontmatter);
+        if (receipt && !receipt.ok) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: receipt.message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        }
+        completionReceipt = receipt?.receipt ?? null;
+    }
     const step = eventIdentity.phase === 'started' || eventIdentity.target === null ? currentStep : eventIdentity.target;
     const logStep = eventIdentity.phase === 'started' ? `${eventIdentity.action} [started]` : eventIdentity.action;
     const body = appendActivityEntry(section, { time: metadata.timestamp, step: logStep, agent: normalized.agent, note: eventIdentity.note });
     const frontmatterSet = { current_step: step, assigned_to: normalized.agent };
+    let frontmatterRemove;
+    if (eventIdentity.phase === 'started' && eventIdentity.family === 'code') {
+        const planInput = artifactContext?.inputs.find((input) => input.family === 'plan');
+        if (!planInput)
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: 'code.started plan input context is unavailable' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        try {
+            frontmatterSet.code_input_artifact = planInput.name;
+            frontmatterSet.code_input_sha256 = sha256File(planInput.path);
+        }
+        catch (error) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot hash code.started plan input: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        }
+    }
+    else if (eventIdentity.phase === 'completed' && eventIdentity.family === 'code') {
+        frontmatterRemove = ['code_input_artifact', 'code_input_sha256'];
+    }
+    else if (eventIdentity.phase === 'started' && eventIdentity.family.startsWith('review-')) {
+        const expectedFamily = reviewInputFamily(eventIdentity.family);
+        const input = artifactContext?.inputs.find((candidate) => candidate.family === expectedFamily);
+        if (!input)
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `review.started ${expectedFamily} input context is unavailable` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        try {
+            frontmatterSet.review_input_artifact = input.name;
+            frontmatterSet.review_input_sha256 = sha256File(input.path);
+        }
+        catch (error) {
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message: `cannot hash review.started input: ${error instanceof Error ? error.message : String(error)}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, artifactContext });
+        }
+    }
+    else if (eventIdentity.phase === 'completed' && eventIdentity.family.startsWith('review-')) {
+        frontmatterRemove = ['review_input_artifact', 'review_input_sha256'];
+    }
     if (eventIdentity.phase === 'started' && normalized.implementationInput)
         frontmatterSet.last_reviewed_commit = '';
     const mutations = [
-        { kind: 'frontmatter', set: frontmatterSet }
+        { kind: 'frontmatter', set: frontmatterSet, remove: frontmatterRemove }
     ];
     if (completedArtifact) {
         const link = buildArtifactLinkSection(content, completedArtifact);
         mutations.push({ kind: 'section', aliases: link.aliases, heading: link.heading, body: link.body });
     }
+    if (completionReceipt) {
+        try {
+            const receiptSection = upsertArtifactReceipt(content, completionReceipt);
+            mutations.push({ kind: 'section', aliases: receiptSection.aliases, heading: receiptSection.heading, body: receiptSection.body });
+        }
+        catch (error) {
+            const message = error instanceof ArtifactReceiptError ? error.message : String(error);
+            return failed(normalized, { code: 'EVENT_ARTIFACT_CONFLICT', message }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+        }
+    }
     if (eventIdentity.phase === 'completed' && normalized.implementationInput) {
         let implementationRows;
         try {
@@ -391,7 +530,7 @@ function applyTaskEventUnlocked(request, options = {}) {
         });
     }
     mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
-    const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, metadataProvider: () => metadata });
+    const result = writeTask({ taskRef: normalized.taskRef, expectedState: stateOverride ? resolved.state : 'active', dryRun: normalized.dryRun, mutations }, { ...options, metadataProvider: () => metadata });
     if (result.status === 'failed')
         return failed(normalized, result.error, { taskId: result.taskId, taskMdPath: result.taskMdPath, fromStep: currentStep, toStep: step, action: eventIdentity.action, phase: eventIdentity.phase, timestamp: result.timestamp, agentInfraVersion: result.agentInfraVersion, operations: result.operations, artifactContext });
     if (!normalized.dryRun && orchestrationCompletion) {
@@ -431,6 +570,8 @@ function applyTaskEvent(request, options = {}) {
     if (invalid)
         return failed(request, invalid);
     const parts = eventParts(request.event);
+    if (options.lockAlreadyHeld)
+        return applyTaskEventUnlocked(request, options);
     if (request.dryRun || parts.phase !== 'completed' || parts.family === 'manual-validation') {
         return applyTaskEventUnlocked(request, options);
     }

package/dist/lib/task/guard-override.js

@@ -0,0 +1,31 @@
+const guardProducerCatalog = [
+    { producerId: 'task.resolve', guardId: 'G-01', code: 'TASK_NOT_FOUND' },
+    { producerId: 'task.resolve', guardId: 'G-01', code: 'TASK_IDENTITY_CONFLICT' },
+    { producerId: 'task.write', guardId: 'G-02', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'task-event', guardId: 'G-04', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'task-event', guardId: 'G-04', code: 'EVENT_TRANSITION_INVALID' },
+    { producerId: 'task-event', guardId: 'G-04', code: 'EVENT_START_MISSING' },
+    { producerId: 'task-verify', guardId: 'G-05', code: 'VERIFY_TASK_STATE_MISMATCH' },
+    { producerId: 'task-verify', guardId: 'G-05', code: 'VERIFY_ARTIFACT_INVALID' },
+    { producerId: 'verification-engine', guardId: 'G-06', code: 'CHECK_FAILED' },
+    { producerId: 'verification-engine', guardId: 'G-06', code: 'CHECK_BLOCKED' },
+    { producerId: 'activity-intent', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'ledger-intent', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'decision-intent', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'workflow-warning', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'review-finalization', guardId: 'G-07', code: 'TASK_STATE_MISMATCH' },
+    { producerId: 'ledger-intent', guardId: 'G-08', code: 'LEDGER_TRANSITION_INVALID' },
+    { producerId: 'lifecycle-execution', guardId: 'G-09', code: 'ORCHESTRATION_STANDALONE_BUSY' },
+    { producerId: 'lifecycle-execution', guardId: 'G-09', code: 'ORCHESTRATION_PROVENANCE_MISMATCH' },
+    { producerId: 'lifecycle-execution', guardId: 'G-09', code: 'ORCHESTRATION_STATE_INVALID' },
+    { producerId: 'platform.issue', guardId: 'G-10', code: 'PLATFORM_BIND_FAILED' },
+    { producerId: 'platform.pull-request', guardId: 'G-10', code: 'PLATFORM_BIND_FAILED' }
+];
+function guardFailureId(producerId, code) {
+    return `${producerId}:${code}`;
+}
+function allowsManualOverride(capability, producerId, code) {
+    return capability?.failureId === guardFailureId(producerId, code);
+}
+export { allowsManualOverride, guardFailureId, guardProducerCatalog };
+//# sourceMappingURL=guard-override.js.map