@fitlab-ai/agent-infra 0.9.8 → 0.9.9

package/lib/internal/task-finalization.ts

@@ -0,0 +1,68 @@
+import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
+import { applyTaskFinalization } from '../task/finalization.ts';
+import { detectRepoRoot, resolveTaskRef } from '../task/resolve-ref.ts';
+import { verifyTaskEvent } from '../task/verification.ts';
+
+const USAGE = 'Usage: agent-infra-internal task-finalization <N | TASK-id> complete --agent <agent>\n';
+
+type FinalizationError = Readonly<{ code: string; message: string; retryable: boolean }>;
+
+function envelope(
+  status: 'completed' | 'failed' | 'blocked' | 'unknown',
+  changed: boolean,
+  accepted: boolean,
+  result: ReturnType<typeof applyTaskFinalization> | null,
+  error: FinalizationError | null
+): string {
+  return `${JSON.stringify({ version: 1, status, changed, accepted, result, error })}\n`;
+}
+
+function exitCode(status: 'completed' | 'failed' | 'blocked' | 'unknown'): number {
+  return status === 'completed' ? 0 : status === 'blocked' ? 2 : 1;
+}
+
+function fail(message: string): void {
+  const error = { code: 'TASK_FINALIZATION_PAYLOAD_INVALID', message, retryable: false };
+  process.stdout.write(envelope('failed', false, false, null, error));
+  process.stderr.write(USAGE);
+  process.exitCode = 1;
+}
+
+function taskFinalization(args: string[] = []): void {
+  if (args[0] === '--help' || args[0] === '-h') { process.stdout.write(USAGE); return; }
+  if (args.length !== 4 || !args[0] || args[1] !== 'complete' || args[2] !== '--agent' || !args[3]) {
+    fail('task ref, complete intent, and --agent are required');
+    return;
+  }
+  const agent = normalizeAgentToken(args[3]);
+  if (!agent) {
+    fail(`invalid --agent: ${AGENT_USAGE_HINT}`);
+    return;
+  }
+  let repoRoot: string;
+  try {
+    repoRoot = detectRepoRoot();
+  } catch (error) {
+    const detail = { code: 'REPO_ROOT_NOT_FOUND', message: error instanceof Error ? error.message : String(error), retryable: false };
+    process.stdout.write(envelope('failed', false, true, null, detail));
+    process.exitCode = 1;
+    return;
+  }
+  const resolved = resolveTaskRef(args[0], { repoRoot });
+  if (!resolved.ok) {
+    const detail = { code: resolved.code, message: resolved.message, retryable: false };
+    process.stdout.write(envelope('failed', false, true, null, detail));
+    process.exitCode = 1;
+    return;
+  }
+  const result = applyTaskFinalization(
+    { taskRef: resolved.taskId, intent: 'complete', agent },
+    { repoRoot, preflight: (request, options) => verifyTaskEvent(
+      { ...request, event: 'complete-task.hard-preflight' }, options
+    ) }
+  );
+  process.stdout.write(envelope(result.status, result.changed, true, result, result.error));
+  process.exitCode = exitCode(result.status);
+}
+
+export { taskFinalization };

package/lib/internal/task-orchestration.ts

@@ -1,31 +1,23 @@
-import { normalizeAgentToken, AGENT_USAGE_HINT } from '../agent-clients/tokens.ts';
 import {
-  abortCommitIntent,
   activateMatchingOrchestrationDelegation,
   activateOrchestrationDelegation,
   advanceOrchestration,
   awaitOrchestrationDelegationActivation,
-  beginCommitIntent,
   beginOrResumeOrchestration,
-  checkpointCommitIntent,
-  completeCommitIntent,
   dispatchOrchestrationDelegation,
+  OrchestrationStateError,
   pauseOrchestration,
-  recoverCommitIntent,
   recoverPreparedOrchestrationDelegation,
   routeOrchestration,
   sealMatchingOrchestrationDelegation,
   sealOrchestrationDelegation,
-  startCommitAttempt,
-  statusCommitIntent,
-  statusOrchestration,
-  terminateCommitAttempt
+  statusOrchestration
 } from '../task/orchestration.ts';
 import { prepareCodexOrchestrationDelegation } from '../task/codex-orchestration.ts';
 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|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: string): void {
   process.stdout.write(`${JSON.stringify({
@@ -48,23 +40,15 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
   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: Record<string, string> = {};
   const seen = new Set<string>();
-  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',
@@ -74,8 +58,7 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
       '--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;
@@ -92,26 +75,6 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
     }
     values[flag] = value;
   }
-  const commitIntentFlags: Record<string, readonly string[]> = {
-    '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: string[]) => flags.find((flag) => values[flag] === undefined);
   const coreOptions = values['--git-worktree-root'] === undefined
     ? {}
@@ -121,66 +84,8 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
     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}'`); 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'] as 'committed' | 'pushed',
-      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') {
+  try {
+  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']);
@@ -295,7 +200,19 @@ async function taskOrchestration(args: string[] = []): Promise<void> {
     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);
   }
-  process.stdout.write(`${JSON.stringify(result)}\n`);
+  } catch (error) {
+    if (!(error instanceof OrchestrationStateError)) throw error;
+    result = {
+      status: 'failed' as const,
+      changed: false,
+      taskId: error.taskId,
+      run: null,
+      next: null,
+      error: { code: error.code, message: error.message }
+    };
+  }
+  const output = result;
+  process.stdout.write(`${JSON.stringify(output)}\n`);
   if (result.status === 'failed') process.exitCode = 1;
 }
 

