@fitlab-ai/agent-infra 0.9.12 → 0.9.14

package/lib/internal/task-finalization.ts

@@ -5,6 +5,7 @@ import {
 } from '../task/control-authority.ts';
 import { applyTaskFinalization } from '../task/finalization.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
 
@@ -14,7 +15,7 @@ function envelope(
   status: 'completed' | 'failed' | 'blocked' | 'unknown',
   changed: boolean,
   accepted: boolean,
-  result: ReturnType<typeof applyTaskFinalization> | null,
+  result: Awaited<ReturnType<typeof applyTaskFinalization>> | null,
   error: FinalizationError | null
 ): string {
   return `${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`;
@@ -36,7 +37,8 @@ function parseFailure(error: unknown): string {
   return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
 }
 
-function taskFinalization(args: string[] = []): void {
+async function taskFinalization(args: string[] = []): Promise<void> {
+  if (!ensureInternalHandlerRoute('task-finalization', args)) return;
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
 
   let operation;
@@ -46,7 +48,7 @@ function taskFinalization(args: string[] = []): void {
     fail(parseFailure(error));
     return;
   }
-  if (operation.family !== 'task-finalization') {
+  if (operation.family !== 'task-finalization' || !internalHandlerRoute('task-finalization', 'complete', args[1] ?? '')) {
     fail('finalization operation is invalid');
     return;
   }
@@ -71,7 +73,7 @@ function taskFinalization(args: string[] = []): void {
     ...operation,
     request: { ...operation.request, taskRef: resolved.taskId }
   };
-  const result = dispatchTaskControlOperation(
+  const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot }),
     boundOperation
   );

package/lib/internal/task-invalidation.ts

@@ -0,0 +1,41 @@
+import { reconcileTaskInvalidation } from '../task/invalidation-command.ts';
+import { resolveTaskRef } from '../task/resolve-ref.ts';
+import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
+
+const USAGE = 'Usage: agent-infra-internal task-invalidation <task-ref> reconcile [--max-targets <n>] [--dry-run]\n';
+
+function taskInvalidation(args: string[] = []): void {
+  if (!ensureInternalHandlerRoute('task-invalidation', args)) return;
+  if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
+  const taskRef = args[0];
+  if (!taskRef || !internalHandlerRoute('task-invalidation', 'reconcile', args[1] ?? '')) {
+    process.stdout.write(`${JSON.stringify({ status: 'failed', changed: false, error: { code: 'INVALIDATION_PAYLOAD_INVALID', message: 'task ref and reconcile are required' } })}\n`);
+    process.stderr.write(USAGE);
+    process.exitCode = 1;
+    return;
+  }
+  let maxTargets: number | undefined;
+  let dryRun = false;
+  for (let index = 2; index < args.length; index += 1) {
+    const flag = args[index]!;
+    if (flag === '--dry-run') { if (dryRun) { process.exitCode = 1; return; } dryRun = true; continue; }
+    if (flag !== '--max-targets') { process.exitCode = 1; return; }
+    const value = Number(args[++index]);
+    if (!Number.isInteger(value) || value < 1 || maxTargets !== undefined) { process.exitCode = 1; return; }
+    maxTargets = value;
+  }
+  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; }
+  try {
+    const result = withTaskExecutionLock(resolved.repoRoot, resolved.taskId, 'task-invalidation.reconcile', () => reconcileTaskInvalidation(taskRef, { ...(maxTargets === undefined ? {} : { maxTargets }), dryRun }));
+    process.stdout.write(`${JSON.stringify(result)}\n`);
+    if (result.status === 'failed') process.exitCode = 1;
+  } 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;
+  }
+}
+
+export { taskInvalidation };

package/lib/internal/task-ledger.ts

