@osolmaz/pi-workflows 0.11.2 → 0.12.0

package/src/builtins/autoimplement.workflow.ts

@@ -1,19 +1,32 @@
 import path from "node:path";
 import {
+  runCommandBatch,
+  type CommandBatchItem,
+  type CommandBatchResult,
+} from "../workflows/command-batch.js";
+import {
+  action,
   agent,
   compute,
   defineWorkflow,
   includeWorkflow,
   includedResult,
-  shell,
 } from "../workflows/definition.js";
 import { digest } from "../workflows/human-decision.js";
-import type {
-  ShellActionExecution,
-  ShellActionResult,
-  WorkflowNodeContext,
-} from "../workflows/types.js";
+import type { WorkflowActionContext, WorkflowNodeContext } from "../workflows/types.js";
 import autodocWorkflow, { type AutodocInput } from "./autodoc.workflow.js";
+import {
+  parseAutoimplementConcurrency,
+  parseCiInspectionBatch,
+  parsePublishedRepositories,
+  parseVerificationCommandPlan,
+  reviewerCommand,
+  type AutoimplementConcurrency,
+  type CiInspectionBatch,
+  type PublishedRepositories,
+  type PublishedRepository,
+  type VerificationCommandPlan,
+} from "./autoimplement-command-batches.js";
 import autoplanWorkflow, { type AutoplanInput } from "./autoplan.workflow.js";
 import planApprovalWorkflow, { type PlanApprovalInput } from "./plan-approval.workflow.js";
 
@@ -35,6 +48,7 @@ export type AutoimplementInput = {
     audience: string;
     maxReplans: number;
   };
