@wichayutdew/pi-workflows 2.5.1 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wichayutdew/pi-workflows",
-  "version": "2.5.1",
+  "version": "2.6.0",
   "description": "A declarative, pauseable workflow harness for Pi",
   "license": "MIT",
   "repository": {
@@ -21,7 +21,6 @@
   "files": [
     "dist",
     "src",
-    "agents",
     "examples",
     "schemas",
     "README.md",
@@ -30,12 +29,7 @@
   "pi": {
     "extensions": [
       "./src/index.ts"
-    ],
-    "subagents": {
-      "agents": [
-        "./agents"
-      ]
-    }
+    ]
   },
   "scripts": {
     "build": "bun build ./src/index.ts --outdir=dist --target=node --format=esm --packages=external",
@@ -44,9 +38,9 @@
     "lint": "bun --bun eslint .",
     "lint:fix": "bun --bun eslint . --fix",
     "test": "bun test --no-orphans --reporter=dots",
+    "test:e2e": "bun --config=bunfig.e2e.toml test --no-orphans ./test/e2e/direct-worker-runtime.test.ts --reporter=dots",
     "test:coverage": "bun --config=bunfig.coverage.toml test --no-orphans --reporter=dots && bun run coverage:check",
     "coverage:check": "bun .github/scripts/check-coverage.mjs coverage/full/lcov.info",
-    "test:e2e": "bun --config=bunfig.e2e.toml test --no-orphans test/e2e/workflow-runtime.test.ts --reporter=dots",
     "typecheck": "tsc --noEmit",
     "check": "bun run lint && bun run format:check && bun run typecheck && bun run test:coverage && bun run test:e2e && bun run build"
   },
@@ -56,14 +50,8 @@
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "*",
     "@earendil-works/pi-tui": "*",
-    "pi-subagents": ">=0.36.0",
     "typebox": "*"
   },
-  "peerDependenciesMeta": {
-    "pi-subagents": {
-      "optional": true
-    }
-  },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^0.81.1",
     "@earendil-works/pi-tui": "^0.81.1",
@@ -72,7 +60,6 @@
     "@types/node": "^24.0.0",
     "eslint": "^10.7.0",
     "globals": "^17.7.0",
-    "pi-subagents": "0.36.0",
     "prettier": "^3.9.5",
     "typebox": "^1.1.38",
     "typescript": "^5.9.3",

package/schemas/workflow.schema.json

@@ -597,19 +597,6 @@
       "type": "object",
       "additionalProperties": false,
       "required": ["prompt", "transitions"],
