@fitlab-ai/agent-infra 0.9.6 → 0.9.8

package/lib/internal/task-lifecycle.ts

@@ -1,14 +1,16 @@
 import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
+import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
 import { applyTaskLifecycle, lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import type { TaskLifecycleRequest } from '../task/lifecycle.ts';
-import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 
-const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\n`;
+const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
 const FLAGS: Record<string, string> = {
   '--agent': 'agent', '--reason': 'reason', '--unblock-condition': 'unblockCondition',
   '--note': 'note', '--alert-number': 'alertNumber', '--staging-dir': 'stagingDir',
-  '--issue-number': 'issueNumber'
+  '--issue-number': 'issueNumber', '--override-ticket': 'overrideTicket',
+  '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 
 function usageFailure(message: string): void {
@@ -39,19 +41,61 @@ function taskLifecycle(args: string[] = []): void {
   const agent = normalizeAgentToken(String(values.agent ?? ''));
   if (!agent) { usageFailure(`invalid --agent '${values.agent}': ${AGENT_USAGE_HINT}`); return; }
   values.agent = agent;
-  const resolved = resolveTaskRef(String(values.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;
+  const dryRunConflict = overrideDryRunConflict(values);
+  if (dryRunConflict) { usageFailure(dryRunConflict.message); return; }
+  let repoRoot: string;
+  let taskId: string;
+  if (values.intent === 'restore') {
+    // restore's precondition is that the task does NOT exist locally yet (it only lives
+    // in a staging dir), so resolveTaskRef's existence check is inapplicable here; identity
+    // is guaranteed by applyTaskLifecycle's own full-TASK-id check plus staging validation.
+    try {
+      repoRoot = detectRepoRoot();
+    } catch (error) {
+      process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'REPO_ROOT_NOT_FOUND', message: error instanceof Error ? error.message : String(error) } })}\n`);
+      process.exitCode = 1;
+      return;
+    }
+    taskId = String(values.taskRef);
+  } else {
+    const resolved = resolveTaskRef(String(values.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;
+    }
+    repoRoot = resolved.repoRoot;
+    taskId = resolved.taskId;
   }
-  let result: ReturnType<typeof applyTaskLifecycle>;
+  let result: ReturnType<typeof applyTaskLifecycle> & { humanOverride?: unknown };
   try {
     result = withTaskExecutionLock(
-      resolved.repoRoot,
-      resolved.taskId,
+      repoRoot,
+      taskId,
       `task-lifecycle.${String(values.intent)}`,
-      () => applyTaskLifecycle(values as TaskLifecycleRequest)
+      () => {
+        const lifecycleResult = applyTaskLifecycle(values as TaskLifecycleRequest);
+        if (lifecycleResult.status !== 'failed' || !values.overrideTicket) return lifecycleResult;
+        if (!values.overrideTarget || !values.overrideScope) {
+          return {
+            ...lifecycleResult,
+            error: { code: 'OVERRIDE_PAYLOAD_INVALID', message: 'override ticket requires --override-target and --override-scope' }
+          };
+        }
+        const override = consumeHumanOverride({
+          taskRef: String(values.taskRef),
+          ticketId: String(values.overrideTicket),
+          failureId: failureId('lifecycle.apply', lifecycleResult.error?.code ?? 'LIFECYCLE_FAILED'),
+          target: String(values.overrideTarget),
+          scope: String(values.overrideScope),
+          intent: String(values.intent) as TaskLifecycleRequest['intent'],
+          ...(values.alertNumber ? { alertNumber: Number(values.alertNumber) } : {}),
+          ...(values.issueNumber ? { issueNumber: Number(values.issueNumber) } : {}),
+          ...(values.stagingDir ? { stagingDir: String(values.stagingDir) } : {})
+        });
+        if (override.status === 'failed') return { ...lifecycleResult, humanOverride: override };
+        return { ...lifecycleResult, ...override, humanOverride: override, error: null };
+      }
     );
   } catch (error) {
     if (!(error instanceof TaskExecutionLockError)) throw error;

package/lib/internal/task-orchestration.ts

@@ -4,12 +4,15 @@ import {
   activateMatchingOrchestrationDelegation,
   activateOrchestrationDelegation,
   advanceOrchestration,
+  awaitOrchestrationDelegationActivation,
   beginCommitIntent,
   beginOrResumeOrchestration,
   checkpointCommitIntent,
   completeCommitIntent,
+  dispatchOrchestrationDelegation,
   pauseOrchestration,
   recoverCommitIntent,
+  recoverPreparedOrchestrationDelegation,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealOrchestrationDelegation,
@@ -22,7 +25,7 @@ import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration
 import { isAgentClientId } from '../agent-clients/types.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
 
-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: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -44,7 +47,8 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
   }
   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}'`);
@@ -64,7 +68,9 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
     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',
@@ -215,17 +221,38 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
     result = await prepareCodexOrchestrationDelegation(taskRef!, {
       client: values['--client'] as AgentClientId,
       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'] as Parameters<typeof awaitOrchestrationDelegationActivation>[1]['stage'],
+      round,
+      artifact: values['--artifact']!,
+      role: values['--role'] as 'executor' | 'reviewer'
+    }, 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}'`); return; }
     const event = {
       nativeAgent: values['--native-agent']!, childId: values['--child-id']!,
-      parentId: values['--parent-id']!, spawnMode: values['--spawn-mode']!,
+      parentId: values['--parent-id']!, spawnMode: values['--spawn-mode'],
       actualModel: values['--actual-model'],
       actualReasoningEffort: values['--actual-reasoning-effort'],
       modelFallbackReason: values['--model-fallback-reason'],
@@ -239,7 +266,11 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
       const missing = requireValues(['--client', '--native-agent', '--child-id']);
       if (missing) { usageFailure(`intent 'hook-stop' requires '${missing}'`); return; }
       result = sealMatchingOrchestrationDelegation(values['--client'] as AgentClientId, {
-        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 {
       const missing = requireValues(['--child-id', '--exit-code', '--after-fingerprint']);
@@ -249,7 +280,11 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
       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);
     }
   } else if (intent === 'advance') {

package/lib/internal/task-override.ts

@@ -0,0 +1,138 @@
+import {
+  consumeHumanOverride,
+  diagnoseHumanOverrideForTask,
+  issueHumanOverride
+} from '../task/human-override.ts';
+import type { ConsumeHumanOverrideRequest, HumanOverrideRequest } from '../task/human-override.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
+
+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: Record<string, string> = {
+  '--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: string): void {
+  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: string[] = []): void {
+  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: Record<string, unknown> = { taskRef };
+  const seen = new Set<string>();
+  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: Record<string, string[]> = {
+    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) as HumanOverrideRequest['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) } : {})
+        } satisfies HumanOverrideRequest)
+      );
+    } 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) as ConsumeHumanOverrideRequest['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 as string[] } : {})
+        } satisfies ConsumeHumanOverrideRequest)
+      );
+    }
+  } 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 };

