@emiliosp/pi-maestro 0.17.0 → 0.18.1

package/src/delegation/trackAgentActivity.ts

@@ -0,0 +1,48 @@
+/**
+ * Objective: Derive agent activity from a session event and the previous snapshot.
+ * Used: During a delegated run, without mutating state or publishing progress.
+ */
+
+import type { AgentSessionEvent } from '@earendil-works/pi-coding-agent';
+
+export type AgentActivitySnapshot = {
+  activeTools: ReadonlyMap<string, string>;
+  assistantText: string;
+};
+
+type TrackAgentActivityInput = {
+  event: AgentSessionEvent;
+  snapshot?: AgentActivitySnapshot;
+};
+
+export const trackAgentActivity = ({
+  event,
+  snapshot = { activeTools: new Map(), assistantText: '' },
+}: TrackAgentActivityInput): AgentActivitySnapshot | undefined => {
+  if (event.type === 'tool_execution_start') {
+    const activeTools = new Map(snapshot.activeTools);
+    activeTools.set(event.toolCallId, event.toolName);
+
+    return { ...snapshot, activeTools };
+  }
+
+  if (event.type === 'tool_execution_end') {
+    const activeTools = new Map(snapshot.activeTools);
+    activeTools.delete(event.toolCallId);
+
+    return { ...snapshot, activeTools };
+  }
+
+  if (event.type !== 'message_update' && event.type !== 'message_end') return;
+
+  if (event.message.role !== 'assistant') return;
+
+  const assistantText = event.message.content
+    .filter((block) => block.type === 'text')
+    .map((block) => block.text)
+    .join('\n');
+
+  if (!assistantText) return;
+
+  return { ...snapshot, assistantText };
+};

package/src/ids/createSpecId.ts

@@ -35,10 +35,8 @@ const normalizeSlug = (value: string): string => {
 
 type CreateSpecIdInput = {
   title: string;
-  instant?: Temporal.Instant;
+  instant: Temporal.Instant;
 };
 
-export const createSpecId = ({
-  title,
-  instant = Temporal.Now.instant(),
-}: CreateSpecIdInput): string => `${formatUtcTimestamp(instant)}-${normalizeSlug(title)}`;
+export const createSpecId = ({ title, instant }: CreateSpecIdInput): string =>
+  `${formatUtcTimestamp(instant)}-${normalizeSlug(title)}`;

package/src/maestro/checks/assertEnvironment.ts

@@ -3,23 +3,11 @@
  * Used: When the owner activates Maestro mode.
  */
 
-import { randomUUID } from 'node:crypto';
 import { realpath } from 'node:fs/promises';
 
-import type { ExtensionAPI, ExtensionContext } from '@earendil-works/pi-coding-agent';
-import { resolveSubagentLaunchContract } from 'pi-subagents/preflight';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 
 import { loadConfiguration } from '#config/loadConfiguration.ts';
-import { AGENTS } from '#config/schema.ts';
-
-export const SUBAGENT_PING = {
-  REQUEST_EVENT: 'subagents:rpc:v1:request',
-  REPLY_EVENT_PREFIX: 'subagents:rpc:v1:reply:',
-  VERSION: 1,
-  METHOD: 'ping',
-  TIMEOUT_MS: 2000,
-  INSTALLATION_ERROR: 'Maestro flow requires pi-subagents installed in the Pi environment.',
-} as const;
 
 const getErrorMessage = (error: unknown): string =>
   error instanceof Error ? error.message : String(error);
@@ -63,114 +51,19 @@ function assertModelsAvailable({ context, models }: AssertModelsAvailableInput):
   }
 }
 