-      "allOf": [
-        {
-          "if": {
-            "required": ["workspace"]
-          },
-          "then": {
-            "required": ["subagent"],
-            "not": {
-              "required": ["gate"]
-            }
-          }
-        }
-      ],
       "properties": {
         "title": {
           "type": "string",
@@ -618,8 +605,8 @@
         "prompt": {
           "$ref": "#/$defs/prompt"
         },
-        "subagent": {
-          "$ref": "#/$defs/subagent"
+        "agent": {
+          "$ref": "#/$defs/subagentRuntimeName"
         },
         "permissions": {
           "$ref": "#/$defs/permissions"

package/src/agents/profile.ts

@@ -0,0 +1,98 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse } from 'yaml';
+import { defaultUserWorkflowDirectory } from '../config/load.ts';
+
+export const THINKING_LEVELS = [
+  'off',
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+  'max',
+] as const;
+
+export type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+export type AgentProfile = {
+  readonly prompt: string;
+  readonly model?: string;
+  readonly thinking?: ThinkingLevel;
+};
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/** Parses the optional YAML frontmatter and role prompt in one agent profile. */
+export function parseAgentProfile(source: string, name: string): AgentProfile {
+  if (!source.startsWith('---\n')) return { prompt: source.trim() };
+  const end = source.indexOf('\n---\n', 4);
+  if (end === -1) {
+    throw new Error(`workflow agent profile is invalid: ${name}`);
+  }
+  const metadata: unknown = parse(source.slice(4, end));
+  if (!isRecord(metadata)) {
+    throw new Error(
+      `workflow agent profile metadata must be an object: ${name}`,
+    );
+  }
+  const unknownKey = Object.keys(metadata).find(
+    (key) => key !== 'model' && key !== 'thinking',
+  );
+  if (unknownKey) {
+    throw new Error(
+      `workflow agent profile has unknown metadata "${unknownKey}": ${name}`,
+    );
+  }
+  const model = metadata.model;
+  if (model !== undefined && (typeof model !== 'string' || !model.trim())) {
+    throw new Error(
+      `workflow agent profile model must be a non-empty string: ${name}`,
+    );
+  }
+  const thinking = metadata.thinking;
+  if (
+    thinking !== undefined &&
+    (typeof thinking !== 'string' ||
+      !THINKING_LEVELS.includes(thinking as ThinkingLevel))
+  ) {
+    throw new Error(
+      `workflow agent profile thinking must be one of ${THINKING_LEVELS.join(', ')}: ${name}`,
+    );
+  }
+  const prompt = source.slice(end + 5).trim();
+  if (!prompt)
+    throw new Error(`workflow agent profile prompt is empty: ${name}`);
+  return {
+    prompt,
+    ...(typeof model === 'string' ? { model: model.trim() } : {}),
+    ...(typeof thinking === 'string'
+      ? { thinking: thinking as ThinkingLevel }
+      : {}),
+  };
+}
+
+/** Loads a user-owned agent profile, with a bundled prompt-only fallback. */
+export function loadAgentProfile(
+  name: string,
+  userDirectory = defaultUserWorkflowDirectory(),
+): AgentProfile {
+  const userPath = join(userDirectory, 'agents', `${name}.md`);
+  const bundledUrl = new URL(
+    `../../examples/starter-kit/agents/${name}.md`,
+    import.meta.url,
+  );
+  const path = existsSync(userPath) ? userPath : fileURLToPath(bundledUrl);
+  try {
+    return parseAgentProfile(readFileSync(path, 'utf8'), name);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('workflow agent')) {
+      throw error;
+    }
+    throw new Error(`workflow agent profile is unavailable: ${name}`, {
+      cause: error,
+    });
+  }
+}

package/src/config/ceiling.ts

@@ -2,8 +2,6 @@ import type {
   BashPermission,
   BashRule,
   PermissionCeiling,
-  StepSubagent,
-  SubagentPermissionCeiling,
   WorkflowDefinition,
 } from './types.ts';
 
@@ -34,81 +32,6 @@ function bashWithinCeiling(
   return requested.allow.every((rule) => allowedRules.has(ruleKey(rule)));
 }
 
-function turnBudgetErrors(
-  subagent: StepSubagent,
-  ceiling: SubagentPermissionCeiling,
-  path: string,
-): Array<string> {
-  if (!subagent.turnBudget) {
-    return [`${path}.turnBudget: required for a project workflow`];
-  }
-  return [
-    ...(subagent.turnBudget.maxTurns > ceiling.maxTurns
-      ? [`${path}.turnBudget.maxTurns: exceeds the user permission ceiling`]
-      : []),
-    ...((subagent.turnBudget.graceTurns ?? 0) > ceiling.maxGraceTurns
-      ? [`${path}.turnBudget.graceTurns: exceeds the user permission ceiling`]
-      : []),
-  ];
-}
-
-function toolBudgetErrors(
-  subagent: StepSubagent,
-  ceiling: SubagentPermissionCeiling,
-  path: string,
-): Array<string> {
-  if (!subagent.toolBudget) {
-    return [`${path}.toolBudget: required for a project workflow`];
-  }
-  return [
-    ...(subagent.toolBudget.hard > ceiling.maxToolCalls
-      ? [`${path}.toolBudget.hard: exceeds the user permission ceiling`]
-      : []),
-    ...(subagent.toolBudget.block !== '*'
-      ? [`${path}.toolBudget.block: must be "*" for a project workflow`]
-      : []),
-  ];
-}
-
-function subagentErrors(
-  subagent: StepSubagent | undefined,
-  ceiling: SubagentPermissionCeiling | undefined,
-  path: string,
-): Array<string> {
-  if (!subagent) return [];
-  if (!ceiling) {
-    return [`${path}: subagent execution exceeds the user permission ceiling`];
-  }
-  return [
-    ...(!ceiling.agents.includes(subagent.agent)
-      ? [
-          `${path}.agent: "${subagent.agent}" exceeds the user permission ceiling`,
-        ]
-      : []),
-    ...(!ceiling.contexts.includes(subagent.context)
-      ? [
-          `${path}.context: "${subagent.context}" exceeds the user permission ceiling`,
-        ]
-      : []),
-    ...(subagent.model && !ceiling.models.includes(subagent.model)
-      ? [
-          `${path}.model: "${subagent.model}" exceeds the user permission ceiling`,
-        ]
-      : []),
-    ...(subagent.timeoutMs > ceiling.maxTimeoutMs
-      ? [`${path}.timeoutMs: exceeds the user permission ceiling`]
-      : []),
-    ...(subagent.artifacts && !ceiling.artifacts
-      ? [`${path}.artifacts: exceeds the user permission ceiling`]
-      : []),
-    ...(subagent.retryToolFailures && !ceiling.retryToolFailures
-      ? [`${path}.retryToolFailures: exceeds the user permission ceiling`]
-      : []),
-    ...turnBudgetErrors(subagent, ceiling, path),
-    ...toolBudgetErrors(subagent, ceiling, path),
-  ];
-}
-
 /** Return every project-workflow permission that exceeds the user ceiling. */
 export function checkWorkflowAgainstCeiling(
   workflow: WorkflowDefinition,
@@ -149,11 +72,6 @@ export function checkWorkflowAgainstCeiling(
       ...(!bashWithinCeiling(step.permissions.bash, ceiling.bash)
         ? [`${path}.bash: exceeds the user permission ceiling`]
         : []),
-      ...subagentErrors(
-        step.subagent,
-        ceiling.subagent,
-        `workflow.steps.${stepId}.subagent`,
-      ),
     ];
   });
 }

