@fitlab-ai/agent-infra 0.11.4 → 0.11.5

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,

package/dist/lib/task/verification-engine.js

@@ -11,6 +11,7 @@ import { inspectPlatformPullRequest } from "../platform/pull-requests.js";
 import { resolveMaterializedReviewedHeadRelation } from "../platform/change-request-git-evidence.js";
 import { resolveReviewedHeadRelation } from "../platform/merged-pr-equivalence.js";
 import { resolveLocalReviewedCommitRelation } from "../git/reviewed-commit-equivalence.js";
+import { resolveBranchWorktree } from "../git/branch-worktree.js";
 import { parseTypedTaskFrontmatter } from "./frontmatter.js";
 import { LEDGER_TERMINAL, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from "./ledger.js";
 import { isValidAgentInfraVersion } from "../version.js";
@@ -483,6 +484,18 @@ function checkArtifact({ taskDir, config, artifactFile, skillName }) {
             return failResult("artifact", `${path.basename(artifactPath)} is missing required pattern: ${pattern}`);
         }
     }
+    const stateCheckPatterns = config.state_check_patterns || [];
+    if (stateCheckPatterns.length > 0) {
+        const scanned = scanVisibleMarkdown(content);
+        const stateCheckHeading = scanned.headings.find((heading) => (heading.level === 2 && (heading.text === "状态核对" || heading.text === "State Check")));
+        const nextHeading = stateCheckHeading && scanned.headings.find((heading) => (heading.start > stateCheckHeading.start && heading.level <= 2));
+        const stateCheckBody = stateCheckHeading ? content.slice(stateCheckHeading.end, nextHeading?.start ?? content.length) : "";
+        for (const pattern of stateCheckPatterns) {
+            if (!new RegExp(pattern, "m").test(stateCheckBody)) {
+                return failResult("artifact", `${path.basename(artifactPath)} state-check section is missing required command: ${pattern}`);
+            }
+        }
+    }
     return passResult("artifact", `${path.basename(artifactPath)} passed (${requiredSections.length} sections)`);
 }
 function checkDecisionDetails({ taskDir, artifactFile }) {
@@ -1078,17 +1091,9 @@ function checkReviewFact({ taskDir, artifactFile, repositoryRoot }) {
 function reviewWorktreeForTask(repositoryRoot, branch) {
     if (!branch)
         return null;
-    const expectedRef = `refs/heads/${branch}`;
-    const records = execFileSync("git", ["-C", repositoryRoot, "worktree", "list", "--porcelain"], {
-        encoding: "utf8",
-        stdio: ["pipe", "pipe", "pipe"]
-    }).trim().split(/\r?\n\r?\n/);
-    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;
-    }
+    const worktree = resolveBranchWorktree(repositoryRoot, branch);
+    if (worktree)
+        return worktree;
     throw new Error(`Task branch '${branch}' is not checked out in a registered worktree`);
 }
 function resolvePostReviewBaseline({ gitRoot, lastReviewedCommit, reviewArtifact }) {

package/dist/lib/task/verification.js

@@ -4,7 +4,6 @@ import path from 'node:path';
 import { verifyInProcess } from './verification-engine.js';
 import { parseArtifactName } from './artifact-name.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { allowsManualOverride } from './guard-override.js';
 const gate = (skill, expectedState, artifactFamily) => ({
     skill, expectedState, mode: 'gate', ...(artifactFamily ? { artifactFamily } : {})
 });
@@ -50,7 +49,7 @@ async function verifyTaskEvent(request, options = {}) {
     if (!resolved.ok)
         return failure(request, resolved.code, resolved.message, { taskId: resolved.taskId, skill: spec.skill, mode: spec.mode });
     const identity = { taskId: resolved.taskId, taskDir: resolved.taskDir, taskState: resolved.state, skill: spec.skill, mode: spec.mode };
-    if (resolved.state !== spec.expectedState && !allowsManualOverride(options.manualOverride, 'task-verify', 'VERIFY_TASK_STATE_MISMATCH')) {
+    if (resolved.state !== spec.expectedState) {
         return failure(request, 'VERIFY_TASK_STATE_MISMATCH', `event '${request.event}' requires workspace '${spec.expectedState}', received '${resolved.state}'`, identity);
     }
     if (spec.artifactFamily) {
@@ -69,23 +68,12 @@ async function verifyTaskEvent(request, options = {}) {
     if (spec.mode === 'gate') {
         const payload = await engine({ mode: 'gate', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [], repositoryRoot: resolved.repoRoot });
         const status = payload.gate;
-        if (status !== 'pass' && allowsManualOverride(options.manualOverride, 'verification-engine', status === 'blocked' ? 'CHECK_BLOCKED' : 'CHECK_FAILED')) {
-            invocations.push({ status: 'pass', exitCode: 0, payload: { ...payload, gate: 'pass', humanOverride: 'human-approved', originalGate: status } });
-            return {
-                status: 'pass', changed: false, event: request.event, requestRef: request.taskRef,
-                ...identity, artifact: request.artifact ?? null, invocations, error: null
-            };
-        }
         invocations.push({ status, exitCode: { pass: 0, fail: 1, blocked: 2 }[status], payload });
     }
     else {
         for (const check of spec.checks ?? []) {
             const payload = await engine({ mode: 'checks', skillName: spec.skill, taskDir: resolved.taskDir, artifactFile: request.artifact, checks: [check], repositoryRoot: resolved.repoRoot });
             const status = (payload.effectiveStatus ?? payload.status);
-            if (status !== 'pass' && allowsManualOverride(options.manualOverride, 'verification-engine', status === 'blocked' ? 'CHECK_BLOCKED' : 'CHECK_FAILED')) {
-                invocations.push({ status: 'pass', exitCode: 0, payload: { ...payload, status: 'pass', humanOverride: 'human-approved', originalStatus: status } });
-                break;
-            }
             invocations.push({ status, exitCode: { pass: 0, fail: 1, blocked: 2 }[status], payload });
             if (status !== 'pass')
                 break;

package/dist/lib/task/workflow-warning-intents.js

@@ -3,7 +3,6 @@ import { resolveTaskRef } from './resolve-ref.js';
 import { parseTaskFrontmatter } from './frontmatter.js';
 import { WORKFLOW_WARNING_COLUMNS, WORKFLOW_WARNING_HEADINGS, WORKFLOW_WARNING_SEVERITIES, WORKFLOW_WARNING_STATUSES, parseWorkflowWarnings } from './workflow-warnings.js';
 import { captureTaskWriteMetadata, writeTask } from './write.js';
-import { allowsManualOverride } from './guard-override.js';
 import { retryHintForWarning } from './operation-outcome.js';
 function failed(intent, code, message, taskId = null, entityId = null) {
     return { status: 'failed', changed: false, intent: intent.kind, taskId, entityId, before: null, after: null, warnings: [], operations: [], error: { code, message } };
@@ -44,8 +43,7 @@ function applyWorkflowWarningIntent(intent, options = {}) {
     const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
     if (!resolved.ok)
         return failed(intent, resolved.code, resolved.message, resolved.taskId);
-    const stateOverride = allowsManualOverride(options.manualOverride, 'workflow-warning', 'TASK_STATE_MISMATCH');
-    if (resolved.state !== 'active' && !stateOverride)
+    if (resolved.state !== 'active')
         return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
     let content;
     let rows;
@@ -102,7 +100,7 @@ function applyWorkflowWarningIntent(intent, options = {}) {
             after = { ...before, status: intent.status, resolvedAt: metadata.timestamp, resolution };
     }
     const writeResult = writeTask({
-        taskRef: intent.taskRef, expectedState: stateOverride ? resolved.state : 'active', mutations: [...sectionMutation(content), rowMutation(after)], dryRun: intent.dryRun
+        taskRef: intent.taskRef, expectedState: 'active', mutations: [...sectionMutation(content), rowMutation(after)], dryRun: intent.dryRun
     }, {
         ...options,
         taskLocation: { repoRoot: resolved.repoRoot, taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, state: resolved.state },

package/dist/lib/task/write.js

@@ -3,7 +3,6 @@ import path from 'node:path';
 import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
-import { allowsManualOverride } from './guard-override.js';
 import { mutateTableRow, upsertSection } from './sections.js';
 import { validateCurrentTaskContract } from './current-contract.js';
 import { invalidationBlocks, parseInvalidationDocument } from './invalidation.js';
@@ -73,7 +72,7 @@ function writeTask(request, options = {}) {
         taskMdPath: resolved.taskMdPath,
         actualState: resolved.state
     };
-    if (resolved.state !== request.expectedState && !allowsManualOverride(options.manualOverride, 'task.write', 'TASK_STATE_MISMATCH')) {
+    if (resolved.state !== request.expectedState) {
         return failure(request, identity, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected ${request.expectedState}`);
     }
     const io = { ...DEFAULT_FILE_SYSTEM, ...options.fileSystem };

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.4",
-  "sourceInputHash": "46c0a39f354bff8c80fe19354cdda89a91a4acad060b1f134b6d599bc0ba6806",
-  "internalExecutableBuildHash": "1bc9e5755c857ee9f13a702452b2ce7c85da94444dc5a8d1305ae80d5899b001"
+  "packageVersion": "0.11.5",
+  "sourceInputHash": "2f29b7f1f134733c3bc1bb7c92ea6c11e57462ed51a5a96b0198b8824a3f455d",
+  "internalExecutableBuildHash": "cb9d00aa3fa974cf936a8aad310e1fa5f28842351f52a53fed43345fe9c46439"
 }

package/lib/decide.ts

@@ -2,7 +2,6 @@ import { VERSION } from './version.ts';
 import { parseTaskScope } from './task/command-options.ts';
 import { applyHumanDecision } from './task/decision-intents.ts';
 import { canonicalTimestamp } from './task/write.ts';
-import { consumeHumanOverride, failureId } from './task/human-override.ts';
 import { resolveTaskContext } from './task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task/task-execution-lock.ts';
 
@@ -12,12 +11,9 @@ type DecideOptions = {
   version?: string;
 };
 
-function parseDecisionParts(parts: string[]): { decision: string; needsImplementation: boolean | undefined; overrideTicket?: string; overrideTarget?: string; overrideScope?: string } {
+function parseDecisionParts(parts: string[]): { decision: string; needsImplementation: boolean | undefined } {
   const decision: string[] = [];
   let needsImplementation: boolean | undefined;
-  let overrideTicket: string | undefined;
-  let overrideTarget: string | undefined;
-  let overrideScope: string | undefined;
   for (let index = 0; index < parts.length; index += 1) {
     const part = parts[index];
     if (part === '--needs-implementation') {
@@ -27,18 +23,14 @@ function parseDecisionParts(parts: string[]): { decision: string; needsImplement
         throw new Error("--needs-implementation must be 'true' or 'false'");
       }
       needsImplementation = value === 'true';
-    } else if (part === '--override-ticket' || part === '--override-target' || part === '--override-scope') {
-      const value = parts[++index];
-      if (!value) throw new Error(`${part} requires a value`);
-      if (part === '--override-ticket') overrideTicket = value;
-      else if (part === '--override-target') overrideTarget = value;
-      else overrideScope = value;
+    } else if (part?.startsWith('--')) {
+      throw new Error(`unknown option '${part}'`);
     } else {
       decision.push(parts[index]!);
     }
   }
   if (decision.length === 0) throw new Error('decision content is required');
-  return { decision: decision.join(' '), needsImplementation, overrideTicket, overrideTarget, overrideScope };
+  return { decision: decision.join(' '), needsImplementation };
 }
 
 export async function decide(args: string[], options: DecideOptions = {}): Promise<number> {
@@ -79,29 +71,7 @@ export async function decide(args: string[], options: DecideOptions = {}): Promi
       metadataProvider: () => ({ timestamp: now, agentInfraVersion: options.version ?? VERSION })
     };
     let result;
-    const execute = async () => {
-      let current = applyHumanDecision(request, writeOptions);
-      if (current.status !== 'failed' || !parsedDecision.overrideTicket) return current;
-      if (!parsedDecision.overrideTarget || !parsedDecision.overrideScope) throw new Error('override ticket requires --override-target and --override-scope');
-      const consumed = await consumeHumanOverride({
-        taskRef: resolved.taskId,
-        ticketId: parsedDecision.overrideTicket,
-        failureId: failureId('decision-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-        target: parsedDecision.overrideTarget,
-        scope: parsedDecision.overrideScope
-      }, {
-        ...writeOptions,
-        effectExecutor: (capability) => {
-          const retried = applyHumanDecision(request, { ...writeOptions, manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed' || retried.status === 'planned'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no decision effect was committed' : `${retried.error?.code ?? 'DECISION_FAILED'}: ${retried.error?.message ?? 'manual decision effect failed'}` }
-            : null;
-        }
-      });
-      if (consumed.status === 'failed') throw new Error(consumed.error.message);
-      return current;
-    };
+    const execute = async () => applyHumanDecision(request, writeOptions);
     result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-decision', execute);
     if (result.error) throw new Error(result.error.message);
     return 0;

package/lib/git/branch-worktree.ts

@@ -0,0 +1,41 @@
+import { execFileSync } from 'node:child_process';
+
+function gitText(repositoryRoot: string, args: string[]): string | null {
+  try {
+    return execFileSync('git', ['-C', repositoryRoot, ...args], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe']
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function verifiedWorktreeRoot(candidate: string, expectedBranch: string, expectedCommonDirectory: string): string | null {
+  const commonDirectory = gitText(candidate, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (commonDirectory !== expectedCommonDirectory) return null;
+  const root = gitText(candidate, ['rev-parse', '--show-toplevel']);
+  if (!root) return null;
+  const branch = gitText(root, ['symbolic-ref', '--short', 'HEAD']);
+  return branch === expectedBranch ? root : null;
+}
+
+export function resolveBranchWorktree(repositoryRoot: string, expectedBranch: string): string | null {
+  const commonDirectory = gitText(repositoryRoot, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (!commonDirectory) return null;
+  const currentRoot = verifiedWorktreeRoot(repositoryRoot, expectedBranch, commonDirectory);
+  if (currentRoot) return currentRoot;
+
+  const records = gitText(repositoryRoot, ['worktree', 'list', '--porcelain']);
+  if (!records) return null;
+  const expectedRef = `refs/heads/${expectedBranch}`;
+  for (const record of records.split(/\r?\n\r?\n/)) {
+    const candidate = /^worktree (.+)$/m.exec(record)?.[1];
+    const branch = /^branch (.+)$/m.exec(record)?.[1];
+    if (candidate && branch === expectedRef) {
+      const verifiedRoot = verifiedWorktreeRoot(candidate, expectedBranch, commonDirectory);
+      if (verifiedRoot) return verifiedRoot;
+    }
+  }
+  return null;
+}

package/lib/internal/cli-route-inventory.ts

@@ -61,7 +61,6 @@ export const INTERNAL_HANDLER_ROUTE_SELECTORS = Object.freeze({
   'task-review': ['preflight', 'finalize-summary'],
   'task-event': ['event'],
   'task-invalidation': ['reconcile'],
-  'task-override': ['diagnose', 'issue', 'consume'],
   'task-lifecycle': ['intent'],
   'task-finalization': ['complete'],
   'task-short-id': ['list', 'list-verify', 'alloc', 'release', 'resolve'],
@@ -98,7 +97,6 @@ export function internalRouteSelector(command: string, args: readonly string[]):
   if (command === 'task-orchestration') return args[1] === 'status' ? 'status' : args[1] ? 'progress' : '';
   if (command === 'task-review') return args[1] ?? '';
   if (command === 'task-invalidation') return args[1] ?? '';
-  if (command === 'task-override') return args[1] ?? '';
   if (command === 'task-artifact') return args[1] ?? '';
   if (command === 'platform-pr-review' && first(args) === 'publish') {
     const scope = optionValue(args, '--scope') ?? '';

package/lib/internal/task-activity.ts

@@ -6,7 +6,6 @@ import type {
   PrReviewActivityIntent,
   PrReviewInspectIntent
 } from '../task/activity-intent.ts';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
@@ -28,14 +27,13 @@ const FLAGS: Record<string, string> = {
   '--minor': 'minor',
   '--outcome': 'outcome',
   '--reason': 'reason'
-  , '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const COMMON = ['agent', 'artifact', 'head'] as const;
 const ALLOWED: Record<string, ReadonlySet<string>> = {
   'pr-review-inspect': new Set(['kind', 'taskRef']),
-  'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope']),
-  'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope']),
-  'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun', 'overrideTicket', 'overrideTarget', 'overrideScope'])
+  'pr-review-start': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'dryRun']),
+  'pr-review-complete': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'verdict', 'blockers', 'major', 'minor', 'dryRun']),
+  'pr-review-terminate': new Set(['kind', 'taskRef', 'agent', 'artifact', 'head', 'outcome', 'reason', 'dryRun'])
 };
 
 function usageFailure(message: string): void {
@@ -95,45 +93,19 @@ async function taskActivity(args: string[] = []): Promise<void> {
   for (const key of operationRequired) {
     if (values[key] === undefined) { usageFailure(`${kind} requires '${key}'`); return; }
   }
-  const dryRunConflict = overrideDryRunConflict(values);
-  if (dryRunConflict) { usageFailure(dryRunConflict.message); return; }
   const resolved = resolveTaskRef(taskRef);
   if (!resolved.ok) { usageFailure(resolved.message); return; }
   let result;
-  let humanOverride: unknown = null;
   try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity.${kind}`, async () => {
-      let current = applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true });
-      if (current.status !== 'failed' || !values.overrideTicket) return current;
-      if (!values.overrideTarget || !values.overrideScope) { usageFailure('override ticket requires target and scope'); return current; }
-      const consumed = await consumeHumanOverride({
-        taskRef, ticketId: String(values.overrideTicket),
-        failureId: failureId('activity-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-        target: String(values.overrideTarget), scope: String(values.overrideScope)
-      }, {
-        effectExecutor: (capability) => {
-          const retried = applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true, manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed' || retried.status === 'planned'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no activity effect was committed' : `${retried.error?.code ?? 'ACTIVITY_FAILED'}: ${retried.error?.message ?? 'manual activity effect failed'}` }
-            : null;
-        }
-      });
-      humanOverride = consumed;
-      return current;
-    });
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity.${kind}`, async () => applyPrReviewActivityIntent(values as PrReviewActivityIntent, { lockAlreadyHeld: true }));
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-  const overrideFailed = Boolean(
-    humanOverride && typeof humanOverride === 'object' &&
-    (humanOverride as { status?: unknown }).status === 'failed'
-  );
-  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskActivity };

package/lib/internal/task-event.ts

@@ -1,7 +1,6 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import { applyTaskEvent, eventCatalog } from '../task/events.ts';
 import type { TaskEventRequest, Verdict } from '../task/events.ts';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
@@ -21,8 +20,7 @@ const FLAGS: Record<string, keyof TaskEventRequest> = {
   '--verdict': 'verdict', '--blockers': 'blockers', '--major': 'major',
   '--minor': 'minor', '--manual-validation': 'manualValidation', '--files-modified': 'filesModified',
   '--tests-passed': 'testsPassed', '--summary-result': 'summaryResult',
-  '--transaction-id': 'transactionId', '--receipt-digest': 'receiptDigest', '--pr-head-sha': 'prHeadSha',
-  '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+  '--transaction-id': 'transactionId', '--receipt-digest': 'receiptDigest', '--pr-head-sha': 'prHeadSha'
 };
 const NUMERIC = new Set(['round', 'question', 'blockers', 'major', 'minor', 'manualValidation', 'filesModified', 'testsPassed']);
 
@@ -59,8 +57,6 @@ export function parseTaskEventRequest(args: readonly string[]): TaskEventRequest
   const agent = normalizeAgentToken(String(request.agent ?? ''));
   if (!agent) throw new Error(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
   request.agent = agent;
-  const dryRunConflict = overrideDryRunConflict(request as unknown as Record<string, unknown>);
-  if (dryRunConflict) throw new Error(dryRunConflict.message);
   return request;
 }
 
@@ -78,45 +74,16 @@ async function taskEvent(args: string[] = []): Promise<void> {
     return;
   }
   let result;
-  let humanOverride: unknown = null;
   try {
-    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, async () => {
-      let current = applyTaskEvent(request, { lockAlreadyHeld: true });
-      const values = request as Record<string, unknown>;
-      if (current.status !== 'failed' || !values.overrideTicket) return current;
-      if (!values.overrideTarget || !values.overrideScope) {
-        return { ...current, humanOverride: { status: 'failed', error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires target and scope' } } } as typeof current & { humanOverride: unknown };
-      }
-      const consumed = await consumeHumanOverride({
-        taskRef: request.taskRef,
-        ticketId: String(values.overrideTicket),
-        failureId: failureId('task-event', current.error?.code ?? 'EVENT_TRANSITION_INVALID'),
-        target: String(values.overrideTarget),
-        scope: String(values.overrideScope)
-      }, {
-        effectExecutor: (capability) => {
-          const retried = applyTaskEvent(request, { lockAlreadyHeld: true, manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed' || retried.status === 'planned'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no task event was committed' : `${retried.error?.code ?? 'EVENT_FAILED'}: ${retried.error?.message ?? 'manual task event effect failed'}` }
-            : null;
-        }
-      });
-      humanOverride = consumed;
-      return current;
-    });
+    result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, async () => applyTaskEvent(request, { lockAlreadyHeld: true }));
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-  const overrideFailed = Boolean(
-    humanOverride && typeof humanOverride === 'object' &&
-    (humanOverride as { status?: unknown }).status === 'failed'
-  );
-  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskEvent };

package/lib/internal/task-finalization.ts

@@ -3,7 +3,8 @@ import {
   dispatchTaskControlOperation,
   parseTaskControlOperation
 } from '../task/control-authority.ts';
-import { applyTaskFinalization, prepareTaskFinalization } from '../task/finalization.ts';
+import { applyTaskFinalization, bindTaskFinalizationReceipt, prepareTaskFinalization } from '../task/finalization.ts';
+import { publishTaskFinalizationHandoff } from '../task/finalization-handoff.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import { verifyTaskEvent } from '../task/verification.ts';
 import { resolveSandboxControlTransport } from './task-operation-registry.ts';
@@ -88,7 +89,13 @@ async function taskFinalization(args: string[] = []): Promise<void> {
       return;
     }
     try {
-      const response = requestSandboxTaskFinalization({ agent: boundOperation.request.agent });
+      const response = requestSandboxTaskFinalization({
+        agent: boundOperation.request.agent,
+        prepareHandoff: (binding) => {
+          const receipt = bindTaskFinalizationReceipt(repoRoot, boundOperation.request.taskRef, binding);
+          return publishTaskFinalizationHandoff('/share/branch', receipt, binding);
+        }
+      });
       process.stdout.write(response.stdout);
       process.stderr.write(response.stderr);
       process.exitCode = response.exitCode ?? 1;

package/lib/internal/task-ledger.ts

@@ -2,7 +2,6 @@ import fs from 'node:fs';
 
 import { applyLedgerIntent } from '../task/ledger-intents.ts';
 import type { LedgerIntent } from '../task/ledger-intents.ts';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
@@ -14,8 +13,7 @@ const FLAGS: Record<string, string> = {
   '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
   '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation',
   '--intent-id': 'intentId', '--finding-id': 'findingId', '--source-artifact': 'sourceArtifact',
-  '--source-sha256': 'sourceSha256', '--classification': 'classification',
-  '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+  '--source-sha256': 'sourceSha256', '--classification': 'classification'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
 const BOOLEAN = new Set(['needsImplementation']);
@@ -78,16 +76,11 @@ async function taskLedger(args: string[] = []): Promise<void> {
     'decision-upsert': ['needsImplementation'],
     'rework-intent-rebuild': ['findingId', 'sourceArtifact', 'sourceSha256', 'classification']
   };
-  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert' || kind === 'rework-intent-rebuild'
-    ? []
-    : ['overrideTicket', 'overrideTarget', 'overrideScope'];
-  const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]!, ...(optional[kind] ?? []), ...overrideFields]);
+  const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]!, ...(optional[kind] ?? [])]);
   const unexpected = Object.keys(values).find((key) => !allowed.has(key));
   const missing = required[kind]!.find((key) => values[key] === undefined);
   if (unexpected) { usageFailure(`${kind} does not accept '${unexpected}'`); return; }
   if (missing) { usageFailure(`${kind} requires '${missing}'`); return; }
-  const dryRunConflict = overrideDryRunConflict(values);
-  if (dryRunConflict) { usageFailure(dryRunConflict.message); return; }
   if (values.classification !== undefined && !REWORK_CLASSIFICATIONS.has(String(values.classification))) {
     usageFailure(`invalid rework classification '${values.classification}'`); return;
   }
@@ -124,42 +117,16 @@ async function taskLedger(args: string[] = []): Promise<void> {
   const lockResolved = resolveTaskRef(taskRef);
   if (!lockResolved.ok) { usageFailure(lockResolved.message); return; }
   let result;
-  let humanOverride: unknown = null;
   try {
-    result = await withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, async () => {
-      let current = applyLedgerIntent(values as LedgerIntent);
-      if (current.status !== 'failed' || !values.overrideTicket) return current;
-      if (!values.overrideTarget || !values.overrideScope) { usageFailure('override ticket requires target and scope'); return current; }
-      const consumed = await consumeHumanOverride({
-        taskRef,
-        ticketId: String(values.overrideTicket),
-        failureId: failureId('ledger-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-        target: String(values.overrideTarget),
-        scope: String(values.overrideScope)
-      }, {
-        effectExecutor: (capability) => {
-          const retried = applyLedgerIntent(values as LedgerIntent, { manualOverride: capability });
-          current = retried;
-          return retried.status === 'failed'
-            ? { code: 'OVERRIDE_EFFECT_FAILED', message: `${retried.error?.code ?? 'LEDGER_FAILED'}: ${retried.error?.message ?? 'manual ledger effect failed'}` }
-            : null;
-        }
-      });
-      humanOverride = consumed;
-      return current;
-    });
+    result = await withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, async () => applyLedgerIntent(values as LedgerIntent));
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: error.code, message: error.message } })}\n`);
     process.exitCode = 1;
     return;
   }
-  process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-  const overrideFailed = Boolean(
-    humanOverride && typeof humanOverride === 'object' &&
-    (humanOverride as { status?: unknown }).status === 'failed'
-  );
-  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
+  process.stdout.write(`${JSON.stringify(result)}\n`);
+  if (result.status === 'failed') process.exitCode = 1;
 }
 
 export { taskLedger };

package/lib/internal/task-lifecycle.ts

@@ -10,7 +10,7 @@ import type { TaskLifecycleResult } from '../task/lifecycle.ts';
 import type { AgentClientLifecycleRecoveryResult as LifecycleRecoveryResult } from '../agent-clients/adapter.ts';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --auto\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nrecover-started: --auto\n`;
 
 function usageFailure(message: string): void {
   process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
@@ -62,7 +62,7 @@ async function taskLifecycle(args: string[] = []): Promise<void> {
   const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot }),
     operation
-  ) as (TaskLifecycleResult | LifecycleRecoveryResult) & { humanOverride?: unknown };
+  ) as TaskLifecycleResult | LifecycleRecoveryResult;
   process.stdout.write(`${JSON.stringify(result)}\n`);
   if (result.status === 'failed' || result.status === 'owner-unknown' || result.status === 'conflict') process.exitCode = 1;
 }

package/lib/internal/task-operation-registry.ts

@@ -143,9 +143,6 @@ function internalTaskRoutes(): TaskOperationDescriptor[] {
     descriptor('internal', 'task-review', 'finalize-summary', 'task-bound', 'progress'),
     descriptor('internal', 'task-event', 'event', 'task-bound', 'progress'),
     descriptor('internal', 'task-invalidation', 'reconcile', 'task-bound', 'progress'),
-    descriptor('internal', 'task-override', 'diagnose', 'task-bound', 'diagnostic'),
-    descriptor('internal', 'task-override', 'issue', 'task-bound', 'progress'),
-    descriptor('internal', 'task-override', 'consume', 'task-bound', 'progress'),
     descriptor('internal', 'task-lifecycle', 'intent', 'task-bound', 'progress'),
     descriptor('internal', 'task-finalization', 'complete', 'task-bound', 'progress'),
     descriptor('internal', 'task-short-id', 'list', 'conditional', 'diagnostic'),
@@ -224,7 +221,7 @@ export const INTERNAL_DISPATCHER_ROUTES = Object.freeze([
   'platform-comment', 'platform-issue', 'platform-pr', 'platform-pr-review', 'pr-review-grade',
   'platform-checks', 'task-context', 'task-ledger', 'task-warning', 'task-activity', 'task-artifact',
   'task-orchestration', 'task-review', 'task-event', 'task-invalidation', 'task-lifecycle',
-  'task-finalization', 'task-override', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
+  'task-finalization', 'task-short-id', 'task-snapshot', 'task-verify', 'task-validate', 'manual-validation'
 ]);
 export const PUBLIC_DISPATCHER_ROUTES = Object.freeze([
   'agent-client', 'cp', 'data', 'decide', 'help', 'init', 'merge', 'run', 'sandbox', 'server', 'task', 'sync', 'update', 'version'