@@ -6,13 +6,16 @@ import { consumeHumanOverride, failureId, overrideDryRunConflict } from '../task
 import { LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, isReviewStage, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from '../task/ledger.ts';
 import { resolveTaskRef } from '../task/resolve-ref.ts';
 import { TaskExecutionLockError, withTaskExecutionLock } from '../task/task-execution-lock.ts';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
-const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, stage-status\n`;
+const USAGE = `Usage: agent-infra-internal task-ledger <task-ref> <intent> [intent flags] [--dry-run]\n\nIntents: finding-upsert, finding-respond, finding-review, decision-next-id, decision-upsert, rework-intent-upsert, stage-status\n`;
 const FLAGS: Record<string, string> = {
   '--stage': 'stage', '--review-artifact': 'reviewArtifact', '--ordinal': 'ordinal',
   '--severity': 'severity', '--evidence': 'evidence', '--id': 'id', '--round': 'round',
-  '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation'
-  , '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
+  '--status': 'status', '--artifact': 'artifact', '--needs-implementation': 'needsImplementation',
+  '--intent-id': 'intentId', '--finding-id': 'findingId', '--source-artifact': 'sourceArtifact',
+  '--source-sha256': 'sourceSha256', '--target': 'target',
+  '--override-ticket': 'overrideTicket', '--override-target': 'overrideTarget', '--override-scope': 'overrideScope'
 };
 const NUMERIC = new Set(['ordinal', 'round']);
 const BOOLEAN = new Set(['needsImplementation']);
@@ -23,11 +26,20 @@ function usageFailure(message: string): void {
   process.exitCode = 1;
 }
 
-function taskLedger(args: string[] = []): void {
+async function taskLedger(args: string[] = []): Promise<void> {
+  if (!ensureInternalHandlerRoute('task-ledger', args)) return;
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
   const [taskRef, kind] = args;
   if (!taskRef || !kind) { usageFailure('task ref and intent are required'); return; }
-  if (!['finding-upsert', 'finding-respond', 'finding-review', 'decision-next-id', 'decision-upsert', 'stage-status'].includes(kind)) {
+  if (![
+    internalHandlerRoute('task-ledger', 'finding-upsert', kind),
+    internalHandlerRoute('task-ledger', 'finding-respond', kind),
+    internalHandlerRoute('task-ledger', 'finding-review', kind),
+    internalHandlerRoute('task-ledger', 'decision-next-id', kind),
+    internalHandlerRoute('task-ledger', 'decision-upsert', kind),
+    internalHandlerRoute('task-ledger', 'rework-intent-upsert', kind),
+    internalHandlerRoute('task-ledger', 'stage-status', kind)
+  ].some(Boolean)) {
     usageFailure(`unknown ledger intent '${kind}'`); return;
   }
   const values: Record<string, unknown> = { kind, taskRef };
@@ -55,13 +67,14 @@ function taskLedger(args: string[] = []): void {
     'finding-review': ['id', 'status', 'evidence'],
     'decision-next-id': [],
     'decision-upsert': ['id', 'stage', 'artifact'],
+    'rework-intent-upsert': ['intentId', 'findingId', 'sourceArtifact', 'sourceSha256', 'target'],
     'stage-status': ['stage']
   };
   const optional: Record<string, string[]> = {
     'finding-review': ['needsImplementation'],
     'decision-upsert': ['needsImplementation']
   };
-  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id'
+  const overrideFields = kind === 'stage-status' || kind === 'decision-next-id' || kind === 'rework-intent-upsert'
     ? []
     : ['overrideTicket', 'overrideTarget', 'overrideScope'];
   const allowed = new Set(['kind', 'taskRef', 'dryRun', ...required[kind]!, ...(optional[kind] ?? []), ...overrideFields]);
@@ -106,11 +119,11 @@ function taskLedger(args: string[] = []): void {
   let result;
   let humanOverride: unknown = null;
   try {
-    result = withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, () => {
+    result = await withTaskExecutionLock(lockResolved.repoRoot, lockResolved.taskId, `task-ledger.${kind}`, async () => {
       let current = applyLedgerIntent(values as LedgerIntent);
       if (current.status !== 'failed' || !values.overrideTicket) return current;
       if (!values.overrideTarget || !values.overrideScope) { usageFailure('override ticket requires target and scope'); return current; }
-      const consumed = consumeHumanOverride({
+      const consumed = await consumeHumanOverride({
         taskRef,
         ticketId: String(values.overrideTicket),
         failureId: failureId('ledger-intent', current.error?.code ?? 'TASK_STATE_MISMATCH'),

package/lib/internal/task-lifecycle.ts

@@ -7,6 +7,7 @@ import {
 import { lifecycleIntentCatalog } from '../task/lifecycle.ts';
 import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
 import type { TaskLifecycleResult } from '../task/lifecycle.ts';
+import { ensureInternalHandlerRoute, internalHandlerRoute } from './cli-route-inventory.ts';
 
 const USAGE = `Usage: agent-infra-internal task-lifecycle <N | TASK-id> <intent> --agent <agent> [intent flags] [--dry-run]\n\nIntents: ${lifecycleIntentCatalog.join(', ')}\nOverride: --override-ticket <ticket> --override-target <target> --override-scope <scope>\n`;
 
@@ -21,7 +22,8 @@ function parseFailure(error: unknown): string {
   return message.replace(/^TASK_CONTROL_OPERATION_INVALID: /u, '');
 }
 
-function taskLifecycle(args: string[] = []): void {
+async function taskLifecycle(args: string[] = []): Promise<void> {
+  if (!ensureInternalHandlerRoute('task-lifecycle', args)) return;
   if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
 
   let operation;
@@ -31,7 +33,7 @@ function taskLifecycle(args: string[] = []): void {
     usageFailure(parseFailure(error));
     return;
   }
-  if (operation.family !== 'task-lifecycle') {
+  if (operation.family !== 'task-lifecycle' || !internalHandlerRoute('task-lifecycle', 'intent', args[1] ? 'intent' : '')) {
     usageFailure('lifecycle operation is invalid');
     return;
   }
@@ -56,7 +58,7 @@ function taskLifecycle(args: string[] = []): void {
     repoRoot = resolved.repoRoot;
   }
 
-  const result = dispatchTaskControlOperation(
+  const result = await dispatchTaskControlOperation(
     createDirectHostExecutionContext({ repoRoot }),
     operation
   ) as TaskLifecycleResult & { humanOverride?: unknown };