@osolmaz/pi-workflows 0.13.0 → 0.13.2

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: "autodoc", revision: "1", definition: autodocWorkflow },
-  { id: "autoimplement", revision: "9", definition: autoimplementWorkflow },
+  { 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: "plan-approval", revision: "4", definition: planApprovalWorkflow },
-  { id: "sanity-check", revision: "4", definition: sanityCheckWorkflow },
+  { id: "sanity-check", revision: "6", definition: sanityCheckWorkflow },
   {
     id: "monitor",
     revision: "11",