@emiliosp/pi-maestro 0.17.0 → 0.18.1

package/TECH_STACK.md

@@ -7,8 +7,7 @@
 | ------------------------------ | ------------------------------------------------------------------------------------------------- |
 | TypeScript                     | Application code and static type checks with `tsc --noEmit`.                                      |
 | Node.js                        | Runtime.                                                                                          |
-| Pi                             | Extension host, agent APIs, and terminal interface.                                               |
-| `pi-subagents`                 | `Builder`, `verifier`, and `simplifier` execution and activity tracking.                          |
+| Pi                             | Extension host, SDK child sessions, native session persistence, and terminal interface.           |
 | TypeBox                        | Schemas and runtime validation for configuration, workflow state, tool inputs, and agent reports. |
 | Vitest with coverage           | Unit tests, integration tests, and code coverage.                                                 |
 | Oxfmt                          | Formatting                                                                                        |

package/agents/builder.md

@@ -1,14 +1,3 @@
----
-name: builder
-package: maestro
-description: Implements an owner-approved Maestro specification.
-systemPromptMode: replace
-inheritProjectContext: true
-inheritGlobalContext: true
-inheritSkills: true
-subagentOnlyExtensions: ../extensions/maestro-subagent.ts
----
-
 # Builder
 
 Implement the approved spec and produce one saved result for this pass. Work in the project directory supplied by Maestro. The owner decides requirements, scope, spec

package/agents/simplifier.md

@@ -1,14 +1,3 @@
----
-name: simplifier
-package: maestro
-description: Refactors accepted Maestro code for clarity without changing behavior.
-systemPromptMode: replace
-inheritProjectContext: true
-inheritGlobalContext: true
-inheritSkills: true
-subagentOnlyExtensions: ../extensions/maestro-subagent.ts
----
-
 # Simplifier
 
 Refactor accepted code for clarity. Work only in the canonical project directory supplied by Maestro. Communicate with Maestro, never directly with the owner. Do not

package/agents/verifier.md

@@ -1,14 +1,3 @@
----
-name: verifier
-package: maestro
-description: Independently verifies a Maestro candidate against its specification.
-systemPromptMode: replace
-inheritProjectContext: true
-inheritGlobalContext: true
-inheritSkills: true
-subagentOnlyExtensions: ../extensions/maestro-subagent.ts
----
-
 # Verifier
 
 Independently verify the supplied candidate against the approved spec and record evidence and findings. Work in the project directory supplied by Maestro. Check its live

package/docs/configuration.md

@@ -52,7 +52,7 @@ For example, if Pi starts in `/work/app/src`, `Maestro` reads `/work/app/src/.pi
 | `simplifier.thinking` |                        No | `high`                      | One supported thinking level.                            |
 
 Model values use the full `provider/model` identifier supplied by Pi's model registry, such as `openrouter/~openai/gpt-mini-latest`. Model IDs may contain additional
-slashes. `Maestro` does not apply a separate format rule; it matches the complete identifier against Pi's available models and passes it unchanged through `pi-subagents`.
+slashes. `Maestro` does not apply a separate format rule; it matches the complete identifier against Pi's available models and uses it unchanged for SDK execution.
 
 `Maestro` accepts these thinking levels:
 
@@ -97,8 +97,8 @@ used for implementation in another workflow. With `builder` enabled, `verifier`
 | `true`             | `false`             | `true`                | `Builder`, then `simplifier`   |
 | `true`             | `true`              | `true`                | All three, in order            |
 
-Disabled phases do not require agent or model availability and produce no `handoff`. The final summary identifies skipped work rather than claiming it was performed.
-Enabled simplification can still be skipped if Git is unavailable.
+Disabled phases do not require model availability and produce no `handoff`. The final summary identifies skipped work rather than claiming it was performed. Enabled
+simplification can still be skipped if Git is unavailable.
 
 ## Schema version
 
@@ -117,12 +117,11 @@ For example, `specDirectory: "planning/specs"` places `specs` in `<project-root>
 
 ## Model access
 
-During activation, `Maestro` checks only enabled agents and their configured models against `context.modelRegistry.getAvailable()`. Pi's registry is the source of truth
-for model availability; `Maestro` does not maintain a separate model list or authentication check. A missing enabled model stops activation and identifies the full
-configured identifier.
+During activation, `Maestro` checks the configured models for enabled agents against Pi's available model registry. Pi's registry is the source of truth for model
+availability; `Maestro` does not maintain a separate model list or authentication check. A missing enabled model stops activation and identifies the full configured
+identifier.
 
