@fitlab-ai/agent-infra 0.11.4 → 0.11.5

package/lib/task/artifact-schema.ts

@@ -13,6 +13,7 @@ type ArtifactSchema = Readonly<{
   family: ArtifactSchemaFamily;
   title: Readonly<{ zh: string; en: string }>;
   sections: readonly ArtifactSection[];
+  stateCheckPatterns: readonly string[];
   requiredPatterns: readonly string[];
 }>;
 type ArtifactSkeletonInput = Readonly<{
@@ -106,21 +107,22 @@ function buildSections(family: ArtifactSchemaFamily): readonly ArtifactSection[]
   }));
 }
 
+const TASK_SNAPSHOT_PATTERN = 'agent-infra-internal[ \\t]+task-snapshot\\b';
+
 const ARTIFACT_SCHEMAS: readonly ArtifactSchema[] = [
-  { family: 'analysis', title: { zh: '需求分析报告', en: 'Requirements Analysis' }, sections: buildSections('analysis'), requiredPatterns: ['^\\$ '] },
-  { family: 'review-analysis', title: { zh: '需求分析审查报告', en: 'Analysis Review Report' }, sections: buildSections('review-analysis'), requiredPatterns: ['^### (?:审查决定|Approval Decision)$', '^\\$ '] },
-  { family: 'plan', title: { zh: '技术方案', en: 'Technical Plan' }, sections: buildSections('plan'), requiredPatterns: ['^\\$ '] },
-  { family: 'review-plan', title: { zh: '技术方案审查报告', en: 'Plan Review Report' }, sections: buildSections('review-plan'), requiredPatterns: ['^### (?:审查决定|Approval Decision)$', '^\\$ '] },
-  { family: 'code', title: { zh: '实现报告', en: 'Implementation Report' }, sections: buildSections('code'), requiredPatterns: ['^\\$ '] },
+  { family: 'analysis', title: { zh: '需求分析报告', en: 'Requirements Analysis' }, sections: buildSections('analysis'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
+  { family: 'review-analysis', title: { zh: '需求分析审查报告', en: 'Analysis Review Report' }, sections: buildSections('review-analysis'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: ['^### (?:审查决定|Approval Decision)$'] },
+  { family: 'plan', title: { zh: '技术方案', en: 'Technical Plan' }, sections: buildSections('plan'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
+  { family: 'review-plan', title: { zh: '技术方案审查报告', en: 'Plan Review Report' }, sections: buildSections('review-plan'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: ['^### (?:审查决定|Approval Decision)$'] },
+  { family: 'code', title: { zh: '实现报告', en: 'Implementation Report' }, sections: buildSections('code'), stateCheckPatterns: [TASK_SNAPSHOT_PATTERN], requiredPatterns: [] },
   { family: 'review-code', title: { zh: '代码审查报告', en: 'Code Review Report' }, sections: buildSections('review-code'), requiredPatterns: [
     '^### (?:审查决定|Approval Decision)$',
-    '^\\$ ',
     '^- \\*\\*(?:总体结论|Overall Verdict)\\*\\*[:：]\\s*(?:通过|需要修改|拒绝|Approved|Changes Requested|Rejected)\\s*$',
     '^- \\*\\*(?:审查基线提交|Review Baseline Commit)\\*\\*[:：]\\s*\\S',
     '^- \\*\\*(?:审查差异基线|Reviewed Diff Base)\\*\\*[:：]\\s*[0-9a-f]{40,64}\\s*$',
     '^- \\*\\*(?:审查差异指纹|Reviewed Diff Fingerprint)\\*\\*[:：]\\s*sha256:[0-9a-f]{64}\\s*$',
     '^- \\*\\*(?:审查快照树|Reviewed Snapshot Tree)\\*\\*[:：]\\s*[0-9a-f]{40,64}\\s*$'
-  ] }
+  ], stateCheckPatterns: [TASK_SNAPSHOT_PATTERN] }
 ];
 
 function getArtifactSchema(family: string): ArtifactSchema | null {

package/lib/task/control-authority.ts

@@ -1,12 +1,10 @@
 import path from 'node:path';
 import crypto from 'node:crypto';
-import fs from 'node:fs';
 
 import { normalizeAgentToken } from '../agent-clients/tokens.ts';
 import { isAgentClientId } from '../agent-clients/types.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
 import { getAgentClientAdapter } from '../agent-clients/registry.ts';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from './human-override.ts';
 import {
   activateMatchingOrchestrationDelegation,
   activateOrchestrationDelegation,
@@ -40,19 +38,12 @@ import type {
   AgentClientLifecycleRecoveryRequest as LifecycleRecoveryRequest,
   AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult
 } from '../agent-clients/adapter.ts';
-import { locateActivityLog } from './activity-log.ts';
 import { resolveTaskRef, TASK_ID_RE } from './resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { verifyTaskEvent } from './verification.ts';
 import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
-import {
-  findArtifactRecoveryIntentsByOperation,
-  writeArtifactRecoveryIntent,
-  type ArtifactRecoveryIntent
-} from './artifact-repair-intent.ts';
 import {
   computeLifecycleBuildIdentity,
-  verifyLifecycleBuildIdentity,
   type LifecycleBuildIdentity
 } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 
@@ -324,7 +315,6 @@ export function consumeLifecycleRecoveryAttestation(
 export function queryLifecycleRecoveryOperation(
   operationId: string,
   options: Readonly<{
-    repoRoot?: string;
     capabilityStore?: ReturnType<typeof createCodexCapabilityStore>;
   }> = {}
 ): LifecycleRecoveryOperationQueryV1 {
@@ -334,7 +324,6 @@ export function queryLifecycleRecoveryOperation(
   const store = options.capabilityStore ?? createCodexCapabilityStore();
   const registry = authorityOperationMap.get(store);
   const known = [...(registry?.values() ?? [])].filter((value) => value.operationId === operationId);
-  const intents = options.repoRoot ? findArtifactRecoveryIntentsByOperation(options.repoRoot, operationId) : [];
   const capabilities = store.findByRecoveryOperation(operationId);
   const phaseMap = new Map<string, LifecycleRecoveryOperationQueryV1['phases'][number]>();
   for (const capability of capabilities) {
@@ -358,21 +347,10 @@ export function queryLifecycleRecoveryOperation(
         ? 'consumed' : 'issued'
     });
   }
-  for (const intent of intents) {
-    if (!intent.phase) continue;
-    const key = `${intent.phase}\0${intent.requestId}`;
-    if (phaseMap.has(key)) continue;
-    phaseMap.set(key, {
-      phase: intent.phase,
-      requestId: intent.requestId,
-      attestationId: null,
-      state: intent.state === 'consumed' ? 'consumed' : 'observed'
-    });
-  }
   const capabilityState = capabilities.some((record) => record.recoveryState === 'consumed')
     ? 'consumed'
     : capabilities.some((record) => record.recoveryState === 'reserved') ? 'reserved' : 'unknown';
-  const committed = capabilityState === 'consumed' || intents.some((intent) => intent.state === 'consumed');
+  const committed = capabilityState === 'consumed';
   return {
     version: 1,
     operationId,
@@ -382,133 +360,6 @@ export function queryLifecycleRecoveryOperation(
   };
 }
 
-type LifecycleRecoveryCompensationOptions = Readonly<{
-  repoRoot: string;
-  controllerBinding: TaskControlControllerBinding;
-  capabilityStore?: ReturnType<typeof createCodexCapabilityStore>;
-  buildIdentity?: LifecycleBuildIdentity;
-  now?: () => number;
-}>;
-
-function lifecycleRecoveryCompensationError(code: string, message: string): Error {
-  const error = new Error(`${code}: ${message}`);
-  error.name = code;
-  return error;
-}
-
-function lifecycleRecoveryEventCommitted(
-  selector: LifecycleAuthorityRequestV1,
-  repoRoot: string
-): boolean {
-  const resolved = resolveTaskRef(selector.taskId, { repoRoot });
-  if (!resolved.ok || resolved.taskId !== selector.taskId) return false;
-  let content: string;
-  try { content = fs.readFileSync(resolved.taskMdPath, 'utf8'); }
-  catch { return false; }
-  const section = locateActivityLog(content);
-  if (!section) return false;
-  const labels = { analysis: 'Analyze Task', plan: 'Plan Task', code: 'Code Task' } as const;
-  const prefix = `${labels[selector.family]} (Round ${selector.round}`;
-  return section.entries.some((entry) => {
-    if (entry.step.endsWith(' [started]') || !entry.step.startsWith(prefix)) return false;
-    const delimiter = entry.step[prefix.length];
-    return (delimiter === ',' || delimiter === ')') && entry.note.endsWith(`→ ${selector.artifact}`);
-  });
-}
-
-function lifecycleRecoveryIntentMatches(
-  intent: ArtifactRecoveryIntent,
-  selector: LifecycleAuthorityRequestV1
-): boolean {
-  return intent.taskId === selector.taskId
-    && intent.family === selector.family
-    && intent.artifact === selector.artifact
-    && (intent.state === 'commit-started' || intent.state === 'consumption-started' || intent.state === 'consumed');
-}
-
-/**
- * Completes only the durable tail of a committed task event after a process
- * restart. The task event itself is the commit boundary and is never replayed.
- */
-export function recoverLifecycleRecoveryOperation(
-  input: LifecycleAuthorityRequestV1,
-  options: LifecycleRecoveryCompensationOptions
-): LifecycleRecoveryOperationQueryV1 {
-  const selector = validateLifecycleAuthorityRequest(input);
-  if (selector.phase !== 'task-event.completed') {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PHASE_UNSUPPORTED', 'only task-event.completed supports durable compensation');
-  }
-  const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(options.repoRoot);
-  if (selector.expectedBuildIdentityDigest !== lifecycleAuthorityBuildDigest(buildIdentity)) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_AUTHORITY_BUILD_MISMATCH', 'current lifecycle build does not match the recovery request');
-  }
-  if (selector.expectedControlGeneration !== options.controllerBinding.controlGeneration
-    || selector.expectedControllerInstanceDigest !== options.controllerBinding.instanceDigest) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_AUTHORITY_CONTROLLER_MISMATCH', 'current controller binding does not match the recovery request');
-  }
-  const store = options.capabilityStore ?? createCodexCapabilityStore();
-  const expected = {
-    taskId: selector.taskId,
-    hookDefinitionHash: selector.expectedHookDefinitionHash,
-    buildIdentity,
-    controller: options.controllerBinding
-  };
-  const capabilities = store.findByRecoveryOperation(selector.operationId);
-  if (capabilities.length !== 1 || capabilities[0]!.capabilityRefDigest !== lifecycleAuthorityDigest(selector.authorityRef)) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PROVENANCE_INVALID', 'durable capability provenance does not identify this operation');
-  }
-  const capability = capabilities[0]!;
-  const build = verifyLifecycleBuildIdentity(capability.buildIdentity, buildIdentity);
-  const expiredReserved = capability.status === 'expired' && capability.recoveryState === 'reserved';
-  if (!build.ok
-    || capability.taskId !== selector.taskId
-    || capability.hookDefinitionHash !== selector.expectedHookDefinitionHash
-    || capability.controller?.controlGeneration !== options.controllerBinding.controlGeneration
-    || capability.controller?.instanceDigest !== options.controllerBinding.instanceDigest
-    || capability.recoveryState === 'unreserved'
-    || capability.recoveryOperationId !== selector.operationId
-    || (!['attested', 'consumed'].includes(capability.status) && !expiredReserved)) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PROVENANCE_INVALID', 'durable capability provenance does not match the recovery request');
-  }
-  const phase = capability.recoveryPhases.find((entry) => entry.phase === selector.phase);
-  if (!phase) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_PHASE_MISSING', 'durable task completion phase is missing');
-  }
-  const intents = findArtifactRecoveryIntentsByOperation(options.repoRoot, selector.operationId)
-    .filter((intent) => intent.taskId === selector.taskId
-      && intent.family === selector.family
-      && intent.artifact === selector.artifact);
-  if (intents.length !== 1) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact recovery intent does not identify this task event');
-  }
-  const intent = intents[0]!;
-  if (!lifecycleRecoveryIntentMatches(intent, selector)
-    || intent.phase !== selector.phase
-    || intent.requestId !== selector.lifecycleRequestId
-    || intent.authorityDigest === null) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_INTENT_INVALID', 'durable artifact recovery intent does not match the recovery request');
-  }
-  if (!lifecycleRecoveryEventCommitted(selector, options.repoRoot)) {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_COMMIT_UNCONFIRMED', 'task completion is not durably present; compensation is not allowed');
-  }
-  if (capability.recoveryState === 'reserved') {
-    if (phase.state === 'issued') {
-      store.consumeRecoveryPhase(selector.authorityRef, selector.operationId, selector.phase, phase.requestId, expected, { allowExpiredReserved: true });
-    }
-    store.consumeReference(selector.authorityRef, selector.operationId, expected, { allowExpiredReserved: true });
-  } else if (phase.state !== 'consumed') {
-    throw lifecycleRecoveryCompensationError('LIFECYCLE_RECOVERY_STATE_INVALID', 'consumed capability has an unconsumed completion phase');
-  }
-  if (intent.state !== 'consumed') {
-    writeArtifactRecoveryIntent(options.repoRoot, {
-      ...intent,
-      state: 'consumed',
-      updatedAt: (options.now ?? Date.now)()
-    }, { expected: intent });
-  }
-  return queryLifecycleRecoveryOperation(selector.operationId, { repoRoot: options.repoRoot, capabilityStore: store });
-}
-
 function authorityRejected(request: LifecycleAuthorityRequestV1, code: string, message: string): LifecycleAuthorityResponseV1 {
   return { version: 1, requestId: request.requestId, operationId: request.operationId, phase: request.phase, status: 'rejected', attestation: null, error: { code, message } };
 }
@@ -537,6 +388,7 @@ export type TaskControlExecutionContext =
       generation: string;
       manifestPath: string;
       requestId: string;
+      handoffDirectory: string;
       controllerBinding?: TaskControlControllerBinding | null;
       lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
     }>;
