@osolmaz/pi-workflows 0.10.0 → 0.11.1

package/src/builtins/autoimplement.workflow.ts

@@ -7,12 +7,15 @@ import {
   includedResult,
   shell,
 } from "../workflows/definition.js";
+import { digest } from "../workflows/human-decision.js";
 import type {
   ShellActionExecution,
   ShellActionResult,
   WorkflowNodeContext,
 } from "../workflows/types.js";
-import autodeviseWorkflow, { type AutodeviseInput } from "./autodevise.workflow.js";
+import autodocWorkflow, { type AutodocInput } from "./autodoc.workflow.js";
+import autoplanWorkflow, { type AutoplanInput } from "./autoplan.workflow.js";
+import planApprovalWorkflow, { type PlanApprovalInput } from "./plan-approval.workflow.js";
 
 export type AutoimplementInput = {
   task: string;
@@ -22,6 +25,25 @@ export type AutoimplementInput = {
   repository?: string;
   baseBranch?: string;
   merge?: boolean;
+  documents?: string[];
+  documentation?: {
+    status: "current";
+    planDigest: string;
+    documents: string[];
+  };
+  approval?: {
+    audience: string;
+    maxReplans: number;
+  };
+};
+
+export type ExistingPlanDiscovery = {
+  route: "found" | "blocked";
+  plan?: unknown;
+  documentation?: "current" | "missing" | "stale";
+  documents: string[];
+  reason: string;
+  evidence: unknown;
 };
 
 type StructuredCommand = {
@@ -65,8 +87,22 @@ export type AutoimplementBlocked = {
   evidence: unknown;
 };
 
+type BlockerChallenge = {
+  route: "continue" | "blocked";
+  blockingNow: boolean;
+  outsideAuthority: boolean;
+  canProceed: boolean;
+  reason: string;
+  nextAction: string;
+  alternativesChecked: string[];
+  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;
 
 function requireRecord(value: unknown, label: string): Record<string, unknown> {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
@@ -82,6 +118,80 @@ function requireString(value: unknown, label: string): string {
   return value.trim();
 }
 
+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`);
+  }
+  return value.map((item, index) => {
+    const text = requireString(item, `${label}[${index}]`);
+    if (text.length > MAX_CHALLENGE_TEXT) {
+      throw new Error(`${label}[${index}] must be at most ${MAX_CHALLENGE_TEXT} characters`);
+    }
+    return text;
+  });
+}
+
+function parseBlockerChallenge(value: unknown): BlockerChallenge {
+  const result = requireRecord(value, "blocker challenge");
+  if (result.route !== "continue" && result.route !== "blocked") {
+    throw new Error("blocker challenge route must be continue or blocked");
+  }
+  for (const key of ["blockingNow", "outsideAuthority", "canProceed"] as const) {
+    if (typeof result[key] !== "boolean") {
+      throw new Error(`blocker challenge ${key} must be a boolean`);
+    }
+  }
+  const blockingNow = result.blockingNow as boolean;
+  const outsideAuthority = result.outsideAuthority as boolean;
+  const canProceed = result.canProceed as boolean;
+  const reason = requireString(result.reason, "blocker challenge reason");
+  if (reason.length > MAX_CHALLENGE_TEXT) {
+    throw new Error(`blocker challenge reason must be at most ${MAX_CHALLENGE_TEXT} characters`);
+  }
+  if (typeof result.nextAction !== "string") {
+    throw new Error("blocker challenge nextAction must be a string");
+  }
+  const nextAction = result.nextAction.trim();
+  if (nextAction.length > MAX_CHALLENGE_TEXT) {
+    throw new Error(
+      `blocker challenge nextAction must be at most ${MAX_CHALLENGE_TEXT} characters`,
+    );
+  }
+  const alternativesChecked = boundedChallengeItems(
+    result.alternativesChecked,
+    "blocker challenge alternativesChecked",
+  );
+  const evidence = boundedChallengeItems(result.evidence, "blocker challenge evidence");
+
+  if (result.route === "blocked") {
+    if (
+      blockingNow !== true ||
+      outsideAuthority !== true ||
+      canProceed !== false ||
+      nextAction.length > 0 ||
+      alternativesChecked.length === 0 ||
+      evidence.length === 0
+    ) {
+      throw new Error(
+        "blocked challenge requires blockingNow=true, outsideAuthority=true, canProceed=false, an empty nextAction, and concrete alternatives and evidence",
+      );
+    }
+  } else if (canProceed !== true || nextAction.length === 0) {
+    throw new Error("continue challenge requires canProceed=true and a practical nextAction");
+  }
+
+  return {
+    route: result.route,
+    blockingNow,
+    outsideAuthority,
+    canProceed,
+    reason,
+    nextAction,
+    alternativesChecked,
+    evidence,
+  };
+}
+
 function parseInput(value: unknown): AutoimplementInput {
   const input = requireRecord(value, "autoimplement input");
   const constraints = input.constraints;
@@ -94,6 +204,51 @@ function parseInput(value: unknown): AutoimplementInput {
   if (input.merge !== undefined && typeof input.merge !== "boolean") {
     throw new Error("autoimplement merge must be a boolean");
   }
+  const documents = input.documents;
+  if (
+    documents !== undefined &&
+    (!Array.isArray(documents) || documents.some((item) => typeof item !== "string"))
+  ) {
+    throw new Error("autoimplement documents must be an array of strings");
+  }
+  let documentation: AutoimplementInput["documentation"];
+  if (input.documentation !== undefined) {
+    if (input.plan === undefined) {
+      throw new Error("autoimplement documentation requires an explicit plan");
+    }
+    const raw = requireRecord(input.documentation, "autoimplement documentation");
+    if (raw.status !== "current") {
+      throw new Error("autoimplement documentation status must be current");
+    }
+    const planDigest = requireString(raw.planDigest, "autoimplement documentation planDigest");
+    if (planDigest !== digest(input.plan)) {
+      throw new Error("autoimplement documentation planDigest does not match the explicit plan");
+    }
+    if (!Array.isArray(raw.documents) || raw.documents.some((item) => typeof item !== "string")) {
+      throw new Error("autoimplement documentation documents must be an array of strings");
+    }
+    documentation = {
+      status: "current",
+      planDigest,
+      documents: [...raw.documents] as string[],
+    };
+  }
+  let approval: AutoimplementInput["approval"];
+  if (input.approval !== undefined) {
+    const raw = requireRecord(input.approval, "autoimplement approval");
+    const maxReplans = raw.maxReplans ?? 3;
+    if (
+      !Number.isInteger(maxReplans) ||
+      (maxReplans as number) < 1 ||
+      (maxReplans as number) > 20
+    ) {
+      throw new Error("autoimplement approval maxReplans must be from 1 through 20");
+    }
+    approval = {
+      audience: requireString(raw.audience, "autoimplement approval audience"),
+      maxReplans: maxReplans as number,
+    };
+  }
   return {
     task: requireString(input.task, "autoimplement task"),
     ...(input.plan !== undefined ? { plan: input.plan } : {}),
@@ -106,6 +261,42 @@ function parseInput(value: unknown): AutoimplementInput {
       ? { baseBranch: requireString(input.baseBranch, "baseBranch") }
       : {}),
     merge: input.merge === true,
+    ...(documents !== undefined ? { documents: [...documents] as string[] } : {}),
+    ...(documentation !== undefined ? { documentation } : {}),
+    ...(approval !== undefined ? { approval } : {}),
+  };
+}
+
+function parseExistingPlan(value: unknown): ExistingPlanDiscovery {
+  const result = requireRecord(value, "existing plan discovery");
+  if (result.route !== "found" && result.route !== "blocked") {
+    throw new Error("existing plan discovery route must be found or blocked");
+  }
+  if (result.route === "found") {
+    if (result.plan === undefined) throw new Error("found plan must include plan");
+    if (
+      result.documentation !== "current" &&
+      result.documentation !== "missing" &&
+      result.documentation !== "stale"
+    ) {
+      throw new Error("found plan documentation must be current, missing, or stale");
+    }
+  }
+  if (
+    !Array.isArray(result.documents) ||
+    result.documents.some((item) => typeof item !== "string")
+  ) {
+    throw new Error("existing plan documents must be an array of strings");
+  }
+  return {
+    route: result.route,
+    ...(result.plan !== undefined ? { plan: result.plan } : {}),
+    ...(result.documentation !== undefined
+      ? { documentation: result.documentation as "current" | "missing" | "stale" }
+      : {}),
+    documents: [...result.documents] as string[],
+    reason: requireString(result.reason, "existing plan discovery reason"),
+    evidence: result.evidence ?? null,
   };
 }
 
@@ -210,11 +401,80 @@ function latestCiCommand(context: WorkflowNodeContext): StructuredCommand {
 
 function currentPlan(context: WorkflowNodeContext): unknown {
   const adopted = context.outputs.adoptPlan as { plan?: unknown } | undefined;
-  return adopted?.plan ?? (context.input as AutoimplementInput).plan;
+  if (adopted?.plan !== undefined) return adopted.plan;
+  const documented = context.outputs.documentation as
+    | { exit?: string; output?: { plan?: unknown } }
+    | undefined;
+  if (documented?.exit === "ready" && documented.output?.plan !== undefined) {
+    return documented.output.plan;
+  }
+  const discovered = context.outputs.findPlan as ExistingPlanDiscovery | undefined;
+  if (discovered?.route === "found" && discovered.plan !== undefined) return discovered.plan;
+  return (context.input as AutoimplementInput).plan;
+}
+
+function currentPlanDigest(context: WorkflowNodeContext): string {
+  const adopted = context.outputs.adoptPlan as { planDigest?: unknown } | undefined;
+  if (typeof adopted?.planDigest === "string") return adopted.planDigest;
+  const documented = context.outputs.documentation as
+    | { exit?: string; output?: { planDigest?: unknown } }
+    | undefined;
+  if (documented?.exit === "ready" && typeof documented.output?.planDigest === "string") {
+    return documented.output.planDigest;
+  }
+  const plan = currentPlan(context);
+  if (plan === undefined) throw new Error("autoimplement does not have a selected plan");
+  return digest(plan);
+}
+
+function blockerChallenges(context: WorkflowNodeContext): BlockerChallenge[] {
+  return context.state.steps
+    .filter((step) => step.nodeId === "challengeBlocker" && step.outcome === "ok")
+    .map((step) => step.output as BlockerChallenge);
+}
+
+function latestBlockerClaim(context: WorkflowNodeContext): unknown {
+  const ids = [
+    "classifyImplementation",
+    "classifyVerification",
+    "repairReviewCommand",
+    "inspectComments",
+    "inspectCi",
+    "repairCiCommand",
+    "assessTrackedCi",
+    "classifyCi",
+    "finalizeDelivery",
+  ];
+  for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
+    const step = context.state.steps[index];
+    if (step && ids.includes(step.nodeId)) {
+      return { source: step.nodeId, result: step.output };
+    }
+  }
+  throw new Error("No model-generated blocker claim is available to challenge");
+}
+
+function recentWorkflowAttempts(context: WorkflowNodeContext): unknown[] {
+  return context.state.steps.slice(-12).map((step) => ({
+    nodeId: step.nodeId,
+    outcome: step.outcome,
+    output: step.output,
+  }));
 }
 
 function latestIssue(context: WorkflowNodeContext): unknown {
+  const approval = context.outputs.approval as
+    | { exit?: string; output?: { instructions?: unknown } }
+    | undefined;
+  if (approval?.exit === "replan" && typeof approval.output?.instructions === "string") {
+    return {
+      source: "human-replan",
+      instructions: approval.output.instructions,
+      priorPlanDigest: currentPlanDigest(context),
+    };
+  }
   const ids = [
+    "challengeBlocker",
     "classifyImplementation",
     "classifyVerification",
     "triageReview",
@@ -279,6 +539,8 @@ function reviewRounds(context: WorkflowNodeContext): ReviewAssessment[] {
 
 function latestBlockedReason(context: WorkflowNodeContext): { reason: string; evidence: unknown } {
   const candidates = [
+    "challengeBlockerGuard",
+    "challengeBlocker",
     "finalizeDelivery",
     "inspectCi",
     "assessTrackedCi",
@@ -287,7 +549,11 @@ function latestBlockedReason(context: WorkflowNodeContext): { reason: string; ev
     "classifyImplementation",
     "classifyVerification",
     "triageReview",
+    "replanGuard",
     "adoptPlan",
+    "findPlan",
+    "documentation",
+    "approval",
   ];
   for (let index = context.state.steps.length - 1; index >= 0; index -= 1) {
     const step = context.state.steps[index];
@@ -311,12 +577,48 @@ export const autoimplementWorkflow = defineWorkflow({
   presentationPrompt:
     "Summarize what was implemented, the review rounds by severity, the CI result, the PR or merge result, and any remaining limitation. Include exact validation commands.",
   startAt: "prepare",
-  maxSteps: 160,
+  maxSteps: 240,
   includes: {
+    documentation: includeWorkflow(autodocWorkflow, {
+      input: (context): AutodocInput => {
+        const request = context.input as AutoimplementInput;
+        const discovery = context.outputs.findPlan as ExistingPlanDiscovery | undefined;
+        const plan = currentPlan(context);
+        if (plan === undefined) throw new Error("autoimplement documentation is missing a plan");
+        return {
+          task: request.task,
+          plan,
+          ...(request.repository !== undefined ? { repository: request.repository } : {}),
+          documents:
+            request.documents ?? request.documentation?.documents ?? discovery?.documents ?? [],
+          evidence: latestIssue(context),
+        };
+      },
+    }),
+    approval: includeWorkflow(planApprovalWorkflow, {
+      input: (context): PlanApprovalInput => {
+        const request = context.input as AutoimplementInput;
+        if (request.approval === undefined) {
+          throw new Error("autoimplement approval was entered without an approval policy");
+        }
+        const plan = currentPlan(context);
+        if (plan === undefined) throw new Error("autoimplement approval is missing a plan");
+        const revisions = context.state.steps.filter(
+          (step) => step.nodeId === "approval/approve",
+        ).length;
+        return {
+          task: request.task,
+          plan,
+          planDigest: currentPlanDigest(context),
+          audience: request.approval.audience,
+          revision: revisions + 1,
+        };
+      },
+    }),
     redesign: includeWorkflow({
-      workflow: "autodevise",
-      contract: autodeviseWorkflow,
-      input: (context): AutodeviseInput => {
+      workflow: "autoplan",
+      contract: autoplanWorkflow,
+      input: (context): AutoplanInput => {
         const request = context.input as AutoimplementInput;
         return {
           problem: request.task,
@@ -340,25 +642,87 @@ export const autoimplementWorkflow = defineWorkflow({
   },
   nodes: {
     prepare: compute({
-      run: ({ input }) => ({
-        route: (input as AutoimplementInput).plan === undefined ? "redesign" : "implement",
-      }),
+      run: ({ input }) => {
+        const request = input as AutoimplementInput;
+        return {
+          route:
+            request.plan === undefined
+              ? "find"
+              : request.documentation?.status === "current"
+                ? "ready"
+                : "document",
+        };
+      },
+    }),
+    findPlan: agent({
+      statusDetail: "finding existing plan",
+      prompt: ({ input }) => {
+        const request = input as AutoimplementInput;
+        return [
+          "Find the clear plan that has already been selected for this task.",
+          "Use the current conversation context and referenced canonical documents.",
+          "Do not devise, improve, replace, document, or implement a plan.",
+          "Return blocked when no single clear existing plan can be found.",
+          "Report whether its canonical documentation is current, missing, or stale.",
+          `Task: ${request.task}`,
+          `Repository: ${request.repository ?? "current repository"}`,
+          `Referenced documents: ${JSON.stringify(request.documents ?? [])}`,
+        ].join("\n");
+      },
+      expectedOutput:
+        '{ "route": "found" | "blocked", "plan": {} (required when found), "documentation": "current" | "missing" | "stale" (required when found), "documents": ["canonical file"], "reason": "reason", "evidence": "evidence" }',
+      validate: parseExistingPlan,
+    }),
+    routeFoundPlan: compute({
+      run: ({ outputs }) => {
+        const discovered = outputs.findPlan as ExistingPlanDiscovery;
+        if (discovered.route !== "found" || discovered.plan === undefined) {
+          return { route: "blocked", reason: discovered.reason, evidence: discovered.evidence };
+        }
+        return {
+          route: discovered.documentation === "current" ? "ready" : "document",
+          plan: discovered.plan,
+          reason: discovered.reason,
+          evidence: discovered.evidence,
+        };
+      },
     }),
     adoptPlan: compute({
       run: ({ outputs }) => {
-        const result = includedResult(autodeviseWorkflow, outputs.redesign);
+        const result = includedResult(autoplanWorkflow, outputs.redesign);
         if (result.exit !== "ready") throw new Error("redesign did not return a ready plan");
         return {
-          route: result.output.changed ? "implement" : "blocked",
+          route: result.output.changed ? "document" : "blocked",
           plan: result.output.plan,
           planDigest: result.output.planDigest,
           changed: result.output.changed,
           reason: result.output.changed
-            ? "The plan changed in response to new evidence."
+            ? "The plan changed in response to new evidence and must be documented."
             : "Redesign returned the same plan for the same unresolved evidence.",
         };
       },
     }),
+    maybeApproval: compute({
+      run: ({ input }) => ({
+        route: (input as AutoimplementInput).approval === undefined ? "implement" : "approve",
+      }),
+    }),
+    replanGuard: compute({
+      run: (context) => {
+        const request = context.input as AutoimplementInput;
+        const limit = request.approval?.maxReplans ?? 3;
+        const replans = context.state.steps.filter(
+          (step) => step.nodeId === "approval/replan",
+        ).length;
+        return replans > limit
+          ? {
+              route: "blocked",
+              reason: `Plan approval reached the ${limit}-replan safety limit.`,
+              evidence: context.outputs.approval,
+            }
+          : { route: "redesign", replans, limit };
+      },
+    }),
     implement: agent({
       timeoutMs: 60 * 60_000,
       statusDetail: "implementing",
@@ -367,6 +731,8 @@ export const autoimplementWorkflow = defineWorkflow({
         return [
           `Implement this task end-to-end: ${request.task}`,
           `Plan: ${JSON.stringify(currentPlan(context))}`,
+          `Authorized scope: ${request.scope ?? request.repository ?? "the current repository and task"}`,
+          `Constraints: ${JSON.stringify(request.constraints ?? [])}`,
           "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.",
           "Do not merge yet.",
@@ -394,6 +760,51 @@ export const autoimplementWorkflow = defineWorkflow({
           "implementation assessment",
         ),
     }),
+    challengeBlockerGuard: compute({
+      run: (context) => {
+        const challenges = blockerChallenges(context);
+        return challenges.length >= MAX_BLOCKER_CHALLENGES
+          ? {
+              route: "blocked",
+              reason: `Blocker challenge reached the ${MAX_BLOCKER_CHALLENGES}-attempt workflow safety limit.`,
+              evidence: { attempts: challenges.length, challenges },
+            }
+          : {
+              route: "challenge",
+              attempt: challenges.length + 1,
+              limit: MAX_BLOCKER_CHALLENGES,
+            };
+      },
+    }),
+    challengeBlocker: agent({
+      statusDetail: "challenging blocker claim",
+      prompt: (context) => {
+        const request = context.input as AutoimplementInput;
+        return [
+          "Independently challenge the latest claim that autoimplement is blocked.",
+          "Are you really blocked?",
+          "Is this really a blocker right now?",
+          "Can you find a safe way to move forward and finish this?",
+          "Are you getting stuck on something trivial, procedural, reversible, or already authorized?",
+          "Inspect the task, approved plan, current result, evidence, scope, authority, previous attempts, and viable alternatives.",
+          "Distinguish a true external blocker from ordinary rollout work, local implementation work, a design adjustment, a missing verification step, or a reversible operational task.",
+          "A local test failure, stale package, packaging or artifact mismatch, rollback preparation, or deployment procedure is not by itself outside authority.",
+          "If a safe deployment and rollback path is already authorized, a supported cutover is work to do, not a blocker.",
+          "Confirm blocked only when the issue blocks progress now, is outside authority, and has no safe practical path forward.",
+          "Return continue with the next practical action when work can proceed. Keep text concise, with at most five alternatives and five evidence items.",
+          `Task: ${request.task}`,
+          `Approved plan: ${JSON.stringify(currentPlan(context))}`,
+          `Current result and claimed blocker: ${JSON.stringify(latestBlockerClaim(context))}`,
+          `Authorized scope: ${request.scope ?? request.repository ?? "the current repository and task"}`,
+          `Constraints and authority: ${JSON.stringify(request.constraints ?? [])}`,
+          `Merge authorized: ${request.merge === true}`,
+          `Previous blocker challenges: ${JSON.stringify(blockerChallenges(context))}`,
+          `Recent workflow attempts: ${JSON.stringify(recentWorkflowAttempts(context))}`,
+        ].join("\n");
+      },
+      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",
@@ -728,28 +1139,73 @@ export const autoimplementWorkflow = defineWorkflow({
   edges: [
     {
       from: "prepare",
-      switch: { on: "$.route", cases: { redesign: "redesign", implement: "implement" } },
+      switch: {
+        on: "$.route",
+        cases: { find: "findPlan", document: "documentation", ready: "maybeApproval" },
+      },
+    },
+    {
+      from: "findPlan",
+      switch: { on: "$.route", cases: { found: "routeFoundPlan", blocked: "blocked" } },
+    },
+    {
+      from: "routeFoundPlan",
+      switch: {
+        on: "$.route",
+        cases: { ready: "maybeApproval", document: "documentation", blocked: "blocked" },
+      },
     },
     { from: "redesign.ready", to: "adoptPlan" },
     { from: "redesign.blocked", to: "blocked" },
     {
       from: "adoptPlan",
-      switch: { on: "$.route", cases: { implement: "implement", blocked: "blocked" } },
+      switch: { on: "$.route", cases: { document: "documentation", blocked: "blocked" } },
+    },
+    { from: "documentation.ready", to: "maybeApproval" },
+    { from: "documentation.blocked", to: "blocked" },
+    {
+      from: "maybeApproval",
+      switch: { on: "$.route", cases: { approve: "approval", implement: "implement" } },
+    },
+    { from: "approval.continue", to: "implement" },
+    { from: "approval.stop", to: "blocked" },
+    { from: "approval.replan", to: "replanGuard" },
+    {
+      from: "replanGuard",
+      switch: { on: "$.route", cases: { redesign: "redesign", blocked: "blocked" } },
     },
     { from: "implement", to: "classifyImplementation" },
     {
       from: "classifyImplementation",
       switch: {
         on: "$.route",
-        cases: { verify: "verify", redesign: "redesign", fix: "fix", blocked: "blocked" },
+        cases: {
+          verify: "verify",
+          redesign: "redesign",
+          fix: "fix",
+          blocked: "challengeBlockerGuard",
+        },
       },
     },
+    {
+      from: "challengeBlockerGuard",
+      switch: { on: "$.route", cases: { challenge: "challengeBlocker", blocked: "blocked" } },
+    },
+    {
+      from: "challengeBlocker",
+      switch: { on: "$.route", cases: { continue: "redesign", blocked: "blocked" } },
+    },
     { from: "verify", to: "classifyVerification" },
     {
       from: "classifyVerification",
       switch: {
         on: "$.route",
-        cases: { publish: "publish", redesign: "redesign", fix: "fix", blocked: "blocked" },
+        cases: {
+          publish: "publish",
+          redesign: "redesign",
+          fix: "fix",
+          blocked: "challengeBlockerGuard",
+        },
       },
     },
     { from: "fix", to: "verify" },
@@ -768,7 +1224,10 @@ export const autoimplementWorkflow = defineWorkflow({
     },
     {
       from: "repairReviewCommand",
-      switch: { on: "$.route", cases: { retry: "runReview", blocked: "blocked" } },
+      switch: {
+        on: "$.route",
+        cases: { retry: "runReview", blocked: "challengeBlockerGuard" },
+      },
     },
     {
       from: "assessReview",
@@ -795,7 +1254,12 @@ export const autoimplementWorkflow = defineWorkflow({
       from: "inspectComments",
       switch: {
         on: "$.route",
-        cases: { redesign: "redesign", fix: "fix", ci: "inspectCi", blocked: "blocked" },
+        cases: {
+          redesign: "redesign",
+          fix: "fix",
+          ci: "inspectCi",
+          blocked: "challengeBlockerGuard",
+        },
       },
     },
     {
@@ -806,7 +1270,7 @@ export const autoimplementWorkflow = defineWorkflow({
           green: "finalizeDelivery",
           failed: "classifyCi",
           pending: "trackCi",
-          unavailable: "blocked",
+          unavailable: "challengeBlockerGuard",
         },
       },
     },
@@ -819,7 +1283,10 @@ export const autoimplementWorkflow = defineWorkflow({
     },
     {
       from: "repairCiCommand",
-      switch: { on: "$.route", cases: { retry: "trackCi", blocked: "blocked" } },
+      switch: {
+        on: "$.route",
+        cases: { retry: "trackCi", blocked: "challengeBlockerGuard" },
+      },
     },
     {
       from: "assessTrackedCi",
@@ -829,7 +1296,7 @@ export const autoimplementWorkflow = defineWorkflow({
           green: "finalizeDelivery",
           failed: "classifyCi",
           pending: "opportunisticTest",
-          unavailable: "blocked",
+          unavailable: "challengeBlockerGuard",
         },
       },
     },
@@ -842,13 +1309,16 @@ export const autoimplementWorkflow = defineWorkflow({
           redesign: "redesign",
           fix: "fix",
           unrelated: "finalizeDelivery",
-          blocked: "blocked",
+          blocked: "challengeBlockerGuard",
         },
       },
     },
     {
       from: "finalizeDelivery",
-      switch: { on: "$.status", cases: { completed: "finalize", blocked: "blocked" } },
+      switch: {
+        on: "$.status",
+        cases: { completed: "finalize", blocked: "challengeBlockerGuard" },
+      },
     },
   ],
 });