@fitlab-ai/agent-infra 0.9.6 → 0.9.8

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

@@ -1,8 +1,8 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.js';
-import { abortCommitIntent, activateMatchingOrchestrationDelegation, activateOrchestrationDelegation, advanceOrchestration, beginCommitIntent, beginOrResumeOrchestration, checkpointCommitIntent, completeCommitIntent, pauseOrchestration, recoverCommitIntent, routeOrchestration, sealMatchingOrchestrationDelegation, sealOrchestrationDelegation, startCommitAttempt, statusCommitIntent, statusOrchestration, terminateCommitAttempt } from '../task/orchestration.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 { 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|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|commit-start|commit-begin|commit-checkpoint|commit-complete|commit-recover|commit-abort|commit-terminate|commit-status> [options]\n';
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed', changed: false,
@@ -22,7 +22,8 @@ async function taskOrchestration(args = []) {
     }
     const [taskRef, intent] = args;
     if (![
-        'begin-or-resume', 'route', 'prepare', 'hook-start', 'hook-stop', 'advance', 'pause', 'status',
+        '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'
     ].includes(intent)) {
         usageFailure(`unknown intent '${intent}'`);
@@ -45,7 +46,9 @@ async function taskOrchestration(args = []) {
         if (![
             '--max-steps', '--executor-model', '--executor-reasoning-effort',
             '--reviewer-model', '--reviewer-reasoning-effort',
-            '--client', '--requested-model', '--requested-reasoning-effort', '--parent-id', '--before-fingerprint',
+            '--client', '--requested-model', '--requested-reasoning-effort', '--capability-token',
+            '--parent-id', '--before-fingerprint',
+            '--stage', '--round', '--artifact', '--role',
             '--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',
@@ -264,13 +267,42 @@ async function taskOrchestration(args = []) {
         result = await prepareCodexOrchestrationDelegation(taskRef, {
             client: values['--client'],
             requestedModel: values['--requested-model'],
-            requestedReasoningEffort: values['--requested-reasoning-effort']
+            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'
+            '--native-agent', '--child-id', '--parent-id'
         ]);
         if (missing) {
             usageFailure(`intent 'hook-start' requires '${missing}'`);
@@ -296,7 +328,11 @@ async function taskOrchestration(args = []) {
                 return;
             }
             result = sealMatchingOrchestrationDelegation(values['--client'], {
-                nativeAgent: values['--native-agent'], childId: values['--child-id']
+                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 {
@@ -313,7 +349,11 @@ async function taskOrchestration(args = []) {
             result = sealOrchestrationDelegation(taskRef, {
                 childId: values['--child-id'], exitCode,
                 afterFingerprint: values['--after-fingerprint'],
-                changedPaths: values['--changed-paths'] ? values['--changed-paths'].split(',').filter(Boolean) : []
+                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);
         }
     }

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

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

@@ -1,5 +1,8 @@
 import { finalizeReviewSummary } from '../task/review-finalization.js';
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
+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';
+const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function failUsage(message) {
     process.stdout.write(`${JSON.stringify({
         status: 'failed',
@@ -27,10 +30,13 @@ function taskReview(args = []) {
     let artifact = '';
     let dryRun = false;
     let orchestrated = false;
+    let overrideTicket = '';
+    let overrideTarget = '';
+    let overrideScope = '';
     const seen = new Set();
     for (let index = 2; index < args.length; index += 1) {
         const flag = args[index];
-        if (!['--stage', '--artifact', '--orchestrated', '--dry-run'].includes(flag)) {
+        if (!['--stage', '--artifact', '--orchestrated', '--dry-run', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) {
             failUsage(`unknown option '${flag}'`);
             return;
         }
@@ -54,16 +60,68 @@ function taskReview(args = []) {
         }
         if (flag === '--stage')
             stage = value;
-        else
+        else 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;
     }
     if (!stage || !artifact) {
         failUsage("options '--stage' and '--artifact' are required");
         return;
     }
-    const result = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun });
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed')
+    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 = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-review.finalize-summary', () => {
+            let current = finalizeReviewSummary({ taskRef: args[0], stage, artifact, orchestrated, dryRun }, { lockAlreadyHeld: true });
+            if (current.status !== 'failed' || !overrideTicket)
+                return current;
+            if (!overrideTarget || !overrideScope) {
+                failUsage('override ticket requires target and scope');
+                return current;
+            }
+            const consumed = 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) {
+        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.status === 'failed');
+    if (result.status === 'failed' || overrideFailed)
         process.exitCode = 1;
 }
 export { taskReview };

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

@@ -1,5 +1,8 @@
 import { renderTaskVerification, verifyTaskEvent } from '../task/verification.js';
-const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text]\n';
+import { consumeHumanOverride, failureId } 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-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text] [--override-ticket <ticket> --override-target <target> --override-scope <scope>]\n';
 function fail(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'VERIFY_PAYLOAD_INVALID', message } })}\n`);
     process.stderr.write(USAGE);
@@ -14,12 +17,17 @@ function taskVerify(args = []) {
         fail('task ref and verification event are required');
         return;
     }
+    const taskRef = args[0];
+    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 (flag !== '--artifact' && flag !== '--format') {
+        if (!['--artifact', '--format', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) {
             fail(`unknown option '${flag}'`);
             return;
         }
@@ -35,6 +43,12 @@ 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 {
@@ -42,7 +56,55 @@ function taskVerify(args = []) {
             return;
         }
     }
-    const result = verifyTaskEvent({ taskRef: args[0], event: args[1], ...(artifact ? { artifact } : {}) });
+    const resolved = resolveTaskRef(taskRef);
+    if (!resolved.ok) {
+        fail(resolved.message);
+        return;
+    }
+    let result;
+    let humanOverride = null;
+    try {
+        result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-verify.${event}`, () => {
+            let current = 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 = consumeHumanOverride({
+                taskRef, ticketId: overrideTicket,
+                failureId: failureId(failureProducer, failureCode),
+                target: overrideTarget, scope: overrideScope
+            }, {
+                effectExecutor: (capability) => {
+                    const retried = 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;
+        });
+    }
+    catch (error) {
+        if (!(error instanceof TaskExecutionLockError))
+            throw error;
+        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;
 }

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

@@ -1,8 +1,12 @@
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.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';
 const USAGE = `Usage: agent-infra-internal task-warning <task-ref> <add|set-status|list> [intent flags] [--dry-run]\n`;
 const FLAGS = {
     '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
-    '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution'
+    '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution',
+    '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 function usageFailure(message) {
     process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'WARNING_PAYLOAD_INVALID', message } })}\n`);
@@ -55,6 +59,9 @@ function taskWarning(args = []) {
     };
     const optional = kind === 'list' ? ['status'] : [];
     const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind], ...optional]);
+    allowed.add('overrideTicket');
+    allowed.add('overrideTarget');
+    allowed.add('overrideScope');
     const unexpected = Object.keys(values).find((key) => !allowed.has(key));
     const missing = required[kind].find((key) => values[key] === undefined);
     if (unexpected) {
@@ -65,9 +72,55 @@ function taskWarning(args = []) {
         usageFailure(`${kind} requires '${missing}'`);
         return;
     }
-    const result = applyWorkflowWarningIntent(values);
-    process.stdout.write(`${JSON.stringify(result)}\n`);
-    if (result.status === 'failed')
+    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 = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, () => {
+            let current = applyWorkflowWarningIntent(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 = consumeHumanOverride({
+                taskRef, ticketId: String(values.overrideTicket),
+                failureId: failureId('workflow-warning', current.error?.code ?? 'TASK_STATE_MISMATCH'),
+                target: String(values.overrideTarget), scope: String(values.overrideScope)
+            }, {
+                effectExecutor: (capability) => {
+                    const retried = applyWorkflowWarningIntent(values, { manualOverride: capability });
+                    current = retried;
+                    return retried.status === 'failed' || retried.status === 'planned'
+                        ? { code: 'OVERRIDE_EFFECT_FAILED', message: retried.status === 'planned' ? 'producer returned planned; no workflow warning effect was committed' : `${retried.error?.code ?? 'WARNING_FAILED'}: ${retried.error?.message ?? 'manual warning effect failed'}` }
+                        : null;
+                }
+            });
+            humanOverride = consumed;
+            return current;
+        });
+    }
+    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.status === 'failed');
+    if (result.status === 'failed' || overrideFailed)
         process.exitCode = 1;
 }
 export { taskWarning };

package/dist/lib/platform/context.js

@@ -5,6 +5,7 @@ import semver from 'semver';
 import { getPlatformAdapter, registerPlatformAdapter } from './adapters.js';
 import { createGitHubClient, MINIMUM_GITHUB_CLI_VERSION } from './github-client.js';
 import { platformResult } from './types.js';
+const CURRENT_USER_QUERY = 'query { viewer { login } }';
 function findRepoRoot(cwd) {
     try {
         return execFileSync('git', ['rev-parse', '--show-toplevel'], {
@@ -89,18 +90,19 @@ function resolveGitHubContext(options) {
             error: { code: 'UPSTREAM_UNRESOLVED', message: 'Unable to resolve the upstream repository', retryable: false }
         });
     }
-    const user = client.json(['api', 'user'], { cwd });
+    const user = client.json(['api', 'graphql', '-f', `query=${CURRENT_USER_QUERY}`], { cwd });
     if (!user.ok)
         return failure(user.error, upstream);
     const userValue = user.value;
+    const currentUser = userValue?.data?.viewer?.login || null;
     const permissions = client.json(['api', `repos/${upstream}`], { cwd });
     if (!permissions.ok)
         return failure(permissions.error, upstream);
     const permissionValue = permissions.value;
     const values = permissionValue?.permissions || {};
     const capabilities = {
-        authenticated: Boolean(userValue?.login),
-        comment: Boolean(userValue?.login),
+        authenticated: Boolean(currentUser),
+        comment: Boolean(currentUser),
         triage: Boolean(values.triage || values.push || values.admin),
         push: Boolean(values.push || values.admin),
         admin: Boolean(values.admin)
@@ -108,7 +110,7 @@ function resolveGitHubContext(options) {
     const status = Object.values(capabilities).every(Boolean) ? 'no-op' : 'degraded';
     return platformResult(status, {
         changed: false,
-        platform: { type: platform, repository: upstream, currentUser: userValue?.login || null },
+        platform: { type: platform, repository: upstream, currentUser },
         resource: { kind: 'repository', number: null },
         capabilities,
         operations: [{ name: 'resolve', status: 'no-op', reasonCode: null }]

package/dist/lib/platform/github-client.js

@@ -1,7 +1,9 @@
 import process from 'node:process';
 import spawn from 'cross-spawn';
 import semver from 'semver';
-const MINIMUM_GITHUB_CLI_VERSION = '2.16.0';
+// closingIssuesReferences (introduced in gh 2.72.0) is the highest-versioned gh feature
+// the platform layer depends on; see github-release-notes.ts:102.
+const MINIMUM_GITHUB_CLI_VERSION = '2.72.0';
 const GITHUB_CLI_MAX_BUFFER = 64 * 1024 * 1024;
 const ERROR_DETAIL_LIMIT = 4096;
 function boundedFailureDetail(result) {
@@ -76,6 +78,41 @@ function classifyGitHubFailure(result) {
     }
     return { code: 'PLATFORM_REQUEST_FAILED', message: detail || 'GitHub request failed', retryable: false };
 }
+function responseUrl(args) {
+    const endpoint = args.find((arg, index) => index > 0 && !arg.startsWith('-')) || '';
+    return endpoint.startsWith('http') ? endpoint : `https://api.github.com/${endpoint.replace(/^\//, '')}`;
+}
+function parseIncludedResponse(stdout, args) {
+    const statusBlocks = [...stdout.matchAll(/^HTTP\/[^\r\n]+/gim)];
+    const headerStart = statusBlocks.at(-1)?.index;
+    if (headerStart === undefined)
+        return null;
+    const response = stdout.slice(headerStart);
+    const separator = response.match(/\r?\n\r?\n/);
+    if (!separator || separator.index === undefined)
+        return null;
+    const header = response.slice(0, separator.index);
+    const body = response.slice(separator.index + separator[0].length);
+    const status = header.match(/^HTTP\/[^ ]+\s+(\d{3})/mi)?.[1];
+    if (!status)
+        return null;
+    const date = header.match(/^Date:\s*(.+)$/mi)?.[1]?.trim();
+    const links = [...header.matchAll(/^Link:\s*(.+)$/gim)].flatMap((match) => match[1].split(',').map((value) => value.trim()));
+    try {
+        return {
+            value: JSON.parse(body || 'null'),
+            metadata: {
+                status: Number(status),
+                requestUrl: responseUrl(args),
+                ...(date ? { date } : {}),
+                links
+            }
+        };
+    }
+    catch {
+        return null;
+    }
+}
 function createGitHubClient(options = {}) {
     const runner = options.runner || defaultRunner;
     const delays = options.retryDelaysMs || retryDelaysFromEnvironment();
@@ -134,8 +171,24 @@ function createGitHubClient(options = {}) {
                     error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub returned invalid JSON', retryable: true }
                 };
             }
+        },
+        jsonWithMetadata(args, request = {}) {
+            const includeArgs = args[0] === 'api' && args[1] !== '--include'
+                ? [args[0], '--include', ...args.slice(1)]
+                : args;
+            const result = run(includeArgs, request);
+            if (!result.ok)
+                return result;
+            const parsed = parseIncludedResponse(result.value, args);
+            if (!parsed) {
+                return {
+                    ok: false,
+                    error: { code: 'INVALID_PLATFORM_RESPONSE', message: 'GitHub response metadata or JSON is invalid', retryable: true }
+                };
+            }
+            return { ok: true, value: parsed };
         }
     };
 }
-export { classifyGitHubFailure, createGitHubClient, MINIMUM_GITHUB_CLI_VERSION };
+export { classifyGitHubFailure, createGitHubClient, MINIMUM_GITHUB_CLI_VERSION, parseIncludedResponse };
 //# sourceMappingURL=github-client.js.map