@@ -575,11 +427,7 @@ export function taskControlOperationKey(operation: TaskControlOperation): string
     : operation.intent;
 }
 
-export type TaskLifecycleControlRequest = TaskLifecycleRequest & Readonly<{
-  overrideTicket?: string;
-  overrideTarget?: string;
-  overrideScope?: string;
-}>;
+export type TaskLifecycleControlRequest = TaskLifecycleRequest;
 
 function invalidContext(message: string): never {
   throw new Error(`TASK_CONTROL_CONTEXT_INVALID: ${message}`);
@@ -625,6 +473,7 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
   generation: string;
   manifestPath: string;
   requestId: string;
+  handoffDirectory?: string;
   controllerBinding?: TaskControlControllerBinding | null;
   lifecycleRecoveryAttestation?: LifecycleRecoveryAttestationV1 | null;
 }>): TaskControlExecutionContext {
@@ -645,6 +494,7 @@ export function createSandboxExecutorExecutionContext(params: Readonly<{
     generation: params.generation,
     manifestPath: absolute('manifestPath', params.manifestPath),
     requestId: params.requestId,
+    handoffDirectory: absolute('handoffDirectory', params.handoffDirectory ?? path.join(params.worktreeRoot, '.agent-infra-handoff')),
     ...(params.controllerBinding === undefined ? {} : { controllerBinding: binding(params.controllerBinding) }),
     ...(params.lifecycleRecoveryAttestation === undefined ? {} : {
       lifecycleRecoveryAttestation: params.lifecycleRecoveryAttestation === null
@@ -670,6 +520,7 @@ export function assertTaskControlExecutionContext(context: TaskControlExecutionC
   absolute('worktreeRoot', context.worktreeRoot);
   absolute('runtimeDir', context.runtimeDir);
   absolute('manifestPath', context.manifestPath);
+  absolute('handoffDirectory', context.handoffDirectory);
   if (path.resolve(context.runtimeDir) !== path.join(path.dirname(path.resolve(context.manifestPath)), 'runtime')) {
     invalidContext('runtimeDir is not bound to the manifest control root');
   }
@@ -706,12 +557,8 @@ function lifecycleTaskId(request: TaskLifecycleControlRequest, repoRoot: string)
 async function applyLifecycleWithAuthority(
   context: TaskControlExecutionContext,
   request: TaskLifecycleControlRequest
-): Promise<(TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown }> {
-  const conflict = overrideDryRunConflict(request as unknown as Record<string, unknown>);
-  if (conflict) {
-    return taskLifecycleFailure(request, { code: 'LIFECYCLE_PAYLOAD_INVALID', message: conflict.message });
-  }
-  const execute = async (): Promise<(TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown }> => {
+): Promise<TaskLifecycleResult | LifecycleRecoveryResult> {
+  const execute = async (): Promise<TaskLifecycleResult | LifecycleRecoveryResult> => {
     if (request.intent === 'recover-started') {
       const adapter = isAgentClientId(request.agent)
         ? getAgentClientAdapter(request.agent).orchestrationAdapter
@@ -725,27 +572,7 @@ async function applyLifecycleWithAuthority(
       }
       return adapter.recoverStarted(request as LifecycleRecoveryRequest, { repoRoot: context.repoRoot });
     }
-    const lifecycleResult = applyTaskLifecycle(request, { repoRoot: context.repoRoot });
-    if (lifecycleResult.status !== 'failed' || !request.overrideTicket) return lifecycleResult;
-    if (!request.overrideTarget || !request.overrideScope) {
-      return {
-        ...lifecycleResult,
-        error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
-      };
-    }
-    const override = await consumeHumanOverride({
-      taskRef: request.taskRef,
-      ticketId: request.overrideTicket,
-      failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
-      target: request.overrideTarget,
-      scope: request.overrideScope,
-      intent: request.intent,
-      ...('alertNumber' in request && request.alertNumber ? { alertNumber: request.alertNumber } : {}),
-      ...('issueNumber' in request && request.issueNumber ? { issueNumber: request.issueNumber } : {}),
-      ...('stagingDir' in request && request.stagingDir ? { stagingDir: request.stagingDir } : {})
-    }, { repoRoot: context.repoRoot });
-    if (override.status === 'failed') return { ...lifecycleResult, humanOverride: override };
-    return { ...lifecycleResult, ...override, humanOverride: override, error: null };
+    return applyTaskLifecycle(request, { repoRoot: context.repoRoot });
   };
   const taskId = lifecycleTaskId(request, context.repoRoot);
   if (!taskId) return await execute();
@@ -840,7 +667,7 @@ function orchestrationFailure(error: unknown): OrchestrationResult {
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-lifecycle' }>
-): Promise<(TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown }>;
+): Promise<TaskLifecycleResult | LifecycleRecoveryResult>;
 export function dispatchTaskControlOperation(
   context: TaskControlExecutionContext,
   operation: Extract<TaskControlOperation, { family: 'task-finalization' }>
@@ -865,7 +692,9 @@ export function dispatchTaskControlOperation(
     return finalize(operation.request, {
       repoRoot: context.repoRoot,
       ...(context.source === 'sandbox-executor' ? {
-        controlBinding: { generation: context.generation, requestId: context.requestId }
+        controlBinding: { generation: context.generation, requestId: context.requestId },
+        handoffDirectory: context.handoffDirectory,
+        manifestPath: context.manifestPath
       } : {}),
       preflight: (request, options) => verifyTaskEvent(
         { ...request, event: 'complete-task.hard-preflight' }, options
@@ -904,7 +733,7 @@ function operationInvalid(message: string): never {
 
 const LIFECYCLE_FLAGS = new Set([
   '--agent', '--reason', '--unblock-condition', '--note', '--alert-number', '--staging-dir', '--issue-number',
-  '--auto', '--override-ticket', '--override-target', '--override-scope', '--dry-run'
+  '--auto', '--dry-run'
 ]);
 
 const FINALIZATION_FLAGS = new Set(['--agent']);
@@ -979,9 +808,6 @@ export function parseTaskControlOperation(
       ...(value(values, '--unblock-condition') ? { unblockCondition: value(values, '--unblock-condition') } : {}),
       ...(value(values, '--note') ? { note: value(values, '--note') } : {}),
       ...(value(values, '--staging-dir') ? { stagingDir: value(values, '--staging-dir') } : {}),
-      ...(value(values, '--override-ticket') ? { overrideTicket: value(values, '--override-ticket') } : {}),
-      ...(value(values, '--override-target') ? { overrideTarget: value(values, '--override-target') } : {}),
-      ...(value(values, '--override-scope') ? { overrideScope: value(values, '--override-scope') } : {}),
       ...(value(values, '--alert-number') ? { alertNumber: Number(value(values, '--alert-number')) } : {}),
       ...(value(values, '--issue-number') ? { issueNumber: Number(value(values, '--issue-number')) } : {}),
       ...(values['--auto'] === true ? { auto: true } : {}),

package/lib/task/decision-intents.ts

@@ -16,7 +16,6 @@ import { resolveTaskContext } from './resolve-ref.ts';
 import { extractSection, extractSubSection, findSectionHeading } from './sections.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
-import { allowsManualOverride } from './guard-override.ts';
 import { consumeHumanDecisionReworkIntents, parseReworkIntentDocument, reworkIntentMutation } from './rework-intent.ts';
 
 type HumanDecisionRequest = {
@@ -87,8 +86,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
   if (!request.selector || !request.decision.trim()) return failed('DECISION_PAYLOAD_INVALID', 'selector and decision are required');
   const resolved = resolveTaskContext(request.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(resolved.code, resolved.message, resolved.taskId);
-  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);
+  if (resolved.state !== 'active') return failed('TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   let content: string;
   let rows: LedgerRow[];
   try {
@@ -186,7 +184,7 @@ function applyHumanDecision(request: HumanDecisionRequest, options: TaskWriteOpt
   } catch (error) {
     return failed('DECISION_DOCUMENT_INVALID', error instanceof Error ? error.message : String(error), resolved.taskId, row.id);
   }
-  const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: stateOverride ? resolved.state : 'active', mutations, dryRun: request.dryRun }, {
+  const writeResult = writeTask({ taskRef: resolved.taskId, expectedState: 'active', mutations, dryRun: request.dryRun }, {
     ...options,
     taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },
     metadataProvider: () => metadata

package/lib/task/events.ts

@@ -2,6 +2,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
 
+import { resolveBranchWorktree } from '../git/branch-worktree.ts';
+
 import { appendActivityEntry, locateActivityLog, pairEntries, startedBackedRows } from './activity-log.ts';
 import {
   buildArtifactLinkSection,
@@ -32,7 +34,6 @@ import type { OrchestrationStageCompletion } from './orchestration.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-lock.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskOperationSummary, TaskWriteErrorCode, TaskWriteOptions } from './write.ts';
-import { allowsManualOverride } from './guard-override.ts';
 import { validateLocalArtifact } from './local-artifact-finalization.ts';
 import type { LocalArtifactFamily } from './local-artifact-finalization.ts';
 import { buildLifecycleFacts, canStart, effectiveReworkTarget } from './capabilities.ts';
@@ -81,7 +82,6 @@ type TaskEventErrorCode =
   | ArtifactErrorCode | TaskWriteErrorCode;
 type TaskEventRequest = {
   taskRef: string; event: TaskEventName | string; agent: string; dryRun?: boolean; orchestrated?: boolean;
-  overrideTicket?: string; overrideTarget?: string; overrideScope?: string;
   initiator?: TriggerInitiator; requestId?: string; reasonCode?: TriggerReason;
   sourceFinding?: string; sourceArtifact?: string; sourceSha256?: string;
   round?: number; question?: number; artifact?: string; fixFor?: string; implementationInput?: string;
@@ -111,22 +111,7 @@ type TaskEventResult = {
 
 function branchWorktree(repoRoot: string, branch: string): string | null {
   if (!branch) return repoRoot;
-  try {
-    const records = execFileSync('git', ['worktree', 'list', '--porcelain'], {
-      cwd: repoRoot,
-      encoding: 'utf8',
-      stdio: ['ignore', 'pipe', 'pipe']
-    }).trim().split(/\r?\n\r?\n/);
-    const expectedRef = `refs/heads/${branch}`;
-    for (const record of records) {
-      const worktree = /^worktree (.+)$/m.exec(record)?.[1];
-      const branchRef = /^branch (.+)$/m.exec(record)?.[1];
-      if (worktree && branchRef === expectedRef) return worktree;
-    }
-  } catch {
-    // A missing worktree must not anchor a review to an unrelated repository.
-  }
-  return null;
+  return resolveBranchWorktree(repoRoot, branch);
 }
 
 function approvedCleanReviewedCommit(reviewContent: string, verdict: Verdict | undefined, repoRoot: string, branch: string): string | null {
@@ -148,7 +133,7 @@ function approvedCleanReviewedCommit(reviewContent: string, verdict: Verdict | u
   }
 }
 
-const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
+const BASE_FIELDS = new Set(['taskRef', 'event', 'agent', 'dryRun', 'initiator', 'requestId', 'reasonCode', 'sourceFinding', 'sourceArtifact', 'sourceSha256']);
 const SCHEMAS: Record<TaskEventName, { required?: string[]; optional?: string[] }> = {
   'analyze.started': { optional: ['round'] },
   'analyze.awaiting-input': { required: ['question'] },
@@ -758,8 +743,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   if (invalid) return failed(request, invalid);
   const resolved = resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(request, { code: resolved.code, message: resolved.message }, { taskId: resolved.taskId });
-  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 });
+  if (resolved.state !== 'active') return failed(request, { code: 'TASK_STATE_MISMATCH', message: `task ${resolved.taskId} is ${resolved.state}, expected active` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath });
   let content: string;
   try { content = fs.readFileSync(resolved.taskMdPath, 'utf8'); }
   catch (error) { return failed(request, { code: 'TASK_READ_FAILED', message: String(error) }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath }); }
@@ -851,7 +835,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     }
     return successNoOp(normalized, resolved.taskId, resolved.taskMdPath, currentStep, eventIdentity, row.started, frontmatter, artifactContext);
   }
-  if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0 && !allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_START_MISSING')) return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires a started event or an earlier completed attempt' }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
+  if (eventIdentity.phase === 'completed' && !row?.started && completedRows.length === 0) return failed(normalized, { code: 'EVENT_START_MISSING', message: 'completion requires a started event or an earlier completed attempt' }, { 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);
     if (!validated.ok) return failed(normalized, validated.error, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
@@ -918,12 +902,9 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
     const facts = buildLifecycleFacts(resolved.taskDir, content, resolved.state);
     if (!facts.ok) return failed(normalized, { code: 'EVENT_TRANSITION_INVALID', message: `${facts.code}: ${facts.message}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     const capability = canStart(lifecycleAction(eventIdentity.family), facts.facts, trigger);
-    const capabilityOverride = capability.reasonCode === 'TASK_NOT_ACTIVE'
-      ? stateOverride
-      : allowsManualOverride(options.manualOverride, 'task-event', 'EVENT_TRANSITION_INVALID');
     const safetyFailure = capability.reasonCode === 'TASK_NOT_ACTIVE'
       || capability.reasonCode === 'LIFECYCLE_EXECUTION_OPEN';
-    if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure) && !capabilityOverride) {
+    if (!capability.allowed && (normalized.initiator === 'orchestrator' || safetyFailure)) {
       const code = capability.reasonCode === 'INVALIDATION_INCOMPLETE' ? 'TASK_INVALIDATION_BLOCKED' : 'EVENT_TRANSITION_INVALID';
       return failed(normalized, { code, message: `${capability.reasonCode}: ${capability.evidence.join(', ')}` }, { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, fromStep: currentStep, toStep: currentStep, action: eventIdentity.action, phase: eventIdentity.phase });
     }
@@ -1078,7 +1059,7 @@ function applyTaskEventUnlocked(request: TaskEventRequest, options: TaskEventOpt
   mutations.push({ kind: 'section', aliases: ['活动日志', 'Activity Log'], heading: section.heading, body });
   const sourceCompletion = eventIdentity.phase === 'completed'
     && ['analyze', 'plan', 'code'].includes(eventIdentity.family);
-  const result = writeTask({ taskRef: normalized.taskRef, expectedState: stateOverride ? resolved.state : 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', metadataProvider: () => metadata });
+  const result = writeTask({ taskRef: normalized.taskRef, expectedState: 'active', dryRun: normalized.dryRun, mutations }, { ...options, invalidationContext: sourceCompletion ? 'source-completion' : 'standard', 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) {
     try {

package/lib/task/finalization-handoff.ts

@@ -0,0 +1,104 @@
+import { createHash, randomUUID } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+
+import type { TaskFinalizationReceipt } from './finalization.ts';
+
+const HANDOFF_VERSION = 1 as const;
+
+type TaskFinalizationHandoff = Readonly<{
+  version: typeof HANDOFF_VERSION;
+  taskId: string;
+  binding: Readonly<{ generation: string; requestId: string }>;
+  receipt: TaskFinalizationReceipt;
+  receiptSha256: string;
+}>;
+type ReadHandoff = Readonly<{ receipt: TaskFinalizationReceipt; cleanup: () => void }>;
+const MAX_HANDOFF_BYTES = 1024 * 1024;
+
+function digest(value: unknown): string {
+  return createHash('sha256').update(JSON.stringify(value)).digest('hex');
+}
+
+export function finalizationHandoffPath(directory: string, taskId: string): string {
+  return path.join(directory, '.agent-infra', 'task-finalization', `${taskId}.json`);
+}
+
+export function publishTaskFinalizationHandoff(
+  directory: string,
+  receipt: TaskFinalizationReceipt,
+  binding: Readonly<{ generation: string; requestId: string }>
+): string {
+  if (receipt.taskId === '' || receipt.controlBinding?.generation !== binding.generation
+    || receipt.controlBinding.requestId !== binding.requestId) {
+    throw new Error('TASK_FINALIZATION_HANDOFF_BINDING_INVALID');
+  }
+  const envelope: TaskFinalizationHandoff = {
+    version: HANDOFF_VERSION, taskId: receipt.taskId, binding, receipt, receiptSha256: digest(receipt)
+  };
+  const target = finalizationHandoffPath(directory, receipt.taskId);
+  fs.mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+  const temporary = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  fs.writeFileSync(temporary, `${JSON.stringify(envelope)}\n`, { mode: 0o600, flag: 'wx' });
+  try { fs.renameSync(temporary, target); } catch (error) {
+    try { fs.unlinkSync(temporary); } catch { /* preserve the primary error */ }
+    throw error;
+  }
+  return digest(envelope);
+}
+
+export function readTaskFinalizationHandoff(
+  directory: string,
+  taskId: string,
+  binding: Readonly<{ generation: string; requestId: string }>,
+  handoffSha256: string
+): ReadHandoff {
+  const file = finalizationHandoffPath(directory, taskId);
+  const initial = fs.lstatSync(file);
+  if (!initial.isFile() || initial.isSymbolicLink() || initial.size > MAX_HANDOFF_BYTES) {
+    throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+  }
+  const descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW ?? 0));
+  let content: string;
+  try {
+    const opened = fs.fstatSync(descriptor);
+    if (!opened.isFile() || opened.dev !== initial.dev || opened.ino !== initial.ino
+      || opened.size > MAX_HANDOFF_BYTES) throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+    const bytes = Buffer.alloc(MAX_HANDOFF_BYTES + 1);
+    const length = fs.readSync(descriptor, bytes, 0, bytes.length, 0);
+    if (length !== opened.size || length > MAX_HANDOFF_BYTES) throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+    content = bytes.toString('utf8', 0, length);
+    const after = fs.fstatSync(descriptor);
+    if (after.dev !== opened.dev || after.ino !== opened.ino || after.size !== opened.size) {
+      throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+    }
+  } finally {
+    fs.closeSync(descriptor);
+  }
+  const envelope = JSON.parse(content) as Partial<TaskFinalizationHandoff>;
+  if (!envelope || typeof envelope !== 'object' || Array.isArray(envelope)
+    || Object.keys(envelope).sort().join('\0') !== ['binding', 'receipt', 'receiptSha256', 'taskId', 'version'].join('\0')
+    || envelope.version !== HANDOFF_VERSION || envelope.taskId !== taskId
+    || !envelope.binding || typeof envelope.binding !== 'object' || Array.isArray(envelope.binding)
+    || Object.keys(envelope.binding).sort().join('\0') !== ['generation', 'requestId'].join('\0')
+    || envelope.binding.generation !== binding.generation
+    || envelope.binding.requestId !== binding.requestId || !envelope.receipt
+    || envelope.receipt.controlBinding?.generation !== binding.generation
+    || envelope.receipt.controlBinding.requestId !== binding.requestId
+    || typeof envelope.receiptSha256 !== 'string' || envelope.receiptSha256 !== digest(envelope.receipt)
+    || digest(envelope) !== handoffSha256) {
+    throw new Error('TASK_FINALIZATION_HANDOFF_INVALID');
+  }
+  return {
+    receipt: envelope.receipt,
+    cleanup: () => {
+      try {
+        const current = fs.lstatSync(file);
+        if (current.isFile() && !current.isSymbolicLink()
+          && current.dev === initial.dev && current.ino === initial.ino) fs.unlinkSync(file);
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;
+      }
+    }
+  };
+}