@fitlab-ai/agent-infra 0.9.7 → 0.9.9

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

@@ -1,8 +1,7 @@
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, dispatchOrchestrationDelegation, pauseOrchestration, recoverCommitIntent, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.js';
+import { activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, awaitOrchestrationDelegationActivation, beginOrResumeOrchestration, dispatchOrchestrationDelegation, OrchestrationStateError, pauseOrchestration, recoverPreparedOrchestrationDelegation, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, statusOrchestration } from '../task/orchestration.js';
 import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.js';
 import { isAgentClientId } from '../agent-clients/types.js';
-const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
+const USAGE = 'Usage: agent-infra-internal task-orchestration <task-ref|auto> <begin-or-resume|route|prepare|dispatch|await-activation|recover-prepared|hook-start|hook-stop|advance|pause|status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -23,26 +22,15 @@ async function taskOrchestration(args = []) {
     const [taskRef, intent] = args;
     if (![
         'begin-or-resume', 'route', 'prepare', 'dispatch', 'await-activation', 'recover-prepared',
-        'hook-start', 'hook-stop', 'advance', 'pause', 'status',
-        'commit-start', 'commit-begin', 'commit-checkpoint', 'commit-complete', 'commit-recover', 'commit-abort', 'commit-terminate', 'commit-status'
+        'hook-start', 'hook-stop', 'advance', 'pause', 'status'
     ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
         return;
     }
     const values = {};
     const seen = new Set();
-    let orchestrated = false;
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (flag === '--orchestrated') {
-            if (seen.has(flag)) {
-                usageFailure(`duplicate option '${flag}'`);
-                return;
-            }
-            seen.add(flag);
-            orchestrated = true;
-            continue;
-        }
         if (![
             '--max-steps', '--executor-model', '--executor-reasoning-effort',
             '--reviewer-model', '--reviewer-reasoning-effort',
@@ -52,8 +40,7 @@ async function taskOrchestration(args = []) {
             '--native-agent', '--child-id', '--spawn-mode', '--actual-model', '--actual-reasoning-effort',
             '--model-fallback-reason', '--reasoning-effort-fallback-reason',
             '--exit-code', '--after-fingerprint', '--changed-paths', '--code', '--message', '--recoverable', '--agent',
-            '--baseline-head', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head',
-            '--attempt', '--git-worktree-root'
+            '--git-worktree-root'
         ].includes(flag)) {
             usageFailure(`unknown option '${flag}'`);
             return;
@@ -70,33 +57,6 @@ async function taskOrchestration(args = []) {
         }
         values[flag] = value;
     }
-    const commitIntentFlags = {
-        'commit-start': ['--agent', '--git-worktree-root'],
-        'commit-begin': ['--agent', '--baseline-head', '--attempt', '--orchestrated', '--git-worktree-root'],
-        'commit-checkpoint': ['--token', '--kind', '--head', '--remote', '--ref', '--git-worktree-root'],
-        'commit-complete': ['--token', '--agent', '--git-worktree-root'],
-        'commit-recover': ['--agent', '--git-worktree-root'],
-        'commit-abort': ['--token', '--expected-head', '--git-worktree-root'],
-        'commit-terminate': ['--attempt', '--agent', '--code', '--git-worktree-root'],
-        'commit-status': ['--git-worktree-root']
-    };
-    if (intent in commitIntentFlags) {
-        const allowed = commitIntentFlags[intent];
-        const invalid = [...seen].find((flag) => !allowed.includes(flag));
-        if (invalid) {
-            usageFailure(`intent '${intent}' does not accept '${invalid}'`);
-            return;
-        }
-    }
-    else {
-        const commitOnly = [...seen].find((flag) => [
-            '--orchestrated', '--baseline-head', '--attempt', '--token', '--kind', '--head', '--remote', '--ref', '--expected-head'
-        ].includes(flag));
-        if (commitOnly) {
-            usageFailure(`intent '${intent}' does not accept '${commitOnly}'`);
-            return;
-        }
-    }
     const requireValues = (flags) => flags.find((flag) => values[flag] === undefined);
     const coreOptions = values['--git-worktree-root'] === undefined
         ? {}
@@ -106,265 +66,178 @@ async function taskOrchestration(args = []) {
         return;
     }
     let result;
-    if (intent === 'commit-start') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-start' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = startCommitAttempt(taskRef, { agent }, coreOptions);
-    }
-    else if (intent === 'commit-begin') {
-        const missing = requireValues(['--agent', '--baseline-head', '--attempt']);
-        if (missing) {
-            usageFailure(`intent 'commit-begin' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = beginCommitIntent(taskRef, {
-            agent, orchestrated, baselineHead: values['--baseline-head'], attempt: values['--attempt']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-checkpoint') {
-        const missing = requireValues(['--token', '--kind', '--head']);
-        if (missing) {
-            usageFailure(`intent 'commit-checkpoint' requires '${missing}'`);
-            return;
-        }
-        if (!['committed', 'pushed'].includes(values['--kind'])) {
-            usageFailure('--kind must be committed or pushed');
-            return;
-        }
-        if (values['--kind'] === 'pushed') {
-            const pushedMissing = requireValues(['--remote', '--ref']);
-            if (pushedMissing) {
-                usageFailure(`pushed checkpoint requires '${pushedMissing}'`);
+    try {
+        if (intent === 'begin-or-resume') {
+            const missing = requireValues(['--client']);
+            if (missing) {
+                usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
                 return;
             }
-        }
-        else if (values['--remote'] !== undefined || values['--ref'] !== undefined) {
-            usageFailure('committed checkpoint does not accept --remote or --ref');
-            return;
-        }
-        result = checkpointCommitIntent(taskRef, {
-            token: values['--token'], kind: values['--kind'],
-            head: values['--head'], remote: values['--remote'], ref: values['--ref']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-complete') {
-        const missing = requireValues(['--token', '--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-complete' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = completeCommitIntent(taskRef, { token: values['--token'], agent }, coreOptions);
-    }
-    else if (intent === 'commit-recover') {
-        const missing = requireValues(['--agent']);
-        if (missing) {
-            usageFailure(`intent 'commit-recover' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        result = recoverCommitIntent(taskRef, { agent }, coreOptions);
-    }
-    else if (intent === 'commit-abort') {
-        const missing = requireValues(['--token', '--expected-head']);
-        if (missing) {
-            usageFailure(`intent 'commit-abort' requires '${missing}'`);
-            return;
-        }
-        result = abortCommitIntent(taskRef, { token: values['--token'], expectedHead: values['--expected-head'] }, coreOptions);
-    }
-    else if (intent === 'commit-terminate') {
-        const missing = requireValues(['--attempt', '--agent', '--code']);
-        if (missing) {
-            usageFailure(`intent 'commit-terminate' requires '${missing}'`);
-            return;
-        }
-        const agent = normalizeAgentToken(values['--agent']);
-        if (!agent) {
-            usageFailure(`invalid --agent '${values['--agent']}': ${AGENT_USAGE_HINT}`);
-            return;
-        }
-        if (!/^[A-Z][A-Z0-9_]{2,63}$/.test(values['--code'])) {
-            usageFailure('--code must be a stable uppercase identifier');
-            return;
-        }
-        result = terminateCommitAttempt(taskRef, {
-            attempt: values['--attempt'], agent, code: values['--code']
-        }, coreOptions);
-    }
-    else if (intent === 'commit-status') {
-        result = statusCommitIntent(taskRef, coreOptions);
-    }
-    else if (intent === 'begin-or-resume') {
-        const missing = requireValues(['--client']);
-        if (missing) {
-            usageFailure(`intent 'begin-or-resume' requires '${missing}'`);
-            return;
-        }
-        const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
-        if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
-            usageFailure('--max-steps must be a positive integer');
-            return;
-        }
-        const policyFlags = [
-            '--executor-model', '--executor-reasoning-effort',
-            '--reviewer-model', '--reviewer-reasoning-effort'
-        ];
-        const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
-        if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
-            usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
-            return;
-        }
-        result = beginOrResumeOrchestration(taskRef, {
-            ...coreOptions,
-            maxSteps,
-            client: values['--client'],
-            modelPolicy: hasAnyPolicy ? {
-                executor: {
-                    model: values['--executor-model'],
-                    reasoningEffort: values['--executor-reasoning-effort']
-                },
-                reviewer: {
-                    model: values['--reviewer-model'],
-                    reasoningEffort: values['--reviewer-reasoning-effort']
-                }
-            } : undefined
-        });
-    }
-    else if (intent === 'route') {
-        result = routeOrchestration(taskRef, coreOptions);
-    }
-    else if (intent === 'status') {
-        result = statusOrchestration(taskRef, coreOptions);
-    }
-    else if (intent === 'prepare') {
-        const missing = requireValues(['--client']);
-        if (missing) {
-            usageFailure(`intent 'prepare' requires '${missing}'`);
-            return;
-        }
-        result = await prepareCodexOrchestrationDelegation(taskRef, {
-            client: values['--client'],
-            requestedModel: values['--requested-model'],
-            requestedReasoningEffort: values['--requested-reasoning-effort'],
-            capabilityToken: values['--capability-token']
-        }, { orchestrationOptions: coreOptions });
-    }
-    else if (intent === 'dispatch') {
-        result = dispatchOrchestrationDelegation(taskRef, coreOptions);
-    }
-    else if (intent === 'await-activation') {
-        const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
-        if (missing) {
-            usageFailure(`intent 'await-activation' requires '${missing}'`);
-            return;
-        }
-        const round = Number(values['--round']);
-        if (!Number.isSafeInteger(round) || round < 1) {
-            usageFailure('--round must be a positive integer');
-            return;
-        }
-        if (!['executor', 'reviewer'].includes(values['--role'])) {
-            usageFailure('--role must be executor or reviewer');
-            return;
-        }
-        result = await awaitOrchestrationDelegationActivation(taskRef, {
-            stage: values['--stage'],
-            round,
-            artifact: values['--artifact'],
-            role: values['--role']
-        }, coreOptions);
-    }
-    else if (intent === 'recover-prepared') {
-        result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
-    }
-    else if (intent === 'hook-start') {
-        const missing = requireValues([
-            ...(taskRef === 'auto' ? ['--client'] : []),
-            '--native-agent', '--child-id', '--parent-id', '--spawn-mode'
-        ]);
-        if (missing) {
-            usageFailure(`intent 'hook-start' requires '${missing}'`);
-            return;
-        }
-        const event = {
-            nativeAgent: values['--native-agent'], childId: values['--child-id'],
-            parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
-            actualModel: values['--actual-model'],
-            actualReasoningEffort: values['--actual-reasoning-effort'],
-            modelFallbackReason: values['--model-fallback-reason'],
-            reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
-        };
-        result = taskRef === 'auto'
-            ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
-            : activateOrchestrationDelegation(taskRef, event, coreOptions);
-    }
-    else if (intent === 'hook-stop') {
-        if (taskRef === 'auto') {
-            const missing = requireValues(['--client', '--native-agent', '--child-id']);
+            const maxSteps = values['--max-steps'] === undefined ? undefined : Number(values['--max-steps']);
+            if (maxSteps !== undefined && (!Number.isInteger(maxSteps) || maxSteps < 1)) {
+                usageFailure('--max-steps must be a positive integer');
+                return;
+            }
+            const policyFlags = [
+                '--executor-model', '--executor-reasoning-effort',
+                '--reviewer-model', '--reviewer-reasoning-effort'
+            ];
+            const hasAnyPolicy = policyFlags.some((flag) => values[flag] !== undefined);
+            if (hasAnyPolicy && policyFlags.some((flag) => values[flag] === undefined)) {
+                usageFailure('explicit model policy requires executor/reviewer model and reasoning effort');
+                return;
+            }
+            result = beginOrResumeOrchestration(taskRef, {
+                ...coreOptions,
+                maxSteps,
+                client: values['--client'],
+                modelPolicy: hasAnyPolicy ? {
+                    executor: {
+                        model: values['--executor-model'],
+                        reasoningEffort: values['--executor-reasoning-effort']
+                    },
+                    reviewer: {
+                        model: values['--reviewer-model'],
+                        reasoningEffort: values['--reviewer-reasoning-effort']
+                    }
+                } : undefined
+            });
+        }
+        else if (intent === 'route') {
+            result = routeOrchestration(taskRef, coreOptions);
+        }
+        else if (intent === 'status') {
+            result = statusOrchestration(taskRef, coreOptions);
+        }
+        else if (intent === 'prepare') {
+            const missing = requireValues(['--client']);
             if (missing) {
-                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                usageFailure(`intent 'prepare' requires '${missing}'`);
                 return;
             }
-            result = sealMatchingOrchestrationDelegation(values['--client'], {
-                nativeAgent: values['--native-agent'], childId: values['--child-id']
-            }, coreOptions);
-        }
-        else {
-            const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+            result = await prepareCodexOrchestrationDelegation(taskRef, {
+                client: values['--client'],
+                requestedModel: values['--requested-model'],
+                requestedReasoningEffort: values['--requested-reasoning-effort'],
+                capabilityToken: values['--capability-token']
+            }, { orchestrationOptions: coreOptions });
+        }
+        else if (intent === 'dispatch') {
+            result = dispatchOrchestrationDelegation(taskRef, coreOptions);
+        }
+        else if (intent === 'await-activation') {
+            const missing = requireValues(['--stage', '--round', '--artifact', '--role']);
             if (missing) {
-                usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                usageFailure(`intent 'await-activation' requires '${missing}'`);
                 return;
             }
-            const exitCode = Number(values['--exit-code']);
-            if (!Number.isInteger(exitCode)) {
-                usageFailure('--exit-code must be an integer');
+            const round = Number(values['--round']);
+            if (!Number.isSafeInteger(round) || round < 1) {
+                usageFailure('--round must be a positive integer');
                 return;
             }
-            result = sealOrchestrationDelegation(taskRef, {
-                childId: values['--child-id'], exitCode,
-                afterFingerprint: values['--after-fingerprint'],
-                changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : []
+            if (!['executor', 'reviewer'].includes(values['--role'])) {
+                usageFailure('--role must be executor or reviewer');
+                return;
+            }
+            result = await awaitOrchestrationDelegationActivation(taskRef, {
+                stage: values['--stage'],
+                round,
+                artifact: values['--artifact'],
+                role: values['--role']
             }, coreOptions);
         }
-    }
-    else if (intent === 'advance') {
-        result = advanceOrchestration(taskRef, coreOptions);
-    }
-    else {
-        const missing = requireValues(['--code', '--message', '--recoverable']);
-        if (missing) {
-            usageFailure(`intent 'pause' requires '${missing}'`);
-            return;
+        else if (intent === 'recover-prepared') {
+            result = recoverPreparedOrchestrationDelegation(taskRef, coreOptions);
         }
-        if (!['true', 'false'].includes(values['--recoverable'])) {
-            usageFailure('--recoverable must be true or false');
-            return;
+        else if (intent === 'hook-start') {
+            const missing = requireValues([
+                ...(taskRef === 'auto' ? ['--client'] : []),
+                '--native-agent', '--child-id', '--parent-id'
+            ]);
+            if (missing) {
+                usageFailure(`intent 'hook-start' requires '${missing}'`);
+                return;
+            }
+            const event = {
+                nativeAgent: values['--native-agent'], childId: values['--child-id'],
+                parentId: values['--parent-id'], spawnMode: values['--spawn-mode'],
+                actualModel: values['--actual-model'],
+                actualReasoningEffort: values['--actual-reasoning-effort'],
+                modelFallbackReason: values['--model-fallback-reason'],
+                reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+            };
+            result = taskRef === 'auto'
+                ? activateMatchingOrchestrationDelegation(values['--client'], event, coreOptions)
+                : activateOrchestrationDelegation(taskRef, event, coreOptions);
+        }
+        else if (intent === 'hook-stop') {
+            if (taskRef === 'auto') {
+                const missing = requireValues(['--client', '--native-agent', '--child-id']);
+                if (missing) {
+                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                    return;
+                }
+                result = sealMatchingOrchestrationDelegation(values['--client'], {
+                    nativeAgent: values['--native-agent'], childId: values['--child-id'],
+                    actualModel: values['--actual-model'],
+                    actualReasoningEffort: values['--actual-reasoning-effort'],
+                    modelFallbackReason: values['--model-fallback-reason'],
+                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+                }, coreOptions);
+            }
+            else {
+                const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
+                if (missing) {
+                    usageFailure(`intent 'hook-stop' requires '${missing}'`);
+                    return;
+                }
+                const exitCode = Number(values['--exit-code']);
+                if (!Number.isInteger(exitCode)) {
+                    usageFailure('--exit-code must be an integer');
+                    return;
+                }
+                result = sealOrchestrationDelegation(taskRef, {
+                    childId: values['--child-id'], exitCode,
+                    afterFingerprint: values['--after-fingerprint'],
+                    changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : [],
+                    actualModel: values['--actual-model'],
+                    actualReasoningEffort: values['--actual-reasoning-effort'],
+                    modelFallbackReason: values['--model-fallback-reason'],
+                    reasoningEffortFallbackReason: values['--reasoning-effort-fallback-reason']
+                }, coreOptions);
+            }
+        }
+        else if (intent === 'advance') {
+            result = advanceOrchestration(taskRef, coreOptions);
         }
-        result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
+        else {
+            const missing = requireValues(['--code', '--message', '--recoverable']);
+            if (missing) {
+                usageFailure(`intent 'pause' requires '${missing}'`);
+                return;
+            }
+            if (!['true', 'false'].includes(values['--recoverable'])) {
+                usageFailure('--recoverable must be true or false');
+                return;
+            }
+            result = pauseOrchestration(taskRef, values['--code'], values['--message'], values['--recoverable'] === 'true', coreOptions);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof OrchestrationStateError))
+            throw error;
+        result = {
+            status: 'failed',
+            changed: false,
+            taskId: error.taskId,
+            run: null,
+            next: null,
+            error: { code: error.code, message: error.message }
+        };
     }
-    process.stdout.write(`${JSON.stringify(result)}\n`);
+    const output = result;
+    process.stdout.write(`${JSON.stringify(output)}\n`);
     if (result.status === 'failed')
         process.exitCode = 1;
 }

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

@@ -0,0 +1,131 @@
+import { consumeHumanOverride, diagnoseHumanOverrideForTask, issueHumanOverride } from '../task/human-override.js';
+import { resolveTaskRef } from '../task/resolve-ref.js';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.js';
+const USAGE = `Usage: agent-infra-internal task-override <task-ref> <diagnose|issue|consume> [options]
+
+Options: --failure-id <id> --target <target> --operator <operator> --reason <reason> --scope <scope>
+         --intent <lifecycle-intent> --alert-number <N> --issue-number <N> --staging-dir <path>
+         --expires-at <timestamp> --ticket <ticket-id> --pr-number <N>
+`;
+const FLAGS = {
+    '--failure-id': 'failureId',
+    '--target': 'target',
+    '--operator': 'operator',
+    '--reason': 'reason',
+    '--scope': 'scope',
+    '--intent': 'intent',
+    '--failure-digest': 'failureDigest',
+    '--expires-at': 'expiresAt',
+    '--ticket': 'ticketId',
+    '--facts': 'observedFacts',
+    '--alert-number': 'alertNumber',
+    '--issue-number': 'issueNumber',
+    '--pr-number': 'pullRequestNumber',
+    '--staging-dir': 'stagingDir'
+};
+function usageFailure(message) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'OVERRIDE_PAYLOAD_INVALID', message } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+}
+function taskOverride(args = []) {
+    if (args[0] === '--help' || args[0] === '-h') {
+        process.stdout.write(USAGE);
+        return;
+    }
+    const [taskRef, operation] = args;
+    if (!taskRef || !operation || !['diagnose', 'issue', 'consume'].includes(operation)) {
+        usageFailure('task ref and a valid operation are required');
+        return;
+    }
+    const values = { taskRef };
+    const seen = new Set();
+    for (let index = 2; index < args.length; index += 1) {
+        const flag = args[index];
+        const key = FLAGS[flag];
+        if (!key) {
+            usageFailure(`unknown option '${flag}'`);
+            return;
+        }
+        if (seen.has(flag)) {
+            usageFailure(`duplicate option '${flag}'`);
+            return;
+        }
+        const value = args[++index];
+        if (value === undefined || value.startsWith('--')) {
+            usageFailure(`option '${flag}' requires a value`);
+            return;
+        }
+        seen.add(flag);
+        values[key] = key === 'observedFacts' ? value.split(',').map((fact) => fact.trim()).filter(Boolean)
+            : key === 'alertNumber' || key === 'issueNumber' || key === 'pullRequestNumber' ? Number(value) : value;
+    }
+    const required = {
+        diagnose: [],
+        issue: ['failureId', 'target', 'operator', 'reason', 'scope', 'expiresAt'],
+        consume: ['failureId', 'target', 'scope', 'ticketId']
+    };
+    const missing = required[operation].find((key) => values[key] === undefined);
+    if (missing) {
+        usageFailure(`${operation} requires '--${missing.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`)}'`);
+        return;
+    }
+    const resolved = resolveTaskRef(taskRef);
+    if (!resolved.ok) {
+        process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: resolved.code, message: resolved.message } })}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    let result;
+    try {
+        if (operation === 'diagnose') {
+            result = diagnoseHumanOverrideForTask(taskRef, values.failureId ? String(values.failureId) : undefined, values.target ? String(values.target) : undefined);
+        }
+        else if (operation === 'issue') {
+            result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.issue', () => issueHumanOverride({
+                taskRef,
+                failureId: String(values.failureId),
+                target: String(values.target),
+                operator: String(values.operator),
+                reason: String(values.reason),
+                scope: String(values.scope),
+                expiresAt: String(values.expiresAt),
+                ...(values.intent ? { intent: String(values.intent) } : {}),
+                ...(values.alertNumber !== undefined ? { alertNumber: Number(values.alertNumber) } : {}),
+                ...(values.issueNumber !== undefined ? { issueNumber: Number(values.issueNumber) } : {}),
+                ...(values.pullRequestNumber !== undefined ? { pullRequestNumber: Number(values.pullRequestNumber) } : {}),
+                ...(values.stagingDir ? { stagingDir: String(values.stagingDir) } : {}),
+                ...(values.failureDigest ? { failureDigest: String(values.failureDigest) } : {})
+            }));
+        }
+        else {
+            result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-override.consume', () => consumeHumanOverride({
+                taskRef,
+                ticketId: String(values.ticketId),
+                failureId: String(values.failureId),
+                target: String(values.target),
+                scope: String(values.scope),
+                ...(values.intent ? { intent: String(values.intent) } : {}),
+                ...(values.alertNumber !== undefined ? { alertNumber: Number(values.alertNumber) } : {}),
+                ...(values.issueNumber !== undefined ? { issueNumber: Number(values.issueNumber) } : {}),
+                ...(values.pullRequestNumber !== undefined ? { pullRequestNumber: Number(values.pullRequestNumber) } : {}),
+                ...(values.stagingDir ? { stagingDir: String(values.stagingDir) } : {}),
+                ...(values.failureDigest ? { failureDigest: String(values.failureDigest) } : {}),
+                ...(values.observedFacts ? { observedFacts: values.observedFacts } : {})
+            }));
+        }
+    }
+    catch (cause) {
+        if (cause instanceof TaskExecutionLockError) {
+            process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: cause.code, message: cause.message } })}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        throw cause;
+    }
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed')
+        process.exitCode = 1;
+}
+export { taskOverride };
+//# sourceMappingURL=task-override.js.map