@osolmaz/pi-workflows 0.10.0 → 0.11.0

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 = {
@@ -94,6 +116,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 +173,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,10 +313,43 @@ 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 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 = [
     "classifyImplementation",
     "classifyVerification",
@@ -287,7 +423,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 +451,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 +516,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 +605,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.",
@@ -728,13 +968,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" },
     {

package/src/builtins/{autodevise.workflow.ts → autoplan.workflow.ts}

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import { agent, compute, defineWorkflow } from "../workflows/definition.js";
 
-export type AutodeviseInput = {
+export type AutoplanInput = {
   problem: string;
   scope?: string;
   constraints?: string[];
@@ -9,7 +9,7 @@ export type AutodeviseInput = {
   newEvidence?: unknown;
 };
 
-export type AutodeviseReady = {
+export type AutoplanReady = {
   status: "ready";
   frame: unknown;
   proposal: unknown;
@@ -21,7 +21,7 @@ export type AutodeviseReady = {
   changed: boolean;
 };
 
-export type AutodeviseBlocked = {
+export type AutoplanBlocked = {
   status: "blocked";
   frame: unknown;
   proposal: unknown;
@@ -44,18 +44,18 @@ function requireString(value: unknown, label: string): string {
   return value.trim();
 }
 
-function parseInput(value: unknown): AutodeviseInput {
-  const input = requireRecord(value, "autodevise input");
+function parseInput(value: unknown): AutoplanInput {
+  const input = requireRecord(value, "autoplan input");
   const constraints = input.constraints;
   if (
     constraints !== undefined &&
     (!Array.isArray(constraints) || constraints.some((item) => typeof item !== "string"))
   ) {
-    throw new Error("autodevise constraints must be an array of strings");
+    throw new Error("autoplan constraints must be an array of strings");
   }
   return {
-    problem: requireString(input.problem, "autodevise problem"),
-    ...(input.scope !== undefined ? { scope: requireString(input.scope, "autodevise scope") } : {}),
+    problem: requireString(input.problem, "autoplan problem"),
+    ...(input.scope !== undefined ? { scope: requireString(input.scope, "autoplan scope") } : {}),
     ...(constraints !== undefined ? { constraints: [...constraints] as string[] } : {}),
     ...(input.previousPlan !== undefined ? { previousPlan: input.previousPlan } : {}),
     ...(input.newEvidence !== undefined ? { newEvidence: input.newEvidence } : {}),
@@ -63,13 +63,13 @@ function parseInput(value: unknown): AutodeviseInput {
 }
 
 function parseSelection(value: unknown): Record<string, unknown> {
-  const selection = requireRecord(value, "autodevise selection");
+  const selection = requireRecord(value, "autoplan selection");
   if (selection.status !== "ready" && selection.status !== "blocked") {
-    throw new Error("autodevise selection status must be ready or blocked");
+    throw new Error("autoplan selection status must be ready or blocked");
   }
-  requireString(selection.selected, "autodevise selected solution");
-  requireString(selection.why, "autodevise selection reason");
-  if (selection.status === "blocked") requireString(selection.blocker, "autodevise blocker");
+  requireString(selection.selected, "autoplan selected solution");
+  requireString(selection.why, "autoplan selection reason");
+  if (selection.status === "blocked") requireString(selection.blocker, "autoplan blocker");
   return selection;
 }
 
@@ -77,12 +77,12 @@ function digest(value: unknown): string {
   return `sha256:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
 }
 
-export const autodeviseWorkflow = defineWorkflow({
+export const autoplanWorkflow = defineWorkflow({
   source: import.meta.url,
-  contractId: "pi-workflows.autodevise.v1",
-  name: "autodevise",
+  contractId: "pi-workflows.autoplan.v1",
+  name: "autoplan",
   input: parseInput,
-  title: ({ input }) => `autodevise: ${input.problem.slice(0, 60)}`,
+  title: ({ input }) => `autoplan: ${input.problem.slice(0, 60)}`,
   presentationPrompt: [
     "Present the selected practical solution and its implementation plan.",
     "Briefly state how the ideal informed the choice and what was excluded as outside scope.",
@@ -93,18 +93,18 @@ export const autodeviseWorkflow = defineWorkflow({
   exits: {
     ready: {
       from: "finalize",
-      validate: (value: unknown): AutodeviseReady => value as AutodeviseReady,
+      validate: (value: unknown): AutoplanReady => value as AutoplanReady,
     },
     blocked: {
       from: "blocked",
-      validate: (value: unknown): AutodeviseBlocked => value as AutodeviseBlocked,
+      validate: (value: unknown): AutoplanBlocked => value as AutoplanBlocked,
     },
   },
   nodes: {
     frame: agent({
       statusDetail: "framing the problem",
       prompt: ({ input }) => {
-        const request = input as AutodeviseInput;
+        const request = input as AutoplanInput;
         return [
           `Frame this problem: ${request.problem}`,
           `Authorized scope: ${request.scope ?? "infer it conservatively from the request and current project"}.`,
@@ -116,7 +116,7 @@ export const autodeviseWorkflow = defineWorkflow({
         ].join("\n");
       },
       expectedOutput: `{ "problem": "concise statement", "success": ["criterion"], "inScope": ["change"], "outOfScope": ["change"], "constraints": ["constraint"], "controlBoundary": "what can change" }`,
-      validate: (value) => requireRecord(value, "autodevise frame"),
+      validate: (value) => requireRecord(value, "autoplan frame"),
     }),
     propose: agent({
       statusDetail: "devising a solution",
@@ -129,7 +129,7 @@ export const autodeviseWorkflow = defineWorkflow({
           `Problem frame: ${JSON.stringify(outputs.frame)}`,
         ].join("\n"),
       expectedOutput: `{ "solution": "proposal", "rationale": "why", "parts": ["part"], "tradeoffs": ["trade-off"] }`,
-      validate: (value) => requireRecord(value, "autodevise proposal"),
+      validate: (value) => requireRecord(value, "autoplan proposal"),
     }),
     ideal: agent({
       statusDetail: "describing the ideal end state",
@@ -141,10 +141,10 @@ export const autodeviseWorkflow = defineWorkflow({
           "Explain the practical value beyond the proposal.",
           `Problem frame: ${JSON.stringify(outputs.frame)}`,
           `Proposal: ${JSON.stringify(outputs.propose)}`,
-          `New evidence: ${JSON.stringify((input as AutodeviseInput).newEvidence ?? null)}`,
+          `New evidence: ${JSON.stringify((input as AutoplanInput).newEvidence ?? null)}`,
         ].join("\n"),
       expectedOutput: `{ "ideal": "ideal end state", "outsideDependencies": ["dependency"], "additionalValue": ["benefit"] }`,
-      validate: (value) => requireRecord(value, "autodevise ideal"),
+      validate: (value) => requireRecord(value, "autoplan ideal"),
     }),
     choose: agent({
       statusDetail: "choosing the practical solution",
@@ -177,11 +177,11 @@ export const autodeviseWorkflow = defineWorkflow({
           "Do not implement the plan.",
           `Frame: ${JSON.stringify(outputs.frame)}`,
           `Selection: ${JSON.stringify(outputs.choose)}`,
-          `Previous plan: ${JSON.stringify((input as AutodeviseInput).previousPlan ?? null)}`,
-          `New evidence: ${JSON.stringify((input as AutodeviseInput).newEvidence ?? null)}`,
+          `Previous plan: ${JSON.stringify((input as AutoplanInput).previousPlan ?? null)}`,
+          `New evidence: ${JSON.stringify((input as AutoplanInput).newEvidence ?? null)}`,
         ].join("\n"),
       expectedOutput: `{ "summary": "approach", "steps": [{ "change": "change", "where": "location", "verification": "evidence" }], "contracts": ["impact"], "tests": ["test"], "risks": [{ "risk": "risk", "mitigation": "mitigation" }], "boundaries": ["excluded work"] }`,
-      validate: (value) => requireRecord(value, "autodevise plan"),
+      validate: (value) => requireRecord(value, "autoplan plan"),
     }),
     blocked: compute({
       run: ({ outputs }) => {
@@ -192,13 +192,13 @@ export const autodeviseWorkflow = defineWorkflow({
           proposal: outputs.propose,
           ideal: outputs.ideal,
           selection,
-          reason: requireString(selection.blocker, "autodevise blocker"),
-        } satisfies AutodeviseBlocked;
+          reason: requireString(selection.blocker, "autoplan blocker"),
+        } satisfies AutoplanBlocked;
       },
     }),
     finalize: compute({
       run: ({ outputs, input }) => {
-        const request = input as AutodeviseInput;
+        const request = input as AutoplanInput;
         const planDigest = digest(outputs.plan);
         const previousPlanDigest =
           request.previousPlan === undefined ? undefined : digest(request.previousPlan);
@@ -212,7 +212,7 @@ export const autodeviseWorkflow = defineWorkflow({
           planDigest,
           ...(previousPlanDigest !== undefined ? { previousPlanDigest } : {}),
           changed: previousPlanDigest === undefined || previousPlanDigest !== planDigest,
-        } satisfies AutodeviseReady;
+        } satisfies AutoplanReady;
       },
     }),
   },
@@ -228,4 +228,4 @@ export const autodeviseWorkflow = defineWorkflow({
   ],
 });
 
-export default autodeviseWorkflow;
+export default autoplanWorkflow;

package/src/builtins/catalog.ts

@@ -1,14 +1,18 @@
 import { BuiltinWorkflowCatalog } from "../workflows/catalog.js";
-import autodeviseWorkflow from "./autodevise.workflow.js";
+import autodocWorkflow from "./autodoc.workflow.js";
 import autoimplementWorkflow from "./autoimplement.workflow.js";
+import autoplanWorkflow from "./autoplan.workflow.js";
 import monitorWorkflow from "./monitor.workflow.js";
+import planApprovalWorkflow from "./plan-approval.workflow.js";
 
 export const builtinWorkflowCatalog = new BuiltinWorkflowCatalog([
-  { id: "autodevise", revision: "1", definition: autodeviseWorkflow },
-  { id: "autoimplement", revision: "1", definition: autoimplementWorkflow },
+  { id: "autoplan", revision: "1", definition: autoplanWorkflow },
+  { id: "autodoc", revision: "1", definition: autodocWorkflow },
+  { id: "autoimplement", revision: "4", definition: autoimplementWorkflow },
+  { id: "plan-approval", revision: "2", definition: planApprovalWorkflow },
   {
     id: "monitor",
-    revision: "4",
+    revision: "7",
     definition: monitorWorkflow,
     legacySources: [
       {

package/src/builtins/index.ts

@@ -1,13 +1,32 @@
 export {
-  autodeviseWorkflow,
-  type AutodeviseBlocked,
-  type AutodeviseInput,
-  type AutodeviseReady,
-} from "./autodevise.workflow.js";
+  autoplanWorkflow,
+  type AutoplanBlocked,
+  type AutoplanInput,
+  type AutoplanReady,
+} from "./autoplan.workflow.js";
+export {
+  autodocWorkflow,
+  type AutodocBlocked,
+  type AutodocInput,
+  type DocumentedPlan,
+} from "./autodoc.workflow.js";
 export {
   autoimplementWorkflow,
   type AutoimplementBlocked,
   type AutoimplementCompleted,
   type AutoimplementInput,
+  type ExistingPlanDiscovery,
 } from "./autoimplement.workflow.js";
-export { default as monitorWorkflow, type MonitorInput } from "./monitor.workflow.js";
+export {
+  default as monitorWorkflow,
+  type MonitorInput,
+  type MonitorRepairPolicy,
+} from "./monitor.workflow.js";
+export { presentPlan } from "./plan-presentation.js";
+export {
+  planApprovalWorkflow,
+  type PlanApprovalContinue,
+  type PlanApprovalInput,
+  type PlanApprovalReplan,
+  type PlanApprovalStop,
+} from "./plan-approval.workflow.js";