-With `builder` disabled, activation checks only project trust and configuration, with no agent checks, model lookup, or `pi-subagents` ping. With `builder` enabled, the
-availability ping remains required.
+With `builder` disabled, activation checks only project trust and configuration, without a model lookup.
 
-The `owner` can correct the identifier or authenticate the provider in Pi, then retry `/maestro`. Authentication or provider errors during delegation still appear as
-`run` failures. Agent names and context are described in [Subagent integration](subagent-integration.md#roles-and-context).
+The `owner` can correct the identifier or authenticate the provider in Pi, then retry `/maestro`. Authentication or provider errors during execution still appear as `run`
+failures. Agent context are described in [Subagent integration](subagent-integration.md#roles-and-context).

package/docs/subagent-integration.md

@@ -1,45 +1,46 @@
 # Subagent integration
 
-`Maestro` uses `pi-subagents` to run the `builder`, `verifier`, and `simplifier` as child sessions. A child session is a separate Pi session for one role. The `owner`
-stays in the main `Maestro` conversation.
+`Maestro` runs the `builder`, `verifier`, and `simplifier` through Pi's SDK. Each child session handles one role while the `owner` stays in the main `Maestro`
+conversation.
 
 ## Roles and context
 
-The package supplies all three roles and the tools that save their results:
+The package supplies the three roles:
 
-| Role         | Agent name           | Definition                                        |
-| ------------ | -------------------- | ------------------------------------------------- |
-| `Builder`    | `maestro.builder`    | [`agents/builder.md`](../agents/builder.md)       |
-| `Verifier`   | `maestro.verifier`   | [`agents/verifier.md`](../agents/verifier.md)     |
-| `Simplifier` | `maestro.simplifier` | [`agents/simplifier.md`](../agents/simplifier.md) |
+| Role         | Instructions                                      |
+| ------------ | ------------------------------------------------- |
+| `Builder`    | [`agents/builder.md`](../agents/builder.md)       |
+| `Verifier`   | [`agents/verifier.md`](../agents/verifier.md)     |
+| `Simplifier` | [`agents/simplifier.md`](../agents/simplifier.md) |
 
-Each `run` starts with a fresh conversation, not the main session's conversation history. All three agents inherit project instructions, the owner's global `AGENTS.md`,
-and available skills. The global file normally lives at `~/.pi/agent/AGENTS.md`.
+Each `run` starts a fresh conversation, without the main session's history or automatic resumption of earlier child sessions. The bundled role instructions supplement
+Pi's normal instructions. Global and project instructions, including `AGENTS.md`, and available skills are discovered through Pi. Models and thinking levels come from
+[Maestro configuration](configuration.md).
 
-`Maestro` supplies the `spec` ID, project directory, model, and thinking level. The agents read all approved documents (`proposal.md`, `spec.md`, and `design.md` when
-present) and saved `artifacts` to understand the work. Earlier `artifacts` provide context, not proof.
+Enabled global and project extensions load in child sessions. Native Pi tools and configured MCP, codemode, and tool search support are available.
 
-The `owner` does not call agent tools directly. `Maestro` starts the enabled `builder` after `GREEN FLAG` approval. The enabled `verifier` starts after successful
-`builder` completion. The enabled `simplifier` follows the selected preceding phases. Disabled agents are not delegated. See
-[Phase selection](configuration.md#phase-selection).
+The `owner` approves the `spec` and selected phases through the main conversation. See [Phase selection](configuration.md#phase-selection).
 
 ## Following a run
 
-`Runs` stay in the foreground and occur one at a time. Pi waits for each `run` to finish before `Maestro` continues. `Maestro` does not run agents in parallel or in the
-background.
+`Runs` stay in the foreground and occur one at a time. Pi waits for each `run` to finish before `Maestro` continues. Maestro's Pi status shows the workflow phase.
 
-Maestro's Pi status shows the workflow phase. `pi-subagents` FleetView shows agent activity, and `/subagents-fleet` opens its inspector for details and transcripts.
+Saved `handoffs` contain the structured results. See [Stored artifacts](workflow.md#stored-artifacts) for further details.
 
-Each child saves its result through `Maestro` tools before returning. `Builder` results produce `B1.json`, `B2.json`, and so on. `Verifier` results produce `V1.json`,
-`V2.json`, and so on. The `simplifier` saves the unnumbered `handoffs/simplifier/S.json`. See [Stored artifacts](workflow.md#stored-artifacts) for the creation sequence.
+## Cancellation and errors
 
-If a `run` fails or returns without a valid saved result, `Maestro` reports the error and stops. Manual follow-up is described in [Limitations](workflow.md#limitations).
+The `owner` can interrupt a running agent with Pi's cancel action (`Escape` by default). `Maestro` forwards cancellation to the child and waits for cleanup.
 
-## External configuration
+Execution errors, interruptions, and missing or invalid `handoffs` stop the workflow. Completed file changes remain.
 
-The `pi-subagents` extension must be installed and enabled in Pi when `builder` is enabled. Workflows with only an approved `spec` need no agent availability or ping.
-`Builder`, `verifier`, and `simplifier` model choices and thinking levels come from [Maestro configuration](configuration.md). `Maestro` does not supply a per-agent
-deadline. Other `pi-subagents` configuration remains the owner's responsibility.
+## Inspecting saved sessions
 
-Only `maestro_run_simplifier` checks Git readiness, with `git rev-parse --is-inside-work-tree`. If readiness cannot be confirmed, it warns and completes without
-delegation. The `simplifier` uses Git to select all uncommitted code changes. `Maestro` does not change the Git index or create commits or checkpoints.
+When a native child session file exists, `Maestro` displays its exact path on completion or failure, including interruptions and invalid `handoffs`. No path is displayed
+when execution fails before a session file is saved.
+
+Child session files live under `subagents/` in Pi's project session directory, outside the project repository. The `owner` can read the displayed JSONL file directly or
+export it with Pi:
+
+```bash
+pi --export /sessions/weather/subagents/child.jsonl conversation.html
+```

package/docs/workflow.md

@@ -31,7 +31,8 @@ issues.
 
 Maestro's Pi status shows the current phase.
 
-`pi-subagents` FleetView and `/subagents-fleet` show live agent activity and transcripts.
+`Maestro` displays the saved native child session path when one exists, including after a failed or interrupted `run`. The `owner` can inspect the file or export it with
+Pi. See [Inspecting saved sessions](subagent-integration.md#inspecting-saved-sessions).
 
 Saved `handoffs` provide a structured account of each reported `run`. The `builder` reports its outcome, `probe` results, notes, and any `escalation` questions. The
 `verifier` reports its independent checks, results, and `findings`. The `simplifier` reports its refactoring separately. Recorded `owner` decisions explain how questions
@@ -359,9 +360,12 @@ these project-specific checks.
 
 ### No automatic rollback
 
-Launch errors, delegation failures, timeouts, interruptions, cancellations, and missing or invalid `handoffs` stop the workflow without a recovery transition. If a `run`
-saves no completed transition, its saved running phase remains unchanged. Partial protocol writes require manual `owner` follow-up. `Maestro` provides no automatic
-rollback, repair, or recovery for these errors. The files that remain are available for `owner` inspection.
+The `owner` can stop a running agent through Pi's cancel action (`Escape` by default). There is no automatic `Maestro` execution deadline. Cancellation does not request a
+final agent turn or create a synthetic `handoff`.
+
+Launch errors, execution failures, interruptions, cancellations, and missing or invalid `handoffs` stop the workflow without a recovery transition. If a `run` saves no
+completed transition, its saved running phase remains unchanged. Partial protocol writes require manual `owner` follow-up. `Maestro` provides no automatic rollback,
+repair, or recovery for these errors. The files that remain are available for `owner` inspection.
 
 ### No reconciliation
 

package/extensions/maestro.ts

@@ -85,7 +85,7 @@ export default (pi: ExtensionAPI): void => {
       }
 
       try {
-        await assertEnvironment({ context, piEventsBus: pi.events });
+        await assertEnvironment({ context });
         const config = await loadConfiguration(context.cwd);
         const isImplementationEnabled = config.builder.required;
 

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@emiliosp/pi-maestro",
-  "version": "0.17.0",
+  "version": "0.18.1",
   "description": "A spec-driven multiagent development workflow for Pi.",
   "keywords": [
     "orchestration",
     "pi",
     "pi-coding-agent",
     "pi-package",
+    "sdd",
     "subagents",
     "workflow"
   ],
@@ -62,43 +63,34 @@
     "fmt": "oxfmt",
     "lint": "oxlint --fix"
   },
-  "dependencies": {
-    "pi-subagents": "0.78.0"
-  },
   "devDependencies": {
     "@earendil-works/pi-ai": "1.5.0",
     "@earendil-works/pi-tui": "1.5.0",
     "@types/node": "26.6.4",
-    "@vitest/coverage-v8": "5.0.3",
+    "@vitest/coverage-v8": "5.0.5",
     "oxfmt": "0.73.0",
     "oxlint": "1.87.0",
     "oxlint-anti-slop": "0.3.8",
     "typebox": "1.3.35",
     "typescript": "7.0.2",
-    "vitest": "5.0.3"
+    "vitest": "5.0.5"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "*",
     "@earendil-works/pi-coding-agent": "*",
     "typebox": "*"
   },
-  "bundleDependencies": [
-    "pi-subagents"
-  ],
   "engines": {
     "node": ">=26.0.0"
   },
   "allowScripts": {
-    "fsevents@2.3.3": true
+    "fsevents@2.3.3": true,
+    "@google/genai": false,
+    "protobufjs": false
   },
   "pi": {
     "extensions": [
       "./extensions/maestro.ts"
-    ],
-    "subagents": {
-      "agents": [
-        "./agents"
-      ]
-    }
+    ]
   }
 }

package/src/config/schema.ts

@@ -5,12 +5,6 @@
 
 import { type Static, Type } from 'typebox';
 
-export const AGENTS = {
-  BUILDER: 'maestro.builder',
-  VERIFIER: 'maestro.verifier',
-  SIMPLIFIER: 'maestro.simplifier',
-} as const;
-
 export const THINKING_LEVELS = {
   OFF: 'off',
   MINIMAL: 'minimal',

package/src/delegation/createAgentProgress.ts

@@ -0,0 +1,68 @@
+/**
+ * Objective: Publish agent activity and elapsed time through Pi's standard progress UI.
+ * Used: During a delegated run, on relevant events and once per second during silence.
+ */
+
+import type { AgentToolUpdateCallback } from '@earendil-works/pi-coding-agent';
+
+import type { AgentActivitySnapshot } from '#src/delegation/trackAgentActivity.ts';
+import type { WorkflowRole } from '#workflow/roles.ts';
+
+type FormatProgressInput = {
+  role: WorkflowRole;
+  elapsedSeconds: number;
+  activity: AgentActivitySnapshot;
+};
+
+const formatProgress = ({ role, elapsedSeconds, activity }: FormatProgressInput): string => {
+  const label = role[0].toUpperCase() + role.slice(1);
+  const elapsed = `${Math.floor(elapsedSeconds / 60)}m ${elapsedSeconds % 60}s`;
+  const tools = [...activity.activeTools.values()].join(', ') || 'none';
+  const recentText = activity.assistantText ? `\n\n${activity.assistantText}` : '';
+
+  return `${label} | Elapsed: ${elapsed} | Active tool: ${tools}${recentText}`;
+};
+
+type CreateAgentProgressInput = {
+  role: WorkflowRole;
+  onUpdate?: AgentToolUpdateCallback;
+};
+
+export const createAgentProgress = ({ role, onUpdate }: CreateAgentProgressInput) => {
+  const startedAt = performance.now();
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let stopped = false;
+  let latestActivity: AgentActivitySnapshot = { activeTools: new Map(), assistantText: '' };
+
+  const show = (activity: AgentActivitySnapshot = latestActivity): void => {
+    if (stopped) return;
+
+    latestActivity = activity;
+
+    onUpdate?.({
+      content: [
+        {
+          type: 'text',
+          text: formatProgress({
+            role,
+            elapsedSeconds: Math.floor((performance.now() - startedAt) / 1000),
+            activity,
+          }),
+        },
+      ],
+      details: undefined,
+    });
+  };
+
+  const startShow = (): void => {
+    timer = setInterval(show, 1000);
+    show();
+  };
+
+  const stopShow = (): void => {
+    stopped = true;
+    clearInterval(timer);
+  };
+
+  return { startShow, show, stopShow };
+};

package/src/delegation/executeRoleTask.ts

@@ -0,0 +1,89 @@
+/**
+ * Objective: Run a bundled SDK role with its handoff tool and UI-only live activity.
+ * Used: By the three foreground run tools after preparing their workflow phase.
+ */
+
+import { readFile } from 'node:fs/promises';
+
+import type { AgentToolUpdateCallback, ExtensionContext } from '@earendil-works/pi-coding-agent';
+
+import { createAgentProgress } from '#src/delegation/createAgentProgress.ts';
+import { executeTask, type ExecuteTaskInput } from '#src/delegation/executeTask.ts';
+import { TaskExecutionError } from '#src/delegation/TaskExecutionError.ts';
+import {
+  trackAgentActivity,
+  type AgentActivitySnapshot,
+} from '#src/delegation/trackAgentActivity.ts';
+import { recordBuilderHandoffTool } from '#tools/child/record-builder-handoff.ts';
+import { recordSimplifierHandoffTool } from '#tools/child/record-simplifier-handoff.ts';
+import { recordVerifierHandoffTool } from '#tools/child/record-verifier-handoff.ts';
+import { WORKFLOW_ROLES, type WorkflowRole } from '#workflow/roles.ts';
+
+const HANDOFF_TOOL_BY_ROLE = {
+  [WORKFLOW_ROLES.BUILDER]: recordBuilderHandoffTool,
+  [WORKFLOW_ROLES.VERIFIER]: recordVerifierHandoffTool,
+  [WORKFLOW_ROLES.SIMPLIFIER]: recordSimplifierHandoffTool,
+} as const;
+
+type ExecuteRoleTaskInput = Pick<
+  ExecuteTaskInput,
+  'prompt' | 'cwd' | 'model' | 'thinkingLevel' | 'signal'
+> & {
+  role: WorkflowRole;
+  ui: ExtensionContext['ui'];
+  onUpdate?: AgentToolUpdateCallback;
+};
+
+export const executeRoleTask = async ({
+  role,
+  ui,
+  onUpdate,
+  prompt,
+  cwd,
+  model,
+  thinkingLevel,
+  signal,
+}: ExecuteRoleTaskInput): Promise<void> => {
+  const roleGuidance = await readFile(new URL(`../../agents/${role}.md`, import.meta.url), 'utf8');
+
+  let snapshot: AgentActivitySnapshot | undefined;
+  const agentProgress = createAgentProgress({ role, onUpdate });
+
+  try {
+    agentProgress.startShow();
+    signal?.addEventListener('abort', agentProgress.stopShow, { once: true });
+
+    if (signal?.aborted) agentProgress.stopShow();
+
+    const result = await executeTask({
+      prompt,
+      cwd,
+      model,
+      thinkingLevel,
+      signal,
+      roleGuidance,
+      additionalTools: [HANDOFF_TOOL_BY_ROLE[role]],
+      onEvent: (event) => {
+        const nextSnapshot = trackAgentActivity({ event, snapshot });
+
+        if (!nextSnapshot) return;
+
+        agentProgress.show(nextSnapshot);
+
+        snapshot = nextSnapshot;
+      },
+    });
+
+    // Publish before protocol validation so a missing handoff still exposes the transcript.
+    if (result.sessionFile) ui.notify(`Saved child session: ${result.sessionFile}`, 'info');
+  } catch (error) {
+    if (error instanceof TaskExecutionError && error.sessionFile) {
+      ui.notify(`Saved child session: ${error.sessionFile}`, 'info');
+    }
+
+    throw error;
+  } finally {
+    agentProgress.stopShow();
+    signal?.removeEventListener('abort', agentProgress.stopShow);
+  }
+};

package/src/delegation/executeTask.ts

@@ -1,14 +1,34 @@
 /**
- * Objective: Execute one independent task in a fresh, persisted native Pi conversation.
+ * Objective: Execute one independent task and own its complete native Pi session lifecycle.
  * Used: By internal callers that await child executions sequentially, outside workflow routing.
  */
 
+import { existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import {
+  type AgentSession,
+  type AgentSessionEvent,
+  createAgentSession,
+  type CreateAgentSessionOptions,
+  SessionManager,
+  type ToolDefinition,
+} from '@earendil-works/pi-coding-agent';
+
+import { prepareSubagentEnvironment } from '#src/delegation/prepareSubagentEnvironment.ts';
 import { readTaskResult } from '#src/delegation/readTaskResult.ts';
-import { SubSession, type SubSessionInput } from '#src/delegation/SubSession.ts';
 import { TaskExecutionError } from '#src/delegation/TaskExecutionError.ts';
 
-export type ExecuteTaskInput = SubSessionInput & {
+export type ExecuteTaskInput = {
   prompt: string;
+  roleGuidance: string;
+  cwd: string;
+  model: string;
+  thinkingLevel: NonNullable<CreateAgentSessionOptions['thinkingLevel']>;
+  additionalTools: ToolDefinition[];
+  signal?: AbortSignal;
+  onEvent?: (event: AgentSessionEvent) => void;
 };
 
 export type TaskExecutionResult = {
@@ -16,23 +36,96 @@ export type TaskExecutionResult = {
   sessionFile?: string;
 };
 
-export const executeTask = async (input: ExecuteTaskInput): Promise<TaskExecutionResult> => {
-  const subSession = new SubSession(input);
+const getSavedFile = (sessionManager?: SessionManager): string | undefined => {
+  const path = sessionManager?.getSessionFile();
+
+  return path && existsSync(path) ? path : undefined;
+};
+
+type CloseSessionInput = {
+  session?: AgentSession;
+  abortPromise?: Promise<void>;
+};
+
+const closeSession = async ({ session, abortPromise }: CloseSessionInput): Promise<void> => {
+  if (!session) return;
+
+  try {
+    await session.abort();
+    await abortPromise;
+  } finally {
+    try {
+      // AgentSession.dispose() does not emit shutdown. Extensions such as MCP need it
+      // to release their connections before the session is disposed.
+      await session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' });
+    } finally {
+      session.dispose();
+    }
+  }
+};
+
+export const executeTask = async ({
+  prompt,
+  roleGuidance,
+  cwd: workingDirectory,
+  model: modelId,
+  thinkingLevel,
+  additionalTools,
+  signal,
+  onEvent,
+}: ExecuteTaskInput): Promise<TaskExecutionResult> => {
+  let session: AgentSession | undefined;
+  let sessionManager: SessionManager | undefined;
+  let abortPromise: Promise<void> | undefined;
+  let unsubscribe: (() => void) | undefined;
+
+  const abort = (): void => {
+    abortPromise = session?.abort();
+    // Cleanup awaits this promise. Handle rejection immediately as well.
+    void abortPromise?.catch(() => {});
+  };
 
   try {
     try {
-      const session = await subSession.open();
-      await session.prompt(input.prompt, { expandPromptTemplates: false });
+      const cwd = await realpath(workingDirectory);
+      const services = await prepareSubagentEnvironment({ cwd, roleGuidance });
+
+      const model = (await services.modelRuntime.getAvailable()).find(
+        (entry) => `${entry.provider}/${entry.id}` === modelId,
+      );
+
+      if (!model) throw new Error(`Model is not available: "${modelId}".`);
+
+      sessionManager = SessionManager.create(
+        cwd,
+        join(SessionManager.create(cwd).getSessionDir(), 'subagents'),
+      );
+
+      ({ session } = await createAgentSession({
+        ...services,
+        sessionManager,
+        model,
+        thinkingLevel,
+        customTools: additionalTools,
+      }));
+
+      if (onEvent) unsubscribe = session.subscribe(onEvent);
+      signal?.addEventListener('abort', abort, { once: true });
+
+      await session.bindExtensions({ mode: 'print' });
+      await session.prompt(prompt, { expandPromptTemplates: false });
 
       const text = readTaskResult(
         session.messages.findLast((message) => message.role === 'assistant'),
       );
 
-      return { text, sessionFile: subSession.getSavedFile() };
+      return { text, sessionFile: getSavedFile(sessionManager) };
     } finally {
-      await subSession.close();
+      unsubscribe?.();
+      signal?.removeEventListener('abort', abort);
+      await closeSession({ session, abortPromise });
     }
   } catch (cause) {
-    throw new TaskExecutionError({ cause, sessionFile: subSession.getSavedFile() });
+    throw new TaskExecutionError({ cause, sessionFile: getSavedFile(sessionManager) });
   }
 };

package/src/delegation/{createChildServices.ts → prepareSubagentEnvironment.ts}

@@ -51,12 +51,15 @@ const isMainExtension = (path: string): boolean => {
   }
 };
 
-type CreateChildServicesInput = {
+type PrepareSubagentEnvironmentInput = {
   cwd: string;
   roleGuidance: string;
 };
 
-export const createChildServices = async ({ cwd, roleGuidance }: CreateChildServicesInput) => {
+export const prepareSubagentEnvironment = async ({
+  cwd,
+  roleGuidance,
+}: PrepareSubagentEnvironmentInput) => {
   const agentDir = getAgentDir();
   const settingsManager = SettingsManager.create(cwd, agentDir);
 
@@ -92,6 +95,8 @@ export const createChildServices = async ({ cwd, roleGuidance }: CreateChildServ
     agentDir,
     settingsManager,
     resourceLoaderOptions: {
+      // Disable automatic extension discovery; load only the filtered paths below
+      // and the built-in factories, so discovery cannot add Maestro back.
       noExtensions: true,
       additionalExtensionPaths,
       extensionFactories,