@osolmaz/pi-workflows 0.11.2 → 0.12.1

package/src/builtins/catalog.ts

@@ -4,15 +4,17 @@ 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";
+import sanityCheckWorkflow from "./sanity-check.workflow.js";
 
 export const builtinWorkflowCatalog = new BuiltinWorkflowCatalog([
   { 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: "autoimplement", revision: "8", definition: autoimplementWorkflow },
+  { id: "plan-approval", revision: "4", definition: planApprovalWorkflow },
+  { id: "sanity-check", revision: "3", definition: sanityCheckWorkflow },
   {
     id: "monitor",
-    revision: "7",
+    revision: "9",
     definition: monitorWorkflow,
     legacySources: [
       {

package/src/builtins/index.ts

@@ -17,16 +17,40 @@ export {
   type AutoimplementInput,
   type ExistingPlanDiscovery,
 } from "./autoimplement.workflow.js";
+export type { AutoimplementConcurrency } from "./autoimplement-command-batches.js";
 export {
   default as monitorWorkflow,
   type MonitorInput,
   type MonitorRepairPolicy,
 } from "./monitor.workflow.js";
+export {
+  planChangeWorkflow,
+  type PlanChangeBlocked,
+  type PlanChangeInput,
+  type PlanChangeReady,
+} from "./plan-change.workflow.js";
 export { presentPlan } from "./plan-presentation.js";
+export {
+  sanityCheckWorkflow,
+  type ContributionEvidence,
+  type SanityCheckArea,
+  type SanityCheckAreaResult,
+  type SanityCheckEvidence,
+  type SanityCheckInput,
+  type SanityCheckMode,
+  type SanityCheckResult,
+  type SanityCheckReview,
+  type SanityCheckVerdict,
+} from "./sanity-check.workflow.js";
 export {
   planApprovalWorkflow,
+  parsePlanApprovalPolicy,
   type PlanApprovalContinue,
   type PlanApprovalInput,
+  type PlanApprovalMode,
+  type PlanApprovalPolicy,
   type PlanApprovalReplan,
+  type PlanApprovalResolution,
   type PlanApprovalStop,
+  type ResolvedPlanApprovalPolicy,
 } from "./plan-approval.workflow.js";

package/src/builtins/monitor.workflow.ts

@@ -20,10 +20,9 @@ import type {
   WorkflowProgressData,
 } from "../workflows/types.js";
 import { validateProgressData } from "../workflows/updates.js";
-import autodocWorkflow, { type AutodocInput } from "./autodoc.workflow.js";
 import autoimplementWorkflow, { type AutoimplementInput } from "./autoimplement.workflow.js";
-import autoplanWorkflow from "./autoplan.workflow.js";
-import planApprovalWorkflow, { type PlanApprovalInput } from "./plan-approval.workflow.js";
+import { parsePlanApprovalPolicy, type PlanApprovalPolicy } from "./plan-approval.workflow.js";
+import planChangeWorkflow, { type NormalizedPlanChangeInput } from "./plan-change.workflow.js";
 
 const MIN_INTERVAL_MINUTES = 1;
 const MAX_INTERVAL_MINUTES = 24 * 60;
@@ -47,10 +46,7 @@ export type MonitorRepairPolicy = {
   repository?: string;
   baseBranch?: string;
   merge?: boolean;
-  approval?: {
-    audience: string;
-    maxReplans: number;
-  };
+  approval?: PlanApprovalPolicy;
 };
 
 export type MonitorInput = {
@@ -169,22 +165,7 @@ export function prepareMonitorInput(input: unknown): MonitorConfig {
     if (raw.merge !== undefined && typeof raw.merge !== "boolean") {
       throw new Error("repair merge must be a boolean");
     }
-    let approval: MonitorRepairPolicy["approval"];
-    if (raw.approval !== undefined) {
-      const value = requireRecord(raw.approval, "repair approval");
-      const maxReplans = value.maxReplans ?? 3;
-      if (
-        !Number.isInteger(maxReplans) ||
-        (maxReplans as number) < 1 ||
-        (maxReplans as number) > 20
-      ) {
-        throw new Error("repair approval maxReplans must be from 1 through 20");
-      }
-      approval = {
-        audience: requireBoundedString(value.audience, "repair approval audience", 200),
-        maxReplans: maxReplans as number,
-      };
-    }
+    const approval = parsePlanApprovalPolicy(raw.approval);
     repair = {
       authorized: true,
       ...(raw.scope !== undefined
@@ -198,7 +179,7 @@ export function prepareMonitorInput(input: unknown): MonitorConfig {
         ? { baseBranch: requireBoundedString(raw.baseBranch, "repair base branch", 256) }
         : {}),
       ...(raw.merge !== undefined ? { merge: raw.merge !== false } : {}),
-      ...(approval !== undefined ? { approval } : {}),
+      approval,
     };
   }
   return {
@@ -325,61 +306,27 @@ function currentRepairPlan(outputs: Record<string, unknown>): {
   planDigest: string;
   documents: string[];
 } {
-  const documentation = outputs.documentation as
-    | {
-        exit?: string;
-        output?: {
-          plan?: unknown;
-          planDigest?: string;
-          documentation?: { files?: string[] };
-        };
-      }
-    | undefined;
-  if (
-    documentation?.exit === "ready" &&
-    documentation.output?.plan !== undefined &&
-    typeof documentation.output.planDigest === "string"
-  ) {
-    return {
-      plan: documentation.output.plan,
-      planDigest: documentation.output.planDigest,
-      documents: documentation.output.documentation?.files ?? [],
-    };
-  }
-  const design = includedResult(autoplanWorkflow, outputs.initialDesign);
-  if (design.exit !== "ready") throw new Error("monitor design did not return a ready plan");
-  return { plan: design.output.plan, planDigest: design.output.planDigest, documents: [] };
-}
-
-function latestReplanInstructions(outputs: Record<string, unknown>): string | undefined {
-  const approval = outputs.approval as
-    | { exit?: string; output?: { instructions?: unknown } }
-    | undefined;
-  return approval?.exit === "replan" && typeof approval.output?.instructions === "string"
-    ? approval.output.instructions
-    : undefined;
+  const result = includedResult(planChangeWorkflow, outputs.planChange);
+  if (result.exit !== "ready") throw new Error("monitor plan change did not return a ready plan");
+  return {
+    plan: result.output.plan,
+    planDigest: result.output.planDigest,
+    documents: result.output.documents,
+  };
 }
 
 function repairBlockedReason(outputs: Record<string, unknown>): string {
   const guard = outputs.repairGuard as { reason?: string; route?: string } | undefined;
   if (guard?.route === "blocked" && guard.reason !== undefined) return guard.reason;
-  const replan = outputs.replanGuard as { reason?: string; route?: string } | undefined;
-  if (replan?.route === "blocked" && replan.reason !== undefined) return replan.reason;
-  const approval = outputs.approval as { exit?: string; output?: { status?: string } } | undefined;
-  if (approval?.exit === "stop") return "The operator stopped the proposed repair.";
-  const documentation = outputs.documentation as
+  const planChange = outputs.planChange as
     | { exit?: string; output?: { reason?: string } }
     | undefined;
   const implementation = outputs.implementation as
     | { exit?: string; output?: { reason?: string } }
     | undefined;
-  const design = outputs.initialDesign as
-    | { exit?: string; output?: { reason?: string } }
-    | undefined;
   return (
     implementation?.output?.reason ??
-    documentation?.output?.reason ??
-    design?.output?.reason ??
+    planChange?.output?.reason ??
     "The repair did not produce new verified progress."
   );
 }
@@ -427,67 +374,28 @@ const monitorWorkflow: WorkflowDefinition = defineWorkflow({
   startAt: "prepare",
   maxSteps: 200_000,
   includes: {
-    initialDesign: includeWorkflow({
-      workflow: "autoplan",
-      contract: autoplanWorkflow,
-      input: ({ outputs }) => {
+    planChange: includeWorkflow(planChangeWorkflow, {
+      input: ({ outputs }): NormalizedPlanChangeInput => {
         const config = configFrom(outputs);
         const repair = (outputs.check as MonitorCheck).repair;
         if (repair === undefined) throw new Error("monitor repair details are missing");
-        const prior = outputs.initialDesign as
+        const prior = outputs.planChange as
           | { exit?: string; output?: { plan?: unknown } }
           | undefined;
-        const instructions = latestReplanInstructions(outputs);
         return {
-          problem: repair.problem,
+          task: repair.problem,
           ...(config.repair?.scope !== undefined ? { scope: config.repair.scope } : {}),
           ...(config.repair?.constraints !== undefined
             ? { constraints: config.repair.constraints }
             : {}),
-          ...(prior?.exit === "ready" && prior.output?.plan !== undefined
-            ? { previousPlan: prior.output.plan }
-            : {}),
-          newEvidence:
-            instructions === undefined
-              ? repair.evidence
-              : { observedEvidence: repair.evidence, operatorInstructions: instructions },
-        };
-      },
-    }),
-    documentation: includeWorkflow(autodocWorkflow, {
-      input: ({ outputs }): AutodocInput => {
-        const config = configFrom(outputs);
-        const repair = (outputs.check as MonitorCheck).repair;
-        const design = includedResult(autoplanWorkflow, outputs.initialDesign);
-        if (design.exit !== "ready") throw new Error("monitor design did not return a ready plan");
-        if (repair === undefined) throw new Error("monitor repair details are missing");
-        return {
-          task: repair.problem,
-          plan: design.output.plan,
           ...(config.repair?.repository !== undefined
             ? { repository: config.repair.repository }
             : {}),
-          evidence: latestReplanInstructions(outputs) ?? repair.evidence,
-        };
-      },
-    }),
-    approval: includeWorkflow(planApprovalWorkflow, {
-      input: ({ outputs, state }): PlanApprovalInput => {
-        const config = configFrom(outputs);
-        const repair = (outputs.check as MonitorCheck).repair;
-        const approval = config.repair?.approval;
-        if (repair === undefined || approval === undefined) {
-          throw new Error("monitor approval was entered without an approval policy");
-        }
-        const current = currentRepairPlan(outputs);
-        const revision =
-          state.steps.filter((step) => step.nodeId === "approval/approve").length + 1;
-        return {
-          task: repair.problem,
-          plan: current.plan,
-          planDigest: current.planDigest,
-          audience: approval.audience,
-          revision,
+          ...(prior?.exit === "ready" && prior.output?.plan !== undefined
+            ? { previousPlan: prior.output.plan }
+            : {}),
+          newEvidence: repair.evidence,
+          approval: parsePlanApprovalPolicy(config.repair?.approval),
         };
       },
     }),
@@ -517,6 +425,7 @@ const monitorWorkflow: WorkflowDefinition = defineWorkflow({
           ...(config.repair?.baseBranch !== undefined
             ? { baseBranch: config.repair.baseBranch }
             : {}),
+          approval: parsePlanApprovalPolicy(config.repair?.approval),
           merge: config.repair?.merge === true,
         };
         return request;
@@ -603,25 +512,6 @@ const monitorWorkflow: WorkflowDefinition = defineWorkflow({
             }
           : { route: "repair", reason: "The issue is new or has changed evidence." },
     }),
-    approvalRoute: compute({
-      run: ({ outputs }) => ({
-        route: configFrom(outputs).repair?.approval === undefined ? "implement" : "approve",
-      }),
-    }),
-    replanGuard: compute({
-      run: (context) => {
-        const limit = configFrom(context.outputs).repair?.approval?.maxReplans ?? 3;
-        const replans = context.state.steps.filter(
-          (step) => step.nodeId === "approval/replan",
-        ).length;
-        return replans > limit
-          ? {
-              route: "blocked",
-              reason: `Monitor repair reached the ${limit}-replan safety limit.`,
-            }
-          : { route: "design", replans, limit };
-      },
-    }),
     repairBlocked: compute({
       run: (context) => ({
         reason: repairBlockedReason(context.outputs),
@@ -707,23 +597,10 @@ const monitorWorkflow: WorkflowDefinition = defineWorkflow({
     },
     {
       from: "repairGuard",
-      switch: { on: "$.route", cases: { repair: "initialDesign", blocked: "repairBlocked" } },
-    },
-    { from: "initialDesign.ready", to: "documentation" },
-    { from: "initialDesign.blocked", to: "repairBlocked" },
-    { from: "documentation.ready", to: "approvalRoute" },
-    { from: "documentation.blocked", to: "repairBlocked" },
-    {
-      from: "approvalRoute",
-      switch: { on: "$.route", cases: { approve: "approval", implement: "implementation" } },
-    },
-    { from: "approval.continue", to: "implementation" },
-    { from: "approval.stop", to: "repairBlocked" },
-    { from: "approval.replan", to: "replanGuard" },
-    {
-      from: "replanGuard",
-      switch: { on: "$.route", cases: { design: "initialDesign", blocked: "repairBlocked" } },
+      switch: { on: "$.route", cases: { repair: "planChange", blocked: "repairBlocked" } },
     },
+    { from: "planChange.ready", to: "implementation" },
+    { from: "planChange.blocked", to: "repairBlocked" },
     { from: "implementation.completed", to: "check" },
     { from: "implementation.blocked", to: "repairBlocked" },
     { from: "repairBlocked", to: "repairReport" },