@wichayutdew/pi-workflows 2.5.1 → 2.6.0

package/src/harness/delegation-plan.ts

@@ -1,19 +1,17 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { loadAgentProfile } from '../agents/profile.ts';
 import type { LoadedWorkflow, WorkflowStep } from '../config/types.ts';
 import type { WorkflowRun } from '../engine/state.ts';
 import { allowedOutcomes } from '../engine/transitions.ts';
 import { digest } from '../digest.ts';
-import { deriveSubagentSessionRoot } from '../integrations/subagents/diagnostics.ts';
 import {
   encodeChildPolicy,
   type ChildStepPolicy,
   type SubagentDelegationRequest,
 } from '../integrations/subagents/protocol.ts';
-import { automaticRecoveryTask, buildDelegatedStepTask } from '../prompt.ts';
-import { WORKFLOW_COMPLETION_PARAMETERS } from '../runtime/completion-tool.ts';
-import { MAX_DELEGATION_RECOVERY_ATTEMPTS } from './delegation-retry-policy.ts';
+import { buildDelegatedStepTask } from '../prompt.ts';
 import type { WorkflowHarnessDependencies } from './dependencies.ts';
-import type { ActiveDelegation, DelegationRecovery } from './types.ts';
+import type { ActiveDelegation } from './types.ts';
 
 type DelegationPlanInput = {
   workflow: LoadedWorkflow;
@@ -21,7 +19,6 @@ type DelegationPlanInput = {
   step: WorkflowStep;
   sessionEpoch: number;
   latestContext: ExtensionContext | undefined;
-  recovery: DelegationRecovery | undefined;
 };
 
 export type DelegationPlan =
@@ -35,13 +32,6 @@ export type DelegationPlan =
       request: SubagentDelegationRequest;
     };
 