package/lib/platform/pr-summary.ts

@@ -11,12 +11,24 @@ import type { GitHubClient } from './github-client.ts';
 import { listRemoteComments, normalizeCommentContent, writeComment } from './issue-comments.ts';
 import { platformResult } from './types.ts';
 import type { PlatformResult } from './types.ts';
+import type { OperationWarning } from '../task/operation-outcome.ts';
 
 type SummaryComment = { id: number; body: string };
 type SummaryContextResult = PlatformResult & {
   task: { id: string | null; prNumber: number | null };
   artifacts: Array<{ family: string; name: string; path: string }>;
 };
+type PullRequestSummaryResult = PlatformResult & {
+  result: 'pr_created_with_warnings' | 'pr_reused_with_warnings' | 'no_op_with_warnings' | null;
+  warnings: readonly OperationWarning[];
+};
+type PullRequestPrimaryResult = 'pr_created' | 'pr_reused' | 'no_op';
+
+function warningResultForPrimary(primaryResult: PullRequestPrimaryResult): NonNullable<PullRequestSummaryResult['result']> {
+  if (primaryResult === 'pr_created') return 'pr_created_with_warnings';
+  if (primaryResult === 'pr_reused') return 'pr_reused_with_warnings';
+  return 'no_op_with_warnings';
+}
 
 function summaryMarker(taskId: string): string {
   return `<!-- sync-pr:${taskId}:summary -->`;
@@ -61,20 +73,50 @@ function summaryContext(taskRef: string, options: { cwd?: string; client?: GitHu
   return { ...platformResult('no-op'), task: { id: resolved.taskId, prNumber }, artifacts: canonicalArtifacts(resolved.taskDir) };
 }
 
-function syncPullRequestSummary(taskRef: string, options: { agent: string; body: string; cwd?: string; client?: GitHubClient; dryRun?: boolean }): PlatformResult {
+function syncPullRequestSummary(taskRef: string, options: { agent: string; body: string; cwd?: string; client?: GitHubClient; dryRun?: boolean; primaryResult: PullRequestPrimaryResult }): PullRequestSummaryResult {
+  const warningResult = warningResultForPrimary(options.primaryResult);
+  let knownPrNumber: number | null = null;
+  const softenFailure = (output: PlatformResult): PullRequestSummaryResult => {
+    const prNumber = output.resource.kind === 'pull-request' && output.resource.number
+      ? output.resource.number
+      : knownPrNumber;
+    const warning = output.error && prNumber
+      && output.error.code !== 'PR_NOT_LINKED'
+      ? {
+        code: output.error.code,
+        message: output.error.message,
+        retryable: output.error.retryable,
+        step: 'pr-summary',
+        target: `pull-request:${prNumber}`,
+        severity: 'ACTION_REQUIRED' as const
+      }
+      : null;
+    return warning
+      ? {
+        ...output,
+        status: 'applied',
+        changed: false,
+        resource: { kind: 'pull-request', number: prNumber },
+        error: null,
+        result: warningResult,
+        warnings: [warning]
+      }
+      : { ...output, result: null, warnings: [] };
+  };
   const resolved = resolveTaskRef(taskRef, options.cwd ? { repoRoot: options.cwd } : {});
-  if (!resolved.ok) return platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } });
+  if (!resolved.ok) return softenFailure(platformResult('failed', { error: { code: resolved.code, message: resolved.message, retryable: false } }));
   const frontmatter = parseTaskFrontmatter(fs.readFileSync(resolved.taskMdPath, 'utf8'));
   const prNumber = Number(frontmatter.pr_number);
-  if (!Number.isInteger(prNumber) || prNumber <= 0) return platformResult('failed', { error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false } });
+  if (!Number.isInteger(prNumber) || prNumber <= 0) return softenFailure(platformResult('failed', { error: { code: 'PR_NOT_LINKED', message: 'Task has no valid pr_number', retryable: false } }));
+  knownPrNumber = prNumber;
   const client = options.client || createGitHubClient();
   const context = resolvePlatformContext({ cwd: resolved.repoRoot, client });
