@osolmaz/pi-workflows 0.10.0 → 0.11.0

package/dist/builtins/autoimplement.workflow.d.ts

@@ -1,4 +1,7 @@
-import { type AutodeviseInput } from "./autodevise.workflow.js";
+import type { WorkflowNodeContext } from "../workflows/types.js";
+import { type AutodocInput } from "./autodoc.workflow.js";
+import { type AutoplanInput } from "./autoplan.workflow.js";
+import { type PlanApprovalInput } from "./plan-approval.workflow.js";
 export type AutoimplementInput = {
     task: string;
     plan?: unknown;
@@ -7,6 +10,24 @@ 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 ReviewFinding = {
     severity: "P0" | "P1" | "P2" | "lower";
@@ -48,14 +69,101 @@ export declare const autoimplementWorkflow: import("../workflows/types.js").Work
         readonly validate: (value: unknown) => AutoimplementBlocked;
     };
 }, {
-    readonly redesign: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<AutodeviseInput, {
+    readonly documentation: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<AutodocInput, {
         readonly ready: {
             readonly from: "finalize";
-            readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseReady;
+            readonly validate: (value: unknown) => import("./autodoc.workflow.js").DocumentedPlan;
         };
         readonly blocked: {
             readonly from: "blocked";
-            readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseBlocked;
+            readonly validate: (value: unknown) => import("./autodoc.workflow.js").AutodocBlocked;
+        };
+    }, import("../workflows/types.js").WorkflowIncludeMap> & {
+        nodes: {
+            readonly prepare: import("../workflows/types.js").ComputeNodeDefinition;
+            readonly locatePlan: import("../workflows/types.js").AgentNodeDefinition;
+            readonly inspectDocumentation: import("../workflows/types.js").AgentNodeDefinition;
+            readonly updateDocumentation: import("../workflows/types.js").AgentNodeDefinition;
+            readonly verifyDocumentation: import("../workflows/types.js").AgentNodeDefinition;
+            readonly finalize: import("../workflows/types.js").ComputeNodeDefinition;
+            readonly blocked: import("../workflows/types.js").ComputeNodeDefinition;
+        };
+        includes?: import("../workflows/types.js").WorkflowIncludeMap;
+        exits?: {
+            readonly ready: {
+                readonly from: "finalize";
+                readonly validate: (value: unknown) => import("./autodoc.workflow.js").DocumentedPlan;
+            };
+            readonly blocked: {
+                readonly from: "blocked";
+                readonly validate: (value: unknown) => import("./autodoc.workflow.js").AutodocBlocked;
+            };
+        };
+    }>;
+    readonly approval: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<PlanApprovalInput, {
+        readonly continue: {
+            readonly from: "continued";
+            readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalContinue;
+        };
+        readonly stop: {
+            readonly from: "stopped";
+            readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalStop;
+        };
+        readonly replan: {
+            readonly from: "replan";
+            readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalReplan;
+        };
+    }, import("../workflows/types.js").WorkflowIncludeMap> & {
+        nodes: {
+            readonly approve: import("../workflows/types.js").WorkflowNodeCommon & {
+                nodeType: "checkpoint";
+                summary?: string;
+                run?: (context: WorkflowNodeContext) => import("../workflows/types.js").MaybePromise<unknown>;
+                humanDecision?: import("../workflows/types.js").HumanDecisionNodeContract;
+            } & {
+                readonly __humanChoices?: {
+                    readonly continue: {
+                        readonly label: "Yes, continue";
+                    };
+                    readonly stop: {
+                        readonly label: "No, stop";
+                    };
+                    readonly replan: {
+                        readonly label: "Replan";
+                        readonly input: import("../workflows/types.js").HumanDecisionTextInput & {
+                            name: "instructions";
+                        };
+                    };
+                };
+            };
+            readonly continued: import("../workflows/types.js").ComputeNodeDefinition;
+            readonly stopped: import("../workflows/types.js").ComputeNodeDefinition;
+            readonly replan: import("../workflows/types.js").ComputeNodeDefinition;
+        };
+        includes?: import("../workflows/types.js").WorkflowIncludeMap;
+        exits?: {
+            readonly continue: {
+                readonly from: "continued";
+                readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalContinue;
+            };
+            readonly stop: {
+                readonly from: "stopped";
+                readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalStop;
+            };
+            readonly replan: {
+                readonly from: "replan";
+                readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalReplan;
+            };
+        };
+    }>;
+    readonly redesign: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<AutoplanInput, {
+        readonly ready: {
+            readonly from: "finalize";
+            readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanReady;
+        };
+        readonly blocked: {
+            readonly from: "blocked";
+            readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanBlocked;
         };
     }, import("../workflows/types.js").WorkflowIncludeMap> & {
         nodes: {
@@ -71,18 +179,22 @@ export declare const autoimplementWorkflow: import("../workflows/types.js").Work
         exits?: {
             readonly ready: {
                 readonly from: "finalize";
-                readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseReady;
+                readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanReady;
             };
             readonly blocked: {
                 readonly from: "blocked";
-                readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseBlocked;
+                readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanBlocked;
             };
         };
     }>;
 }> & {
     nodes: {
         readonly prepare: import("../workflows/types.js").ComputeNodeDefinition;
+        readonly findPlan: import("../workflows/types.js").AgentNodeDefinition;
+        readonly routeFoundPlan: import("../workflows/types.js").ComputeNodeDefinition;
         readonly adoptPlan: import("../workflows/types.js").ComputeNodeDefinition;
+        readonly maybeApproval: import("../workflows/types.js").ComputeNodeDefinition;
+        readonly replanGuard: import("../workflows/types.js").ComputeNodeDefinition;
         readonly implement: import("../workflows/types.js").AgentNodeDefinition;
         readonly classifyImplementation: import("../workflows/types.js").AgentNodeDefinition;
         readonly verify: import("../workflows/types.js").AgentNodeDefinition;
@@ -108,14 +220,101 @@ export declare const autoimplementWorkflow: import("../workflows/types.js").Work
         readonly finalize: import("../workflows/types.js").ComputeNodeDefinition;
     };
     includes?: {
-        readonly redesign: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<AutodeviseInput, {
+        readonly documentation: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<AutodocInput, {
+            readonly ready: {
+                readonly from: "finalize";
+                readonly validate: (value: unknown) => import("./autodoc.workflow.js").DocumentedPlan;
+            };
+            readonly blocked: {
+                readonly from: "blocked";
+                readonly validate: (value: unknown) => import("./autodoc.workflow.js").AutodocBlocked;
+            };
+        }, import("../workflows/types.js").WorkflowIncludeMap> & {
+            nodes: {
+                readonly prepare: import("../workflows/types.js").ComputeNodeDefinition;
+                readonly locatePlan: import("../workflows/types.js").AgentNodeDefinition;
+                readonly inspectDocumentation: import("../workflows/types.js").AgentNodeDefinition;
+                readonly updateDocumentation: import("../workflows/types.js").AgentNodeDefinition;
+                readonly verifyDocumentation: import("../workflows/types.js").AgentNodeDefinition;
+                readonly finalize: import("../workflows/types.js").ComputeNodeDefinition;
+                readonly blocked: import("../workflows/types.js").ComputeNodeDefinition;
+            };
+            includes?: import("../workflows/types.js").WorkflowIncludeMap;
+            exits?: {
+                readonly ready: {
+                    readonly from: "finalize";
+                    readonly validate: (value: unknown) => import("./autodoc.workflow.js").DocumentedPlan;
+                };
+                readonly blocked: {
+                    readonly from: "blocked";
+                    readonly validate: (value: unknown) => import("./autodoc.workflow.js").AutodocBlocked;
+                };
+            };
+        }>;
+        readonly approval: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<PlanApprovalInput, {
+            readonly continue: {
+                readonly from: "continued";
+                readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalContinue;
+            };
+            readonly stop: {
+                readonly from: "stopped";
+                readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalStop;
+            };
+            readonly replan: {
+                readonly from: "replan";
+                readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalReplan;
+            };
+        }, import("../workflows/types.js").WorkflowIncludeMap> & {
+            nodes: {
+                readonly approve: import("../workflows/types.js").WorkflowNodeCommon & {
+                    nodeType: "checkpoint";
+                    summary?: string;
+                    run?: (context: WorkflowNodeContext) => import("../workflows/types.js").MaybePromise<unknown>;
+                    humanDecision?: import("../workflows/types.js").HumanDecisionNodeContract;
+                } & {
+                    readonly __humanChoices?: {
+                        readonly continue: {
+                            readonly label: "Yes, continue";
+                        };
+                        readonly stop: {
+                            readonly label: "No, stop";
+                        };
+                        readonly replan: {
+                            readonly label: "Replan";
+                            readonly input: import("../workflows/types.js").HumanDecisionTextInput & {
+                                name: "instructions";
+                            };
+                        };
+                    };
+                };
+                readonly continued: import("../workflows/types.js").ComputeNodeDefinition;
+                readonly stopped: import("../workflows/types.js").ComputeNodeDefinition;
+                readonly replan: import("../workflows/types.js").ComputeNodeDefinition;
+            };
+            includes?: import("../workflows/types.js").WorkflowIncludeMap;
+            exits?: {
+                readonly continue: {
+                    readonly from: "continued";
+                    readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalContinue;
+                };
+                readonly stop: {
+                    readonly from: "stopped";
+                    readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalStop;
+                };
+                readonly replan: {
+                    readonly from: "replan";
+                    readonly validate: (value: unknown) => import("./plan-approval.workflow.js").PlanApprovalReplan;
+                };
+            };
+        }>;
+        readonly redesign: import("../workflows/types.js").WorkflowIncludeDefinition<import("../workflows/types.js").WorkflowDefinition<AutoplanInput, {
             readonly ready: {
                 readonly from: "finalize";
-                readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseReady;
+                readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanReady;
             };
             readonly blocked: {
                 readonly from: "blocked";
-                readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseBlocked;
+                readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanBlocked;
             };
         }, import("../workflows/types.js").WorkflowIncludeMap> & {
             nodes: {
@@ -131,11 +330,11 @@ export declare const autoimplementWorkflow: import("../workflows/types.js").Work
             exits?: {
                 readonly ready: {
                     readonly from: "finalize";
-                    readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseReady;
+                    readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanReady;
                 };
                 readonly blocked: {
                     readonly from: "blocked";
-                    readonly validate: (value: unknown) => import("./autodevise.workflow.js").AutodeviseBlocked;
+                    readonly validate: (value: unknown) => import("./autoplan.workflow.js").AutoplanBlocked;
                 };
             };
         }>;

package/dist/builtins/autoimplement.workflow.js

@@ -1,6 +1,9 @@
 import path from "node:path";
 import { agent, compute, defineWorkflow, includeWorkflow, includedResult, shell, } from "../workflows/definition.js";
-import autodeviseWorkflow, {} from "./autodevise.workflow.js";
+import { digest } from "../workflows/human-decision.js";
+import autodocWorkflow, {} from "./autodoc.workflow.js";
+import autoplanWorkflow, {} from "./autoplan.workflow.js";
+import planApprovalWorkflow, {} from "./plan-approval.workflow.js";
 const FIVE_MINUTES_MS = 5 * 60_000;
 const TEN_MINUTES_MS = 10 * 60_000;
 function requireRecord(value, label) {
@@ -25,6 +28,47 @@ function parseInput(value) {
     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;
+    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],
+        };
+    }
+    let approval;
+    if (input.approval !== undefined) {
+        const raw = requireRecord(input.approval, "autoimplement approval");
+        const maxReplans = raw.maxReplans ?? 3;
+        if (!Number.isInteger(maxReplans) ||
+            maxReplans < 1 ||
+            maxReplans > 20) {
+            throw new Error("autoimplement approval maxReplans must be from 1 through 20");
+        }
+        approval = {
+            audience: requireString(raw.audience, "autoimplement approval audience"),
+            maxReplans: maxReplans,
+        };
+    }
     return {
         task: requireString(input.task, "autoimplement task"),
         ...(input.plan !== undefined ? { plan: input.plan } : {}),
@@ -37,6 +81,38 @@ function parseInput(value) {
             ? { baseBranch: requireString(input.baseBranch, "baseBranch") }
             : {}),
         merge: input.merge === true,
+        ...(documents !== undefined ? { documents: [...documents] } : {}),
+        ...(documentation !== undefined ? { documentation } : {}),
+        ...(approval !== undefined ? { approval } : {}),
+    };
+}
+function parseExistingPlan(value) {
+    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 }
+            : {}),
+        documents: [...result.documents],
+        reason: requireString(result.reason, "existing plan discovery reason"),
+        evidence: result.evidence ?? null,
     };
 }
 function parseRoute(value, routes, label) {
@@ -124,9 +200,39 @@ function latestCiCommand(context) {
 }
 function currentPlan(context) {
     const adopted = context.outputs.adoptPlan;
-    return adopted?.plan ?? context.input.plan;
+    if (adopted?.plan !== undefined)
+        return adopted.plan;
+    const documented = context.outputs.documentation;
+    if (documented?.exit === "ready" && documented.output?.plan !== undefined) {
+        return documented.output.plan;
+    }
+    const discovered = context.outputs.findPlan;
+    if (discovered?.route === "found" && discovered.plan !== undefined)
+        return discovered.plan;
+    return context.input.plan;
+}
+function currentPlanDigest(context) {
+    const adopted = context.outputs.adoptPlan;
+    if (typeof adopted?.planDigest === "string")
+        return adopted.planDigest;
+    const documented = context.outputs.documentation;
+    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 latestIssue(context) {
+    const approval = context.outputs.approval;
+    if (approval?.exit === "replan" && typeof approval.output?.instructions === "string") {
+        return {
+            source: "human-replan",
+            instructions: approval.output.instructions,
+            priorPlanDigest: currentPlanDigest(context),
+        };
+    }
     const ids = [
         "classifyImplementation",
         "classifyVerification",
@@ -198,7 +304,11 @@ function latestBlockedReason(context) {
         "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];
@@ -222,11 +332,46 @@ export const autoimplementWorkflow = defineWorkflow({
     title: ({ input }) => `autoimplement: ${input.task.slice(0, 60)}`,
     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) => {
+                const request = context.input;
+                const discovery = context.outputs.findPlan;
+                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) => {
+                const request = context.input;
+                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,
+            workflow: "autoplan",
+            contract: autoplanWorkflow,
             input: (context) => {
                 const request = context.input;
                 return {
@@ -251,26 +396,84 @@ export const autoimplementWorkflow = defineWorkflow({
     },
     nodes: {
         prepare: compute({
-            run: ({ input }) => ({
-                route: input.plan === undefined ? "redesign" : "implement",
-            }),
+            run: ({ input }) => {
+                const request = input;
+                return {
+                    route: request.plan === undefined
+                        ? "find"
+                        : request.documentation?.status === "current"
+                            ? "ready"
+                            : "document",
+                };
+            },
+        }),
+        findPlan: agent({
+            statusDetail: "finding existing plan",
+            prompt: ({ input }) => {
+                const request = input;
+                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;
+                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.approval === undefined ? "implement" : "approve",
+            }),
+        }),
+        replanGuard: compute({
+            run: (context) => {
+                const request = context.input;
+                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",
@@ -279,6 +482,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.",
@@ -601,13 +806,40 @@ 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" },
         {