-function delegationTranscriptBinding(
-  requestId: string,
-  policyDigest: string,
-): string {
-  return `<pi-workflows-delegation-binding-v1>${requestId}:${policyDigest}</pi-workflows-delegation-binding-v1>`;
-}
-
 /**
  * Creates one immutable subagent request from workflow state and injected
  * identity/workspace effects.
@@ -55,12 +45,21 @@ export function createDelegationPlan(
     | 'resolveWorkspaceDirectory'
   >,
 ): DelegationPlan {
-  const { workflow, run, step, latestContext, recovery } = input;
-  const subagent = step.subagent;
-  if (!subagent) {
+  const { workflow, run, step, latestContext } = input;
+  const agent = step.agent?.name;
+  if (!agent) {
+    return {
+      kind: 'invalid',
+      reason: `Step "${run.currentStepId}" has no agent profile`,
+    };
+  }
+  let agentProfile;
+  try {
+    agentProfile = loadAgentProfile(agent);
+  } catch (error) {
     return {
       kind: 'invalid',
-      reason: `Step "${run.currentStepId}" has no subagent configuration`,
+      reason: error instanceof Error ? error.message : String(error),
     };
   }
   if (!run.cwd) {
@@ -160,7 +159,7 @@ export function createDelegationPlan(
   const policyDigest = digest({
     version: 1,
     requestId,
-    agent: subagent.agent,
+    agent,
     runId: run.runId,
     stepId: run.currentStepId,
     stepDigest: run.currentStepDigest,
@@ -174,7 +173,7 @@ export function createDelegationPlan(
   const policy: ChildStepPolicy = {
     version: 1,
     requestId,
-    agent: subagent.agent,
+    agent,
     workflowId: workflow.definition.id,
     runId: run.runId,
     stepId: run.currentStepId,
@@ -195,22 +194,7 @@ export function createDelegationPlan(
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
     ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
   };
-  const trustedSessionRoot = deriveSubagentSessionRoot(
-    latestContext.sessionManager.getSessionFile(),
-  );
-  const transcriptTask = [
-    buildDelegatedStepTask(workflow, run, ''),
-    delegationTranscriptBinding(requestId, policyDigest),
-    ...(recovery
-      ? [
-          automaticRecoveryTask(
-            recovery.failures.map(({ reason }) => reason),
-            recovery.attempt,
-            MAX_DELEGATION_RECOVERY_ATTEMPTS,
-          ),
-        ]
-      : []),
-  ].join('\n\n');
+  const task = buildDelegatedStepTask(workflow, run, '');
   const active: ActiveDelegation = {
     requestId,
     runId: run.runId,
@@ -219,56 +203,18 @@ export function createDelegationPlan(
     sessionEpoch: input.sessionEpoch,
     resultDirectory: workspace.resultDirectory,
     policy,
-    transcriptTask,
-    agent: subagent.agent,
-    ...(trustedSessionRoot ? { trustedSessionRoot } : {}),
-    broadRecoveryAuthorized: subagent.retryToolFailures,
-    recoveryAttemptCount: recovery?.attempt ?? 0,
-    recoveryFailures: recovery?.failures ?? [],
+    transcriptTask: task,
+    agent,
   };
   const request: SubagentDelegationRequest = {
     version: 1,
     requestId,
-    agent: subagent.agent,
-    task: `${encodeChildPolicy(policy)}\n\n${transcriptTask}`,
-    // Workflow steps are isolation boundaries. Parent/sibling transcripts are
-    // replaced by the explicit workflow handoff.
-    context: 'fresh',
+    agent,
+    task: `${encodeChildPolicy(policy)}\n\n${task}`,
     cwd: delegationCwd,
-    timeoutMs: subagent.timeoutMs,
-    skill:
-      step.permissions.skills.length > 0 ? [...step.permissions.skills] : false,
-    output: false,
-    // TypeBox schemas are structurally JSON objects, but the upstream contract
-    // exposes a generic record.
-    outputSchema: WORKFLOW_COMPLETION_PARAMETERS as unknown as Record<
-      string,
-      unknown
-    >,
-    agentContract: { version: 1 },
-    artifacts: subagent.artifacts,
-    ...(subagent.model ? { model: subagent.model } : {}),
-    ...(subagent.turnBudget
-      ? { turnBudget: structuredClone(subagent.turnBudget) }
-      : {}),
-    ...(subagent.toolBudget
-      ? {
-          toolBudget: {
-            hard: subagent.toolBudget.hard,
-            ...(subagent.toolBudget.soft === undefined
-              ? {}
-              : { soft: subagent.toolBudget.soft }),
-            ...(subagent.toolBudget.block === undefined
-              ? {}
-              : {
-                  block:
-                    subagent.toolBudget.block === '*'
-                      ? '*'
-                      : [...subagent.toolBudget.block],
-                }),
-          },
-        }
-      : {}),
+    timeoutMs: 900_000,
+    ...(agentProfile.model ? { model: agentProfile.model } : {}),
+    ...(agentProfile.thinking ? { thinking: agentProfile.thinking } : {}),
   };
 
   return { kind: 'ready', active, request };

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

@@ -4,13 +4,10 @@ import {
   type SubagentDelegationUpdate,
 } from '../integrations/subagents/protocol.ts';
 import { advanceRun } from '../engine/transitions.ts';
-import {
-  attachSubagentTranscript,
-  recordCurrentStepResult,
-} from '../engine/step-trace.ts';
+import { recordCurrentStepResult } from '../engine/step-trace.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
-import type { ActiveDelegation, DelegationFailureDetails } from './types.ts';
+import type { ActiveDelegation } from './types.ts';
 import { resolveStepEffects } from './step-effects.ts';
 
 type HarnessActionContext = Pick<
@@ -18,7 +15,6 @@ type HarnessActionContext = Pick<
   | 'activeDelegation'
   | 'catalog'
   | 'cleanupDelegation'
-  | 'delegationFailures'
   | 'dependencies'
   | 'finishDelegation'
   | 'isSessionActive'
@@ -27,7 +23,6 @@ type HarnessActionContext = Pick<
   | 'pauseForDelegationFailure'
   | 'releaseMainAfterCancellation'
   | 'retainUnconfirmedDelegation'
-  | 'retryDelegationAfterFailure'
   | 'run'
   | 'sessionEpoch'
   | 'settleAfterTransition'
@@ -70,11 +65,22 @@ function handleDelegationUpdate(
 ): void {
   if (this.activeDelegation !== active) return;
   const progress = [
+    update.activity,
     update.currentTool ? `tool ${update.currentTool}` : undefined,
     update.toolCount !== undefined ? `${update.toolCount} calls` : undefined,
     update.tokens !== undefined ? `${update.tokens} tokens` : undefined,
   ].filter((part): part is string => part !== undefined);
   active.progress = progress.join(', ') || 'running';
+  if (update.detail) {
+    const previous = active.activityLog ?? [];
+    const replacesPreviousResponse =
+      update.detail.startsWith('response: ') &&
+      previous.at(-1)?.startsWith('response: ');
+    active.activityLog = [
+      ...(replacesPreviousResponse ? previous.slice(0, -1) : previous),
+      update.detail,
+    ].slice(-8);
+  }
   this.updateStatus();
 }
 
@@ -128,7 +134,6 @@ async function finishDelegation(
     return;
   }
   this.activeDelegation = undefined;
-  let terminalFailure: DelegationFailureDetails | undefined;
   let cleanupAttempted = false;
 
   try {
@@ -144,80 +149,15 @@ async function finishDelegation(
       return;
     }
     const terminalAt = this.dependencies.now();
-    if (
-      response.requestId === active.requestId &&
-      (response.agent === undefined || response.agent === active.agent) &&
-      response.sessionFile &&
-      active.trustedSessionRoot &&
-      typeof response.runId === 'string' &&
-      response.runId &&
-      response.childIndex === 0
-    ) {
-      try {
-        this.run = attachSubagentTranscript(
-          this.run,
-          active.requestId,
-          {
-            trustedRoot: active.trustedSessionRoot,
-            sessionFile: response.sessionFile,
-            runId: response.runId,
-            childIndex: response.childIndex,
-          },
-          terminalAt,
-        );
-      } catch {
-        // Status evidence is best-effort and cannot alter terminal handling.
-      }
-    }
     const workflow = this.catalog.workflows.get(this.run.workflowId);
     const step = workflow?.definition.steps[this.run.currentStepId];
     if (!workflow || !step) {
       throw new Error('Active workflow configuration is unavailable');
     }
-    if (response.status === 'completed') {
-      const transcriptAudit =
-        await this.delegationFailures.completedResponseAudit(active, response);
-      if (!transcriptAudit.verified) {
-        throw new Error(
-          `Subagent "${active.agent}" completed without a verifiable terminal transcript: ${transcriptAudit.reason}`,
-        );
-      }
-      if (transcriptAudit.warning) {
-        throw new Error(
-          `Subagent "${active.agent}" completed with an unresolved post-completion watchdog warning: ${transcriptAudit.warning}`,
-        );
-      }
-    }
-    let recoveredTerminalFailure: DelegationFailureDetails | undefined;
-    if (
-      response.status !== 'completed' ||
-      this.delegationFailures.hasContradictoryCompletion(response)
-    ) {
-      const failure = await this.delegationFailures.describeDelegationFailure(
-        active,
-        response,
-      );
-      terminalFailure = failure;
-      if (
-        response.status !== 'failed' ||
-        failure.diagnostic?.completionAfterFailure !== true
-      ) {
-        throw new Error(failure.reason);
-      }
-      const projectionError = this.delegationFailures.recoveredProjectionError(
-        active,
-        response,
-        failure.diagnostic,
+    if (response.status !== 'completed') {
+      throw new Error(
+        `Workflow worker "${active.agent}" ${response.status.replaceAll('_', ' ')}${response.error ? `: ${response.error}` : ''}`,
       );
-      if (projectionError) {
-        throw new Error(
-          this.delegationFailures.rejectedRecoveryReason(
-            failure,
-            projectionError,
-          ),
-        );
-      }
-      recoveredTerminalFailure = failure;
     }
     const requiredSkillWarning =
       step.requires.skills.length > 0
@@ -233,15 +173,6 @@ async function finishDelegation(
     try {
       serializedResult = await this.dependencies.readDelegatedResult(active);
     } catch (error) {
-      if (recoveredTerminalFailure) {
-        throw new Error(
-          this.delegationFailures.rejectedRecoveryReason(
-            recoveredTerminalFailure,
-            error,
-          ),
-          { cause: error },
-        );
-      }
       if (hasErrorCode(error, 'ENOENT')) {
         throw new Error(
           `Subagent "${active.agent}" completed without producing the required correlated structured_output result`,
@@ -251,49 +182,12 @@ async function finishDelegation(
       throw error;
     }
 
-    let result: WorkflowStepResult;
-    try {
-      const rawResult: unknown = JSON.parse(serializedResult);
-      result = parseDelegatedStepResult(rawResult, active.policy);
-    } catch (error) {
-      if (recoveredTerminalFailure) {
-        throw new Error(
-          this.delegationFailures.rejectedRecoveryReason(
-            recoveredTerminalFailure,
-            error,
-          ),
-          { cause: error },
-        );
-      }
-      throw error;
-    }
-    if (
-      recoveredTerminalFailure?.diagnostic &&
-      !this.delegationFailures.completionMatchesResult(
-        recoveredTerminalFailure.diagnostic,
-        result,
-        active.policy,
-      )
-    ) {
-      throw new Error(
-        this.delegationFailures.rejectedRecoveryReason(
-          recoveredTerminalFailure,
-          'structured_output transcript value does not match the correlated result',
-        ),
-      );
-    }
+    const rawResult: unknown = JSON.parse(serializedResult);
+    const result: WorkflowStepResult = parseDelegatedStepResult(
+      rawResult,
+      active.policy,
+    );
     const acceptedAt = terminalAt;
-    if (recoveredTerminalFailure) {
-      const isFalsePositive =
-        recoveredTerminalFailure.diagnostic?.correlation ===
-        'successful-output-before-completion';
-      this.latestContext?.ui.notify(
-        isFalsePositive
-          ? `Accepted "${active.stepId}" because the trusted child transcript proved the terminal tool error was a false positive and produced a matching structured result`
-          : `Accepted "${active.stepId}" because the child resolved an earlier tool failure and produced a valid structured result`,
-        'warning',
-      );
-    }
     if (step.gate?.submitOutcome === result.outcome) {
       this.run = recordCurrentStepResult(this.run, result, acceptedAt);
       await this.submitGate(
@@ -335,14 +229,7 @@ async function finishDelegation(
     const reason = error instanceof Error ? error.message : String(error);
     cleanupAttempted = true;
     await this.cleanupDelegation(active);
-    if (!this.retryDelegationAfterFailure(active, terminalFailure, reason)) {
-      const failureSummary = terminalFailure?.error
-        ? `Subagent ${terminalFailure.status.replaceAll('_', ' ')}: ${terminalFailure.error}`
-        : terminalFailure
-          ? `Subagent ${terminalFailure.status.replaceAll('_', ' ')}`
-          : reason;
-      this.pauseForDelegationFailure(reason, failureSummary);
-    }
+    this.pauseForDelegationFailure(reason);
   } finally {
     try {
       if (!cleanupAttempted) await this.cleanupDelegation(active);

package/src/harness/dependencies.ts

@@ -14,11 +14,6 @@ import {
   createSubagentDelegationClient,
   type SubagentDelegationClientController,
 } from '../integrations/subagents/client.ts';
-import {
-  auditCompletedDelegationTranscript,
-  readDelegationReplayAudit,
-  readToolFailureDiagnostic,
-} from '../integrations/subagents/diagnostics.ts';
 import {
   createMainStepRuntime,
   type MainStepRuntimeController,
@@ -61,9 +56,6 @@ export type WorkflowHarnessDependencies = {
   readonly requestPlannotatorReview: typeof requestPlannotatorReview;
   readonly requestPlannotatorReviewStatus: typeof requestPlannotatorReviewStatus;
   readonly requestPromptGateReview: typeof requestPromptGateReview;
-  readonly readDelegationReplayAudit: typeof readDelegationReplayAudit;
-  readonly readToolFailureDiagnostic: typeof readToolFailureDiagnostic;
-  readonly auditCompletedDelegationTranscript: typeof auditCompletedDelegationTranscript;
   readonly showWorkflowStatus: typeof showWorkflowStatus;
   readonly createSubagentClient: (
     pi: ExtensionAPI,
@@ -150,11 +142,8 @@ const DEFAULT_DEPENDENCIES: WorkflowHarnessDependencies = {
   requestPlannotatorReview,
   requestPlannotatorReviewStatus,
   requestPromptGateReview,
-  readDelegationReplayAudit,
-  readToolFailureDiagnostic,
-  auditCompletedDelegationTranscript,
   showWorkflowStatus,
-  createSubagentClient: (pi) => createSubagentDelegationClient(pi.events),
+  createSubagentClient: () => createSubagentDelegationClient(),
   createMainStepRuntime: (pi) => createMainStepRuntime({ pi }),
   createMutationQueue: createSerialTaskQueue,
   flushUnwrittenSession,

package/src/harness/status-actions.ts

@@ -63,6 +63,7 @@ function workflowStatusSnapshot(
       agent: this.activeDelegation.agent,
       requestId: this.activeDelegation.requestId,
       progress: this.activeDelegation.progress ?? 'starting',
+      activityLog: this.activeDelegation.activityLog ?? [],
     };
   } else if (this.mainSteps.activeStepId) {
     execution = { kind: 'main' };

package/src/harness/step-execution-actions.ts

@@ -15,7 +15,7 @@ import type { MainStepExecution } from '../runtime/main-step-runtime.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
 import { createDelegationPlan } from './delegation-plan.ts';
-import type { DelegationRecovery, MainStepIdentity } from './types.ts';
+import type { MainStepIdentity } from './types.ts';
 import { resolveStepEffects } from './step-effects.ts';
 
 type HarnessActionContext = Pick<
@@ -50,7 +50,6 @@ export type StepExecutionActions = {
   launchCurrentStep: (
     this: HarnessActionContext,
     workflow: LoadedWorkflow,
-    recovery?: DelegationRecovery,
   ) => void;
   launchMainStep: (
     this: HarnessActionContext,
@@ -87,7 +86,6 @@ export type StepExecutionActions = {
 function launchCurrentStep(
   this: HarnessActionContext,
   workflow: LoadedWorkflow,
-  recovery?: DelegationRecovery,
 ): void {
   const run = this.run;
   if (
@@ -106,11 +104,6 @@ function launchCurrentStep(
     );
     return;
   }
-  if (!step.subagent) {
-    this.launchMainStep(workflow, run, step);
-    return;
-  }
-
   const plan = createDelegationPlan(
     {
       workflow,
@@ -118,7 +111,6 @@ function launchCurrentStep(
       step,
       sessionEpoch: this.sessionEpoch,
       latestContext: this.latestContext,
-      recovery,
     },
     this.dependencies,
   );
@@ -243,6 +235,7 @@ function launchMainStep(
     outcomes: allowedOutcomes(workflow, run),
     summaryMaxChars: workflow.definition.summaryMaxChars,
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
+    ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
     onTrace: (lines, context) =>
       this.queueMainStepLog(identity, lines, context),
     onSettled: (result, context) =>

package/src/harness/types.ts

@@ -1,10 +1,5 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
-import type { DelegationReplayAudit } from '../integrations/subagents/diagnostics.ts';
-import type {
-  ChildStepPolicy,
-  SubagentDelegationStatus,
-} from '../integrations/subagents/protocol.ts';
-import type { WorkflowHarnessDependencies } from './dependencies.ts';
+import type { ChildStepPolicy } from '../integrations/subagents/protocol.ts';
 
 export type ActiveDelegation = {
   requestId: string;
@@ -16,34 +11,11 @@ export type ActiveDelegation = {
   policy: ChildStepPolicy;
   transcriptTask: string;
   agent: string;
-  trustedSessionRoot?: string;
-  broadRecoveryAuthorized: boolean;
-  recoveryAttemptCount: number;
-  recoveryFailures: ReadonlyArray<DelegationRecoveryFailure>;
   progress?: string;
+  activityLog?: Array<string>;
   cancelling?: boolean;
 };
 
-export type DelegationRecoveryBlocker =
-  | 'cancelled'
-  | 'detached'
-  | 'inconsistent-timeout'
-  | 'interrupted'
-  | 'reported-mutation'
-  | 'stopped';
-
-export type DelegationFailureDetails = {
-  reason: string;
-  status: SubagentDelegationStatus;
-  error?: string;
-  exitCode?: number;
-  recoveryBlocker?: DelegationRecoveryBlocker;
-  diagnostic?: Awaited<
-    ReturnType<WorkflowHarnessDependencies['readToolFailureDiagnostic']>
-  >;
-  replayAudit?: DelegationReplayAudit;
-};
-
 export type MainStepIdentity = {
   requestId: string;
   runId: string;
@@ -65,13 +37,3 @@ export type WorkflowStartContext = {
   skills: () => ReadonlyArray<{ name: string }> | undefined;
   waitForIdle: () => Promise<void>;
 };
-
-export type DelegationRecoveryFailure = {
-  readonly fingerprint: string;
-  readonly reason: string;
-};
-
-export type DelegationRecovery = {
-  readonly attempt: number;
-  readonly failures: ReadonlyArray<DelegationRecoveryFailure>;
-};

package/src/harness.ts

@@ -24,10 +24,6 @@ import {
 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 {
-  createDelegationFailureActions,
-  type DelegationFailureActions,
-} from './harness/delegation-failure.ts';
 import { createEmptyCatalog } from './harness/catalog.ts';
 import {
   createWorkflowHarnessDependencies,
@@ -36,8 +32,6 @@ import {
 import type {
   ActiveDelegation,
   ActivePromptReview,
-  DelegationRecovery,
-  DelegationFailureDetails,
   MainStepIdentity,
   WorkflowStartContext,
 } from './harness/types.ts';
@@ -79,7 +73,6 @@ const CORE_ACTIONS = createCoreActions();
 export class WorkflowHarness implements WorkflowCommandController {
   private readonly pi: ExtensionAPI;
   private readonly dependencies: WorkflowHarnessDependencies;
-  private readonly delegationFailures: DelegationFailureActions;
   private readonly subagents: SubagentDelegationClientController;
   private readonly mainSteps: MainStepRuntimeController;
   private catalog: WorkflowCatalog = createEmptyCatalog();
@@ -149,10 +142,8 @@ export class WorkflowHarness implements WorkflowCommandController {
     LIFECYCLE_ACTIONS.registerLifecycle;
   private readonly registerPolicy: () => void =
     LIFECYCLE_ACTIONS.registerPolicy;
-  private readonly launchCurrentStep: (
-    workflow: LoadedWorkflow,
-    recovery?: DelegationRecovery,
-  ) => void = STEP_EXECUTION_ACTIONS.launchCurrentStep;
+  private readonly launchCurrentStep: (workflow: LoadedWorkflow) => void =
+    STEP_EXECUTION_ACTIONS.launchCurrentStep;
   private readonly launchMainStep: (
     workflow: LoadedWorkflow,
     run: WorkflowRun,
@@ -200,11 +191,6 @@ export class WorkflowHarness implements WorkflowCommandController {
   private readonly cleanupDelegation: (
     active: ActiveDelegation,
   ) => Promise<void> = DELEGATION_CONTROL_ACTIONS.cleanupDelegation;
-  private readonly retryDelegationAfterFailure: (
-    active: ActiveDelegation,
-    failure: DelegationFailureDetails | undefined,
-    reason: string,
-  ) => boolean = DELEGATION_CONTROL_ACTIONS.retryDelegationAfterFailure;
   private readonly pauseForDelegationFailure: (
     reason: string,
     failureSummary?: string,
@@ -298,7 +284,6 @@ export class WorkflowHarness implements WorkflowCommandController {
   ) {
     this.pi = pi;
     this.dependencies = createWorkflowHarnessDependencies(dependencyOverrides);
-    this.delegationFailures = createDelegationFailureActions(this.dependencies);
     this.statusShortcut = statusShortcut;
     this.statusShortcutLabel = formatShortcutLabel(statusShortcut);
     this.subagents = this.dependencies.createSubagentClient(pi);

package/src/index.ts

@@ -3,7 +3,6 @@ import type { KeyId } from '@earendil-works/pi-tui';
 import { defaultUserWorkflowDirectory, loadSettings } from './config/load.ts';
 import { WorkflowHarness } from './harness.ts';
 import { registerSubagentChildRuntime } from './integrations/subagents/child-runtime.ts';
-import { isSubagentRuntimeName } from './integrations/subagents/protocol.ts';
 
 /**
  * Asynchronous entry point accepted by Pi's extension loader.
@@ -25,7 +24,6 @@ export type PiWorkflowsExtensionDependencies = {
   readonly loadSettings: typeof loadSettings;
   readonly userWorkflowDirectory: () => string;
   readonly runtimeEnvironment: () => PiWorkflowsRuntimeEnvironment;
-  readonly isSubagentRuntimeName: typeof isSubagentRuntimeName;
   readonly registerChildRuntime: (pi: ExtensionAPI, childAgent: string) => void;
   readonly createHarness: (pi: ExtensionAPI, statusShortcut: KeyId) => void;
 };
@@ -34,10 +32,9 @@ const DEFAULT_DEPENDENCIES = {
   loadSettings,
   userWorkflowDirectory: defaultUserWorkflowDirectory,
   runtimeEnvironment: (): PiWorkflowsRuntimeEnvironment => ({
-    isSubagentChild: process.env.PI_SUBAGENT_CHILD === '1',
-    childAgent: process.env.PI_SUBAGENT_CHILD_AGENT?.trim(),
+    isSubagentChild: process.env.PI_WORKFLOWS_CHILD === '1',
+    childAgent: process.env.PI_WORKFLOWS_CHILD_AGENT?.trim(),
   }),
-  isSubagentRuntimeName,
   registerChildRuntime: (pi, childAgent): void => {
     registerSubagentChildRuntime(pi, { childAgent });
   },
@@ -59,10 +56,8 @@ export function createPiWorkflowsExtension(
   return async (pi): Promise<void> => {
     const environment = dependencies.runtimeEnvironment();
 
-    if (environment.isSubagentChild) {
-      if (dependencies.isSubagentRuntimeName(environment.childAgent)) {
-        dependencies.registerChildRuntime(pi, environment.childAgent);
-      }
+    if (environment.isSubagentChild && environment.childAgent) {
+      dependencies.registerChildRuntime(pi, environment.childAgent);
       return;
     }