-type AssertAgentsAvailableInput = {
-  projectRoot: string;
-  agents: string[];
-};
-
-async function assertAgentsAvailable({
-  projectRoot,
-  agents,
-}: AssertAgentsAvailableInput): Promise<void> {
-  for (const agent of agents) {
-    const result = await resolveSubagentLaunchContract({
-      agent,
-      cwd: projectRoot,
-      context: 'fresh',
-    });
-
-    if (!result.ok) {
-      throw new Error(result.message);
-    }
-  }
-}
-
-const isRecord = (value: unknown): value is Record<string, unknown> =>
-  typeof value === 'object' && value !== null && !Array.isArray(value);
-
-const isReplyWithRequestId = (
-  reply: unknown,
-): reply is Record<string, unknown> & { requestId: string } =>
-  isRecord(reply) && typeof reply.requestId === 'string';
-
-function assertSuccessfulPingReply(reply: unknown): void {
-  if (
-    !isReplyWithRequestId(reply) ||
-    reply.version !== SUBAGENT_PING.VERSION ||
-    reply.method !== SUBAGENT_PING.METHOD ||
-    reply.success !== true ||
-    !isRecord(reply.data) ||
-    reply.data.version !== SUBAGENT_PING.VERSION
-  ) {
-    throw new Error('Unsuccessful or invalid pi-subagents ping reply.');
-  }
-}
-
-async function assertSubagentsRespond(piEventsBus: ExtensionAPI['events']): Promise<void> {
-  const requestId = randomUUID();
-  const { promise, resolve, reject } = Promise.withResolvers<unknown>();
-
-  const unsubscribe = piEventsBus.on(`${SUBAGENT_PING.REPLY_EVENT_PREFIX}${requestId}`, (reply) => {
-    if (isReplyWithRequestId(reply) && reply.requestId !== requestId) {
-      return;
-    }
-
-    resolve(reply);
-  });
-
-  const timeout = setTimeout(
-    () => reject(new Error('Pi-subagents ping timed out after 2000 ms.')),
-    SUBAGENT_PING.TIMEOUT_MS,
-  );
-
-  try {
-    piEventsBus.emit(SUBAGENT_PING.REQUEST_EVENT, {
-      version: SUBAGENT_PING.VERSION,
-      requestId,
-      method: SUBAGENT_PING.METHOD,
-    });
-    assertSuccessfulPingReply(await promise);
-  } finally {
-    clearTimeout(timeout);
-    unsubscribe();
-  }
-}
-
 type AssertEnvironmentInput = {
   context: ExtensionContext;
-  piEventsBus: ExtensionAPI['events'];
 };
 