package/lib/internal/task-review.ts

@@ -1,6 +1,9 @@
 import { finalizeReviewSummary } from '../task/review-finalization.ts';
+import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-review <task-ref> finalize-summary --stage <analysis|plan|code> --artifact <review-*.md> [--orchestrated] [--dry-run]\n';
+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: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -30,10 +33,13 @@ function taskReview(args: string[] = []): void {
   let artifact = '';
   let dryRun = false;
   let orchestrated = false;
+  let overrideTicket = '';
+  let overrideTarget = '';
+  let overrideScope = '';
   const seen = new Set<string>();
   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;
     }
@@ -56,15 +62,54 @@ function taskReview(args: string[] = []): void {
       return;
     }
     if (flag === '--stage') stage = value;
-    else artifact = value;
+    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') process.exitCode = 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: unknown = 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 as { status?: unknown }).status === 'failed'
+  );
+  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
 }
 
 export { taskReview };

package/lib/internal/task-verify.ts

@@ -1,6 +1,9 @@
 import { renderTaskVerification, verifyTaskEvent } from '../task/verification.ts';
+import { consumeHumanOverride, failureId } from '../task/human-override.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 
-const USAGE = 'Usage: agent-infra-internal task-verify <N | TASK-id> <verification-event> [--artifact <canonical.md>] [--format json|text]\n';
+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: string): void {
   process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'VERIFY_PAYLOAD_INVALID', message } })}\n`);
@@ -11,21 +14,67 @@ function fail(message: string): void {
 function taskVerify(args: string[] = []): void {
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   if (!args[0] || !args[1] || args[0].startsWith('--') || args[1].startsWith('--')) { fail('task ref and verification event are required'); return; }
+  const taskRef = args[0];
+  const event = args[1];
   let artifact: string | undefined;
   let format: 'json' | 'text' = 'json';
+  let overrideTicket: string | undefined;
+  let overrideTarget: string | undefined;
+  let overrideScope: string | undefined;
   const seen = new Set<string>();
   for (let index = 2; index < args.length; index += 1) {
     const flag = args[index]!;
-    if (flag !== '--artifact' && flag !== '--format') { fail(`unknown option '${flag}'`); return; }
+    if (!['--artifact', '--format', '--override-ticket', '--override-target', '--override-scope'].includes(flag)) { fail(`unknown option '${flag}'`); return; }
     if (seen.has(flag)) { fail(`duplicate option '${flag}'`); return; }
     const value = args[++index];
     if (!value || value.startsWith('--')) { fail(`option '${flag}' requires a value`); return; }
     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 { fail("option '--format' requires 'json' or 'text'"); 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: unknown = 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 } as typeof result;
   process.stdout.write(format === 'text' ? renderTaskVerification(result) : `${JSON.stringify(result)}\n`);
   process.exitCode = result.status === 'pass' ? 0 : result.status === 'blocked' ? 2 : 1;
 }

package/lib/internal/task-warning.ts

@@ -1,10 +1,14 @@
 import { applyWorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
 import type { WorkflowWarningIntent } from '../task/workflow-warning-intents.ts';
+import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task/human-override.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
 
 const USAGE = `Usage: agent-infra-internal task-warning <task-ref> <add|set-status|list> [intent flags] [--dry-run]\n`;
 const FLAGS: Record<string, string> = {
   '--step': 'step', '--severity': 'severity', '--code': 'code', '--target': 'target',
   '--message': 'message', '--action': 'action', '--id': 'id', '--status': 'status', '--resolution': 'resolution'
+  , '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 
 function usageFailure(message: string): void {
@@ -38,13 +42,50 @@ function taskWarning(args: string[] = []): void {
   };
   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) { usageFailure(`${kind} does not accept '${unexpected}'`); return; }
   if (missing) { usageFailure(`${kind} requires '${missing}'`); return; }
-  const result = applyWorkflowWarningIntent(values as WorkflowWarningIntent);
-  process.stdout.write(`${JSON.stringify(result)}\n`);
-  if (result.status === 'failed') process.exitCode = 1;
+  const dryRunConflict = overrideDryRunConflict(values);
+  if (dryRunConflict) { usageFailure(dryRunConflict.message); return; }
+  const resolved = resolveTaskRef(taskRef);
+  if (!resolved.ok) { usageFailure(resolved.message); return; }
+  let result;
+  let humanOverride: unknown = null;
+  try {
+    result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, `task-warning.${kind}`, () => {
+      let current = applyWorkflowWarningIntent(values as WorkflowWarningIntent);
+      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 as WorkflowWarningIntent, { 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 as { status?: unknown }).status === 'failed'
+  );
+  if (result.status === 'failed' || overrideFailed) process.exitCode = 1;
 }
 
 export { taskWarning };

package/lib/platform/context.ts

@@ -20,6 +20,8 @@ type ContextOptions = {
   platformType?: string;
 };
 
+const CURRENT_USER_QUERY = 'query { viewer { login } }';
+
 function findRepoRoot(cwd: string): string {
   try {
     return execFileSync('git', ['rev-parse', '--show-toplevel'], {
@@ -105,16 +107,17 @@ function resolveGitHubContext(options: ContextOptions & { cwd: string }): Platfo
       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 as { login?: string } | null;
+  const userValue = user.value as { data?: { viewer?: { login?: string } } } | null;
+  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 as { permissions?: Record<string, boolean> } | null;
   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)
@@ -122,7 +125,7 @@ function resolveGitHubContext(options: ContextOptions & { cwd: string }): Platfo
   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 }]