@wichayutdew/pi-workflows 3.6.0 → 3.7.0

package/dist/index.js

@@ -731,6 +731,13 @@ function parseWorkflowStep(value, stepId, path, errors) {
       errors.push(`${path}.transitions: artifact-contract retry requires a "retry" transition`);
     }
   }
+  if (agent && maxToolCalls !== undefined) {
+    if (!Object.hasOwn(transitions, "handoff")) {
+      errors.push(`${path}.transitions: maxToolCalls requires a "handoff" transition`);
+    } else if (transitions.handoff !== stepId) {
+      errors.push(`${path}.transitions: handoff transition must target "${stepId}"`);
+    }
+  }
   if (workspace) {
     workspace.bindOn.forEach((outcome) => {
       if (!Object.hasOwn(transitions, outcome)) {
@@ -2615,6 +2622,22 @@ var RESULT_KEYS = new Set([
 var isObject = (value) => {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 };
+function validateNonSuccessSummary(outcome, summary) {
+  if (outcome === "blocked") {
+    const isActionable = /^# Blocked:\s+.+/m.test(summary) && /^\s*\*\*Action:\*\*\s+.+/m.test(summary) && /^\s*\*\*Next:\*\*\s+.+/m.test(summary);
+    if (!isActionable) {
+      throw new Error("blocked summary must identify the missing user prerequisite and next action");
+    }
+  }
+  if (outcome === "retry") {
+    const describesTransientFailure = /\btransient\b/i.test(summary);
+    const hasSafeRetryCondition = /\b(safe (retry|to retry)|retry (when|after|once))\b/i.test(summary);
+    const requestsUserInput = /\b(provide|confirm|choose|approve|decide)\b/i.test(summary);
+    if (!/^# Retry:\s+.+/m.test(summary) || !describesTransientFailure || !hasSafeRetryCondition || requestsUserInput) {
+      throw new Error("retry summary must identify a transient failure and safe retry condition");
+    }
+  }
+}
 function parseResultWorkspace(value, outcome, policy) {
   const requiresWorkspace = policy.workspace?.bindOn.includes(outcome) === true;
   if (!requiresWorkspace) {
@@ -2669,6 +2692,7 @@ function parseWorkflowStepResult(value, policy) {
   if (summary.length > policy.summaryMaxChars) {
     throw new Error(`workflow step summary exceeds ${policy.summaryMaxChars} characters`);
   }
+  validateNonSuccessSummary(value.outcome, summary);
   if (value.artifact !== undefined && typeof value.artifact !== "string") {
     throw new Error("workflow step artifact must be a string");
   }
@@ -6059,6 +6083,7 @@ var resolveStep = (workflow, run) => {
   return step;
 };
 var RESUME_INPUT_PLACEHOLDER = /\{\{\s*resume\.input\s*\}\}/;
+var WORKFLOW_INPUT_PLACEHOLDER = /\{\{\s*workflow\.input\s*\}\}/;
 var renderStepPrompt = ({
   workflow,
   run,
@@ -6100,6 +6125,7 @@ function buildStepTask(options) {
   const isDelegated = execution === "delegated";
   const promptTemplate = workflow.prompts[run.currentStepId] ?? "";
   const prompt = renderStepPrompt({ workflow, run, step, execution });
+  const showWorkflowInput = WORKFLOW_INPUT_PLACEHOLDER.test(promptTemplate);
   const handoff = currentStepHandoff(run);
   const contract = createStepContract({ workflow, run, step });
   const completionTool = isDelegated ? "structured_output" : "workflow_complete_step";
@@ -6119,6 +6145,7 @@ function buildStepTask(options) {
     ...step.agent ? ["## Role prompt", "", rolePrompt(step.agent.name), ""] : [],
     prompt,
     "",
+    ...showWorkflowInput ? ["## Original workflow request", "", run.input || "(none supplied)", ""] : [],
     ...isDelegated ? buildDelegatedHandoffSection(handoff) : [],
     ...buildRestartWorkspaceSection(run.restartWorkspaceCwd),
     ...buildResumeInputSection(run, RESUME_INPUT_PLACEHOLDER.test(promptTemplate)),
@@ -6402,6 +6429,7 @@ var POLICY_KEYS = new Set([
   "maxToolCalls",
   "handoffReserve",
   "totalToolCalls",
+  "handoffOutcome",
   "gateSubmitOutcome",
   "workspace"
 ]);
@@ -6497,10 +6525,28 @@ var parseChildPolicy = (value, environment = DEFAULT_CHILD_POLICY_ENVIRONMENT) =
   if (!isRecord11(value))
     throw new Error("child policy must be an object");
   rejectUnknownProperties(value);
+  const sections = parseChildPolicySections(value);
+  const toolBudget = parseToolBudget(value);
+  const handoffOutcome = value.handoffOutcome;
+  if (handoffOutcome !== undefined) {
+    if (typeof handoffOutcome !== "string" || handoffOutcome !== "handoff") {
+      throw new Error("child policy handoffOutcome is invalid");
+    }
+    if (toolBudget.maxToolCalls === undefined) {
+      throw new Error("child policy handoffOutcome requires a tool budget");
+    }
+    if (!sections.outcomes.includes(handoffOutcome)) {
+      throw new Error("child policy handoffOutcome must be an allowed outcome");
+    }
+  }
+  if (toolBudget.maxToolCalls !== undefined && handoffOutcome === undefined) {
+    throw new Error("child policy tool budget requires handoffOutcome");
+  }
   return {
     ...parseIdentityAndPaths(value, environment),
-    ...parseChildPolicySections(value),
-    ...parseToolBudget(value)
+    ...sections,
+    ...toolBudget,
+    ...handoffOutcome ? { handoffOutcome } : {}
   };
 };
 
@@ -6695,7 +6741,8 @@ function createDelegationPlan(input, dependencies) {
   const toolBudget = step.maxToolCalls === undefined ? {} : {
     maxToolCalls: step.maxToolCalls,
     handoffReserve: HANDOFF_RESERVE,
-    totalToolCalls: step.maxToolCalls + HANDOFF_RESERVE
+    totalToolCalls: step.maxToolCalls + HANDOFF_RESERVE,
+    handoffOutcome: "handoff"
   };
   const policyDigest = digest({
     version: 1,
@@ -6730,6 +6777,7 @@ function createDelegationPlan(input, dependencies) {
     pauseOutcomes: Object.entries(step.transitions).filter(([outcome, target]) => target === "$pause" && outcomeSet.has(outcome)).map(([outcome]) => outcome),
     summaryMaxChars: workflow.definition.summaryMaxChars,
     ...toolBudget,
+    ...step.maxToolCalls === undefined ? {} : { handoffOutcome: "handoff" },
     ...step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {},
     ...step.workspace ? { workspace: structuredClone(step.workspace) } : {}
   };
@@ -8007,9 +8055,30 @@ var toolBudgetWarningPrompt = ({
 var TOOL_BUDGET_HANDOFF_PROMPT = [
   "The productive tool-call budget is exhausted.",
   "Work tools are locked; do not execute further work.",
-  "Call `structured_output` exactly once, alone, with one configured outcome and a compact handoff."
+  "Call `structured_output` exactly once, alone, with a detailed configured result if you can complete now.",
+  "If you settle without a result, the extension persists an `handoff` result for a fresh child."
 ].join(`
 `);
+var toolBudgetHandoffResult = (policy, productiveCalls) => {
+  if (policy.handoffOutcome !== "handoff") {
+    throw new Error("tool-budget handoff requires a configured handoff outcome");
+  }
+  return {
+    version: 1,
+    policyDigest: policy.policyDigest,
+    outcome: policy.handoffOutcome,
+    summary: [
+      "# Handoff: Productive tool-call budget exhausted.",
+      "",
+      `- Completed work: Productive calls completed: ${productiveCalls}.`,
+      "- Current state: Work tools are locked; no further productive tool calls ran.",
+      "- Remaining work: A fresh child must inspect the previous handoff and continue this same step.",
+      "- Blocker: The configured productive tool-call budget is exhausted.",
+      "**Next:** Start a fresh delegated attempt for this step using the persisted handoff."
+    ].join(`
+`)
+  };
+};
 var needsCompletionRepair = ({
   policy,
   dependencies
@@ -8094,6 +8163,10 @@ var childSystemPrompt = (policy) => {
     "",
     "The parent workflow harness owns orchestration and state transitions.",
     "Perform only this delegated step. Its child-side tool policy is enforced.",
+    "Do not launch subagents while executing this declarative workflow step.",
+    "Use `blocked` only when progress requires user-provided information, a decision, authority, credentials, or approval.",
+    "Use `retry` only for a transient failure that can be retried without new user input.",
+    "Do not open a skill unless this step YAML lists that skill.",
     "When finished, call `structured_output` exactly once and as the only tool call in that message.",
     "Pass the workflow result as its `value`: outcome, summary, optional artifact, and workspace only when required below.",
     `Valid outcomes: ${policy.outcomes.join(", ")}`,
@@ -8105,9 +8178,9 @@ var childSystemPrompt = (policy) => {
       `Productive tool-call budget: ${policy.maxToolCalls} calls.`,
       `Handoff reserve: ${policy.handoffReserve} calls.`,
       `Total tool-call budget: ${policy.totalToolCalls} calls.`,
-      "At 2 productive calls remaining, begin handoff.",
+      "At 2 productive calls remaining, prepare a concise handoff with completed work, current state, remaining work, and any blocker.",
       "Work tools are locked when the productive budget is exhausted.",
-      "Continue with `handoff` using the reserved calls."
+      "If the child settles without a result after exhaustion, the extension writes the configured `handoff` structured result."
     ],
     ...policy.gateSubmitOutcome ? [
       `Outcome "${policy.gateSubmitOutcome}" requires the complete gate artifact.`
@@ -8245,14 +8318,27 @@ ${childSystemPrompt(state.activePolicy)}`
     if (productiveCalls >= policy.maxToolCalls) {
       state = {
         ...state,
-        effectiveTools: new Set([CHILD_COMPLETION_TOOL]),
+        effectiveTools: new Set,
         productiveToolCallIds,
         runtimeMode: "handoff"
       };
-      pi.setActiveTools([CHILD_COMPLETION_TOOL]);
-      pi.sendUserMessage(TOOL_BUDGET_HANDOFF_PROMPT, {
-        deliverAs: "followUp"
-      });
+      try {
+        writeChildResult({
+          policy,
+          result: toolBudgetHandoffResult(policy, productiveCalls),
+          dependencies
+        });
+        pi.setActiveTools([]);
+      } catch {
+        state = {
+          ...state,
+          effectiveTools: new Set([CHILD_COMPLETION_TOOL])
+        };
+        pi.setActiveTools([CHILD_COMPLETION_TOOL]);
+        pi.sendUserMessage(TOOL_BUDGET_HANDOFF_PROMPT, {
+          deliverAs: "followUp"
+        });
+      }
       return;
     }
     state = { ...state, productiveToolCallIds };
@@ -8267,9 +8353,20 @@ ${childSystemPrompt(state.activePolicy)}`
   });
   pi.on("agent_settled", () => {
     const policy = state.activePolicy;
-    if (!policy || state.repairRequested || !needsCompletionRepair({ policy, dependencies })) {
+    if (!policy || state.repairRequested)
       return;
+    if (state.runtimeMode === "handoff" && needsCompletionRepair({ policy, dependencies })) {
+      try {
+        writeChildResult({
+          policy,
+          result: toolBudgetHandoffResult(policy, state.productiveToolCallIds.size),
+          dependencies
+        });
+        return;
+      } catch {}
     }
+    if (!needsCompletionRepair({ policy, dependencies }))
+      return;
     state = {
       ...state,
       repairRequested: true,
@@ -8331,7 +8428,7 @@ ${childSystemPrompt(state.activePolicy)}`
     if (state.runtimeMode === "handoff") {
       return {
         block: true,
-        reason: "Productive tool-call budget is exhausted; only structured_output is available for handoff"
+        reason: "Productive tool-call budget is exhausted; the extension-owned handoff is already persisted"
       };
     }
     if (CHILD_COORDINATION_TOOLS.has(event.toolName)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wichayutdew/pi-workflows",
-  "version": "3.6.0",
+  "version": "3.7.0",
   "description": "A declarative, pauseable workflow harness for Pi",
   "license": "MIT",
   "repository": {

package/src/config/validation/step.ts

@@ -438,6 +438,17 @@ export function parseWorkflowStep(
       );
     }
   }
+  if (agent && maxToolCalls !== undefined) {
+    if (!Object.hasOwn(transitions, 'handoff')) {
+      errors.push(
+        `${path}.transitions: maxToolCalls requires a "handoff" transition`,
+      );
+    } else if (transitions.handoff !== stepId) {
+      errors.push(
+        `${path}.transitions: handoff transition must target "${stepId}"`,
+      );
+    }
+  }
   if (workspace) {
     workspace.bindOn.forEach((outcome) => {
       if (!Object.hasOwn(transitions, outcome)) {

package/src/harness/delegation-plan.ts

@@ -165,6 +165,7 @@ export function createDelegationPlan(
           maxToolCalls: step.maxToolCalls,
           handoffReserve: HANDOFF_RESERVE,
           totalToolCalls: step.maxToolCalls + HANDOFF_RESERVE,
+          handoffOutcome: 'handoff',
         };
   const policyDigest = digest({
     version: 1,
@@ -203,6 +204,7 @@ export function createDelegationPlan(
       .map(([outcome]) => outcome),
     summaryMaxChars: workflow.definition.summaryMaxChars,
     ...toolBudget,
+    ...(step.maxToolCalls === undefined ? {} : { handoffOutcome: 'handoff' }),
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
     ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
   };

package/src/integrations/subagents/child-policy-types.ts

@@ -28,6 +28,8 @@ export type ChildStepPolicy = {
   readonly handoffReserve?: number;
   /** Productive calls plus the mandatory handoff reserve. */
   readonly totalToolCalls?: number;
+  /** Extension-owned outcome persisted when an exhausted child settles without a result. */
+  readonly handoffOutcome?: string;
   readonly gateSubmitOutcome?: string;
   readonly workspace?: StepWorkspaceBinding;
 };

package/src/integrations/subagents/child-policy-validation.ts

@@ -31,6 +31,7 @@ const POLICY_KEYS: ReadonlySet<string> = new Set([
   'maxToolCalls',
   'handoffReserve',
   'totalToolCalls',
+  'handoffOutcome',
   'gateSubmitOutcome',
   'workspace',
 ]);
@@ -206,9 +207,27 @@ export const parseChildPolicy = (
   if (!isRecord(value)) throw new Error('child policy must be an object');
 
   rejectUnknownProperties(value);
+  const sections = parseChildPolicySections(value);
+  const toolBudget = parseToolBudget(value);
+  const handoffOutcome = value.handoffOutcome;
+  if (handoffOutcome !== undefined) {
+    if (typeof handoffOutcome !== 'string' || handoffOutcome !== 'handoff') {
+      throw new Error('child policy handoffOutcome is invalid');
+    }
+    if (toolBudget.maxToolCalls === undefined) {
+      throw new Error('child policy handoffOutcome requires a tool budget');
+    }
+    if (!sections.outcomes.includes(handoffOutcome)) {
+      throw new Error('child policy handoffOutcome must be an allowed outcome');
+    }
+  }
+  if (toolBudget.maxToolCalls !== undefined && handoffOutcome === undefined) {
+    throw new Error('child policy tool budget requires handoffOutcome');
+  }
   return {
     ...parseIdentityAndPaths(value, environment),
-    ...parseChildPolicySections(value),
-    ...parseToolBudget(value),
+    ...sections,
+    ...toolBudget,
+    ...(handoffOutcome ? { handoffOutcome } : {}),
   };
 };

package/src/integrations/subagents/child-runtime-policy.ts

@@ -29,6 +29,10 @@ export const childSystemPrompt = (policy: ChildStepPolicy): string => {
     '',
     'The parent workflow harness owns orchestration and state transitions.',
     'Perform only this delegated step. Its child-side tool policy is enforced.',
+    'Do not launch subagents while executing this declarative workflow step.',
+    'Use `blocked` only when progress requires user-provided information, a decision, authority, credentials, or approval.',
+    'Use `retry` only for a transient failure that can be retried without new user input.',
+    'Do not open a skill unless this step YAML lists that skill.',
     'When finished, call `structured_output` exactly once and as the only tool call in that message.',
     'Pass the workflow result as its `value`: outcome, summary, optional artifact, and workspace only when required below.',
     `Valid outcomes: ${policy.outcomes.join(', ')}`,
@@ -42,9 +46,9 @@ export const childSystemPrompt = (policy: ChildStepPolicy): string => {
           `Productive tool-call budget: ${policy.maxToolCalls} calls.`,
           `Handoff reserve: ${policy.handoffReserve} calls.`,
           `Total tool-call budget: ${policy.totalToolCalls} calls.`,
-          'At 2 productive calls remaining, begin handoff.',
+          'At 2 productive calls remaining, prepare a concise handoff with completed work, current state, remaining work, and any blocker.',
           'Work tools are locked when the productive budget is exhausted.',
-          'Continue with `handoff` using the reserved calls.',
+          'If the child settles without a result after exhaustion, the extension writes the configured `handoff` structured result.',
         ]),
     ...(policy.gateSubmitOutcome
       ? [

package/src/integrations/subagents/child-runtime-repair.ts

@@ -1,3 +1,4 @@
+import type { WorkflowStepResult } from '../../runtime/step-result.ts';
 import type { ChildStepPolicy } from './child-policy-types.ts';
 import type { SubagentChildRuntimeDependencies } from './child-runtime-types.ts';
 
@@ -27,9 +28,36 @@ export const toolBudgetWarningPrompt = ({
 export const TOOL_BUDGET_HANDOFF_PROMPT = [
   'The productive tool-call budget is exhausted.',
   'Work tools are locked; do not execute further work.',
-  'Call `structured_output` exactly once, alone, with one configured outcome and a compact handoff.',
+  'Call `structured_output` exactly once, alone, with a detailed configured result if you can complete now.',
+  'If you settle without a result, the extension persists an `handoff` result for a fresh child.',
 ].join('\n');
 
+/** Builds the only extension-owned result allowed after productive budget exhaustion. */
+export const toolBudgetHandoffResult = (
+  policy: ChildStepPolicy,
+  productiveCalls: number,
+): WorkflowStepResult => {
+  if (policy.handoffOutcome !== 'handoff') {
+    throw new Error(
+      'tool-budget handoff requires a configured handoff outcome',
+    );
+  }
+  return {
+    version: 1,
+    policyDigest: policy.policyDigest,
+    outcome: policy.handoffOutcome,
+    summary: [
+      '# Handoff: Productive tool-call budget exhausted.',
+      '',
+      `- Completed work: Productive calls completed: ${productiveCalls}.`,
+      '- Current state: Work tools are locked; no further productive tool calls ran.',
+      '- Remaining work: A fresh child must inspect the previous handoff and continue this same step.',
+      '- Blocker: The configured productive tool-call budget is exhausted.',
+      '**Next:** Start a fresh delegated attempt for this step using the persisted handoff.',
+    ].join('\n'),
+  };
+};
+
 /** Returns whether a same-child completion repair may be requested safely. */
 export const needsCompletionRepair = ({
   policy,

package/src/integrations/subagents/child-runtime.ts

@@ -17,6 +17,7 @@ import {
   COMPLETION_REPAIR_PROMPT,
   needsCompletionRepair,
   TOOL_BUDGET_HANDOFF_PROMPT,
+  toolBudgetHandoffResult,
   toolBudgetWarningPrompt,
 } from './child-runtime-repair.ts';
 import {
@@ -210,14 +211,27 @@ export const registerSubagentChildRuntime = (
     if (productiveCalls >= policy.maxToolCalls) {
       state = {
         ...state,
-        effectiveTools: new Set([CHILD_COMPLETION_TOOL]),
+        effectiveTools: new Set(),
         productiveToolCallIds,
         runtimeMode: 'handoff',
       };
-      pi.setActiveTools([CHILD_COMPLETION_TOOL]);
-      pi.sendUserMessage(TOOL_BUDGET_HANDOFF_PROMPT, {
-        deliverAs: 'followUp',
-      });
+      try {
+        writeChildResult({
+          policy,
+          result: toolBudgetHandoffResult(policy, productiveCalls),
+          dependencies,
+        });
+        pi.setActiveTools([]);
+      } catch {
+        state = {
+          ...state,
+          effectiveTools: new Set([CHILD_COMPLETION_TOOL]),
+        };
+        pi.setActiveTools([CHILD_COMPLETION_TOOL]);
+        pi.sendUserMessage(TOOL_BUDGET_HANDOFF_PROMPT, {
+          deliverAs: 'followUp',
+        });
+      }
       return;
     }
 
@@ -237,13 +251,27 @@ export const registerSubagentChildRuntime = (
 
   pi.on('agent_settled', () => {
     const policy = state.activePolicy;
+    if (!policy || state.repairRequested) return;
     if (
-      !policy ||
-      state.repairRequested ||
-      !needsCompletionRepair({ policy, dependencies })
+      state.runtimeMode === 'handoff' &&
+      needsCompletionRepair({ policy, dependencies })
     ) {
-      return;
+      try {
+        writeChildResult({
+          policy,
+          result: toolBudgetHandoffResult(
+            policy,
+            state.productiveToolCallIds.size,
+          ),
+          dependencies,
+        });
+        return;
+      } catch {
+        // Preserve the normal completion-repair path so the parent gets the
+        // correlated result failure if the protected write cannot be made.
+      }
     }
+    if (!needsCompletionRepair({ policy, dependencies })) return;
     state = {
       ...state,
       repairRequested: true,
@@ -309,7 +337,7 @@ export const registerSubagentChildRuntime = (
       return {
         block: true,
         reason:
-          'Productive tool-call budget is exhausted; only structured_output is available for handoff',
+          'Productive tool-call budget is exhausted; the extension-owned handoff is already persisted',
       };
     }
     if (CHILD_COORDINATION_TOOLS.has(event.toolName)) {

package/src/prompt/step-task.ts

@@ -51,6 +51,7 @@ type RenderStepPromptOptions = {
 };
 
 const RESUME_INPUT_PLACEHOLDER = /\{\{\s*resume\.input\s*\}\}/;
+const WORKFLOW_INPUT_PLACEHOLDER = /\{\{\s*workflow\.input\s*\}\}/;
 
 const renderStepPrompt = ({
   workflow,
@@ -110,6 +111,7 @@ export function buildStepTask(options: BuildStepTaskOptions): string {
   const isDelegated = execution === 'delegated';
   const promptTemplate = workflow.prompts[run.currentStepId] ?? '';
   const prompt = renderStepPrompt({ workflow, run, step, execution });
+  const showWorkflowInput = WORKFLOW_INPUT_PLACEHOLDER.test(promptTemplate);
   const handoff = currentStepHandoff(run);
   const contract = createStepContract({ workflow, run, step });
   const completionTool = isDelegated
@@ -135,6 +137,9 @@ export function buildStepTask(options: BuildStepTaskOptions): string {
       : []),
     prompt,
     '',
+    ...(showWorkflowInput
+      ? ['## Original workflow request', '', run.input || '(none supplied)', '']
+      : []),
     ...(isDelegated ? buildDelegatedHandoffSection(handoff) : []),
     ...buildRestartWorkspaceSection(run.restartWorkspaceCwd),
     ...buildResumeInputSection(

package/src/runtime/step-result.ts

@@ -45,6 +45,37 @@ const isObject = (value: unknown): value is Record<string, unknown> => {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 };
 
+function validateNonSuccessSummary(outcome: string, summary: string): void {
+  if (outcome === 'blocked') {
+    const isActionable =
+      /^# Blocked:\s+.+/m.test(summary) &&
+      /^\s*\*\*Action:\*\*\s+.+/m.test(summary) &&
+      /^\s*\*\*Next:\*\*\s+.+/m.test(summary);
+    if (!isActionable) {
+      throw new Error(
+        'blocked summary must identify the missing user prerequisite and next action',
+      );
+    }
+  }
+  if (outcome === 'retry') {
+    const describesTransientFailure = /\btransient\b/i.test(summary);
+    const hasSafeRetryCondition =
+      /\b(safe (retry|to retry)|retry (when|after|once))\b/i.test(summary);
+    const requestsUserInput =
+      /\b(provide|confirm|choose|approve|decide)\b/i.test(summary);
+    if (
+      !/^# Retry:\s+.+/m.test(summary) ||
+      !describesTransientFailure ||
+      !hasSafeRetryCondition ||
+      requestsUserInput
+    ) {
+      throw new Error(
+        'retry summary must identify a transient failure and safe retry condition',
+      );
+    }
+  }
+}
+
 function parseResultWorkspace(
   value: unknown,
   outcome: string,
@@ -131,6 +162,7 @@ export function parseWorkflowStepResult(
       `workflow step summary exceeds ${policy.summaryMaxChars} characters`,
     );
   }
+  validateNonSuccessSummary(value.outcome, summary);
   if (value.artifact !== undefined && typeof value.artifact !== 'string') {
     throw new Error('workflow step artifact must be a string');
   }