+  concurrency?: Partial<AutoimplementConcurrency>;
 };
 
 export type ExistingPlanDiscovery = {
@@ -46,19 +60,26 @@ export type ExistingPlanDiscovery = {
   evidence: unknown;
 };
 
-type StructuredCommand = {
-  command: string;
-  args: string[];
-  cwd: string;
-  timeoutMs: number;
-};
-
 type ReviewFinding = {
   severity: "P0" | "P1" | "P2" | "lower";
   kind: "design" | "implementation";
   summary: string;
 };
 
+type RepositoryReviewAssessment = {
+  id: string;
+  repository: string;
+  baseBranch: string;
+  headRevision: string;
+  dependencyFingerprint?: string;
+  invocationSucceeded: boolean;
+  p0: ReviewFinding[];
+  p1: ReviewFinding[];
+  p2: ReviewFinding[];
+  lower: ReviewFinding[];
+  reason: string;
+};
+
 type ReviewAssessment = {
   route: "critical" | "p2" | "clean" | "command_error";
   invocationSucceeded: boolean;
@@ -67,6 +88,7 @@ type ReviewAssessment = {
   p2: ReviewFinding[];
   lower: ReviewFinding[];
   reason: string;
+  repositories?: RepositoryReviewAssessment[];
 };
 
 export type AutoimplementCompleted = {
@@ -98,11 +120,49 @@ type BlockerChallenge = {
   evidence: string[];
 };
 
-const FIVE_MINUTES_MS = 5 * 60_000;
-const TEN_MINUTES_MS = 10 * 60_000;
 const MAX_BLOCKER_CHALLENGES = 3;
 const MAX_CHALLENGE_ITEMS = 5;
 const MAX_CHALLENGE_TEXT = 500;
+const MAX_TIMEOUT_FALLBACKS = 3;
+const MAX_TIMEOUT_FALLBACK_EVIDENCE = 8;
+const TIMEOUT_FALLBACK_SOURCES = [
+  "implement",
+  "planVerification",
+  "verify",
+  "fix",
+  "publish",
+  "addressP2",
+  "verifyP2",
+  "inspectComments",
+  "inspectCi",
+  "opportunisticTest",
+  "finalizeDelivery",
+] as const;
+
+const WORK_ATTEMPT_NODES = ["implement", "fix", "addressP2"] as const;
+
+type TimeoutFallbackSource = (typeof TIMEOUT_FALLBACK_SOURCES)[number];
+type TimeoutFallbackRoute = "retry" | "verify" | "review" | "ci" | "deliver" | "replan" | "blocked";
+
+const TIMEOUT_FALLBACK_ROUTES: Record<TimeoutFallbackSource, readonly TimeoutFallbackRoute[]> = {
+  implement: ["retry", "replan", "blocked"],
+  planVerification: ["retry", "verify", "replan", "blocked"],
+  verify: ["retry", "verify", "replan", "blocked"],
+  fix: ["retry", "replan", "blocked"],
+  publish: ["retry", "replan", "blocked"],
+  addressP2: ["retry", "replan", "blocked"],
+  verifyP2: ["retry", "replan", "blocked"],
+  inspectComments: ["retry", "review", "ci", "replan", "blocked"],
+  inspectCi: ["retry", "ci", "deliver", "replan", "blocked"],
+  opportunisticTest: ["retry", "ci", "deliver", "replan", "blocked"],
+  finalizeDelivery: ["retry", "deliver", "replan", "blocked"],
+};
+
+type TimeoutFallbackResult = {
+  route: TimeoutFallbackRoute;
+  reason: string;
+  evidence: string[];
+};
 
 function requireRecord(value: unknown, label: string): Record<string, unknown> {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
@@ -118,6 +178,13 @@ function requireString(value: unknown, label: string): string {
   return value.trim();
 }
 
+function requireStringArray(value: unknown, label: string): string[] {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+    throw new Error(`${label} must be an array of strings`);
+  }
+  return [...value] as string[];
+}
+
 function boundedChallengeItems(value: unknown, label: string): string[] {
   if (!Array.isArray(value) || value.length > MAX_CHALLENGE_ITEMS) {
     throw new Error(`${label} must be an array with at most ${MAX_CHALLENGE_ITEMS} items`);
@@ -131,6 +198,170 @@ function boundedChallengeItems(value: unknown, label: string): string[] {
   });
 }
 
+function isTimeoutFallbackSource(nodeId: string): nodeId is TimeoutFallbackSource {
+  return (TIMEOUT_FALLBACK_SOURCES as readonly string[]).includes(nodeId);
+}
+
+function latestTimedOutStep(context: WorkflowNodeContext) {
+  for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
+    const step = context.state.steps[index];
+    if (step?.outcome === "timed_out" && isTimeoutFallbackSource(step.nodeId)) return step;
+  }
+  throw new Error("No supported timed-out Autoimplement step is available");
+}
+
+function latestStepIndex(
+  context: WorkflowNodeContext,
+  predicate: (step: WorkflowNodeContext["state"]["steps"][number]) => boolean,
+): number {
+  for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
+    const step = context.state.steps[index];
+    if (step && predicate(step)) return index;
+  }
+  return -1;
+}
+
+function latestWorkAttemptIndex(context: WorkflowNodeContext): number {
+  return latestStepIndex(context, (step) =>
+    (WORK_ATTEMPT_NODES as readonly string[]).includes(step.nodeId),
+  );
+}
+
+function hasCurrentAcceptedWork(context: WorkflowNodeContext): boolean {
+  const index = latestWorkAttemptIndex(context);
+  return index >= 0 && context.state.steps[index]?.outcome === "ok";
+}
+
+function hasCurrentPublication(context: WorkflowNodeContext): boolean {
+  const workIndex = latestWorkAttemptIndex(context);
+  const publicationIndex = latestStepIndex(context, (step) => {
+    if (step.outcome !== "ok") return false;
+    if (step.nodeId === "publish") return true;
+    if (step.nodeId !== "verifyP2") return false;
+    const output = step.output as { passed?: unknown } | null;
+    return output?.passed === true;
+  });
+  return publicationIndex > workIndex;
+}
+
+function parseTimeoutFallback(value: unknown, context: WorkflowNodeContext): TimeoutFallbackResult {
+  const result = requireRecord(value, "timeout fallback");
+  const routes: TimeoutFallbackRoute[] = [
+    "retry",
+    "verify",
+    "review",
+    "ci",
+    "deliver",
+    "replan",
+    "blocked",
+  ];
+  if (!routes.includes(result.route as TimeoutFallbackRoute)) {
+    throw new Error(`timeout fallback route must be one of ${routes.join(", ")}`);
+  }
+  const route = result.route as TimeoutFallbackRoute;
+  const reason = requireString(result.reason, "timeout fallback reason");
+  const evidence = requireStringArray(result.evidence, "timeout fallback evidence").map(
+    (item, index) => requireString(item, `timeout fallback evidence[${index}]`),
+  );
+  if (evidence.length === 0 || evidence.length > MAX_TIMEOUT_FALLBACK_EVIDENCE) {
+    throw new Error(
+      `timeout fallback evidence must contain 1 through ${MAX_TIMEOUT_FALLBACK_EVIDENCE} items`,
+    );
+  }
+
+  const timedOut = latestTimedOutStep(context);
+  const source = timedOut.nodeId as TimeoutFallbackSource;
+  if (!TIMEOUT_FALLBACK_ROUTES[source].includes(route)) {
+    throw new Error(`timeout fallback route ${route} is not safe after timed-out ${source}`);
+  }
+  if (route === "verify" && !hasCurrentAcceptedWork(context)) {
+    throw new Error("timeout fallback cannot route to verification without current accepted work");
+  }
+  if (["review", "ci", "deliver"].includes(route) && !hasCurrentPublication(context)) {
+    throw new Error(
+      "timeout fallback cannot move past publication without a current published head",
+    );
+  }
+  if (route === "ci") {
+    const comments = context.outputs.inspectComments as { route?: unknown } | undefined;
+    if (comments?.route !== "ci") {
+      throw new Error("timeout fallback cannot route to CI before comment inspection completed");
+    }
+  }
+  if (route === "deliver") {
+    const ci = (context.outputs.assessTrackedCi ?? context.outputs.inspectCi) as
+      | { route?: unknown }
+      | undefined;
+    const classification = context.outputs.classifyCi as { route?: unknown } | undefined;
+    if (ci?.route !== "green" && classification?.route !== "unrelated") {
+      throw new Error("timeout fallback cannot route to delivery before CI is ready");
+    }
+  }
+
+  return { route, reason, evidence };
+}
+
+function timeoutFallbackTarget(context: WorkflowNodeContext): { route: string } {
+  const fallback = context.outputs.timeoutFallback as TimeoutFallbackResult;
+  if (fallback.route !== "retry") {
+    const routes: Record<Exclude<TimeoutFallbackRoute, "retry">, string> = {
+      verify: "planVerification",
+      review: "selectReviewCommands",
+      ci: "inspectCi",
+      deliver: "finalizeDelivery",
+      replan: "redesign",
+      blocked: "blocked",
+    };
+    return { route: routes[fallback.route] };
+  }
+  return { route: latestTimedOutStep(context).nodeId };
+}
+
+function timeoutFallbackGuard(context: WorkflowNodeContext) {
+  const timeout = latestTimedOutStep(context);
+  const attempts = context.state.steps.filter(
+    (step) => step.nodeId === "timeoutFallback" && step.outcome === "ok",
+  ).length;
+  if (attempts >= MAX_TIMEOUT_FALLBACKS) {
+    const timeouts = context.state.steps
+      .filter((step) => step.outcome === "timed_out" && isTimeoutFallbackSource(step.nodeId))
+      .map((step) => ({
+        nodeId: step.nodeId,
+        attemptId: step.attemptId,
+        error: step.error,
+      }));
+    return {
+      route: "blocked",
+      reason: `Autoimplement reached the ${MAX_TIMEOUT_FALLBACKS}-fallback timeout safety limit.`,
+      evidence: {
+        attempts,
+        limit: MAX_TIMEOUT_FALLBACKS,
+        timeouts,
+      },
+    };
+  }
+  return {
+    route: "recover",
+    attempt: attempts + 1,
+    limit: MAX_TIMEOUT_FALLBACKS,
+    timeout: {
+      nodeId: timeout.nodeId,
+      attemptId: timeout.attemptId,
+      error: timeout.error,
+    },
+  };
+}
+
+function throwLatestSupportedFailure(context: WorkflowNodeContext): never {
+  for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
+    const step = context.state.steps[index];
+    if (step?.outcome === "failed" && isTimeoutFallbackSource(step.nodeId)) {
+      throw new Error(step.error ?? `Autoimplement node failed: ${step.nodeId}`);
+    }
+  }
+  throw new Error("No supported failed Autoimplement step is available");
+}
+
 function parseBlockerChallenge(value: unknown): BlockerChallenge {
   const result = requireRecord(value, "blocker challenge");
   if (result.route !== "continue" && result.route !== "blocked") {
@@ -233,6 +464,7 @@ function parseInput(value: unknown): AutoimplementInput {
       documents: [...raw.documents] as string[],
     };
   }
+  const concurrency = parseAutoimplementConcurrency(input.concurrency);
   let approval: AutoimplementInput["approval"];
   if (input.approval !== undefined) {
     const raw = requireRecord(input.approval, "autoimplement approval");
@@ -264,6 +496,7 @@ function parseInput(value: unknown): AutoimplementInput {
     ...(documents !== undefined ? { documents: [...documents] as string[] } : {}),
     ...(documentation !== undefined ? { documentation } : {}),
     ...(approval !== undefined ? { approval } : {}),
+    concurrency,
   };
 }
 
@@ -312,70 +545,71 @@ function parseRoute<T extends string>(
   return { ...record, route: record.route as T };
 }
 
-function parseCommand(
-  value: unknown,
-  options: {
-    command: string;
-    maxTimeoutMs: number;
-    validateArgs: (args: string[]) => boolean;
-    label: string;
-  },
-): StructuredCommand {
-  const command = requireRecord(value, options.label);
-  if (command.command !== options.command) {
-    throw new Error(`${options.label} command must be ${options.command}`);
-  }
-  if (!Array.isArray(command.args) || command.args.some((arg) => typeof arg !== "string")) {
-    throw new Error(`${options.label} args must be an array of strings`);
-  }
-  const args = [...command.args] as string[];
-  if (!options.validateArgs(args)) throw new Error(`${options.label} args are not allowed`);
-  const cwd = requireString(command.cwd, `${options.label} cwd`);
-  if (!path.isAbsolute(cwd)) throw new Error(`${options.label} cwd must be absolute`);
-  const timeoutMs = command.timeoutMs;
-  if (
-    typeof timeoutMs !== "number" ||
-    !Number.isInteger(timeoutMs) ||
-    timeoutMs <= 0 ||
-    timeoutMs > options.maxTimeoutMs
-  ) {
-    throw new Error(`${options.label} timeoutMs must be at most ${options.maxTimeoutMs}`);
-  }
-  return { command: options.command, args, cwd, timeoutMs };
+type ReviewCommandSelection = {
+  route: "run" | "reuse";
+  repositories: PublishedRepository[];
+  commands: CommandBatchItem[];
+};
+
+type BatchExecution = {
+  route: "assess" | "repair";
+  batch: CommandBatchResult;
+};
+
+function concurrency(context: WorkflowNodeContext): AutoimplementConcurrency {
+  return parseAutoimplementConcurrency((context.input as AutoimplementInput).concurrency);
 }
 
-function parseReviewerCommand(value: unknown): StructuredCommand {
-  return parseCommand(value, {
-    command: "pi-reviewer",
-    maxTimeoutMs: TEN_MINUTES_MS,
-    label: "reviewer command",
-    validateArgs: (args) => {
-      const base = args.indexOf("--base");
-      return base >= 0 && typeof args[base + 1] === "string" && args[base + 1]!.length > 0;
+async function runAutoimplementBatch(
+  context: WorkflowActionContext,
+  kind: "review" | "ciWatch" | "verification",
+  commands: CommandBatchItem[],
+  maxConcurrency: number,
+): Promise<CommandBatchResult> {
+  return await runCommandBatch(
+    { items: commands, maxConcurrency: Math.min(maxConcurrency, Math.max(1, commands.length)) },
+    {
+      signal: context.signal,
+      onItemSettled: async (result, completed, total) => {
+        if (context.signal.aborted) return;
+        try {
+          await context.publishUpdate({
+            type: "command-batch.item",
+            key: `${kind}/${result.id}`,
+            data: {
+              schema: "pi-workflows.command-batch-item.v1",
+              batchKind: kind,
+              itemId: result.id,
+              outcome: result.outcome,
+              completed,
+              total,
+            },
+          });
+        } catch (error) {
+          if (!context.signal.aborted) throw error;
+        }
+      },
     },
-  });
+  );
 }
 
-function parseCiCommand(value: unknown): StructuredCommand {
-  return parseCommand(value, {
-    command: "gh",
-    maxTimeoutMs: FIVE_MINUTES_MS,
-    label: "CI tracking command",
-    validateArgs: (args) =>
-      (args[0] === "pr" && args[1] === "checks" && args.includes("--watch")) ||
-      (args[0] === "run" && args[1] === "watch"),
-  });
+function commandBatchTimeoutMs(commands: CommandBatchItem[], maxConcurrency: number): number {
+  if (commands.length === 0) return 10_000;
+  const concurrency = Math.min(maxConcurrency, commands.length);
+  const waves = Math.ceil(commands.length / concurrency);
+  const longestItem = Math.max(...commands.map((command) => command.timeoutMs));
+  return waves * longestItem + 10_000;
 }
 
-function commandExecution(command: StructuredCommand): ShellActionExecution {
-  return {
-    command: command.command,
-    args: command.args,
-    cwd: command.cwd,
-    timeoutMs: command.timeoutMs,
-    allowNonZeroExit: true,
-    maxOutputChars: 1_000_000,
-  };
+function reviewBatchNeedsRepair(result: CommandBatchResult): boolean {
+  return result.items.some(
+    (item) =>
+      item.outcome === "timedOut" ||
+      item.outcome === "cancelled" ||
+      (item.outcome === "failed" && item.exitCode === null) ||
+      item.stdoutTruncated ||
+      item.stderrTruncated,
+  );
 }
 
 function latestOutput<T>(context: WorkflowNodeContext, nodeIds: string[]): T {
@@ -383,20 +617,10 @@ function latestOutput<T>(context: WorkflowNodeContext, nodeIds: string[]): T {
     const step = context.state.steps[index];
     if (step && nodeIds.includes(step.nodeId)) return step.output as T;
   }
-  throw new Error(`No output found for ${nodeIds.join(" or ")}`);
-}
-
-function latestCiCommand(context: WorkflowNodeContext): StructuredCommand {
-  for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
-    const step = context.state.steps[index];
-    if (!step) continue;
-    if (step.nodeId === "repairCiCommand") return step.output as StructuredCommand;
-    if (step.nodeId === "inspectCi") {
-      const output = step.output as { trackingCommand?: StructuredCommand };
-      if (output.trackingCommand !== undefined) return output.trackingCommand;
-    }
+  for (const nodeId of nodeIds) {
+    if (context.outputs[nodeId] !== undefined) return context.outputs[nodeId] as T;
   }
-  throw new Error("No CI tracking command is available");
+  throw new Error(`No output found for ${nodeIds.join(" or ")}`);
 }
 
 function currentPlan(context: WorkflowNodeContext): unknown {
@@ -444,6 +668,7 @@ function latestBlockerClaim(context: WorkflowNodeContext): unknown {
     "assessTrackedCi",
     "classifyCi",
     "finalizeDelivery",
+    "timeoutFallback",
   ];
   for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
     const step = context.state.steps[index];
@@ -480,6 +705,7 @@ function latestIssue(context: WorkflowNodeContext): unknown {
     "triageReview",
     "inspectComments",
     "classifyCi",
+    "timeoutFallback",
     "adoptPlan",
   ];
   for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
@@ -501,18 +727,356 @@ function parseFinding(value: unknown, severity: ReviewFinding["severity"]): Revi
   };
 }
 
-function parseReviewAssessment(value: unknown): ReviewAssessment {
-  const review = requireRecord(value, "review assessment");
-  const parseList = (key: "p0" | "p1" | "p2" | "lower", severity: ReviewFinding["severity"]) => {
-    const raw = review[key];
-    if (!Array.isArray(raw)) throw new Error(`review ${key} must be an array`);
-    return raw.map((item) => parseFinding(item, severity));
+function parseVerificationForContext(
+  value: unknown,
+  context: WorkflowNodeContext,
+): VerificationCommandPlan {
+  const plan = parseVerificationCommandPlan(value);
+  const implementation = latestOutput<Record<string, unknown>>(context, ["implement"]);
+  const reported = Array.isArray(implementation.repositories)
+    ? implementation.repositories.filter((entry): entry is string => typeof entry === "string")
+    : [];
+  const request = context.input as AutoimplementInput;
+  const roots = new Set(
+    (reported.length > 0 ? reported : [request.repository ?? process.cwd()]).map((entry) =>
+      path.resolve(entry),
+    ),
+  );
+  for (const command of plan.commands) {
+    const cwd = path.resolve(command.cwd);
+    if (!roots.delete(cwd)) {
+      throw new Error(
+        `verification command cwd was not reported by implementation: ${command.cwd}`,
+      );
+    }
+  }
+  if (roots.size > 0) {
+    throw new Error(`verification plan is missing reported repositories: ${[...roots].join(", ")}`);
+  }
+  return plan;
+}
+
+function currentPublishedRepositories(context: WorkflowNodeContext): PublishedRepositories {
+  return latestOutput<PublishedRepositories>(context, ["verifyP2", "publish"]);
+}
+
+type DeliveryRepositoryResult = {
+  repository: string;
+  pr: string;
+  merged: boolean;
+  reportComment: string;
+  reason: string;
+};
+
+function parseDeliveryRepository(value: unknown, index: number): DeliveryRepositoryResult {
+  const result = requireRecord(value, `delivery repositories[${index}]`);
+  const repository = requireString(result.repository, `delivery repositories[${index}].repository`);
+  if (!path.isAbsolute(repository)) {
+    throw new Error(`delivery repositories[${index}].repository must be absolute`);
+  }
+  if (typeof result.merged !== "boolean") {
+    throw new Error(`delivery repositories[${index}].merged must be a boolean`);
+  }
+  return {
+    repository: path.resolve(repository),
+    pr: requireString(result.pr, `delivery repositories[${index}].pr`),
+    merged: result.merged,
+    reportComment: requireString(
+      result.reportComment,
+      `delivery repositories[${index}].reportComment`,
+    ),
+    reason: requireString(result.reason, `delivery repositories[${index}].reason`),
+  };
+}
+
+function parseDeliveryResult(
+  value: unknown,
+  context: WorkflowNodeContext,
+): Record<string, unknown> {
+  const result = requireRecord(value, "delivery result");
+  if (result.status !== "completed" && result.status !== "blocked") {
+    throw new Error("delivery status must be completed or blocked");
+  }
+  const request = context.input as AutoimplementInput;
+  if (request.merge !== true && result.merged === true) {
+    throw new Error("delivery cannot merge without explicit merge: true");
+  }
+  if (result.status === "blocked") return result;
+  if (typeof result.merged !== "boolean") {
+    throw new Error("completed delivery merged must be a boolean");
+  }
+  const pr = requireString(result.pr, "completed delivery pr");
+  const reportComment = requireString(result.reportComment, "completed delivery reportComment");
+  const reason = requireString(result.reason, "completed delivery reason");
+  const published = currentPublishedRepositories(context).repositories;
+  let repositories: DeliveryRepositoryResult[];
+  if (result.repositories === undefined) {
+    if (published.length !== 1) {
+      throw new Error("completed delivery repositories must cover every published repository");
+    }
+    const only = published[0];
+    if (only === undefined) throw new Error("completed delivery has no published repository");
+    repositories = [
+      {
+        repository: path.resolve(only.repository),
+        pr,
+        merged: result.merged,
+        reportComment,
+        reason,
+      },
+    ];
+  } else {
+    if (!Array.isArray(result.repositories)) {
+      throw new Error("completed delivery repositories must be an array");
+    }
+    repositories = result.repositories.map(parseDeliveryRepository);
+  }
+  const actual = new Map<string, DeliveryRepositoryResult>();
+  for (const repository of repositories) {
+    if (actual.has(repository.repository)) {
+      throw new Error(`completed delivery repository is duplicated: ${repository.repository}`);
+    }
+    actual.set(repository.repository, repository);
+  }
+  const mergeExpected = request.merge === true;
+  for (const expected of published) {
+    const repository = actual.get(path.resolve(expected.repository));
+    if (repository === undefined || repository.pr !== expected.pr) {
+      throw new Error(
+        `completed delivery does not match published repository and PR: ${expected.repository}`,
+      );
+    }
+    if (repository.merged !== mergeExpected) {
+      throw new Error(
+        `completed delivery merge result does not match merge policy: ${expected.repository}`,
+      );
+    }
+    actual.delete(repository.repository);
+  }
+  if (actual.size > 0) {
+    throw new Error(
+      `completed delivery contains unpublished repositories: ${[...actual.keys()].join(", ")}`,
+    );
+  }
+  const firstPublished = published[0];
+  const first =
+    firstPublished === undefined
+      ? undefined
+      : repositories.find(
+          (repository) => repository.repository === path.resolve(firstPublished.repository),
+        );
+  if (
+    first === undefined ||
+    first.pr !== pr ||
+    first.merged !== result.merged ||
+    first.reportComment !== reportComment
+  ) {
+    throw new Error(
+      "completed delivery top-level compatibility fields must match the first result",
+    );
+  }
+  return { status: "completed", merged: result.merged, pr, reportComment, reason, repositories };
+}
+
+function parseP2Verification(
+  value: unknown,
+  context: WorkflowNodeContext,
+): Record<string, unknown> {
+  const result = requireRecord(value, "P2 verification");
+  if (typeof result.passed !== "boolean") {
+    throw new Error("P2 verification passed must be a boolean");
+  }
+  if (result.pushed !== true) {
+    throw new Error("P2 verification pushed must be true");
+  }
+  const refreshed = parsePublishedRepositories(result);
+  const previous = latestOutput<PublishedRepositories>(context, ["publish"]);
+  const expected = new Map(
+    previous.repositories.map((repository) => [repository.id, repository] as const),
+  );
+  for (const repository of refreshed.repositories) {
+    const prior = expected.get(repository.id);
+    if (
+      prior === undefined ||
+      prior.repository !== repository.repository ||
+      prior.branch !== repository.branch ||
+      prior.baseBranch !== repository.baseBranch ||
+      prior.pr !== repository.pr ||
+      prior.dependencyFingerprint !== repository.dependencyFingerprint
+    ) {
+      throw new Error(`P2 verification repository does not match publication: ${repository.id}`);
+    }
+    expected.delete(repository.id);
+  }
+  if (expected.size > 0) {
+    throw new Error(
+      `P2 verification is missing repository ids: ${[...expected.keys()].join(", ")}`,
+    );
+  }
+  return { ...result, repositories: refreshed.repositories };
+}
+
+function parseCiInspectionForPublished(
+  value: unknown,
+  context: WorkflowNodeContext,
+): CiInspectionBatch {
+  const inspected = parseCiInspectionBatch(value);
+  const published = currentPublishedRepositories(context);
+  const expected = new Map(
+    published.repositories.map((repository) => [repository.id, repository] as const),
+  );
+  for (const target of inspected.targets) {
+    const repository = expected.get(target.id);
+    if (
+      repository === undefined ||
+      repository.repository !== target.repository ||
+      repository.headRevision !== target.headRevision ||
+      repository.pr !== target.pr
+    ) {
+      throw new Error(
+        `CI target does not match the published repository and head: ${target.id} (${JSON.stringify({ target, repository })})`,
+      );
+    }
+    expected.delete(target.id);
+  }
+  if (expected.size > 0) {
+    throw new Error(`CI inspection is missing repository ids: ${[...expected.keys()].join(", ")}`);
+  }
+  return inspected;
+}
+
+function parseTrackedCiAssessment(
+  value: unknown,
+  context: WorkflowNodeContext,
+): Record<string, unknown> & { route: CiInspectionBatch["route"] } {
+  const result = requireRecord(value, "tracked CI assessment");
+  const inspected = latestOutput<CiInspectionBatch>(context, ["inspectCi"]);
+  const execution = latestOutput<BatchExecution>(context, ["trackCi"]);
+  const expectedIds = execution.batch.items.map((item) => item.id);
+  if (!Array.isArray(result.targets)) {
+    throw new Error("tracked CI assessment targets must be an array");
+  }
+  const seen = new Set<string>();
+  const targets = result.targets.map((entry, index) => {
+    const target = requireRecord(entry, `tracked CI assessment targets[${index}]`);
+    const id = requireString(target.id, `tracked CI assessment targets[${index}].id`);
+    if (seen.has(id)) throw new Error(`tracked CI assessment target is duplicated: ${id}`);
+    seen.add(id);
+    if (
+      target.route !== "green" &&
+      target.route !== "failed" &&
+      target.route !== "pending" &&
+      target.route !== "unavailable"
+    ) {
+      throw new Error(`tracked CI assessment targets[${index}].route is invalid`);
+    }
+    return {
+      id,
+      route: target.route,
+      reason: requireString(target.reason, `tracked CI assessment targets[${index}].reason`),
+    };
+  });
+  const missing = expectedIds.filter((id) => !seen.has(id));
+  const unexpected = [...seen].filter((id) => !expectedIds.includes(id));
+  if (missing.length > 0 || unexpected.length > 0 || targets.length !== expectedIds.length) {
+    throw new Error(
+      `tracked CI assessment targets must exactly cover watched ids; missing: ${missing.join(", ") || "none"}; unexpected: ${unexpected.join(", ") || "none"}`,
+    );
+  }
+  const trackedRoutes = new Map(targets.map((target) => [target.id, target.route] as const));
+  const routes = inspected.targets.map((target) => trackedRoutes.get(target.id) ?? target.route);
+  const route = routes.includes("failed")
+    ? "failed"
+    : routes.includes("pending")
+      ? "pending"
+      : routes.includes("unavailable")
+        ? "unavailable"
+        : "green";
+  if (result.route !== route) {
+    throw new Error(`tracked CI assessment route must be ${route}`);
+  }
+  return {
+    ...result,
+    route,
+    reason: requireString(result.reason, "tracked CI assessment reason"),
+    targets,
+    relatedFailures: requireStringArray(
+      result.relatedFailures ?? [],
+      "tracked CI assessment relatedFailures",
+    ),
+    unrelatedFailures: requireStringArray(
+      result.unrelatedFailures ?? [],
+      "tracked CI assessment unrelatedFailures",
+    ),
   };
-  const p0 = parseList("p0", "P0");
-  const p1 = parseList("p1", "P1");
-  const p2 = parseList("p2", "P2");
-  const lower = parseList("lower", "lower");
-  const invocationSucceeded = review.invocationSucceeded === true;
+}
+
+function selectReviewCommands(context: WorkflowNodeContext): ReviewCommandSelection {
+  const published = latestOutput<PublishedRepositories>(context, ["publish"]);
+  const reviewed = reviewRounds(context).flatMap((round) => round.repositories ?? []);
+  const repositories = published.repositories.filter(
+    (repository) =>
+      !reviewed.some(
+        (entry) =>
+          entry.id === repository.id &&
+          entry.headRevision === repository.headRevision &&
+          entry.dependencyFingerprint === repository.dependencyFingerprint &&
+          entry.invocationSucceeded,
+      ),
+  );
+  return {
+    route: repositories.length === 0 ? "reuse" : "run",
+    repositories,
+    commands: repositories.map(reviewerCommand),
+  };
+}
+
+function parseReviewAssessment(value: unknown, context: WorkflowNodeContext): ReviewAssessment {
+  const review = requireRecord(value, "review assessment");
+  if (!Array.isArray(review.repositories)) {
+    throw new Error("review repositories must be an array");
+  }
+  const selected = latestOutput<ReviewCommandSelection>(context, ["selectReviewCommands"]);
+  const expected = new Map(selected.repositories.map((repository) => [repository.id, repository]));
+  const repositories = review.repositories.map((value, index) => {
+    const raw = requireRecord(value, `review repositories[${index}]`);
+    const id = requireString(raw.id, `review repositories[${index}].id`);
+    const published = expected.get(id);
+    if (published === undefined)
+      throw new Error(`review repository id was not in the batch: ${id}`);
+    expected.delete(id);
+    const parseList = (key: "p0" | "p1" | "p2" | "lower", severity: ReviewFinding["severity"]) => {
+      const list = raw[key];
+      if (!Array.isArray(list))
+        throw new Error(`review repositories[${index}].${key} must be an array`);
+      return list.map((item) => parseFinding(item, severity));
+    };
+    return {
+      id,
+      repository: published.repository,
+      baseBranch: published.baseBranch,
+      headRevision: published.headRevision,
+      ...(published.dependencyFingerprint !== undefined
+        ? { dependencyFingerprint: published.dependencyFingerprint }
+        : {}),
+      invocationSucceeded: raw.invocationSucceeded === true,
+      p0: parseList("p0", "P0"),
+      p1: parseList("p1", "P1"),
+      p2: parseList("p2", "P2"),
+      lower: parseList("lower", "lower"),
+      reason: requireString(raw.reason, `review repositories[${index}].reason`),
+    } satisfies RepositoryReviewAssessment;
+  });
+  if (expected.size > 0) {
+    throw new Error(
+      `review assessment is missing repository ids: ${[...expected.keys()].join(", ")}`,
+    );
+  }
+  const p0 = repositories.flatMap((entry) => entry.p0);
+  const p1 = repositories.flatMap((entry) => entry.p1);
+  const p2 = repositories.flatMap((entry) => entry.p2);
+  const lower = repositories.flatMap((entry) => entry.lower);
+  const invocationSucceeded = repositories.every((entry) => entry.invocationSucceeded);
   const route = !invocationSucceeded
     ? "command_error"
     : p0.length + p1.length > 0
@@ -528,6 +1092,7 @@ function parseReviewAssessment(value: unknown): ReviewAssessment {
     p2,
     lower,
     reason: requireString(review.reason, "review reason"),
+    repositories,
   };
 }
 
@@ -537,8 +1102,39 @@ function reviewRounds(context: WorkflowNodeContext): ReviewAssessment[] {
     .map((step) => step.output as ReviewAssessment);
 }
 
+function reviewRoundsForOutput(context: WorkflowNodeContext): ReviewAssessment[] {
+  const rounds = reviewRounds(context);
+  const repositoryIds = new Set(
+    rounds.flatMap((round) => (round.repositories ?? []).map((repository) => repository.id)),
+  );
+  if (repositoryIds.size > 1) return rounds;
+  return rounds.map(({ repositories: _repositories, ...round }) => round);
+}
+
+function ciForOutput(context: WorkflowNodeContext): unknown {
+  const result = latestOutput<Record<string, unknown>>(context, ["assessTrackedCi", "inspectCi"]);
+  const targets = result.targets;
+  if (!Array.isArray(targets) || targets.length !== 1) return result;
+  const { targets: _targets, ...aggregate } = result;
+  if (result.route === "green" || result.route === "failed" || result.route === "unavailable") {
+    const target = targets[0];
+    if (target !== null && typeof target === "object" && !Array.isArray(target)) {
+      const record = target as Record<string, unknown>;
+      return {
+        ...aggregate,
+        reason: aggregate.reason ?? record.reason,
+        relatedFailures: aggregate.relatedFailures ?? record.relatedFailures ?? [],
+        unrelatedFailures: aggregate.unrelatedFailures ?? record.unrelatedFailures ?? [],
+      };
+    }
+  }
+  return aggregate;
+}
+
 function latestBlockedReason(context: WorkflowNodeContext): { reason: string; evidence: unknown } {
   const candidates = [
+    "timeoutFallbackGuard",
+    "timeoutFallback",
     "challengeBlockerGuard",
     "challengeBlocker",
     "finalizeDelivery",
@@ -723,8 +1319,58 @@ export const autoimplementWorkflow = defineWorkflow({
           : { route: "redesign", replans, limit };
       },
     }),
+    timeoutFallbackGuard: compute({
+      run: timeoutFallbackGuard,
+    }),
+    timeoutFallback: agent({
+      timeoutMs: 30 * 60_000,
+      statusDetail: "choosing a safe timeout fallback",
+      prompt: (context) => {
+        const request = context.input as AutoimplementInput;
+        const guard = context.outputs.timeoutFallbackGuard;
+        const previousFallbacks = context.state.steps
+          .filter((step) => step.nodeId === "timeoutFallback" && step.outcome === "ok")
+          .map((step) => step.output);
+        return [
+          "A bounded Autoimplement agent step timed out. Choose the safest existing workflow stage to run next instead of ending the run blindly.",
+          "This is a read-only fallback step. Inspect state, but do not edit files, run mutating commands, commit, push, open or update a pull request, post comments, merge, deploy, or release.",
+          "Inspect the current repository worktree, branch, diff, and commits. Inspect the remote branch, pull request, review, CI, merge, and final report when they exist and affect the next route.",
+          "Do not assume that the timed-out step failed or completed. Use accepted workflow outputs and durable repository or pull-request state.",
+          "Before any forward route, confirm that its accepted output belongs to the current work attempt and that observed local and remote heads match the accepted publication. Otherwise retry, replan, or block.",
+          "Choose retry only when the timed-out stage must run again. Choose verify when accepted implementation output exists and verification is next. Choose review when accepted publication output exists. Choose ci only after comment inspection routed to CI. Choose deliver only after CI is green or classified unrelated. Choose replan when evidence invalidates the approved plan. Choose blocked only when no safe route exists.",
+          "Do not skip required implementation, verification, review, CI, authorization, or delivery checks.",
+          `Task: ${request.task}`,
+          `Approved plan: ${JSON.stringify(currentPlan(context))}`,
+          `Authorized scope: ${request.scope ?? request.repository ?? "the current repository and task"}`,
+          `Timeout: ${JSON.stringify(guard)}`,
+          `Accepted outputs: ${JSON.stringify(context.outputs)}`,
+          `Previous fallback results: ${JSON.stringify(previousFallbacks)}`,
+          `Recent workflow attempts: ${JSON.stringify(recentWorkflowAttempts(context))}`,
+        ].join("\n");
+      },
+      expectedOutput: `{ "route": "retry" | "verify" | "review" | "ci" | "deliver" | "replan" | "blocked", "reason": "why this is the safest next stage", "evidence": ["state inspected before choosing the route"] }`,
+      validate: parseTimeoutFallback,
+    }),
+    routeTimeoutFallback: compute({
+      run: timeoutFallbackTarget,
+    }),
+    propagateSupportedFailure: compute({
+      run: throwLatestSupportedFailure,
+    }),
+    routeVerifyP2Result: compute({
+      run: ({ outputs }) => outputs.verifyP2,
+    }),
+    routeInspectCommentsResult: compute({
+      run: ({ outputs }) => outputs.inspectComments,
+    }),
+    routeInspectCiResult: compute({
+      run: ({ outputs }) => outputs.inspectCi,
+    }),
+    routeFinalizeDeliveryResult: compute({
+      run: ({ outputs }) => outputs.finalizeDelivery,
+    }),
     implement: agent({
-      timeoutMs: 60 * 60_000,
+      timeoutMs: 8 * 60 * 60_000,
       statusDetail: "implementing",
       prompt: (context) => {
         const request = context.input as AutoimplementInput;
@@ -733,12 +1379,14 @@ export const autoimplementWorkflow = defineWorkflow({
           `Plan: ${JSON.stringify(currentPlan(context))}`,
           `Authorized scope: ${request.scope ?? request.repository ?? "the current repository and task"}`,
           `Constraints: ${JSON.stringify(request.constraints ?? [])}`,
+          "Before changing files, inspect the current worktree, diff, commits, branch, remote state, and matching pull request. Continue existing work and do not repeat completed effects.",
           "Follow repository instructions and use the most elegant long-term production-ready implementation without unnecessary work.",
           "If implementation exposes a new design or scope problem, report it precisely instead of forcing the old plan.",
+          "Report every changed repository as an absolute path so independent verification can be bounded safely.",
           "Do not merge yet.",
         ].join("\n");
       },
-      expectedOutput: `{ "status": "implemented" | "issue" | "blocked", "summary": "work completed or issue", "files": ["changed file"], "issueKind": "design" | "implementation" | null, "evidence": "new evidence" }`,
+      expectedOutput: `{ "status": "implemented" | "issue" | "blocked", "summary": "work completed or issue", "files": ["changed file"], "repositories": ["absolute repository path changed"], "issueKind": "design" | "implementation" | null, "evidence": "new evidence" }`,
       validate: (value) => requireRecord(value, "implementation result"),
     }),
     classifyImplementation: agent({
@@ -805,15 +1453,46 @@ export const autoimplementWorkflow = defineWorkflow({
       expectedOutput: `{ "route": "continue" | "blocked", "blockingNow": true | false, "outsideAuthority": true | false, "canProceed": true | false, "reason": "concise reason", "nextAction": "practical action or empty when blocked", "alternativesChecked": ["checked alternative"], "evidence": ["concrete evidence"] }`,
       validate: parseBlockerChallenge,
     }),
-    verify: agent({
-      timeoutMs: 45 * 60_000,
-      statusDetail: "verifying",
+    planVerification: agent({
+      timeoutMs: 15 * 60_000,
+      statusDetail: "planning independent verification commands",
       prompt: () =>
         [
-          "Verify the implementation thoroughly.",
-          "Run required tests, formatting, lint, type checks, builds, and useful local smoke tests.",
-          "Do not put optional mutation testing on the critical path.",
-          "State exactly what ran, what passed, what failed, and what still needs remote verification.",
+          "Select the required local verification commands for the implementation.",
+          "Return one command per independent repository working directory.",
+          "Use exact executables and argument arrays without shell wrappers, environment overrides, stdin, Git or GitHub mutations, package publication, deployment, merge, or release commands.",
+          "Use absolute repository paths, explicit timeouts no longer than 2700000ms, and maxOutputChars no larger than 1000000.",
+          "List checks that cannot run locally under untested.",
+        ].join("\n"),
+      expectedOutput: `{ "commands": [{ "id": "stable-id", "command": "npm", "args": ["run", "check"], "cwd": "/absolute/repository", "timeoutMs": 2700000, "maxOutputChars": 1000000 }], "untested": ["remaining check"] }`,
+      validate: parseVerificationForContext,
+    }),
+    runVerification: action({
+      timeoutMs: (context) => {
+        const plan = latestOutput<VerificationCommandPlan>(context, ["planVerification"]);
+        return commandBatchTimeoutMs(plan.commands, concurrency(context).verification);
+      },
+      statusDetail: "running independent verification commands",
+      run: async (context) => {
+        const plan = latestOutput<VerificationCommandPlan>(context, ["planVerification"]);
+        return await runAutoimplementBatch(
+          context,
+          "verification",
+          plan.commands,
+          concurrency(context).verification,
+        );
+      },
+    }),
+    verify: agent({
+      timeoutMs: 20 * 60_000,
+      statusDetail: "assessing verification",
+      prompt: (context) =>
+        [
+          "Assess the completed local verification commands.",
+          "Set passed true only when every required command succeeded without truncated output.",
+          "Report exact command outcomes, failures, and checks that still need remote verification.",
+          `Command plan: ${JSON.stringify(latestOutput(context, ["planVerification"]))}`,
+          `Command results: ${JSON.stringify(latestOutput(context, ["runVerification"]))}`,
         ].join("\n"),
       expectedOutput: `{ "passed": true | false, "commands": [{ "command": "exact command", "outcome": "result" }], "failures": ["failure"], "untested": ["remaining check"] }`,
       validate: (value) => requireRecord(value, "verification result"),
@@ -843,6 +1522,7 @@ export const autoimplementWorkflow = defineWorkflow({
       prompt: (context) =>
         [
           "Fix the current implementation issue without expanding the approved design.",
+          "Inspect the current diff and commits first. Continue any partial fix and change only work that is still missing.",
           `Issue: ${JSON.stringify(latestIssue(context))}`,
           `Current plan: ${JSON.stringify(currentPlan(context))}`,
           "Stop after the fix so verification can run again.",
@@ -857,82 +1537,68 @@ export const autoimplementWorkflow = defineWorkflow({
         const request = input as AutoimplementInput;
         return [
           "Commit and push the verified implementation before review.",
+          "Inspect the branch, local and remote heads, and matching pull requests first. Do not push an already-pushed head or create a second pull request for the same branch and base.",
           "Use the existing implementation-plan PR when one exists. Otherwise open a PR and use the pr-description skill for its body.",
           "Inspect the complete public diff before every push or PR mutation.",
-          `Requested base branch: ${request.baseBranch ?? "discover the repository default branch"}.`,
+          "Report every repository that received a pushed pull request with its absolute repository path, branch, base branch, pushed head revision, and PR URL.",
+          "Include dependencyFingerprint only when a declared dependency result is relevant to review reuse.",
+          `Requested base branch: ${request.baseBranch ?? "discover each repository default branch"}.`,
           "Do not merge yet.",
         ].join("\n");
       },
-      expectedOutput: `{ "branch": "branch", "baseBranch": "base", "headRevision": "revision", "pr": "URL", "pushed": true }`,
-      validate: (value) => requireRecord(value, "publication result"),
-    }),
-    authorReviewCommand: agent({
-      statusDetail: "writing reviewer command",
-      prompt: ({ outputs, input }) => {
-        const published = outputs.publish as Record<string, unknown>;
-        const request = input as AutoimplementInput;
-        return [
-          "Write the exact Pi Reviewer command for the pushed branch.",
-          "The executable must be pi-reviewer. Use its configured model and thinking settings.",
-          "Use the repository base branch and an absolute repository working directory.",
-          "Set timeoutMs to at most 600000.",
-          `Published branch: ${JSON.stringify(published)}`,
-          `Repository hint: ${request.repository ?? "current repository"}`,
-        ].join("\n");
-      },
-      expectedOutput: `{ "command": "pi-reviewer", "args": ["--base", "main"], "cwd": "/absolute/repository", "timeoutMs": 600000 }`,
-      validate: parseReviewerCommand,
+      expectedOutput: `{ "repositories": [{ "repository": "/absolute/repository", "branch": "branch", "baseBranch": "base", "headRevision": "revision", "pr": "URL", "pushed": true, "dependencyFingerprint": "optional digest" }] }`,
+      validate: parsePublishedRepositories,
     }),
-    runReview: shell({
-      statusDetail: "running Pi Reviewer",
-      timeoutMs: TEN_MINUTES_MS + 10_000,
-      exec: (context) =>
-        commandExecution(
-          latestOutput<StructuredCommand>(context, ["authorReviewCommand", "repairReviewCommand"]),
-        ),
+    selectReviewCommands: compute({
+      run: selectReviewCommands,
     }),
-    repairReviewCommand: agent({
-      statusDetail: "correcting reviewer command",
-      prompt: (context) => {
-        const failed = context.results.runReview;
-        return [
-          "The Pi Reviewer invocation failed. Diagnose the exact command, arguments, base branch, working directory, and error.",
-          "Write a corrected pi-reviewer command. Do not substitute codex review or another reviewer.",
-          "If Pi Reviewer or its configuration is missing, report that through the same command shape only when another valid invocation exists; otherwise the next assessment must block.",
-          `Failed result: ${JSON.stringify(failed)}`,
-        ].join("\n");
+    runReview: action({
+      statusDetail: "running pi-reviewer commands",
+      timeoutMs: (context) => {
+        const selected = latestOutput<ReviewCommandSelection>(context, ["selectReviewCommands"]);
+        return commandBatchTimeoutMs(selected.commands, concurrency(context).reviewer);
       },
-      expectedOutput: `{ "route": "retry" | "blocked", "command": "pi-reviewer", "args": ["--base", "main"], "cwd": "/absolute/repository", "timeoutMs": 600000, "reason": "diagnosis" }`,
-      validate: (value) => {
-        const result = requireRecord(value, "reviewer command repair");
-        if (result.route === "blocked") {
-          return {
-            route: "blocked",
-            reason: requireString(result.reason, "reviewer command blocker"),
-          };
-        }
-        if (result.route !== "retry")
-          throw new Error("reviewer command repair route must be retry or blocked");
-        return {
-          route: "retry",
-          ...parseReviewerCommand(result),
-          reason: requireString(result.reason, "reviewer command repair reason"),
-        };
+      run: async (context): Promise<BatchExecution> => {
+        const selected = latestOutput<ReviewCommandSelection>(context, ["selectReviewCommands"]);
+        const batch = await runAutoimplementBatch(
+          context,
+          "review",
+          selected.commands,
+          concurrency(context).reviewer,
+        );
+        return { route: reviewBatchNeedsRepair(batch) ? "repair" : "assess", batch };
       },
     }),
+    repairReviewCommand: agent({
+      statusDetail: "repairing reviewer prerequisites",
+      prompt: (context) =>
+        [
+          "One or more pi-reviewer commands failed, timed out, or returned truncated output.",
+          "Diagnose and fix only local reviewer prerequisites or configuration that are in scope.",
+          "Do not change the deterministic executable, base branch, or repository command shape, and do not substitute another reviewer.",
+          "Choose retry only when the same commands can now produce complete reviews. Choose blocked when pi-reviewer or required configuration remains unavailable.",
+          `Failed batch: ${JSON.stringify(context.outputs.runReview)}`,
+        ].join("\n"),
+      expectedOutput: `{ "route": "retry" | "blocked", "reason": "diagnosis and action" }`,
+      validate: (value) =>
+        parseRoute(value, ["retry", "blocked"] as const, "reviewer command repair"),
+    }),
     assessReview: agent({
       statusDetail: "assessing reviewer findings",
       prompt: (context) => {
-        const result = latestOutput<ShellActionResult>(context, ["runReview"]);
+        const selected = latestOutput<ReviewCommandSelection>(context, ["selectReviewCommands"]);
+        const execution = latestOutput<BatchExecution>(context, ["runReview"]);
         return [
-          "Assess the completed Pi Reviewer invocation.",
-          "Set invocationSucceeded false only when the reviewer did not produce a valid review.",
-          "Record each finding under P0, P1, P2, or lower. Mark each finding as design or implementation.",
+          "Assess each completed pi-reviewer result separately.",
+          "Return one repository entry for every selected command, using the exact repository id.",
+          "Set invocationSucceeded false when a complete valid review was not produced.",
+          "Record every finding under P0, P1, P2, or lower and mark it as design or implementation.",
           "Do not promote P2 findings to P1 merely to force another review round.",
-          `Reviewer result: ${JSON.stringify(result)}`,
+          `Selected repositories: ${JSON.stringify(selected.repositories)}`,
+          `Reviewer results: ${JSON.stringify(execution.batch)}`,
         ].join("\n");
       },
-      expectedOutput: `{ "invocationSucceeded": true | false, "p0": [{ "kind": "design" | "implementation", "summary": "finding" }], "p1": [], "p2": [], "lower": [], "reason": "assessment" }`,
+      expectedOutput: `{ "repositories": [{ "id": "repository-id", "invocationSucceeded": true | false, "p0": [{ "kind": "design" | "implementation", "summary": "finding" }], "p1": [], "p2": [], "lower": [], "reason": "assessment" }], "reason": "batch assessment" }`,
       validate: parseReviewAssessment,
     }),
     triageReview: compute({
@@ -952,7 +1618,8 @@ export const autoimplementWorkflow = defineWorkflow({
       prompt: ({ outputs }) =>
         [
           "Address valid P2 findings from the last review when the improvement is proportionate and in scope.",
-          "Do not rerun Pi Reviewer solely because P2 work changes files. Verification will run once, then the workflow continues.",
+          "Inspect the current diff and commits first. Do not repeat a P2 change that is already present.",
+          "Do not rerun pi-reviewer solely because P2 work changes files. Verification will run once, then the workflow continues.",
           `Review: ${JSON.stringify(outputs.assessReview)}`,
         ].join("\n"),
       expectedOutput: `{ "addressed": ["P2 change"], "skipped": [{ "finding": "finding", "reason": "why" }] }`,
@@ -964,20 +1631,23 @@ export const autoimplementWorkflow = defineWorkflow({
       prompt: () =>
         [
           "Run focused verification for the P2 changes and push the verified result.",
-          "Do not run Pi Reviewer again because the previous round had no P0 or P1 findings.",
+          "Inspect the local and remote heads first. Do not push again when the verified head is already remote.",
+          "Do not run pi-reviewer again because the previous round had no P0 or P1 findings.",
+          "Re-observe every published PR after the push and return its current repository, branch, base branch, head revision, PR URL, pushed status, and unchanged dependency fingerprint.",
           "Report exact commands and outcomes.",
         ].join("\n"),
-      expectedOutput: `{ "passed": true | false, "commands": [{ "command": "command", "outcome": "result" }], "pushed": true }`,
-      validate: (value) => requireRecord(value, "P2 verification"),
+      expectedOutput: `{ "passed": true | false, "commands": [{ "command": "command", "outcome": "result" }], "pushed": true, "repositories": [{ "repository": "/absolute/repository", "branch": "branch", "baseBranch": "base", "headRevision": "current pushed revision", "pr": "URL", "pushed": true, "dependencyFingerprint": "optional fingerprint" }] }`,
+      validate: parseP2Verification,
     }),
     inspectComments: agent({
       timeoutMs: 20 * 60_000,
       statusDetail: "checking PR comments",
-      prompt: () =>
+      prompt: (context) =>
         [
-          "Inspect current inline review comments and PR issue comments.",
-          "Reply to and resolve every comment. Ignore stale or irrelevant comments only after explaining why.",
-          "Choose redesign for a valid design issue, fix for a local code issue, ci when no actionable comment remains, or blocked for an external blocker.",
+          "Inspect current inline review comments and PR issue comments for every published pull request.",
+          "Handle pull requests one at a time. Reply to and resolve every comment. Ignore stale or irrelevant comments only after explaining why.",
+          "Choose redesign for a valid design issue, fix for a local code issue, ci when no actionable comment remains on any PR, or blocked for an external blocker.",
+          `Published repositories: ${JSON.stringify(currentPublishedRepositories(context))}`,
         ].join("\n"),
       expectedOutput: `{ "route": "redesign" | "fix" | "ci" | "blocked", "summary": "comment status", "evidence": ["comment or response"] }`,
       validate: (value) =>
@@ -986,71 +1656,75 @@ export const autoimplementWorkflow = defineWorkflow({
     inspectCi: agent({
       timeoutMs: 10 * 60_000,
       statusDetail: "checking CI",
-      prompt: () =>
+      prompt: (context) =>
         [
-          "Inspect CI once without waiting for completion.",
-          "Choose green, failed, pending, or unavailable.",
-          "When pending, provide an exact gh command that tracks this PR or run and set timeoutMs to at most 300000.",
-          "Separate failures caused by this change from unrelated failures.",
+          "Inspect every published pull request once without waiting for completion.",
+          "Return one target per repository and current PR head.",
+          "Choose green, failed, pending, or unavailable for each target.",
+          "When pending, provide an exact supported gh pr checks --watch or gh run watch command with the repository id, absolute repository cwd, timeoutMs at most 300000, and maxOutputChars at most 1000000. The workflow binds it to the target PR before execution.",
+          "Separate failures caused by this change from unrelated failures. Do not invent an ETA.",
+          `Published repositories: ${JSON.stringify(currentPublishedRepositories(context))}`,
         ].join("\n"),
-      expectedOutput: `{ "route": "green" | "failed" | "pending" | "unavailable", "reason": "status", "relatedFailures": ["failure"], "unrelatedFailures": ["failure"], "trackingCommand": { "command": "gh", "args": ["pr", "checks", "--watch"], "cwd": "/absolute/repository", "timeoutMs": 300000 } (required when pending) }`,
-      validate: (value) => {
-        const result = parseRoute(
-          value,
-          ["green", "failed", "pending", "unavailable"] as const,
-          "CI inspection",
+      expectedOutput: `{ "targets": [{ "repository": "/absolute/repository", "headRevision": "revision", "pr": "URL", "route": "green" | "failed" | "pending" | "unavailable", "reason": "status", "relatedFailures": ["failure"], "unrelatedFailures": ["failure"], "trackingCommand": { "id": "repository-id", "command": "gh", "args": ["pr", "checks", "PR URL", "--watch"], "cwd": "/absolute/repository", "timeoutMs": 300000, "maxOutputChars": 1000000 } }] }`,
+      validate: parseCiInspectionForPublished,
+    }),
+    trackCi: action({
+      statusDetail: "tracking pending CI commands",
+      timeoutMs: (context) => {
+        const inspected = latestOutput<CiInspectionBatch>(context, ["inspectCi"]);
+        const commands = inspected.targets.flatMap((target) =>
+          target.trackingCommand === undefined ? [] : [target.trackingCommand],
         );
-        if (result.route === "pending")
-          result.trackingCommand = parseCiCommand(result.trackingCommand);
-        return result;
+        return commandBatchTimeoutMs(commands, concurrency(context).ciWatch);
+      },
+      run: async (context): Promise<BatchExecution> => {
+        const inspected = latestOutput<CiInspectionBatch>(context, ["inspectCi"]);
+        const commands = inspected.targets.flatMap((target) =>
+          target.trackingCommand === undefined ? [] : [target.trackingCommand],
+        );
+        const batch = await runAutoimplementBatch(
+          context,
+          "ciWatch",
+          commands,
+          concurrency(context).ciWatch,
+        );
+        const needsRepair = batch.items.some(
+          (item) =>
+            (item.outcome === "failed" && item.exitCode === null) ||
+            item.stdoutTruncated ||
+            item.stderrTruncated,
+        );
+        return { route: needsRepair ? "repair" : "assess", batch };
       },
-    }),
-    trackCi: shell({
-      statusDetail: "tracking CI for at most five minutes",
-      timeoutMs: FIVE_MINUTES_MS + 10_000,
-      exec: (context) => commandExecution(latestCiCommand(context)),
     }),
     repairCiCommand: agent({
-      statusDetail: "correcting CI tracking command",
+      statusDetail: "repairing CI watch prerequisites",
       prompt: (context) =>
         [
-          "The CI tracking command failed before it could provide a useful status.",
-          "Write a corrected gh pr checks --watch or gh run watch command for the same PR or run.",
-          "Use an absolute repository path and a timeout no longer than five minutes.",
-          `Failure: ${JSON.stringify(context.results.trackCi)}`,
+          "One or more supported CI watch commands failed or returned truncated output.",
+          "Diagnose and fix only local gh prerequisites or authentication that are already authorized.",
+          "Do not change the PR identity or substitute another command form.",
+          "Choose retry only when the same validated commands can now provide useful status. Choose blocked otherwise.",
+          `Failure: ${JSON.stringify(context.outputs.trackCi)}`,
         ].join("\n"),
-      expectedOutput: `{ "route": "retry" | "blocked", "command": "gh", "args": ["pr", "checks", "--watch"], "cwd": "/absolute/repository", "timeoutMs": 300000, "reason": "diagnosis" }`,
-      validate: (value) => {
-        const result = requireRecord(value, "CI command repair");
-        if (result.route === "blocked") {
-          return { route: "blocked", reason: requireString(result.reason, "CI command blocker") };
-        }
-        if (result.route !== "retry")
-          throw new Error("CI command repair route must be retry or blocked");
-        return {
-          route: "retry",
-          ...parseCiCommand(result),
-          reason: requireString(result.reason, "CI command repair reason"),
-        };
-      },
+      expectedOutput: `{ "route": "retry" | "blocked", "reason": "diagnosis" }`,
+      validate: (value) => parseRoute(value, ["retry", "blocked"] as const, "CI command repair"),
     }),
     assessTrackedCi: agent({
       statusDetail: "assessing tracked CI",
       prompt: (context) => {
-        const result = latestOutput<ShellActionResult>(context, ["trackCi"]);
+        const inspected = latestOutput<CiInspectionBatch>(context, ["inspectCi"]);
+        const execution = latestOutput<BatchExecution>(context, ["trackCi"]);
         return [
-          "Assess the CI tracking result without starting another wait.",
-          "Choose green, failed, pending, or unavailable and separate related from unrelated failures.",
-          `Tracking result: ${JSON.stringify(result)}`,
+          "Assess every CI watch result without starting another wait.",
+          "Return one target result for every watched PR and an aggregate route of green, failed, pending, or unavailable.",
+          "A timed-out watch normally remains pending. Separate related from unrelated failures. Do not invent an ETA.",
+          `Initial inspection: ${JSON.stringify(inspected)}`,
+          `Tracking results: ${JSON.stringify(execution.batch)}`,
         ].join("\n");
       },
-      expectedOutput: `{ "route": "green" | "failed" | "pending" | "unavailable", "reason": "status", "relatedFailures": ["failure"], "unrelatedFailures": ["failure"] }`,
-      validate: (value) =>
-        parseRoute(
-          value,
-          ["green", "failed", "pending", "unavailable"] as const,
-          "tracked CI assessment",
-        ),
+      expectedOutput: `{ "route": "green" | "failed" | "pending" | "unavailable", "reason": "status", "targets": [{ "id": "repository-id", "route": "green" | "failed" | "pending" | "unavailable", "reason": "status" }], "relatedFailures": ["failure"], "unrelatedFailures": ["failure"] }`,
+      validate: parseTrackedCiAssessment,
     }),
     opportunisticTest: agent({
       timeoutMs: 30 * 60_000,
@@ -1083,30 +1757,23 @@ export const autoimplementWorkflow = defineWorkflow({
     }),
     finalizeDelivery: agent({
       timeoutMs: 30 * 60_000,
-      statusDetail: "finalizing PR",
-      prompt: ({ input }) => {
-        const request = input as AutoimplementInput;
+      statusDetail: "finalizing PRs",
+      prompt: (context) => {
+        const request = context.input as AutoimplementInput;
         return [
           request.merge === false
-            ? "Leave the verified PR ready without merging because input disabled merge."
-            : "Merge the verified PR unless repository policy or explicit user instructions prohibit it.",
-          "Use the repository's required merge method.",
-          "Post a final PR report with the implementation summary and exact validation commands.",
+            ? "Leave every verified PR ready without merging because input disabled merge."
+            : "Handle verified PRs one at a time and merge each unless repository policy or explicit user instructions prohibit it.",
+          "Before each mutation, inspect the current PR head, merge state, and existing final report. Do not merge an already merged expected head or post a duplicate report.",
+          "Use each repository's required merge method.",
+          "Post a final report with the implementation summary and exact validation commands on every PR only when that report is missing.",
+          "Keep the existing top-level merged, pr, reportComment, and reason fields. For several PRs, use the first PR for the top-level compatibility fields and include every result under repositories.",
           "Return blocked instead of claiming completion when a required merge or report action fails.",
+          `Published repositories: ${JSON.stringify(currentPublishedRepositories(context))}`,
         ].join("\n");
       },
-      expectedOutput: `{ "status": "completed" | "blocked", "merged": true | false, "pr": "URL", "reportComment": "URL or summary", "reason": "result" }`,
-      validate: (value, context) => {
-        const result = requireRecord(value, "delivery result");
-        if (result.status !== "completed" && result.status !== "blocked") {
-          throw new Error("delivery status must be completed or blocked");
-        }
-        const request = context.input as AutoimplementInput;
-        if (request.merge !== true && result.merged === true) {
-          throw new Error("delivery cannot merge without explicit merge: true");
-        }
-        return result;
-      },
+      expectedOutput: `{ "status": "completed" | "blocked", "merged": true | false, "pr": "first PR URL", "reportComment": "first report URL or summary", "reason": "aggregate result", "repositories": [{ "repository": "/absolute/repository", "pr": "URL", "merged": true | false, "reportComment": "URL or summary", "reason": "result" }] }`,
+      validate: parseDeliveryResult,
     }),
     blocked: compute({
       run: (context) => {
@@ -1127,11 +1794,11 @@ export const autoimplementWorkflow = defineWorkflow({
           status: "completed",
           task: request.task,
           plan: currentPlan(context),
-          implementation: context.outputs.implement,
-          verification: context.outputs.verifyP2 ?? context.outputs.verify,
-          reviewRounds: reviewRounds(context),
-          ci: context.outputs.assessTrackedCi ?? context.outputs.inspectCi,
-          delivery: context.outputs.finalizeDelivery,
+          implementation: latestOutput(context, ["implement"]),
+          verification: latestOutput(context, ["verifyP2", "verify"]),
+          reviewRounds: reviewRoundsForOutput(context),
+          ci: ciForOutput(context),
+          delivery: latestOutput(context, ["finalizeDelivery"]),
         } satisfies AutoimplementCompleted;
       },
     }),
@@ -1174,13 +1841,51 @@ export const autoimplementWorkflow = defineWorkflow({
       from: "replanGuard",
       switch: { on: "$.route", cases: { redesign: "redesign", blocked: "blocked" } },
     },
-    { from: "implement", to: "classifyImplementation" },
     {
-      from: "classifyImplementation",
+      from: "timeoutFallbackGuard",
+      switch: { on: "$.route", cases: { recover: "timeoutFallback", blocked: "blocked" } },
+    },
+    { from: "timeoutFallback", to: "routeTimeoutFallback" },
+    { from: "propagateSupportedFailure", to: "blocked" },
+    {
+      from: "routeTimeoutFallback",
       switch: {
         on: "$.route",
         cases: {
+          implement: "implement",
+          planVerification: "planVerification",
           verify: "verify",
+          fix: "fix",
+          publish: "publish",
+          addressP2: "addressP2",
+          verifyP2: "verifyP2",
+          inspectComments: "inspectComments",
+          inspectCi: "inspectCi",
+          opportunisticTest: "opportunisticTest",
+          finalizeDelivery: "finalizeDelivery",
+          selectReviewCommands: "selectReviewCommands",
+          redesign: "redesign",
+          blocked: "blocked",
+        },
+      },
+    },
+    {
+      from: "implement",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "classifyImplementation",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    {
+      from: "classifyImplementation",
+      switch: {
+        on: "$.route",
+        cases: {
+          verify: "planVerification",
           redesign: "redesign",
           fix: "fix",
           blocked: "challengeBlockerGuard",
@@ -1195,7 +1900,29 @@ export const autoimplementWorkflow = defineWorkflow({
       from: "challengeBlocker",
       switch: { on: "$.route", cases: { continue: "redesign", blocked: "blocked" } },
     },
-    { from: "verify", to: "classifyVerification" },
+    {
+      from: "planVerification",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "runVerification",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    { from: "runVerification", to: "verify" },
+    {
+      from: "verify",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "classifyVerification",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
     {
       from: "classifyVerification",
       switch: {
@@ -1208,20 +1935,36 @@ export const autoimplementWorkflow = defineWorkflow({
         },
       },
     },
-    { from: "fix", to: "verify" },
-    { from: "publish", to: "authorReviewCommand" },
-    { from: "authorReviewCommand", to: "runReview" },
     {
-      from: "runReview",
+      from: "fix",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "planVerification",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    {
+      from: "publish",
       switch: {
         on: "$result.outcome",
         cases: {
-          ok: "assessReview",
-          failed: "repairReviewCommand",
-          timed_out: "repairReviewCommand",
+          ok: "selectReviewCommands",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
         },
       },
     },
+    {
+      from: "selectReviewCommands",
+      switch: { on: "$.route", cases: { run: "runReview", reuse: "inspectComments" } },
+    },
+    {
+      from: "runReview",
+      switch: { on: "$.route", cases: { assess: "assessReview", repair: "repairReviewCommand" } },
+    },
     {
       from: "repairReviewCommand",
       switch: {
@@ -1245,13 +1988,45 @@ export const autoimplementWorkflow = defineWorkflow({
       from: "triageReview",
       switch: { on: "$.route", cases: { redesign: "redesign", fix: "fix" } },
     },
-    { from: "addressP2", to: "verifyP2" },
+    {
+      from: "addressP2",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "verifyP2",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
     {
       from: "verifyP2",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "routeVerifyP2Result",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    {
+      from: "routeVerifyP2Result",
       switch: { on: "$.passed", cases: { true: "inspectComments", false: "fix" } },
     },
     {
       from: "inspectComments",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "routeInspectCommentsResult",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    {
+      from: "routeInspectCommentsResult",
       switch: {
         on: "$.route",
         cases: {
@@ -1264,6 +2039,17 @@ export const autoimplementWorkflow = defineWorkflow({
     },
     {
       from: "inspectCi",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "routeInspectCiResult",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    {
+      from: "routeInspectCiResult",
       switch: {
         on: "$.route",
         cases: {
@@ -1276,10 +2062,7 @@ export const autoimplementWorkflow = defineWorkflow({
     },
     {
       from: "trackCi",
-      switch: {
-        on: "$result.outcome",
-        cases: { ok: "assessTrackedCi", failed: "repairCiCommand", timed_out: "opportunisticTest" },
-      },
+      switch: { on: "$.route", cases: { assess: "assessTrackedCi", repair: "repairCiCommand" } },
     },
     {
       from: "repairCiCommand",
@@ -1300,7 +2083,17 @@ export const autoimplementWorkflow = defineWorkflow({
         },
       },
     },
-    { from: "opportunisticTest", to: "inspectCi" },
+    {
+      from: "opportunisticTest",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "inspectCi",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
     {
       from: "classifyCi",
       switch: {
@@ -1315,6 +2108,17 @@ export const autoimplementWorkflow = defineWorkflow({
     },
     {
       from: "finalizeDelivery",
+      switch: {
+        on: "$result.outcome",
+        cases: {
+          ok: "routeFinalizeDeliveryResult",
+          timed_out: "timeoutFallbackGuard",
+          failed: "propagateSupportedFailure",
+        },
+      },
+    },
+    {
+      from: "routeFinalizeDeliveryResult",
       switch: {
         on: "$.status",
         cases: { completed: "finalize", blocked: "challengeBlockerGuard" },