-export async function assertEnvironment({
-  context,
-  piEventsBus,
-}: AssertEnvironmentInput): Promise<void> {
+export async function assertEnvironment({ context }: AssertEnvironmentInput): Promise<void> {
   const projectRoot = await getProjectRoot(context);
   const config = await getActivationConfiguration(projectRoot);
 
   if (!config.builder.required) return;
 
-  const enabledAgents = [
-    { agent: AGENTS.BUILDER, settings: config.builder },
-    { agent: AGENTS.VERIFIER, settings: config.verifier },
-    { agent: AGENTS.SIMPLIFIER, settings: config.simplifier },
-  ].filter(({ settings }) => settings.required);
-
-  try {
-    await assertAgentsAvailable({ projectRoot, agents: enabledAgents.map(({ agent }) => agent) });
-  } catch (error) {
-    throw new Error(
-      `Builder, verifier, or simplifier agent check failed: ${getErrorMessage(error)}`,
-    );
-  }
-
-  assertModelsAvailable({ context, models: enabledAgents.map(({ settings }) => settings.model) });
+  const enabledAgents = [config.builder, config.verifier, config.simplifier].filter(
+    ({ required }) => required,
+  );
 
-  try {
-    await assertSubagentsRespond(piEventsBus);
-  } catch (error) {
-    throw new Error(`${SUBAGENT_PING.INSTALLATION_ERROR} ${getErrorMessage(error)}`, {
-      cause: error,
-    });
-  }
+  assertModelsAvailable({ context, models: enabledAgents.map(({ model }) => model) });
 }

package/src/maestro/instructions/getMaestroInstructions.ts

@@ -33,7 +33,8 @@ The project root is the canonical Pi working directory, resolved with realpath.
 Load .pi/maestro.json only from this root. Each agent's required boolean defaults to true. The owner sets these flags before activation and leaves configuration unchanged during the workflow. Do not add caching or runtime flag controls.
 If builder.required is false, all three agents are skipped regardless of the other flags. Otherwise verifier and simplifier can be disabled independently. Never run a disabled phase.
 Resolve spec and product paths against this root. Children run in this directory.
-Do not add worktree checks, activation gates, warnings, or configuration changes: compatible pi-subagents configuration is the owner's responsibility.
+All three roles use the internal Pi SDK executor with bundled role guidance and handoff tools. Do not add another execution engine or a delegation preflight.
+Run tools forward manual cancellation and display the saved native child session path when one exists. Errors stop the workflow; do not retry, repair, resume, or roll back automatically.
 Use generic tools for project inspection. Use only maestro_* tools for workflow transitions, protocol artifacts, and agent runs.
 Do not edit workflow.json or handoffs directly, including through shell commands.
 The spec, prototype, and experiment permissions below are the only exceptions for file changes.

package/src/specs/create.ts

@@ -44,7 +44,7 @@ export const createSpec = async ({
     throw new Error(`Workflow ${activeWorkflowSpecId} is already active.`);
   }
 
-  const specId = createSpecId({ title, instant });
+  const specId = createSpecId({ title, instant: instant ?? Temporal.Now.instant() });
   const specPath = paths.getSpecPath(specId);
   const proposalFilePath = paths.getProposalFilePath(specId);
   const specFilePath = paths.getSpecFilePath(specId);

package/src/tools/child/record-builder-handoff.ts

@@ -1,9 +1,9 @@
 /**
- * Objective: Register the builder handoff tool for the current project.
+ * Objective: Define the builder handoff tool for the current project.
  * Used: When the builder reports a done or escalation result.
  */
 
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 
 import {
@@ -38,35 +38,33 @@ const BuilderHandoffToolParameters = Type.Union([
   ),
 ]);
 
-export const registerRecordBuilderHandoffTool = (pi: ExtensionAPI): void => {
-  pi.registerTool({
-    name: BUILDER_HANDOFF_TOOL.NAME,
-    label: BUILDER_HANDOFF_TOOL.LABEL,
-    description: BUILDER_HANDOFF_TOOL.DESCRIPTION,
-    parameters: BuilderHandoffToolParameters,
-    async execute(_toolCallId, params, _signal, _onUpdate, context) {
-      const { specId, ...handoff } = params;
+export const recordBuilderHandoffTool = {
+  name: BUILDER_HANDOFF_TOOL.NAME,
+  label: BUILDER_HANDOFF_TOOL.LABEL,
+  description: BUILDER_HANDOFF_TOOL.DESCRIPTION,
+  parameters: BuilderHandoffToolParameters,
+  async execute(_toolCallId, params, _signal, _onUpdate, context) {
+    const { specId, ...handoff } = params;
 
-      const { paths, config } = await resolveWorkflowContext({
-        cwd: context.cwd,
-        specId,
-      });
+    const { paths, config } = await resolveWorkflowContext({
+      cwd: context.cwd,
+      specId,
+    });
 
-      const completed = await completeBuilderPass({ config, paths, specId, handoff });
+    const completed = await completeBuilderPass({ config, paths, specId, handoff });
 
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Builder handoff recorded as ${completed.handoff.status}. The handoff and workflow phase are saved. Stop now.`,
-          },
-        ],
-        details: {
-          specId: completed.handoff.specId,
-          handoffPath: completed.handoffPath,
-          phase: completed.state.phase,
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Builder handoff recorded as ${completed.handoff.status}. The handoff and workflow phase are saved. Stop now.`,
         },
-      };
-    },
-  });
-};
+      ],
+      details: {
+        specId: completed.handoff.specId,
+        handoffPath: completed.handoffPath,
+        phase: completed.state.phase,
+      },
+    };
+  },
+} satisfies ToolDefinition<typeof BuilderHandoffToolParameters>;

