@emiliosp/pi-maestro 0.18.0 → 0.18.2

package/ADR.md

@@ -280,7 +280,7 @@ Approval can finish at `candidate-ready` without agent execution. Agent and mode
 
 ### Status
 
-Design decisions confirmed by the `owner`. Not implemented.
+Design decisions confirmed by the `owner`. Implemented.
 
 ### Context
 

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 This file summarizes meaningful changes to the codebase, including behavior, data formats, architecture, and development tools. Git tags identify version boundaries;
 GitHub Releases are not required.
 
+## 0.18.2
+
+1. The `run` progress for `builder`, `verifier`, and `simplifier` now shows only elapsed time and the latest assistant text. The role name and the active tool no longer
+   appear.
+
+## 0.18.1
+
+1. Running `builder`, `verifier`, and `simplifier` tools now show elapsed time, active tools, and streaming normal assistant text. Elapsed time keeps updating during
+   silent work. Pi controls preview and expansion, while intermediate activity stays out of the main model's context.
+
 ## 0.18.0
 
 1. `Builder`, `verifier`, and `simplifier` now run in fresh native Pi SDK sessions. Activation no longer requires a separate agent extension. The `owner` can interrupt

package/ROADMAP.md

@@ -38,7 +38,7 @@ Completed entries preserve recorded outcomes and evidence, which may describe be
 | MAESTRO-FREE-3     | [Run the builder through the Pi SDK](#maestro-free-3-run-the-builder-through-the-pi-sdk)                                           | Completed |
 | MAESTRO-FREE-4     | [Run the verifier through the Pi SDK](#maestro-free-4-run-the-verifier-through-the-pi-sdk)                                         | Completed |
 | MAESTRO-FREE-5     | [Run the simplifier through the Pi SDK](#maestro-free-5-run-the-simplifier-through-the-pi-sdk)                                     | Completed |
-| MAESTRO-FREE-6     | [Show SDK agent activity through Pi](#maestro-free-6-show-sdk-agent-activity-through-pi)                                           | Backlog   |
+| MAESTRO-FREE-6     | [Show SDK agent activity through Pi](#maestro-free-6-show-sdk-agent-activity-through-pi)                                           | Completed |
 | MAESTRO-FREE-7     | [Remove the pi-subagents dependency](#maestro-free-7-remove-the-pi-subagents-dependency)                                           | Completed |
 
 ## MAESTRO-6: Display specs in a browser
@@ -176,6 +176,10 @@ Connect the `simplifier` to the SDK executor delivered by [MAESTRO-FREE-PRE-3](#
 
 ## MAESTRO-FREE-6: Show SDK agent activity through Pi
 
+Implemented under the [approved specification](.specs/20261106-143021-maestro-free-6-show-sdk-agent-activity-through-pi/spec.md), with `builder` checks passing. `Owner`
+acceptance is pending. Review follow-up moved the shared role executor to `src/delegation/executeRoleTask.ts` and separated event tracking in `trackAgentActivity.ts` from
+UI updates in `createAgentProgress.ts`. The full check passes all 293 tests.
+
 ### Objective
 
 Show activity for SDK-based agent `runs` through Pi's standard `onUpdate` presentation, as decided in
@@ -192,7 +196,7 @@ Show activity for SDK-based agent `runs` through Pi's standard `onUpdate` presen
 ## MAESTRO-FREE-7: Remove the pi-subagents dependency
 
 Implementation follows the [approved migration specification](.specs/20261106-092601-feat-migrate-builder-verifier-and-simplifier-to-the-pi-sdk/spec.md). Code cleanup is
-included in this migration. Package declarations, lockfile entries, bundling, and `pi.subagents` metadata remain for the `owner` to remove manually.
+included in this migration. Package declarations, lockfile entries, bundling, and `pi.subagents` metadata are removed.
 
 ### Objective
 
@@ -221,8 +225,7 @@ Linear marks this item Done, but its description still says final `owner` accept
 [specification](.specs/20261030-145712-automatically-exit-maestro-mode-at-workflow-completion/spec.md), and
 [original issue](https://linear.app/emilio-spatola/issue/MAESTRO-26/feat-exit-maestro-mode-automatically-at-workflow-completion).
 
-Completed entries include historical records imported from Linear and work explicitly accepted by the `owner`. Historical verification evidence alone does not establish
-final `owner` acceptance.
+Completed entries include historical records imported from Linear.
 
 ## MAESTRO-FREE-1: Require Pi 1.5.0
 
@@ -261,7 +264,7 @@ The `pi-subagents` integration then in use still received a fixed deadline of 9,
 ### Implementation and evidence
 
 The standalone executor is implemented under `src/delegation/` against the [approved specification](.specs/20261105-212231-implement-internal-pi-sdk-delegation/spec.md).
-Execution orchestration, session lifecycle, and pure reply interpretation are separated into `executeTask`, `SubSessionManager`, and `readTaskResult`. Manual verification
+Review follow-up consolidated execution orchestration and session lifecycle in `executeTask`; pure reply interpretation remains in `readTaskResult`. Manual verification
 on Pi 1.5.0 exercised fresh context, native and additional tools, MCP through tool search and codemode, sequential waiting, failure, cancellation, cleanup, and native
 session persistence. See [manual evidence](.specs/20261105-212231-implement-internal-pi-sdk-delegation/handoffs/verifier/V1.json). The three workflow roles still use
 `pi-subagents`. The `owner` confirmed completion. The caller's message is named `prompt`, execution is inlined in `executeTask`, and cancellation comments explain Node.js
@@ -427,6 +430,8 @@ and [merged PR #34](https://github.com/emilioSp/pi-maestro/pull/34).
 
 ## MAESTRO-13: Check subagent extensions at activation
 
+Historical outcome: activation no longer requires the parent `pi-subagents` availability check after the SDK migration. See [changelog](CHANGELOG.md).
+
 Require a successful parent `pi-subagents` availability reply before activation.
 
 Implemented in `0.9.3`. Activation requires a matching successful version 1 `ping` reply from the parent `pi-subagents` extension within 2000 ms. A failed or invalid

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emiliosp/pi-maestro",
-  "version": "0.18.0",
+  "version": "0.18.2",
   "description": "A spec-driven multiagent development workflow for Pi.",
   "keywords": [
     "orchestration",

package/src/delegation/createAgentProgress.ts

@@ -0,0 +1,60 @@
+/**
+ * Objective: Publish elapsed run time and the latest normal assistant text through Pi's progress UI.
+ * Used: During a delegated run, on assistant text events and once per second during silence.
+ */
+
+import type { AgentToolUpdateCallback } from '@earendil-works/pi-coding-agent';
+
+type FormatProgressInput = {
+  elapsedSeconds: number;
+  assistantText: string;
+};
+
+const formatProgress = ({ elapsedSeconds, assistantText }: FormatProgressInput): string => {
+  const elapsed = `${Math.floor(elapsedSeconds / 60)}m ${elapsedSeconds % 60}s`;
+  const recentText = assistantText ? `\n\n${assistantText}` : '';
+
+  return `Elapsed: ${elapsed}${recentText}`;
+};
+
+type CreateAgentProgressInput = {
+  onUpdate?: AgentToolUpdateCallback;
+};
+
+export const createAgentProgress = ({ onUpdate }: CreateAgentProgressInput) => {
+  const startedAt = performance.now();
+  let timer: ReturnType<typeof setInterval> | undefined;
+  let stopped = false;
+  let latestText = '';
+
+  const show = (assistantText: string = latestText): void => {
+    if (stopped) return;
+
+    latestText = assistantText;
+
+    onUpdate?.({
+      content: [
+        {
+          type: 'text',
+          text: formatProgress({
+            elapsedSeconds: Math.floor((performance.now() - startedAt) / 1000),
+            assistantText,
+          }),
+        },
+      ],
+      details: undefined,
+    });
+  };
+
+  const startShow = (): void => {
+    timer = setInterval(show, 1000);
+    show();
+  };
+
+  const stopShow = (): void => {
+    stopped = true;
+    clearInterval(timer);
+  };
+
+  return { startShow, show, stopShow };
+};

package/src/{tools/utils → delegation}/executeRoleTask.ts

@@ -1,12 +1,17 @@
 /**
- * Objective: Supply bundled role guidance and its handoff tool to the shared SDK executor.
+ * 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 { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type {
+  AgentSessionEvent,
+  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 { recordBuilderHandoffTool } from '#tools/child/record-builder-handoff.ts';
@@ -20,29 +25,59 @@ const HANDOFF_TOOL_BY_ROLE = {
   [WORKFLOW_ROLES.SIMPLIFIER]: recordSimplifierHandoffTool,
 } as const;
 
+const readAssistantText = (event: AgentSessionEvent): string => {
+  if (event.type !== 'message_update' && event.type !== 'message_end') return '';
+
+  if (event.message.role !== 'assistant') return '';
+
+  return event.message.content
+    .filter((block) => block.type === 'text')
+    .map((block) => block.text)
+    .join('\n');
+};
+
 type ExecuteRoleTaskInput = Pick<
   ExecuteTaskInput,
   'prompt' | 'cwd' | 'model' | 'thinkingLevel' | 'signal'
 > & {
   role: WorkflowRole;
   ui: ExtensionContext['ui'];
+  onUpdate?: AgentToolUpdateCallback;
 };
 
 export const executeRoleTask = async ({
   role,
   ui,
-  ...input
+  onUpdate,
+  prompt,
+  cwd,
+  model,
+  thinkingLevel,
+  signal,
 }: ExecuteRoleTaskInput): Promise<void> => {
-  const roleGuidance = await readFile(
-    new URL(`../../../agents/${role}.md`, import.meta.url),
-    'utf8',
-  );
+  const roleGuidance = await readFile(new URL(`../../agents/${role}.md`, import.meta.url), 'utf8');
+
+  const agentProgress = createAgentProgress({ onUpdate });
 
   try {
+    agentProgress.startShow();
+    signal?.addEventListener('abort', agentProgress.stopShow, { once: true });
+
+    if (signal?.aborted) agentProgress.stopShow();
+
     const result = await executeTask({
-      ...input,
+      prompt,
+      cwd,
+      model,
+      thinkingLevel,
+      signal,
       roleGuidance,
       additionalTools: [HANDOFF_TOOL_BY_ROLE[role]],
+      onEvent: (event) => {
+        const assistantText = readAssistantText(event);
+
+        if (assistantText) agentProgress.show(assistantText);
+      },
     });
 
     // Publish before protocol validation so a missing handoff still exposes the transcript.
@@ -53,5 +88,8 @@ export const executeRoleTask = async ({
     }
 
     throw error;
+  } finally {
+    agentProgress.stopShow();
+    signal?.removeEventListener('abort', agentProgress.stopShow);
   }
 };

package/src/delegation/executeTask.ts

@@ -1,17 +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 { readTaskResult } from '#src/delegation/readTaskResult.ts';
+import { existsSync } from 'node:fs';
+import { realpath } from 'node:fs/promises';
+import { join } from 'node:path';
+
 import {
-  SubSessionManager,
-  type SubSessionManagerInput,
-} from '#src/delegation/SubSessionManager.ts';
+  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 { TaskExecutionError } from '#src/delegation/TaskExecutionError.ts';
 
-export type ExecuteTaskInput = SubSessionManagerInput & {
+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 = {
@@ -19,38 +36,96 @@ export type TaskExecutionResult = {
   sessionFile?: string;
 };
 
+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,
-  model,
+  cwd: workingDirectory,
+  model: modelId,
   thinkingLevel,
   additionalTools,
   signal,
+  onEvent,
 }: ExecuteTaskInput): Promise<TaskExecutionResult> => {
-  const subSessionManager = new SubSessionManager({
-    roleGuidance,
-    cwd,
-    model,
-    thinkingLevel,
-    additionalTools,
-    signal,
-  });
+  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 subSessionManager.open();
+      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: subSessionManager.getSavedFile() };
+      return { text, sessionFile: getSavedFile(sessionManager) };
     } finally {
-      await subSessionManager.close();
+      unsubscribe?.();
+      signal?.removeEventListener('abort', abort);
+      await closeSession({ session, abortPromise });
     }
   } catch (cause) {
-    throw new TaskExecutionError({ cause, sessionFile: subSessionManager.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,

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/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/main/run-builder.ts

@@ -15,7 +15,7 @@ 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 { executeRoleTask } from '#tools/utils/executeRoleTask.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';
@@ -155,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({
@@ -174,6 +174,7 @@ export const registerRunBuilderTool = (pi: ExtensionAPI): void => {
         thinkingLevel: config.builder.thinking,
         signal,
         ui: context.ui,
+        onUpdate,
       });
 
       const result = await readBuilderResult({ paths, specId, config, builderRunningState });

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

@@ -10,7 +10,7 @@ import { readSimplifierHandoff } from '#artifacts/simplifier-handoff/readSimplif
 import { SPEC_ID_PATTERN } from '#ids/isValidSpecId.ts';
 import { refreshMaestroStatus } from '#maestro/status/refreshMaestroStatus.ts';
 import type { MaestroPaths } from '#MaestroPaths.ts';
-import { executeRoleTask } from '#tools/utils/executeRoleTask.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';
@@ -87,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,6 +136,7 @@ export const registerRunSimplifierTool = (pi: ExtensionAPI): void => {
         thinkingLevel: config.simplifier.thinking,
         signal,
         ui: context.ui,
+        onUpdate,
       });
 
       const result = await readSimplifierResult({ paths, specId });

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

@@ -12,7 +12,7 @@ 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 { executeRoleTask } from '#tools/utils/executeRoleTask.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';
@@ -124,7 +124,7 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
     label: RUN_VERIFIER_TOOL.LABEL,
     description: RUN_VERIFIER_TOOL.DESCRIPTION,
     parameters: RunVerifierToolParameters,
-    async execute(_toolCallId, { specId }, signal, _onUpdate, context) {
+    async execute(_toolCallId, { specId }, signal, onUpdate, context) {
       const { paths, config } = await resolveToolRunContext(context.cwd);
 
       const run = await prepareVerifierRun({ config, paths, specId });
@@ -138,6 +138,7 @@ export const registerRunVerifierTool = (pi: ExtensionAPI): void => {
         thinkingLevel: config.verifier.thinking,
         signal,
         ui: context.ui,
+        onUpdate,
       });
 
       const result = await readVerifierResult({ paths, specId, config, runningState: run.state });

package/src/delegation/SubSessionManager.ts

@@ -1,102 +0,0 @@
-/**
- * Objective: Own the native session, cancellation, and cleanup for one child execution.
- * Used: By the task executor while opening and closing a fresh SDK conversation.
- */
-
-import { existsSync } from 'node:fs';
-import { realpath } from 'node:fs/promises';
-import { join } from 'node:path';
-
-import {
-  type AgentSession,
-  createAgentSession,
-  type CreateAgentSessionOptions,
-  SessionManager,
-  type ToolDefinition,
-} from '@earendil-works/pi-coding-agent';
-
-import { createChildServices } from '#src/delegation/createChildServices.ts';
-
-export type SubSessionManagerInput = {
-  roleGuidance: string;
-  cwd: string;
-  model: string;
-  thinkingLevel: NonNullable<CreateAgentSessionOptions['thinkingLevel']>;
-  additionalTools: ToolDefinition[];
-  signal?: AbortSignal;
-};
-
-export class SubSessionManager {
-  private session?: AgentSession;
-  private sessionManager?: SessionManager;
-  private abortPromise?: Promise<void>;
-
-  private readonly input: SubSessionManagerInput;
-
-  constructor(input: SubSessionManagerInput) {
-    this.input = input;
-  }
-
-  public getSavedFile = (): string | undefined => {
-    const path = this.sessionManager?.getSessionFile();
-
-    return path && existsSync(path) ? path : undefined;
-  };
-
-  private abort = (): void => {
-    this.abortPromise = this.session?.abort();
-    // The cleanup path awaits this promise. Handle rejection immediately as well.
-    void this.abortPromise?.catch(() => {});
-  };
-
-  public open = async (): Promise<AgentSession> => {
-    const cwd = await realpath(this.input.cwd);
-    const services = await createChildServices({ cwd, roleGuidance: this.input.roleGuidance });
-
-    const model = (await services.modelRuntime.getAvailable()).find(
-      (entry) => `${entry.provider}/${entry.id}` === this.input.model,
-    );
-
-    if (!model) throw new Error(`Model is not available: "${this.input.model}".`);
-
-    this.sessionManager = SessionManager.create(
-      cwd,
-      join(SessionManager.create(cwd).getSessionDir(), 'subagents'),
-    );
-
-    const { session } = await createAgentSession({
-      ...services,
-      sessionManager: this.sessionManager,
-      model,
-      thinkingLevel: this.input.thinkingLevel,
-      customTools: this.input.additionalTools, // here child tool registration happens through SDK
-    });
-
-    this.session = session;
-
-    this.input.signal?.addEventListener('abort', this.abort, { once: true });
-
-    await this.session.bindExtensions({ mode: 'print' });
-
-    return this.session;
-  };
-
-  public close = async (): Promise<void> => {
-    this.input.signal?.removeEventListener('abort', this.abort);
-
-    if (!this.session) return;
-
-    try {
-      await this.session.abort();
-      await this.abortPromise;
-    } finally {
-      try {
-        // AgentSession.dispose() does not emit shutdown. This is the native runtime's
-        // shutdown sequence, including extensions such as MCP that own connections.
-        await this.session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' });
-      } finally {
-        this.session.dispose();
-      }
-    }
-  };
-}