@osolmaz/pi-workflows 0.13.1 → 0.13.3

package/docs/workflows.md

@@ -85,6 +85,9 @@ type WorkflowNodeContext = {
   outputs: Record<string, unknown>; // accepted output per finished node id
   results: Record<string, WorkflowNodeResult>; // full result records, including failures
   state: WorkflowRunState; // the live run state (read-only by convention)
+  settings?: unknown; // fixed typed settings for this attempt, when declared
+  settingsScopeId?: string;
+  settingsChangeNumber?: number;
   signal: AbortSignal; // aborted on node timeout or run cancellation
 };
 ```
@@ -98,6 +101,12 @@ Long-running compute, action, and checkpoint callbacks should observe
 steps). When the node times out or the run is cancelled, the engine stops
 waiting immediately, but only cooperative callbacks stop doing work.
 
+A workflow can declare typed JSON settings with `workflowSettings()`. Each node
+attempt receives one fixed copy. Authorized changes use RFC 6902 JSON Patch and
+affect only later attempts. Use `settingsRoute()` for a pure route choice that
+must retry when a newer settings change wins before route settlement. See
+[Change workflow settings during a run](2026-08-25-workflow-settings.md).
+
 Function actions receive `WorkflowActionContext`, which adds
 `publishUpdate(update)`. Other callbacks keep the read-only node context.
 
@@ -424,6 +433,9 @@ The model sees one `workflow` tool. Its `action` field supports:
 - `status` for the active run or a supplied run ID.
 - `pause`, `resume`, and `cancel` for the active run.
 - `answer` with ordinary checkpoint input and an optional run ID. Protected `humanDecision()` gates reject this model-facing action.
+- `change-settings` with an RFC 6902 patch, optional scope ID, and optional expected change number.
+- `queue-follow-up` to save one ordered normal user prompt for after successful completion.
+- `remove-follow-up` to remove an unsent prompt created by the same model source.
 - `update` for a non-completing update from the current agent attempt.
 - `submit` for the current workflow step contract.
 
@@ -432,16 +444,25 @@ workflow prompt then starts a new turn. This keeps the requesting turn outside
 the workflow's first attempt and prevents an early missing-submission reminder.
 The normal extension offers all actions. The headless RPC bridge offers only
 `update` and `submit`, so a workflow child cannot recursively control other
-runs.
+runs. Direct `/workflow change-settings`, `queue-follow-up`, and
+`remove-follow-up` commands use verified interactive provenance. Controller
+code can use the matching `ctx.workflows` methods. All surfaces call the same
+SQLite operations.
+
+Follow-up prompts stay separate from workflow settings. Successful terminal
+state is saved before delivery. A final presentation settles first. The Pi
+extension then sends prompts in order as normal user messages without
+reactivating the completed run. See [Continue normal work after a workflow
+finishes](2026-08-25-workflow-follow-ups.md).
 
 ### Built-in plain summary
 
 The built-in `plain-summary` workflow turns supplied structured data into one
-short normal assistant message. Its input has `source`, `purpose`, optional
+normal assistant message. Its input has `source`, `purpose`, optional
 `mustInclude`, optional `maxChars`, optional `maxSentences`, and `format` set to
-`paragraphs`, `bullets`, or `mixed`. The workflow defaults to 2,000 characters,
-five sentences, and mixed format. These are workflow-specific limits;
-`assistantMessage()` itself has no default limit.
+`paragraphs`, `bullets`, or `mixed`. The workflow applies no character or
+sentence limit by default. A caller can request either limit with a positive
+integer. `assistantMessage()` itself also has no default limit.
 
 The summarizer uses only the supplied source, treats instructions inside that
 source as data, keeps required points, and returns the same text as its
@@ -452,11 +473,38 @@ before the parent continues.
 
 ### Built-in planning and implementation
 
-The built-in `autoplan` workflow records two through four practical candidates,
-describes the ideal separately, chooses one option, records a rejection reason
-for every other explicit option, and writes a detailed plan. It then includes
-`plain-summary` to show the chosen plan, its main steps, and the rejected options
-in one short assistant message. The detailed records remain in the run bundle. The standalone `autodoc` workflow finds an already selected plan, records it in canonical documentation, and never devises or implements. It prepares a safe workspace only when documentation must change. Program actions run candidate checks, compare eligible failures with the base revision in a temporary detached worktree, and keep matching baseline failures visible without blocking the current change. The built-in `autoimplement` workflow finds a clear existing plan from explicit input, conversation context, or referenced canonical documents. A missing-plan claim and every other non-exempt blocker enter one bounded challenge path. An explicit plan bypasses autodoc only when a current-document receipt carries its matching plan digest; otherwise autodoc inspects and adopts or updates the canonical documents. Later invalidating evidence returns to `autoplan` followed by `autodoc`.
+The built-in `autoplan` workflow first asks the model to capture everything the
+user has instructed for the intended purpose in the available conversation
+context. Relevant earlier and queued user messages must keep their wording and
+order. The model returns one `originalUserInstructions` string and must not
+summarize, rewrite, explain, label, omit, or add instructions. Validation checks
+only that the string is not empty and preserves the accepted text without
+normalization. Every later Autoplan agent prompt includes this string as the
+authoritative user instructions. Structured run input such as scope,
+constraints, a previous plan, and new evidence remains supplemental. Ready and
+blocked final outputs include the same string for audit and downstream use.
+
+Autoplan then records two through four practical candidates, describes the ideal
+separately, chooses one option, records a rejection reason for every other
+explicit option, and writes a detailed plan. It includes `plain-summary` to show
+the chosen plan, its main steps, and the rejected options in one assistant
+message without a character or sentence limit. The detailed records remain in
+the run bundle. See
+[Capture the user's complete intent in Autoplan](plans/2026-08-25-autoplan-user-intent-capture-plan.md)
+for the selected design and implementation plan.
+
+The standalone `autodoc` workflow finds an already selected plan, records it in
+canonical documentation, and never devises or implements. It prepares a safe
+workspace only when documentation must change. Program actions run candidate
+checks, compare eligible failures with the base revision in a temporary
+detached worktree, and keep matching baseline failures visible without blocking
+the current change. The built-in `autoimplement` workflow finds a clear existing
+plan from explicit input, conversation context, or referenced canonical
+documents. A missing-plan claim and every other non-exempt blocker enter one
+bounded challenge path. An explicit plan bypasses autodoc only when a
+current-document receipt carries its matching plan digest; otherwise autodoc
+inspects and adopts or updates the canonical documents. Later invalidating
+evidence returns to `autoplan` followed by `autodoc`.
 
 The built-in `plan-approval` workflow offers `continue`, `stop`, and exact-text `replan` exits. Its shared policy uses `auto`, `required`, or `skip` mode. Omitted policy defaults to `auto`: ask audience `operator`, then continue with the exact plan after 10 minutes without an answer. Required mode waits for a human. Skip mode creates no decision. Stop and replan always require a human answer.
 

package/examples/workflows/live-settings.workflow.ts

@@ -0,0 +1,93 @@
+import {
+  agent,
+  allowSettingsPath,
+  compute,
+  defineWorkflow,
+  settingsRoute,
+  workflowSettings,
+} from "@osolmaz/pi-workflows";
+
+type Settings = {
+  instructions: string[];
+  route: "normal" | "careful";
+  variables: Record<string, unknown>;
+};
+
+function parseSettings(value: unknown): Settings {
+  if (value === null || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("settings must be an object");
+  }
+  const settings = value as Partial<Settings>;
+  if (
+    !Array.isArray(settings.instructions) ||
+    !settings.instructions.every((item) => typeof item === "string") ||
+    (settings.route !== "normal" && settings.route !== "careful") ||
+    settings.variables === null ||
+    typeof settings.variables !== "object" ||
+    Array.isArray(settings.variables)
+  ) {
+    throw new Error("settings are invalid");
+  }
+  return {
+    instructions: [...settings.instructions],
+    route: settings.route,
+    variables: { ...settings.variables },
+  };
+}
+
+export default defineWorkflow({
+  name: "live-settings",
+  settings: workflowSettings<Settings>({
+    initial: { instructions: [], route: "normal", variables: {} },
+    parse: parseSettings,
+    description: "Instructions, variables, and the future route for this example.",
+    paths: [
+      allowSettingsPath("/instructions", {
+        read: ["session", "human"],
+        add: ["session", "human"],
+        remove: ["session", "human"],
+        replace: ["session", "human"],
+      }),
+      allowSettingsPath("/route", {
+        read: ["session", "human"],
+        replace: ["session", "human"],
+      }),
+      allowSettingsPath("/variables", {
+        read: ["session", "human"],
+        add: ["session", "human"],
+        remove: ["session", "human"],
+        replace: ["session", "human"],
+      }),
+    ],
+  }),
+  startAt: "prepare",
+  nodes: {
+    prepare: agent({
+      prompt: ({ settings }) =>
+        [
+          "Prepare the requested work.",
+          `Current instructions and variables: ${JSON.stringify(settings)}`,
+          "The user can change future settings or queue several post-completion prompts while this step runs.",
+        ].join("\n"),
+      expectedOutput: `{ "prepared": "summary" }`,
+    }),
+    choose: settingsRoute({
+      run: ({ settings }) => ({ route: (settings as Settings).route }),
+    }),
+    normal: compute({
+      run: ({ settings }) => ({ mode: "normal", settings }),
+    }),
+    careful: compute({
+      run: ({ settings }) => ({ mode: "careful", settings }),
+    }),
+  },
+  edges: [
+    { from: "prepare", to: "choose" },
+    {
+      from: "choose",
+      switch: { on: "$.route", cases: { normal: "normal", careful: "careful" } },
+    },
+  ],
+  presentationPrompt:
+    "Explain which route and settings were used. Any queued follow-up prompts run only after this response settles.",
+});

package/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "osolmaz.pi-workflows"
 name = "pi-workflows"
-version = "0.13.1"
+version = "0.13.3"
 min_herdr_version = "0.7.0"
 description = "Open the active pi-workflows run in piw from a managed Herdr pane."
 platforms = ["linux", "macos"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@osolmaz/pi-workflows",
-  "version": "0.13.1",
+  "version": "0.13.3",
   "description": "Workflow and controller runtime with a live terminal viewer for the pi coding agent",
   "keywords": [
     "pi-package"

package/src/builtins/autoimplement.workflow.ts

@@ -13,6 +13,7 @@ import {
   includedResult,
 } from "../workflows/definition.js";
 import { digest } from "../workflows/human-decision.js";
+import { allowSettingsPath, workflowSettings } from "../workflows/settings.js";
 import type { WorkflowActionContext, WorkflowNodeContext } from "../workflows/types.js";
 import autodocWorkflow, { type AutodocInput } from "./autodoc.workflow.js";
 import {
@@ -40,6 +41,11 @@ import workspacePreparationWorkflow, {
   type WorkspacePreparationInput,
 } from "./workspace-preparation.workflow.js";
 
+export type AutoimplementSettings = {
+  merge: boolean;
+  addedInstructions: string[];
+};
+
 export type AutoimplementInput = {
   task: string;
   plan?: unknown;
@@ -577,6 +583,27 @@ function parseInput(value: unknown): AutoimplementInput {
   };
 }
 
+function parseAutoimplementSettings(value: unknown): AutoimplementSettings {
+  const settings = requireRecord(value, "autoimplement settings");
+  if (typeof settings.merge !== "boolean") {
+    throw new Error("autoimplement settings merge must be a boolean");
+  }
+  if (
+    !Array.isArray(settings.addedInstructions) ||
+    settings.addedInstructions.some((item) => typeof item !== "string")
+  ) {
+    throw new Error("autoimplement settings addedInstructions must be an array of strings");
+  }
+  return {
+    merge: settings.merge,
+    addedInstructions: [...settings.addedInstructions] as string[],
+  };
+}
+
+function autoimplementSettings(context: WorkflowNodeContext): AutoimplementSettings {
+  return parseAutoimplementSettings(context.settings);
+}
+
 function parseExistingPlan(value: unknown): ExistingPlanDiscovery {
   const result = requireRecord(value, "existing plan discovery");
   if (result.route !== "found" && result.route !== "blocked") {
@@ -790,7 +817,7 @@ function createBlockerClaim(context: WorkflowNodeContext): BlockerClaim {
     unrelatedFailures: Array.isArray(result.unrelatedFailures) ? result.unrelatedFailures : [],
     recoveryAttempts: Array.isArray(result.repairAttempts) ? result.repairAttempts : [],
     alternativesChecked: [],
-    authorityFact: `scope=${(context.input as AutoimplementInput).scope ?? "unspecified"}; merge=${(context.input as AutoimplementInput).merge === true}`,
+    authorityFact: `scope=${(context.input as AutoimplementInput).scope ?? "unspecified"}; merge=${autoimplementSettings(context).merge}`,
   };
 }
 
@@ -919,8 +946,8 @@ function parseDeliveryResult(
   if (result.status !== "completed" && result.status !== "blocked") {
     throw new Error("delivery status must be completed or blocked");
   }
-  const request = context.input as AutoimplementInput;
-  if (request.merge !== true && result.merged === true) {
+  const settings = autoimplementSettings(context);
+  if (settings.merge !== true && result.merged === true) {
     throw new Error("delivery cannot merge without explicit merge: true");
   }
   if (result.status === "blocked") return result;
@@ -960,7 +987,7 @@ function parseDeliveryResult(
     }
     actual.set(repository.repository, repository);
   }
-  const mergeExpected = request.merge === true;
+  const mergeExpected = settings.merge === true;
   for (const expected of published) {
     const repository = actual.get(path.resolve(expected.repository));
     if (repository === undefined || repository.pr !== expected.pr) {
@@ -1298,6 +1325,28 @@ export const autoimplementWorkflow = defineWorkflow({
   contractId: "pi-workflows.autoimplement.v1",
   name: "autoimplement",
   input: parseInput,
+  settings: workflowSettings<AutoimplementSettings, AutoimplementInput>({
+    initial: (input) => ({ merge: input.merge === true, addedInstructions: [] }),
+    parse: parseAutoimplementSettings,
+    description: "Future merge behavior and instructions added during this run.",
+    paths: [
+      allowSettingsPath("/merge", {
+        read: ["session", "human"],
+        replace: ["session", "human"],
+      }),
+      allowSettingsPath("/addedInstructions", {
+        read: ["session", "human"],
+        add: ["session", "human"],
+        remove: ["session", "human"],
+        replace: ["session", "human"],
+      }),
+    ],
+    validateChange: ({ before, after, actor }) => {
+      if (actor.type === "session" && before.merge === false && after.merge === true) {
+        throw new Error("A model workflow step cannot grant merge authority");
+      }
+    },
+  }),
   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.",
@@ -1616,7 +1665,7 @@ export const autoimplementWorkflow = defineWorkflow({
           `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}`,
+          `Merge currently allowed: ${autoimplementSettings(context).merge === true}`,
           `Previous blocker challenges: ${JSON.stringify(blockerChallenges(context))}`,
           `Recent workflow attempts: ${JSON.stringify(recentWorkflowAttempts(context))}`,
         ].join("\n");
@@ -1925,10 +1974,9 @@ export const autoimplementWorkflow = defineWorkflow({
       timeoutMs: 30 * 60_000,
       statusDetail: "finalizing PRs",
       prompt: (context) => {
-        const request = context.input as AutoimplementInput;
         return [
-          request.merge === false
-            ? "Leave every verified PR ready without merging because input disabled merge."
+          autoimplementSettings(context).merge === false
+            ? "Leave every verified PR ready without merging because current workflow settings disable merge."
             : "Handle verified PRs one at a time and merge each unless repository policy or explicit user instructions prohibit it.",
           "Before each mutation, inspect the current PR head, merge state, and existing final report. Do not merge an already merged expected head or post a duplicate report.",
           "Use each repository's required merge method.",

package/src/builtins/autoplan.workflow.ts

@@ -46,8 +46,13 @@ export type AutoplanSelection = {
   blocker?: string;
 };
 
+export type AutoplanIntent = {
+  originalUserInstructions: string;
+};
+
 export type AutoplanReady = {
   status: "ready";
+  originalUserInstructions: string;
   frame: unknown;
   proposal: AutoplanProposal;
   ideal: AutoplanIdeal;
@@ -61,6 +66,7 @@ export type AutoplanReady = {
 
 export type AutoplanBlocked = {
   status: "blocked";
+  originalUserInstructions: string;
   frame: unknown;
   proposal: AutoplanProposal;
   ideal: AutoplanIdeal;
@@ -76,6 +82,25 @@ function requireRecord(value: unknown, label: string): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
+function parseIntent(value: unknown): AutoplanIntent {
+  const intent = requireRecord(value, "autoplan user intent");
+  const instructions = intent.originalUserInstructions;
+  if (typeof instructions !== "string" || instructions.trim().length === 0) {
+    throw new Error("autoplan originalUserInstructions must be a non-empty string");
+  }
+  return { originalUserInstructions: instructions };
+}
+
+function originalUserInstructions(outputs: Record<string, unknown>): string {
+  return parseIntent(outputs.captureIntent).originalUserInstructions;
+}
+
+function originalInstructionsPrompt(outputs: Record<string, unknown>): string {
+  return ["Original user instructions (authoritative):", originalUserInstructions(outputs)].join(
+    "\n",
+  );
+}
+
 function requireString(value: unknown, label: string): string {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new Error(`${label} must be a non-empty string`);
@@ -279,6 +304,7 @@ function summaryInput(
   const selected = candidateSummary(proposal, ideal, selection.selectedId);
   return {
     source: {
+      originalUserInstructions: originalUserInstructions(outputs),
       status: selection.status,
       selected,
       why: selection.why,
@@ -307,8 +333,6 @@ function summaryInput(
         : []),
       ...(blocked ? [selection.blocker as string] : ["The plan is selected for approval"]),
     ],
-    maxChars: 2_500,
-    maxSentences: 12,
     format: "mixed",
   };
 }
@@ -319,7 +343,7 @@ export const autoplanWorkflow = defineWorkflow({
   name: "autoplan",
   input: parseInput,
   title: ({ input }) => `autoplan: ${input.problem.slice(0, 60)}`,
-  startAt: "frame",
+  startAt: "captureIntent",
   maxSteps: 16,
   includes: {
     readySummary: includeWorkflow(plainSummaryWorkflow, {
@@ -340,18 +364,35 @@ export const autoplanWorkflow = defineWorkflow({
     },
   },
   nodes: {
+    captureIntent: agent({
+      statusDetail: "capturing the user's instructions",
+      prompt: () =>
+        [
+          "Read the conversation that came before this workflow step.",
+          "Return one text string named originalUserInstructions.",
+          "Include everything that the user has instructed for the intended purpose in the given context.",
+          "Include relevant earlier or queued user messages that are present in the context.",
+          "When several messages contribute, preserve their wording and chronological order in the one text value.",
+          "Do not summarize, rewrite, explain, label, omit, or add instructions.",
+          "Do not return an array or message objects.",
+        ].join("\n"),
+      expectedOutput: `{ "originalUserInstructions": "all relevant user instructions in one text string" }`,
+      validate: parseIntent,
+    }),
     frame: agent({
       statusDetail: "framing the problem",
-      prompt: ({ input }) => {
+      prompt: ({ outputs, input }) => {
         const request = input as AutoplanInput;
         return [
-          `Frame this problem: ${request.problem}`,
-          `Authorized scope: ${request.scope ?? "infer it conservatively from the request and current project"}.`,
+          originalInstructionsPrompt(outputs),
+          `Caller-provided problem description (supplemental): ${request.problem}`,
+          `Allowed scope: ${request.scope ?? "infer it conservatively from the request and current project"}.`,
           `Constraints: ${JSON.stringify(request.constraints ?? [])}.`,
           `Previous plan: ${JSON.stringify(request.previousPlan ?? null)}.`,
           `New evidence: ${JSON.stringify(request.newEvidence ?? null)}.`,
-          "Identify the goal, observable success criteria, systems in scope, systems outside scope, and interfaces we control.",
-          "Do not invent permission to change an upstream project, external service, or unrelated repository.",
+          "State the goal and describe what success looks like.",
+          "List the systems we may change and the systems we must leave alone. Name the interfaces we control.",
+          "Do not assume permission to change an upstream project, an external service, or an unrelated repository.",
         ].join("\n");
       },
       expectedOutput: `{ "problem": "concise statement", "success": ["criterion"], "inScope": ["change"], "outOfScope": ["change"], "constraints": ["constraint"], "controlBoundary": "what can change" }`,
@@ -361,12 +402,13 @@ export const autoplanWorkflow = defineWorkflow({
       statusDetail: "devising candidate solutions",
       prompt: ({ outputs, input }) =>
         [
-          "Devise two through four distinct practical solutions within the framed scope.",
-          "Each candidate needs a stable lowercase id, short title, plain gist, full solution, rationale, parts, and trade-offs.",
-          "Prefer a small number of general parts, clear ownership boundaries, and existing public interfaces.",
-          "Avoid one-off mechanisms and unnecessary infrastructure.",
-          "When a previous plan exists, mark it as a candidate or reject it with a reason.",
-          "Do not implement anything.",
+          originalInstructionsPrompt(outputs),
+          "Give two to four practical options that fit the allowed scope.",
+          "For each option return a stable lowercase id and a short title. Add a plain gist and full solution, explain the reason and trade-offs, and list the parts.",
+          "Favor a few reusable parts with clear owners and use interfaces that already exist.",
+          "Reject one-off machinery and infrastructure that the task does not need.",
+          "If the input includes an earlier plan, keep it as an option or explain why the new evidence rules it out.",
+          "Do not change files.",
           `Problem frame: ${JSON.stringify(outputs.frame)}`,
           `Previous plan: ${JSON.stringify((input as AutoplanInput).previousPlan ?? null)}`,
         ].join("\n"),
@@ -378,10 +420,11 @@ export const autoplanWorkflow = defineWorkflow({
       statusDetail: "describing the ideal end state",
       prompt: ({ outputs, input }) =>
         [
-          "Set the practical candidates aside and describe the holy grail for this problem.",
-          "The holy grail can match a candidate or exceed the current scope.",
-          "Name dependencies outside our authority instead of assuming they can change.",
-          "Explain the practical value beyond the candidates.",
+          originalInstructionsPrompt(outputs),
+          "Describe the best possible end state separately from the practical options.",
+          "It may match one option or go beyond the current scope.",
+          "List each dependency we do not control. Do not assume that it can change.",
+          "State what this end state would improve beyond the practical options.",
           `Problem frame: ${JSON.stringify(outputs.frame)}`,
           `Candidates: ${JSON.stringify(outputs.propose)}`,
           `New evidence: ${JSON.stringify((input as AutoplanInput).newEvidence ?? null)}`,
@@ -393,14 +436,15 @@ export const autoplanWorkflow = defineWorkflow({
       statusDetail: "choosing the practical solution",
       prompt: ({ outputs }) =>
         [
-          "Choose the right solution without asking the user to decide.",
-          "Choose the ideal when it is production-ready, proportionate, in scope, and implementable through interfaces we control.",
-          "Otherwise choose the strongest practical in-scope candidate with a clear path toward the ideal.",
-          "Do not block only because the ideal depends on work outside our authority.",
-          "Do not make an upstream change, unrelated repository, new service, or unapproved resource a requirement.",
-          "Prefer the simpler choice when options give materially equivalent results.",
-          "Return one rejection reason for every non-selected candidate, including the ideal when it is not selected.",
-          "Return blocked only when no truthful in-scope solution can meet the success criteria.",
+          originalInstructionsPrompt(outputs),
+          "Select one option. Do not ask the user to choose.",
+          "Select the ideal only when it fits the allowed scope and is ready for production. Its value must justify the added complexity.",
+          "Otherwise select the best option we can build now that still moves toward the ideal.",
+          "Work outside our control does not by itself make the plan blocked.",
+          "Do not require changes to an upstream project or an unrelated repository. Do not require a new service or resource without approval.",
+          "When two options solve the problem equally well, choose the simpler one.",
+          "Give one specific rejection reason for every option you do not select, including the ideal.",
+          "Return blocked only if no option inside the allowed scope can meet the success criteria.",
           `Frame: ${JSON.stringify(outputs.frame)}`,
           `Candidates: ${JSON.stringify(outputs.propose)}`,
           `Ideal candidate id: ideal`,
@@ -414,12 +458,13 @@ export const autoplanWorkflow = defineWorkflow({
       statusDetail: "writing the implementation plan",
       prompt: ({ outputs, input }) =>
         [
-          "Write a detailed implementation-ready plan for the selected solution.",
-          "Keep every step inside the framed scope and authority.",
-          "For each step, state what changes, where it changes, and how to verify it.",
-          "Include contract changes, compatibility boundaries, tests, rollout or migration work, and failure handling when they apply.",
-          "Use the new evidence to correct the previous plan when one exists.",
-          "Do not implement the plan.",
+          originalInstructionsPrompt(outputs),
+          "Turn the selected option into a plan that another engineer can implement.",
+          "Keep every step inside the allowed scope and authority.",
+          "For each step name the location and exact change before stating the check that proves it works.",
+          "Describe contract changes and compatibility boundaries before listing tests. Include rollout, migration, and failure handling only where they apply.",
+          "Correct the earlier plan when the new evidence proves it wrong.",
+          "Do not change files.",
           `Frame: ${JSON.stringify(outputs.frame)}`,
           `Selection: ${JSON.stringify(outputs.choose)}`,
           `Candidates: ${JSON.stringify(outputs.propose)}`,
@@ -434,6 +479,7 @@ export const autoplanWorkflow = defineWorkflow({
         const selection = outputs.choose as AutoplanSelection;
         return {
           status: "blocked",
+          originalUserInstructions: originalUserInstructions(outputs),
           frame: outputs.frame,
           proposal: outputs.propose as AutoplanProposal,
           ideal: outputs.ideal as AutoplanIdeal,
@@ -451,6 +497,7 @@ export const autoplanWorkflow = defineWorkflow({
           request.previousPlan === undefined ? undefined : digest(request.previousPlan);
         return {
           status: "ready",
+          originalUserInstructions: originalUserInstructions(outputs),
           frame: outputs.frame,
           proposal: outputs.propose as AutoplanProposal,
           ideal: outputs.ideal as AutoplanIdeal,
@@ -465,6 +512,7 @@ export const autoplanWorkflow = defineWorkflow({
     }),
   },
   edges: [
+    { from: "captureIntent", to: "frame" },
     { from: "frame", to: "propose" },
     { from: "propose", to: "ideal" },
     { from: "ideal", to: "choose" },

package/src/builtins/catalog.ts

@@ -8,12 +8,12 @@ import planApprovalWorkflow from "./plan-approval.workflow.js";
 import sanityCheckWorkflow from "./sanity-check.workflow.js";
 
 export const builtinWorkflowCatalog = new BuiltinWorkflowCatalog([
-  { id: "plain-summary", revision: "1", definition: plainSummaryWorkflow },
-  { id: "autoplan", revision: "2", definition: autoplanWorkflow },
+  { id: "plain-summary", revision: "3", definition: plainSummaryWorkflow },
+  { id: "autoplan", revision: "5", definition: autoplanWorkflow },
   { id: "autodoc", revision: "2", definition: autodocWorkflow },
-  { id: "autoimplement", revision: "10", definition: autoimplementWorkflow },
+  { id: "autoimplement", revision: "11", definition: autoimplementWorkflow },
   { id: "plan-approval", revision: "4", definition: planApprovalWorkflow },
-  { id: "sanity-check", revision: "4", definition: sanityCheckWorkflow },
+  { id: "sanity-check", revision: "6", definition: sanityCheckWorkflow },
   {
     id: "monitor",
     revision: "11",