@fitlab-ai/agent-infra 0.11.4 → 0.11.6

package/dist/bin/internal-cli.js

@@ -240,11 +240,6 @@ if (!controlRouted && !taskViewGuardFailed && internalRouteRegistered)
             await taskFinalization(process.argv.slice(3));
             break;
         }
-        case 'task-override': {
-            const { taskOverride } = await import('../lib/internal/task-override.js');
-            await taskOverride(process.argv.slice(3));
-            break;
-        }
         case 'task-short-id': {
             const { taskShortId } = await import('../lib/internal/task-short-id.js');
             taskShortId(process.argv.slice(3));

package/dist/lib/decide.js

@@ -2,15 +2,11 @@ import { VERSION } from './version.js';
 import { parseTaskScope } from './task/command-options.js';
 import { applyHumanDecision } from './task/decision-intents.js';
 import { canonicalTimestamp } from './task/write.js';
-import { consumeHumanOverride, failureId } from './task/human-override.js';
 import { resolveTaskContext } from './task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from './task/task-execution-lock.js';
 function parseDecisionParts(parts) {
     const decision = [];
     let needsImplementation;
-    let overrideTicket;
-    let overrideTarget;
-    let overrideScope;
     for (let index = 0; index < parts.length; index += 1) {
         const part = parts[index];
         if (part === '--needs-implementation') {
@@ -22,16 +18,8 @@ function parseDecisionParts(parts) {
             }
             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]);
@@ -39,7 +27,7 @@ function parseDecisionParts(parts) {
     }
     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, options = {}) {
     let scope;
@@ -94,32 +82,7 @@ export async function decide(args, options = {}) {
             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);

package/dist/lib/git/branch-worktree.js

@@ -0,0 +1,45 @@
+import { execFileSync } from 'node:child_process';
+function gitText(repositoryRoot, args) {
+    try {
+        return execFileSync('git', ['-C', repositoryRoot, ...args], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'pipe']
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function verifiedWorktreeRoot(candidate, expectedBranch, expectedCommonDirectory) {
+    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, expectedBranch) {
+    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;
+}
+//# sourceMappingURL=branch-worktree.js.map

package/dist/lib/internal/cli-route-inventory.js

@@ -58,7 +58,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'],
@@ -105,8 +104,6 @@ export function internalRouteSelector(command, args) {
         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') {

package/dist/lib/internal/task-activity.js

@@ -1,5 +1,4 @@
 import { applyPrReviewActivityIntent, inspectPrReviewActivity } from '../task/activity-intent.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
@@ -18,15 +17,14 @@ const FLAGS = {
     '--major': 'major',
     '--minor': 'minor',
     '--outcome': 'outcome',
-    '--reason': 'reason',
-    '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+    '--reason': 'reason'
 };
 const COMMON = ['agent', 'artifact', 'head'];
 const ALLOWED = {
     '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) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'ACTIVITY_PAYLOAD_INVALID', message } })}\n`);
@@ -109,43 +107,14 @@ async function taskActivity(args = []) {
             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 = null;
     try {
-        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-activity.${kind}`, async () => {
-            let current = applyPrReviewActivityIntent(values, { 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, { 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, { lockAlreadyHeld: true }));
     }
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))
@@ -154,10 +123,8 @@ async function taskActivity(args = []) {
         process.exitCode = 1;
         return;
     }
-    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
-        humanOverride.status === 'failed');
-    if (result.status === 'failed' || overrideFailed)
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskActivity };

package/dist/lib/internal/task-event.js

@@ -1,6 +1,5 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
 import { applyTaskEvent, eventCatalog } from '../task/events.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
@@ -18,8 +17,7 @@ const FLAGS = {
     '--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']);
 function usageFailure(message) {
@@ -68,9 +66,6 @@ export function parseTaskEventRequest(args) {
     if (!agent)
         throw new Error(`invalid --agent '${request.agent}': ${AGENT_USAGE_HINT}`);
     request.agent = agent;
-    const dryRunConflict = overrideDryRunConflict(request);
-    if (dryRunConflict)
-        throw new Error(dryRunConflict.message);
     return request;
 }
 async function taskEvent(args = []) {
@@ -99,34 +94,8 @@ async function taskEvent(args = []) {
         return;
     }
     let result;
-    let humanOverride = null;
     try {
-        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-event.${request.event}`, async () => {
-            let current = applyTaskEvent(request, { lockAlreadyHeld: true });
-            const values = request;
-            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' } } };
-            }
-            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))
@@ -135,10 +104,8 @@ async function taskEvent(args = []) {
         process.exitCode = 1;
         return;
     }
-    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
-        humanOverride.status === 'failed');
-    if (result.status === 'failed' || overrideFailed)
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskEvent };

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

@@ -1,5 +1,6 @@
 import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTaskControlOperation } from '../task/control-authority.js';
-import { applyTaskFinalization, prepareTaskFinalization } from '../task/finalization.js';
+import { applyTaskFinalization, bindTaskFinalizationReceipt, prepareTaskFinalization } from '../task/finalization.js';
+import { publishTaskFinalizationHandoff } from '../task/finalization-handoff.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { verifyTaskEvent } from '../task/verification.js';
 import { resolveSandboxControlTransport } from './task-operation-registry.js';
@@ -74,7 +75,13 @@ async function taskFinalization(args = []) {
             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/dist/lib/internal/task-ledger.js

@@ -1,6 +1,5 @@
 import fs from 'node:fs';
 import { applyLedgerIntent } from '../task/ledger-intents.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
@@ -11,8 +10,7 @@ const FLAGS = {
     '--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']);
@@ -96,10 +94,7 @@ async function taskLedger(args = []) {
         '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) {
@@ -110,11 +105,6 @@ async function taskLedger(args = []) {
         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;
@@ -159,34 +149,8 @@ async function taskLedger(args = []) {
         return;
     }
     let result;
-    let humanOverride = null;
     try {
-        result = await withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, async () => {
-            let current = applyLedgerIntent(values);
-            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, { 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));
     }
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))
@@ -195,10 +159,8 @@ async function taskLedger(args = []) {
         process.exitCode = 1;
         return;
     }
-    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
-        humanOverride.status === 'failed');
-    if (result.status === 'failed' || overrideFailed)
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskLedger };

package/dist/lib/internal/task-lifecycle.js

@@ -2,7 +2,7 @@ import { createDirectHostExecutionContext, dispatchTaskControlOperation, parseTa
 import { lifecycleIntentCatalog } from '../task/lifecycle.js';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-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) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'LIFECYCLE_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);

package/dist/lib/internal/task-operation-registry.js

@@ -103,9 +103,6 @@ function internalTaskRoutes() {
         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'),
@@ -181,7 +178,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'

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

@@ -1,10 +1,9 @@
 import { parseReviewCommand } from '../task/review-command.js';
 import { finalizeReviewSummary, preflightReviewSummary } from '../task/review-finalization.js';
-import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> <preflight|finalize-summary> --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -30,48 +29,19 @@ async function taskReview(args = []) {
         failUsage(error instanceof Error ? error.message : String(error));
         return;
     }
-    const { stage, artifact, dryRun, orchestrated, overrideTicket, overrideTarget, overrideScope } = request;
+    const { stage, artifact, dryRun, orchestrated } = request;
     const operation = args[1];
-    const dryRunConflict = overrideDryRunConflict({ dryRun, overrideTicket, overrideTarget, overrideScope });
-    if (dryRunConflict) {
-        failUsage(dryRunConflict.message);
-        return;
-    }
     const resolved = resolveTaskRef(args[0]);
     if (!resolved.ok) {
         failUsage(resolved.message);
         return;
     }
     let result;
-    let humanOverride = null;
     try {
         result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-review.${operation}`, async () => {
-            let current = operation === 'preflight'
+            return operation === 'preflight'
                 ? preflightReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true })
                 : finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
-            if (operation === 'preflight')
-                return current;
-            if (current.status !== 'failed' || !overrideTicket)
-                return current;
-            if (!overrideTarget || !overrideScope) {
-                failUsage('override ticket requires target and scope');
-                return current;
-            }
-            const consumed = await consumeHumanOverride({
-                taskRef: args[0], ticketId: overrideTicket,
-                failureId: failureId('review-finalization', current.error?.code ?? 'TASK_STATE_MISMATCH'),
-                target: overrideTarget, scope: overrideScope
-            }, {
-                effectExecutor: (capability) => {
-                    const retried = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { 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 review effect was committed' : `${retried.error?.code ?? 'REVIEW_FAILED'}: ${retried.error?.message ?? 'manual review effect failed'}` }
-                        : null;
-                }
-            });
-            humanOverride = consumed;
-            return current;
         });
     }
     catch (error) {
@@ -81,10 +51,8 @@ async function taskReview(args = []) {
         process.exitCode = 1;
         return;
     }
-    process.stdout.write(`${JSON.stringify(humanOverride ? { ...result, humanOverride } : result)}\n`);
-    const overrideFailed = Boolean(humanOverride && typeof humanOverride === 'object' &&
-        humanOverride.status === 'failed');
-    if (result.status === 'failed' || overrideFailed)
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
         process.exitCode = 1;
 }
 export { taskReview };

package/dist/lib/internal/task-verify.js

@@ -1,9 +1,8 @@
 import { renderTaskVerification, verifyTaskEvent } from '../task/verification.js';
-import { consumeHumanOverride, failureId } from '../task/human-override.js';
 import { resolveTaskRef } from '../task/resolve-ref.js';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
 import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.js';
-const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
+const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text]\n';
 function fail(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'VERIFY_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -25,13 +24,10 @@ async function taskVerify(args = []) {
     const event = args[1];
     let artifact;
     let format = 'json';
-    let overrideTicket;
-    let overrideTarget;
-    let overrideScope;
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (!['--artifact', '--format', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) {
+        if (!['--artifact', '--format'].includes(flag)) {
             fail(`unknown option '${flag}'`);
             return;
         }
@@ -47,12 +43,6 @@ async function taskVerify(args = []) {
         seen.add(flag);
         if (flag === '--artifact')
             artifact = value;
-        else if (flag === '--override-ticket')
-            overrideTicket = value;
-        else if (flag === '--override-target')
-            overrideTarget = value;
-        else if (flag === '--override-scope')
-            overrideScope = value;
         else if (value === 'json' || value === 'text')
             format = value;
         else {
@@ -66,40 +56,8 @@ async function taskVerify(args = []) {
         return;
     }
     let result;
-    let humanOverride = null;
     try {
-        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, async () => {
-            let current = await verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) });
-            if (current.status === 'pass' || !overrideTicket)
-                return current;
-            if (!overrideTarget || !overrideScope) {
-                fail('override ticket requires target and scope');
-                return current;
-            }
-            const failureProducer = current.status === 'blocked' || current.status === 'fail'
-                ? 'verification-engine'
-                : 'task-verify';
-            const failureCode = current.status === 'blocked'
-                ? 'CHECK_BLOCKED'
-                : current.status === 'fail'
-                    ? 'CHECK_FAILED'
-                    : current.error?.code ?? 'VERIFY_TASK_STATE_MISMATCH';
-            const consumed = await consumeHumanOverride({
-                taskRef, ticketId: overrideTicket,
-                failureId: failureId(failureProducer, failureCode),
-                target: overrideTarget, scope: overrideScope
-            }, {
-                effectExecutor: async (capability) => {
-                    const retried = await verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) }, { manualOverride: capability });
-                    current = retried;
-                    return retried.status !== 'pass'
-                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: `${retried.error?.code ?? 'VERIFY_FAILED'}: ${retried.error?.message ?? 'manual verification effect failed'}` }
-                        : null;
-                }
-            });
-            humanOverride = consumed;
-            return current;
-        });
+        result = await withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, async () => verifyTaskEvent({ taskRef, event, ...(artifact ? { artifact } : {}) }));
     }
     catch (error) {
         if (!(error instanceof TaskExecutionLockError))
@@ -107,8 +65,6 @@ async function taskVerify(args = []) {
         fail(`${error.code}: ${error.message}`);
         return;
     }
-    if (humanOverride)
-        result = { ...result, humanOverride };
     process.stdout.write(format === 'text' ? renderTaskVerification(result) : `${JSON.stringify(result)}\n`);
     process.exitCode = result.status === 'pass' ? 0 : result.status === 'blocked' ? 2 : 1;
 }