-  if (!context.platform.repository || !['no-op', 'degraded'].includes(context.status)) return context;
+  if (!context.platform.repository || !['no-op', 'degraded'].includes(context.status)) return softenFailure(context);
   let headSha: string;
   try {
     headSha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: resolved.repoRoot, encoding: 'utf8' }).trim();
   } catch (error) {
-    return platformResult('failed', { platform: context.platform, capabilities: context.capabilities, error: { code: 'GIT_HEAD_UNRESOLVED', message: error instanceof Error ? error.message : String(error), retryable: false } });
+    return softenFailure(platformResult('failed', { platform: context.platform, capabilities: context.capabilities, error: { code: 'GIT_HEAD_UNRESOLVED', message: error instanceof Error ? error.message : String(error), retryable: false } }));
   }
   const desired = buildPullRequestSummary(
     resolved.taskId,
@@ -83,15 +125,17 @@ function syncPullRequestSummary(taskRef: string, options: { agent: string; body:
     renderHumanOverrideAudit(fs.readFileSync(resolved.taskMdPath, 'utf8'))
   );
   const listed = listRemoteComments(client, context.platform.repository, prNumber, resolved.repoRoot);
-  if (!listed.ok) return platformResult(listed.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: listed.error });
+  if (!listed.ok) return softenFailure(platformResult(listed.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: listed.error }));
   const reconciliation = reconcileSummaryComment(listed.value, resolved.taskId, desired);
-  if (reconciliation.action === 'conflict') return platformResult('failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: { code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple PR comments contain the summary marker', retryable: false } });
-  if (reconciliation.action === 'no-op') return platformResult('no-op', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: [reconciliation.commentId!], parts: 1 }, error: null });
-  if (options.dryRun) return platformResult('planned', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, operations: [{ name: `summary:${reconciliation.action}`, status: 'planned', reasonCode: null }], error: null });
+  if (reconciliation.action === 'conflict') return softenFailure(platformResult('failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: { code: 'PR_SUMMARY_MARKER_AMBIGUOUS', message: 'Multiple PR comments contain the summary marker', retryable: false } }));
+  if (reconciliation.action === 'no-op') return softenFailure(platformResult('no-op', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: [reconciliation.commentId!], parts: 1 }, error: null }));
+  if (options.dryRun) return softenFailure(platformResult('planned', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, operations: [{ name: `summary:${reconciliation.action}`, status: 'planned', reasonCode: null }], error: null }));
   const written = writeComment(client, context.platform.repository, prNumber, resolved.repoRoot, desired, reconciliation.commentId || undefined);
-  if (!written.ok) return platformResult(written.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: written.error });
+  if (!written.ok) return softenFailure(platformResult(written.error.retryable ? 'blocked' : 'failed', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, error: written.error }));
   const id = Number(written.value.id || reconciliation.commentId);
-  return platformResult('applied', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: Number.isInteger(id) ? [id] : [], parts: 1 }, operations: [{ name: `summary:${reconciliation.action}`, status: 'applied', reasonCode: null }], error: null });
+  return softenFailure(platformResult('applied', { platform: context.platform, capabilities: context.capabilities, resource: { kind: 'pull-request', number: prNumber }, comment: { kind: 'summary', marker: summaryMarker(resolved.taskId), ids: Number.isInteger(id) ? [id] : [], parts: 1 }, operations: [{ name: `summary:${reconciliation.action}`, status: 'applied', reasonCode: null }], error: null }));
 }
 
 export { buildPullRequestSummary, reconcileSummaryComment, summaryContext, summaryMarker, syncPullRequestSummary };
+export type { PullRequestSummaryResult, SummaryContextResult };
+export { warningResultForPrimary };