package/src/config/types.ts

@@ -2,7 +2,7 @@ import type { KeyId } from '@earendil-works/pi-tui';
 
 export const WORKFLOW_SCHEMA_VERSION = 1 as const;
 export const DEFAULT_STATUS_SHORTCUT = 'ctrl+alt+w' as const satisfies KeyId;
-export const SUBAGENT_RUNTIME_NAME_PATTERN =
+export const AGENT_PROFILE_NAME_PATTERN =
   /^[a-z0-9][a-z0-9-]*(?:\.[a-z0-9][a-z0-9-]*)*$/;
 export const MAX_WORKSPACE_PATH_CHARS = 4_096;
 export const MAX_WORKSPACE_ALLOWED_ROOTS = 32;
@@ -41,35 +41,9 @@ export type StepRequirements = {
   readonly skills: ReadonlyArray<string>;
 };
 
-export type SubagentContext = 'fresh';
-
-export type SubagentTurnBudget = {
-  readonly maxTurns: number;
-  readonly graceTurns?: number;
-};
-
-export type SubagentToolBudget = {
-  readonly hard: number;
-  readonly soft?: number;
-  readonly block?: ReadonlyArray<string> | '*';
-};
-
-export type StepSubagent = {
-  /** Pi Subagents agent profile launched for this isolated step. */
-  readonly agent: string;
-  /** Workflow steps always use a fresh context. */
-  readonly context: SubagentContext;
-  readonly model?: string;
-  readonly timeoutMs: number;
-  readonly turnBudget?: SubagentTurnBudget;
-  readonly toolBudget?: SubagentToolBudget;
-  readonly artifacts: boolean;
-  /**
-   * Authorizes bounded automatic recovery when Bash can execute commands.
-   * Every failed attempt must still have a complete, mutation-safe replay
-   * audit.
-   */
-  readonly retryToolFailures: boolean;
+export type StepAgent = {
+  /** Workflow-owned role prompt applied to this main-agent step. */
+  readonly name: string;
 };
 
 export type PromptSpec =
@@ -102,8 +76,8 @@ export type StepWorkspaceBinding = {
 export type WorkflowStep = {
   readonly title: string;
   readonly prompt: PromptSpec;
-  /** Omit to execute this step in the main Pi agent. */
-  readonly subagent?: StepSubagent;
+  /** Optional workflow-owned role prompt for this main-agent step. */
+  readonly agent?: StepAgent;
   readonly permissions: StepPermissions;
   readonly requires: StepRequirements;
   readonly transitions: Readonly<Record<string, StepTarget>>;
@@ -142,19 +116,6 @@ export type PermissionCeiling = {
   readonly extensions: ReadonlyArray<string>;
   readonly skills: ReadonlyArray<string>;
   readonly bash: BashPermission;
-  readonly subagent?: SubagentPermissionCeiling;
-};
-
-export type SubagentPermissionCeiling = {
-  readonly agents: ReadonlyArray<string>;
-  readonly contexts: ReadonlyArray<SubagentContext>;
-  readonly models: ReadonlyArray<string>;
-  readonly maxTimeoutMs: number;
-  readonly maxTurns: number;
-  readonly maxGraceTurns: number;
-  readonly maxToolCalls: number;
-  readonly artifacts: boolean;
-  readonly retryToolFailures: boolean;
 };
 
 export type WorkflowSettings = {
@@ -192,14 +153,6 @@ export const EMPTY_REQUIREMENTS = {
   skills: [],
 } as const satisfies StepRequirements;
 
-export const DEFAULT_STEP_SUBAGENT = {
-  agent: 'pi-workflows.step',
-  context: 'fresh',
-  timeoutMs: 900_000,
-  artifacts: false,
-  retryToolFailures: false,
-} as const satisfies StepSubagent;
-
 export const DEFAULT_SETTINGS = {
   version: WORKFLOW_SCHEMA_VERSION,
   allowProjectWorkflows: false,

package/src/config/validation/settings.ts

@@ -12,7 +12,6 @@ import {
   type ValidationResult,
 } from './shared.ts';
 import { readStatusShortcut } from './shortcut.ts';
-import { parseSubagentPermissionCeiling } from './subagent.ts';
 
 function parsePermissionCeiling(
   value: unknown,
@@ -26,7 +25,7 @@ function parsePermissionCeiling(
   }
   rejectUnknownKeys(
     value,
-    ['tools', 'mcp', 'extensions', 'skills', 'bash', 'subagent'],
+    ['tools', 'mcp', 'extensions', 'skills', 'bash'],
     path,
     errors,
   );
@@ -43,18 +42,7 @@ function parsePermissionCeiling(
     path,
     errors,
   );
-  const subagent =
-    value.subagent === undefined
-      ? undefined
-      : parseSubagentPermissionCeiling(
-          value.subagent,
-          `${path}.subagent`,
-          errors,
-        );
-  return {
-    ...permissions,
-    ...(subagent ? { subagent } : {}),
-  };
+  return permissions;
 }
 
 /** Validate and normalize untrusted user workflow settings. */

package/src/config/validation/step.ts

@@ -17,7 +17,7 @@ import {
   rejectUnknownKeys,
   type ValidationErrors,
 } from './shared.ts';
-import { parseStepSubagent } from './subagent.ts';
+import { AGENT_PROFILE_NAME_PATTERN, type StepAgent } from '../types.ts';
 
 function parsePrompt(
   value: unknown,
@@ -248,7 +248,7 @@ export function parseWorkflowStep(
     [
       'title',
       'prompt',
-      'subagent',
+      'agent',
       'permissions',
       'requires',
       'transitions',
@@ -264,11 +264,15 @@ export function parseWorkflowStep(
       ? stepId
       : readString(value.title, `${path}.title`, errors);
   const prompt = parsePrompt(value.prompt, `${path}.prompt`, errors);
-  const subagent = parseStepSubagent(
-    value.subagent,
-    `${path}.subagent`,
-    errors,
-  );
+  const agentName =
+    value.agent === undefined
+      ? undefined
+      : readString(value.agent, `${path}.agent`, errors, {
+          pattern: AGENT_PROFILE_NAME_PATTERN,
+        });
+  const agent: StepAgent | undefined = agentName
+    ? { name: agentName }
+    : undefined;
   const permissions = parsePermissions(
     value.permissions,
     `${path}.permissions`,
@@ -323,7 +327,7 @@ export function parseWorkflowStep(
   return {
     title,
     prompt,
-    ...(subagent ? { subagent } : {}),
+    ...(agent ? { agent } : {}),
     permissions,
     requires,
     transitions,

package/src/config/validation/workflow.ts

@@ -91,9 +91,6 @@ function validateWorkspaceGraph(
         `${workspacePath}: only one workspace-binding step is allowed; "${firstBinderId}" also configures workspace binding`,
       );
     }
-    if (!step.subagent) {
-      errors.push(`${workspacePath}: workspace binding requires a subagent`);
-    }
     if (step.gate) {
       errors.push(
         `${workspacePath}: workspace binding is not allowed on a gated step`,
@@ -110,14 +107,13 @@ function validateWorkspaceGraph(
       }
       return target && Object.hasOwn(steps, target) ? [target] : [];
     });
-    validateWorkspaceDescendants(steps, downstream, errors);
+    validateWorkspaceDescendants(steps, downstream);
   });
 }
 
 function validateWorkspaceDescendants(
   steps: Readonly<Record<string, WorkflowStep>>,
   initialStepIds: ReadonlyArray<string>,
-  errors: ValidationErrors,
 ): void {
   const pending = [...initialStepIds];
   const visited = new Set<string>();
@@ -127,11 +123,6 @@ function validateWorkspaceDescendants(
     visited.add(stepId);
     const step = steps[stepId];
     if (!step) continue;
-    if (!step.subagent) {
-      errors.push(
-        `workflow.steps.${stepId}.subagent: every nonterminal step reachable after workspace binding must use a subagent`,
-      );
-    }
     Object.values(step.transitions).forEach((target) => {
       if (
         target !== '$done' &&

package/src/engine/run-workflow-validation.ts

@@ -183,9 +183,6 @@ export function validateRunWorkflowSemantics(
   if (sameWorkflowDigest && currentStepChanged) {
     return `current step "${run.currentStepId}" does not match the active workflow digest`;
   }
-  if (boundWorkspaceCwd && !currentStep.subagent) {
-    return `bound workflow current step "${run.currentStepId}" must use a subagent`;
-  }
   if (currentStepChanged) return undefined;
   return validatePendingGate(run, currentStep);
 }

package/src/engine/state-types.ts

@@ -46,7 +46,7 @@ export type SubagentTranscriptReference = {
   readonly trustedRoot: string;
   /** Exact child session returned by the delegation protocol. */
   readonly sessionFile: string;
-  /** Pi-subagents run identity used to confine the session path. */
+  /** Legacy child-run identity used to confine the session path. */
   readonly runId: string;
   readonly childIndex: number;
 };

package/src/harness/action-context.ts

@@ -20,14 +20,11 @@ import type { MainStepRuntimeController } from '../runtime/main-step-runtime.ts'
 import type { SerialTaskQueueController } from '../runtime/serial-task-queue.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { WorkflowStatusSnapshot } from '../workflow-status.ts';
-import type { DelegationFailureActions } from './delegation-failure.ts';
 import type { WorkflowHarnessDependencies } from './dependencies.ts';
 import type { SettledStepReport } from './step-reporting.ts';
 import type {
   ActiveDelegation,
   ActivePromptReview,
-  DelegationRecovery,
-  DelegationFailureDetails,
   MainStepIdentity,
   WorkflowStartContext,
 } from './types.ts';
@@ -41,7 +38,6 @@ import type {
 export type HarnessActionContext = {
   pi: ExtensionAPI;
   dependencies: WorkflowHarnessDependencies;
-  delegationFailures: DelegationFailureActions;
   subagents: SubagentDelegationClientController;
   mainSteps: MainStepRuntimeController;
   catalog: WorkflowCatalog;
@@ -98,10 +94,7 @@ export type HarnessActionContext = {
   registerLifecycle: () => void;
   registerPolicy: () => void;
   registerMultilineCommandInput: () => void;
-  launchCurrentStep: (
-    workflow: LoadedWorkflow,
-    recovery?: DelegationRecovery,
-  ) => void;
+  launchCurrentStep: (workflow: LoadedWorkflow) => void;
   launchMainStep: (
     workflow: LoadedWorkflow,
     run: WorkflowRun,
@@ -142,11 +135,6 @@ export type HarnessActionContext = {
   ) => Promise<void>;
   cancelActiveDelegation: (reason: string) => Promise<boolean>;
   cleanupDelegation: (active: ActiveDelegation) => Promise<void>;
-  retryDelegationAfterFailure: (
-    active: ActiveDelegation,
-    failure: DelegationFailureDetails | undefined,
-    reason: string,
-  ) => boolean;
   pauseForDelegationFailure: (reason: string, failureSummary?: string) => void;
   pauseForExecutionFailure: (
     label: string,

package/src/harness/delegation-control-actions.ts

@@ -1,33 +1,28 @@
 import { failRun } from '../engine/transitions.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
-import {
-  boundedFailureField,
-  MAX_DELEGATION_RECOVERY_ATTEMPTS,
-} from './delegation-retry-policy.ts';
 import {
   conciseStepFailureSummary,
   reportFailedStep,
 } from './step-reporting.ts';
-import type { ActiveDelegation, DelegationFailureDetails } from './types.ts';
+import type { ActiveDelegation } from './types.ts';
+
+const boundedFailureField = (value: string): string =>
+  value.length <= 500 ? value : `${value.slice(0, 499)}…`;
 
 type HarnessActionContext = Pick<
   FullHarnessActionContext,
   | 'activeDelegation'
   | 'catalog'
   | 'cleanupDelegation'
-  | 'delegationFailures'
   | 'dependencies'
-  | 'isSessionActive'
   | 'isolateMainSessionTools'
   | 'latestContext'
-  | 'launchCurrentStep'
   | 'mainSteps'
   | 'pauseForExecutionFailure'
   | 'persist'
   | 'pi'
   | 'restoreBaselineTools'
   | 'run'
-  | 'sessionEpoch'
   | 'subagents'
   | 'updateStatus'
 >;
@@ -41,12 +36,6 @@ export type DelegationControlActions = {
     this: HarnessActionContext,
     active: ActiveDelegation,
   ) => Promise<void>;
-  retryDelegationAfterFailure: (
-    this: HarnessActionContext,
-    active: ActiveDelegation,
-    failure: DelegationFailureDetails | undefined,
-    reason: string,
-  ) => boolean;
   pauseForDelegationFailure: (
     this: HarnessActionContext,
     reason: string,
@@ -119,53 +108,6 @@ async function cleanupDelegation(
   }
 }
 
-function retryDelegationAfterFailure(
-  this: HarnessActionContext,
-  active: ActiveDelegation,
-  failure: DelegationFailureDetails | undefined,
-  reason: string,
-): boolean {
-  if (!failure) return false;
-  const fingerprint =
-    this.delegationFailures.delegationFailureFingerprint(failure);
-  const isRepeatedFailure = active.recoveryFailures.some(
-    (previousFailure) => previousFailure.fingerprint === fingerprint,
-  );
-  if (
-    active.recoveryAttemptCount >= MAX_DELEGATION_RECOVERY_ATTEMPTS ||
-    isRepeatedFailure ||
-    !this.delegationFailures.isRetryableTerminalFailure(failure) ||
-    !this.delegationFailures.isSafeToRetryDelegation(
-      active.policy,
-      active.broadRecoveryAuthorized,
-      failure.replayAudit,
-    ) ||
-    !this.isSessionActive ||
-    this.sessionEpoch !== active.sessionEpoch ||
-    !this.run ||
-    this.run.status !== 'running' ||
-    this.run.runId !== active.runId ||
-    this.run.currentStepId !== active.stepId ||
-    this.run.currentStepDigest !== active.stepDigest ||
-    this.activeDelegation
-  ) {
-    return false;
-  }
-  const workflow = this.catalog.workflows.get(this.run.workflowId);
-  if (!workflow) return false;
-
-  const attempt = active.recoveryAttemptCount + 1;
-  this.latestContext?.ui.notify(
-    `Automatic recovery for "${active.stepId}" after a subagent failure (${attempt}/${MAX_DELEGATION_RECOVERY_ATTEMPTS})`,
-    'warning',
-  );
-  this.launchCurrentStep(workflow, {
-    attempt,
-    failures: [...active.recoveryFailures, { fingerprint, reason }],
-  });
-  return true;
-}
-
 function pauseForDelegationFailure(
   this: HarnessActionContext,
   reason: string,
@@ -266,7 +208,6 @@ export function createDelegationControlActions(): DelegationControlActions {
   return {
     cancelActiveDelegation,
     cleanupDelegation,
-    retryDelegationAfterFailure,
     pauseForDelegationFailure,
     pauseForExecutionFailure,
     retainUnconfirmedDelegation,