package/src/tools/child/record-simplifier-handoff.ts

@@ -1,9 +1,9 @@
 /**
- * Objective: Register the simplifier's fixed result recording tool.
+ * Objective: Define the simplifier's fixed result recording tool.
  * Used: When a child simplifier completes its refactoring pass.
  */
 
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
 import { type Static, Type } from 'typebox';
 import { Value } from 'typebox/value';
 
@@ -35,40 +35,38 @@ function assertSimplifierSubmission(
   }
 }
 
-export const registerRecordSimplifierHandoffTool = (pi: ExtensionAPI): void => {
-  pi.registerTool({
-    name: SIMPLIFIER_HANDOFF_TOOL.NAME,
-    label: SIMPLIFIER_HANDOFF_TOOL.LABEL,
-    description: SIMPLIFIER_HANDOFF_TOOL.DESCRIPTION,
-    parameters: SimplifierHandoffToolParameters,
-    async execute(_toolCallId, params, _signal, _onUpdate, context) {
-      assertSimplifierSubmission(params);
+export const recordSimplifierHandoffTool = {
+  name: SIMPLIFIER_HANDOFF_TOOL.NAME,
+  label: SIMPLIFIER_HANDOFF_TOOL.LABEL,
+  description: SIMPLIFIER_HANDOFF_TOOL.DESCRIPTION,
+  parameters: SimplifierHandoffToolParameters,
+  async execute(_toolCallId, params, _signal, _onUpdate, context) {
+    assertSimplifierSubmission(params);
 
-      const { paths, config } = await resolveWorkflowContext({
-        cwd: context.cwd,
-        specId: params.specId,
-      });
+    const { paths, config } = await resolveWorkflowContext({
+      cwd: context.cwd,
+      specId: params.specId,
+    });
 
-      const completed = await completeSimplifierPass({
-        config,
-        paths,
-        specId: params.specId,
-        handoff: { ...params, version: SIMPLIFIER_HANDOFF_VERSION },
-      });
+    const completed = await completeSimplifierPass({
+      config,
+      paths,
+      specId: params.specId,
+      handoff: { ...params, version: SIMPLIFIER_HANDOFF_VERSION },
+    });
 
-      return {
-        content: [
-          {
-            type: 'text',
-            text: 'Simplifier handoff and candidate-ready phase saved. Stop now.',
-          },
-        ],
-        details: {
-          specId: params.specId,
-          handoffPath: completed.handoffPath,
-          phase: completed.state.phase,
+    return {
+      content: [
+        {
+          type: 'text',
+          text: 'Simplifier handoff and candidate-ready phase saved. Stop now.',
         },
-      };
-    },
-  });
-};
+      ],
+      details: {
+        specId: params.specId,
+        handoffPath: completed.handoffPath,
+        phase: completed.state.phase,
+      },
+    };
+  },
+} satisfies ToolDefinition<typeof SimplifierHandoffToolParameters>;

package/src/tools/child/record-verifier-handoff.ts

@@ -1,9 +1,9 @@
 /**
- * Objective: Register the verifier handoff tool for the current project.
+ * Objective: Define the verifier handoff tool for the current project.
  * Used: When the verifier reports its terminal review result.
  */
 
-import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import type { ToolDefinition } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 
 import { BuilderAcceptanceCriterionSchema } from '#artifacts/builder-handoff/schema.ts';
@@ -44,46 +44,44 @@ const VerifierHandoffToolParameters = Type.Object(
   { additionalProperties: false },
 );
 
-export const registerRecordVerifierHandoffTool = (pi: ExtensionAPI): void => {
-  pi.registerTool({
-    name: VERIFIER_HANDOFF_TOOL.NAME,
-    label: VERIFIER_HANDOFF_TOOL.LABEL,
-    description: VERIFIER_HANDOFF_TOOL.DESCRIPTION,
-    parameters: VerifierHandoffToolParameters,
-    async execute(_toolCallId, params, _signal, _onUpdate, context) {
-      const { specId, ...submission } = params;
+export const recordVerifierHandoffTool = {
+  name: VERIFIER_HANDOFF_TOOL.NAME,
+  label: VERIFIER_HANDOFF_TOOL.LABEL,
+  description: VERIFIER_HANDOFF_TOOL.DESCRIPTION,
+  parameters: VerifierHandoffToolParameters,
+  async execute(_toolCallId, params, _signal, _onUpdate, context) {
+    const { specId, ...submission } = params;
 
-      const { paths, config } = await resolveWorkflowContext({
-        cwd: context.cwd,
-        specId,
-      });
+    const { paths, config } = await resolveWorkflowContext({
+      cwd: context.cwd,
+      specId,
+    });
 
-      const currentState = await readWorkflowState(paths.getWorkflowPath(specId));
+    const currentState = await readWorkflowState(paths.getWorkflowPath(specId));
 
-      const handoff = {
-        version: VERIFIER_HANDOFF_VERSION,
-        specId: currentState.specId,
-        summary: submission.summary,
-        acceptanceCriteria: submission.acceptanceCriteria,
-        findings: submission.findings,
-        notes: submission.notes,
-      };
+    const handoff = {
+      version: VERIFIER_HANDOFF_VERSION,
+      specId: currentState.specId,
+      summary: submission.summary,
+      acceptanceCriteria: submission.acceptanceCriteria,
+      findings: submission.findings,
+      notes: submission.notes,
+    };
 
-      const completed = await completeVerifierPass({ config, paths, specId, handoff });
+    const completed = await completeVerifierPass({ config, paths, specId, handoff });
 
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `Verifier handoff recorded as ${completed.state.phase}. The handoff and workflow phase are saved. Stop now.`,
-          },
-        ],
-        details: {
-          handoffPath: completed.handoffPath,
-          phase: completed.state.phase,
-          specId: completed.handoff.specId,
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Verifier handoff recorded as ${completed.state.phase}. The handoff and workflow phase are saved. Stop now.`,
         },
-      };
-    },
-  });
-};
+      ],
+      details: {
+        handoffPath: completed.handoffPath,
+        phase: completed.state.phase,
+        specId: completed.handoff.specId,
+      },
+    };
+  },
+} satisfies ToolDefinition<typeof VerifierHandoffToolParameters>;

package/src/tools/main/run-builder.ts

@@ -3,10 +3,7 @@
  * Used: When the owner invokes the run-builder tool.
  */
 
-import { randomUUID } from 'node:crypto';
-
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
 
 import { readBuilderHandoff } from '#artifacts/builder-handoff/readBuilderHandoff.ts';
@@ -14,15 +11,11 @@ import {
   BUILDER_HANDOFF_STATUSES,
   type BuilderHandoff,
 } from '#artifacts/builder-handoff/schema.ts';
-import { AGENTS, type MaestroConfig } from '#config/schema.ts';
+import type { MaestroConfig } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
-import {
-  assertDelegationResponse,
-  SUBAGENT_TIMEOUT_MS,
-  waitForDelegationResponse,
-} from '#tools/utils/pi-subagent-delegation.ts';
+import { executeRoleTask } from '#src/delegation/executeRoleTask.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { prepareBuilderRun } from '#workflow/builder/prepareBuilderRun.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
@@ -162,7 +155,7 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
     label: RUN_BUILDER_TOOL.LABEL,
     description: RUN_BUILDER_TOOL.DESCRIPTION,
     parameters: RunBuilderToolParameters,
-    async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
+    async execute(_toolCallId, { specId }, signal, onUpdate, context) {
       const { paths, config } = await resolveToolRunContext(context.cwd);
 
       const { projectRoot, state: builderRunningState } = await prepareBuilderRun({
@@ -173,28 +166,17 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
 
       await refreshMaestroStatus(context);
 
-      const request: SubagentDelegationRequest = {
-        requestId: randomUUID(),
-        ownerRunId: toolCallId,
-        nodeId: WORKFLOW_ROLES.BUILDER,
-        // pi-subagents loads this name from agents/builder.md through package.json.
-        // See docs/subagent-integration.md.
-        agent: AGENTS.BUILDER,
-        task: `Implement specId "${specId}" in the project directory "${projectRoot}".`,
-        context: 'fresh',
+      await executeRoleTask({
+        role: WORKFLOW_ROLES.BUILDER,
+        prompt: `Implement specId "${specId}" in the project directory "${projectRoot}".`,
         cwd: projectRoot,
         model: config.builder.model,
-        thinking: config.builder.thinking,
-        timeoutMs: SUBAGENT_TIMEOUT_MS,
-        result: { kind: 'text' },
-      };
-
-      const response = await waitForDelegationResponse({
-        piEventsBus: pi.events,
-        request,
+        thinkingLevel: config.builder.thinking,
+        signal,
+        ui: context.ui,
+        onUpdate,
       });
 
-      assertDelegationResponse(response);
       const result = await readBuilderResult({ paths, specId, config, builderRunningState });
 
       return {

package/src/tools/main/run-simplifier.ts

@@ -3,22 +3,14 @@
  * Used: After verification succeeds or the owner rejects all findings.
  */
 
-import { randomUUID } from 'node:crypto';
-
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-import type { SubagentDelegationRequest } from 'pi-subagents/delegation';
 import { Type } from 'typebox';
 
 import { readSimplifierHandoff } from '#artifacts/simplifier-handoff/readSimplifierHandoff.ts';
-import { AGENTS } from '#config/schema.ts';
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
-import {
-  assertDelegationResponse,
-  SUBAGENT_TIMEOUT_MS,
-  waitForDelegationResponse,
-} from '#tools/utils/pi-subagent-delegation.ts';
+import { executeRoleTask } from '#src/delegation/executeRoleTask.ts';
 import { resolveToolRunContext } from '#tools/utils/resolveToolRunContext.ts';
 import { WORKFLOW_ROLES } from '#workflow/roles.ts';
 import { readWorkflowState } from '#workflow/state/readWorkflowState.ts';
@@ -95,7 +87,7 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
     label: RUN_SIMPLIFIER_TOOL.LABEL,
     description: RUN_SIMPLIFIER_TOOL.DESCRIPTION,
     parameters: RunSimplifierToolParameters,
-    async execute(toolCallId, { specId }, _signal, _onUpdate, context) {
+    async execute(_toolCallId, { specId }, signal, onUpdate, context) {
       const { paths, config, projectRoot } = await resolveToolRunContext(context.cwd);
 
       const workflowPath = paths.getWorkflowPath(specId);
@@ -136,26 +128,17 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
         };
       }
 
-      const request: SubagentDelegationRequest = {
-        requestId: randomUUID(),
-        ownerRunId: toolCallId,
-        nodeId: WORKFLOW_ROLES.SIMPLIFIER,
-        agent: AGENTS.SIMPLIFIER,
-        task: `Simplify accepted code for specId "${specId}" in the project directory "${projectRoot}". Discover all current staged, unstaged, and untracked code changes with Git, including pre-existing changes.`,
-        context: 'fresh',
+      await executeRoleTask({
+        role: WORKFLOW_ROLES.SIMPLIFIER,
+        prompt: `Simplify accepted code for specId "${specId}" in the project directory "${projectRoot}". Discover all current staged, unstaged, and untracked code changes with Git, including pre-existing changes.`,
         cwd: projectRoot,
         model: config.simplifier.model,
-        thinking: config.simplifier.thinking,
-        timeoutMs: SUBAGENT_TIMEOUT_MS,
-        result: { kind: 'text' },
-      };
-
-      const response = await waitForDelegationResponse({
-        piEventsBus: pi.events,
-        request,
+        thinkingLevel: config.simplifier.thinking,
+        signal,
+        ui: context.ui,
+        onUpdate,
       });
 
-      assertDelegationResponse(response);
       const result = await readSimplifierResult({ paths, specId });
 
       return {