@narumitw/pi-subagents 3.2.1 → 3.3.0

package/dist/index.ts

@@ -29,12 +29,29 @@ import {
   serializeChildBootstrap,
   validateMessage
 } from "./chunks/chunk-YMVSJ5GE.ts";
+import {
+  CHILD_CORE_TOOL_NAMES,
+  DEFAULT_SUBAGENT_TOOLS,
+  SUBAGENT_THINKING_LEVELS,
+  TERMINAL_JOB_STATES
+} from "./chunks/chunk-FY5HIU6Y.ts";
 
-// src/completion-renderer.ts
+// src/display-text.ts
+function sanitizeSubagentDisplayText(value) {
+  const text = value.replace(
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: Strip untrusted terminal sequences before display.
+    /(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]|(?:\u001b[\]PX^_]|[\u0090\u0098\u009d-\u009f])[^\u0007\u001b\u0080-\u009f]*(?:\u0007|\u001b\\|\u009c)|\u001b[ -/]*[0-~]/gu,
+    ""
+  );
+  return sanitizeTerminalText(text.replace(/\p{Bidi_Control}/gu, "")).replace(/\s+/gu, " ").trim();
+}
+
+// src/message-renderers.ts
 import { getMarkdownTheme, keyText } from "@earendil-works/pi-coding-agent";
 import { Box, Markdown, Spacer, Text } from "@earendil-works/pi-tui";
 var COMPLETION_MESSAGE_TYPE = "pi-subagents-completion";
-function createCompletionBox(children, outputPad, background) {
+var BROKER_MESSAGE_TYPE = "pi-subagents-message";
+function createMessageBox(children, outputPad, background) {
   return {
     render(width) {
       if (width <= 0) return [];
@@ -48,30 +65,157 @@ function createCompletionBox(children, outputPad, background) {
     }
   };
 }
-function registerCompletionRenderer(pi) {
-  pi.registerMessageRenderer(COMPLETION_MESSAGE_TYPE, (message, options, theme) => {
-    const children = [
-      new Text(theme.fg("customMessageLabel", theme.bold(`[${COMPLETION_MESSAGE_TYPE}]`)), 0, 0),
-      new Spacer(1)
-    ];
-    if (!options.expanded) {
-      children.push(
-        new Text(
-          theme.fg("customMessageText", "Subagent job completion (") + theme.fg("dim", keyText("app.tools.expand")) + theme.fg("customMessageText", " to expand)"),
-          0,
-          0
-        )
-      );
+function registerMessageRenderers(pi) {
+  for (const [messageType, summary] of [
+    [COMPLETION_MESSAGE_TYPE, "Subagent job completion"],
+    [BROKER_MESSAGE_TYPE, "Subagent message"]
+  ]) {
+    pi.registerMessageRenderer(messageType, (message, options, theme) => {
+      const children = [
+        new Text(theme.fg("customMessageLabel", theme.bold(`[${messageType}]`)), 0, 0),
+        new Spacer(1)
+      ];
+      if (!options.expanded) {
+        children.push(
+          new Text(
+            theme.fg("customMessageText", `${summary} (`) + theme.fg("dim", keyText("app.tools.expand")) + theme.fg("customMessageText", " to expand)"),
+            0,
+            0
+          )
+        );
+      } else {
+        const content = typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
+        children.push(
+          new Markdown(sanitizeTerminalText(content), 0, 0, getMarkdownTheme(), {
+            color: (text) => theme.fg("customMessageText", text)
+          })
+        );
+      }
+      return createMessageBox(children, options.outputPad, (text) => theme.bg("customMessageBg", text));
+    });
+  }
+}
+
+// src/settings.ts
+import fs from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { getAgentDir, withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+var DEFAULT_SUBAGENT_SETTINGS = Object.freeze({
+  showWidget: true,
+  showJobId: true,
+  showTools: true,
+  showTiming: true
+});
+var SETTINGS_KEYS = Object.keys(DEFAULT_SUBAGENT_SETTINGS);
+function subagentSettingsPath() {
+  return join(getAgentDir(), "pi-subagents.json");
+}
+var SubagentSettingsStore = class {
+  constructor(userPath) {
+    this.userPath = userPath;
+  }
+  userPath;
+  effective = { ...DEFAULT_SUBAGENT_SETTINGS };
+  tail = Promise.resolve();
+  get settings() {
+    return { ...this.effective };
+  }
+  load() {
+    return this.enqueue(async () => {
+      const loaded = await readDocument(this.userPath);
+      const settings = normalizeSettings(loaded.document ?? {}, loaded.diagnostics);
+      this.effective = settings;
+      return { settings: this.settings, diagnostics: loaded.diagnostics };
+    }).catch((error) => ({
+      settings: this.settings,
+      diagnostics: [readDiagnostic(this.userPath, error)]
+    }));
+  }
+  save(key, value, signal) {
+    return this.enqueue(async () => {
+      signal.throwIfAborted();
+      if (!SETTINGS_KEYS.includes(key) || typeof value !== "boolean") {
+        throw new Error("Invalid subagent settings update");
+      }
+      const loaded = await readDocument(this.userPath);
+      signal.throwIfAborted();
+      if (!loaded.document) {
+        throw new Error(`Cannot save subagent settings: ${loaded.diagnostics.join("; ")}`);
+      }
+      const document = { ...loaded.document, [key]: value };
+      const settings = normalizeSettings(document, []);
+      const parent = dirname(this.userPath);
+      await fs.mkdir(parent, { recursive: true });
+      signal.throwIfAborted();
+      const temporary = await fs.mkdtemp(join(parent, ".pi-subagents-"));
+      try {
+        signal.throwIfAborted();
+        const staged = join(temporary, "settings.json");
+        await fs.writeFile(staged, `${JSON.stringify(document, null, 2)}
+`, { flag: "wx", signal });
+        signal.throwIfAborted();
+        await fs.rename(staged, this.userPath);
+        this.effective = settings;
+        return this.settings;
+      } finally {
+        await fs.rm(temporary, { recursive: true, force: true }).catch(() => {
+        });
+      }
+    });
+  }
+  flush() {
+    return this.tail;
+  }
+  enqueue(operation) {
+    const previous = this.tail;
+    const result = withFileMutationQueue(this.userPath, async () => {
+      await previous;
+      return operation();
+    });
+    this.tail = result.then(
+      () => {
+      },
+      () => {
+      }
+    );
+    return result;
+  }
+};
+async function readDocument(path4) {
+  let text;
+  try {
+    text = await fs.readFile(path4, "utf8");
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return { document: {}, diagnostics: [] };
+    }
+    return { diagnostics: [readDiagnostic(path4, error)] };
+  }
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch {
+    return { diagnostics: [`Cannot load subagent settings at ${path4}: invalid JSON`] };
+  }
+  if (typeof document !== "object" || document === null || Array.isArray(document)) {
+    return { diagnostics: [`Cannot load subagent settings at ${path4}: expected a JSON object`] };
+  }
+  return { document, diagnostics: [] };
+}
+function normalizeSettings(document, diagnostics) {
+  const settings = { ...DEFAULT_SUBAGENT_SETTINGS };
+  for (const key of SETTINGS_KEYS) {
+    if (!Object.hasOwn(document, key)) continue;
+    if (typeof document[key] === "boolean") {
+      settings[key] = document[key];
     } else {
-      const content = typeof message.content === "string" ? message.content : message.content.filter((part) => part.type === "text").map((part) => part.text).join("\n");
-      children.push(
-        new Markdown(sanitizeTerminalText(content), 0, 0, getMarkdownTheme(), {
-          color: (text) => theme.fg("customMessageText", text)
-        })
-      );
+      diagnostics.push(`Ignored invalid subagent setting ${key}: expected a boolean`);
     }
-    return createCompletionBox(children, options.outputPad, (text) => theme.bg("customMessageBg", text));
-  });
+  }
+  return settings;
+}
+function readDiagnostic(path4, error) {
+  return `Cannot load subagent settings at ${path4}: ${error instanceof Error ? error.message : String(error)}`;
 }
 
 // src/tools.ts
@@ -114,7 +258,7 @@ function modelVisibleJson(value, options = {}) {
 
 // src/process.ts
 import { spawn } from "node:child_process";
-import * as fs from "node:fs";
+import * as fs2 from "node:fs";
 import * as path from "node:path";
 import { StringDecoder } from "node:string_decoder";
 import { fileURLToPath } from "node:url";
@@ -696,23 +840,23 @@ async function executeProcess(invocation, request) {
   };
 }
 function resolvePiInvocation(args) {
-  const packageDirectory = fs.realpathSync(getPackageDir());
+  const packageDirectory = fs2.realpathSync(getPackageDir());
   const manifestPath = path.join(packageDirectory, "package.json");
-  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const manifest = JSON.parse(fs2.readFileSync(manifestPath, "utf8"));
   if (manifest.name !== CORE_PACKAGE_NAME || typeof manifest.bin?.pi !== "string") {
     throw new Error("Loaded Pi core package does not declare a valid bin.pi entry.");
   }
   const declared = manifest.bin.pi;
   if (path.isAbsolute(declared)) throw new Error("Pi core bin.pi must be package-relative.");
-  if (globalThis.process.versions.bun && /^pi(?:\.exe)?$/iu.test(path.basename(globalThis.process.execPath)) && path.dirname(fs.realpathSync(globalThis.process.execPath)) === packageDirectory) {
+  if (globalThis.process.versions.bun && /^pi(?:\.exe)?$/iu.test(path.basename(globalThis.process.execPath)) && path.dirname(fs2.realpathSync(globalThis.process.execPath)) === packageDirectory) {
     return { command: globalThis.process.execPath, args };
   }
-  const cliPath = fs.realpathSync(path.resolve(packageDirectory, declared));
+  const cliPath = fs2.realpathSync(path.resolve(packageDirectory, declared));
   const relative4 = path.relative(packageDirectory, cliPath);
   if (relative4 === ".." || relative4.startsWith(`..${path.sep}`) || path.isAbsolute(relative4)) {
     throw new Error("Pi core bin.pi escapes its package directory.");
   }
-  if (!fs.statSync(cliPath).isFile()) throw new Error("Pi core bin.pi is not a file.");
+  if (!fs2.statSync(cliPath).isFile()) throw new Error("Pi core bin.pi is not a file.");
   return { command: globalThis.process.execPath, args: [cliPath, ...args] };
 }
 function signalPosixProcess(process2, signal) {
@@ -783,7 +927,7 @@ function assertTrustedChildResources(value, cwd) {
   if (!Array.isArray(commands)) throw invalid();
   let canonicalCwd;
   try {
-    canonicalCwd = fs.realpathSync(cwd);
+    canonicalCwd = fs2.realpathSync(cwd);
   } catch {
     throw invalid();
   }
@@ -796,7 +940,7 @@ function assertTrustedChildResources(value, cwd) {
     const lexicalPath = path.resolve(cwd, resourcePath);
     let canonicalPath;
     try {
-      canonicalPath = fs.realpathSync(lexicalPath);
+      canonicalPath = fs2.realpathSync(lexicalPath);
     } catch {
       throw invalid();
     }
@@ -1193,36 +1337,6 @@ function deduplicatePackageSkillPaths(packageSkillPaths, explicitSkillPaths) {
   return uniquePaths;
 }
 
-// src/types.ts
-var TERMINAL_JOB_STATES = /* @__PURE__ */ new Set([
-  "completed",
-  "partial",
-  "failed",
-  "timed_out",
-  "cancelled"
-]);
-var CHILD_CORE_TOOL_NAMES = [
-  "read",
-  "bash",
-  "powershell",
-  "edit",
-  "write",
-  "grep",
-  "find",
-  "ls",
-  "codemode"
-];
-var DEFAULT_SUBAGENT_TOOLS = ["read", "grep", "find", "ls"];
-var SUBAGENT_THINKING_LEVELS = [
-  "off",
-  "minimal",
-  "low",
-  "medium",
-  "high",
-  "xhigh",
-  "max"
-];
-
 // src/resource-attachments.ts
 var MAX_ATTACHED_SKILLS = 16;
 var MAX_ATTACHED_EXTENSIONS = 16;
@@ -2152,7 +2266,6 @@ function abortError2(message) {
 // src/tools.ts
 var MAX_TASK_BYTES = 50 * 1024;
 var MAX_TOOLS = MAX_SELECTED_TOOLS;
-var MESSAGE_TYPE = "pi-subagents-message";
 var CHILD_CORE_TOOL_SET = new Set(CHILD_CORE_TOOL_NAMES);
 var THINKING_LEVEL_SET = new Set(SUBAGENT_THINKING_LEVELS);
 var SpawnParameters = Type.Object(
@@ -2420,7 +2533,7 @@ function deliverMessage(pi, message) {
   );
   pi.sendMessage(
     {
-      customType: MESSAGE_TYPE,
+      customType: BROKER_MESSAGE_TYPE,
       content,
       display: true,
       details: {
@@ -2532,6 +2645,7 @@ function toolResult(value) {
 
 // src/widget.ts
 import { stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { EditorStatusWidget } from "@narumitw/pi-tui-kit/editor-status-widget";
 var SUBAGENT_WIDGET_KEY = "subagents";
 var SUBAGENT_WIDGET_REFRESH_INTERVAL_MS = 1e3;
 var WIDGET_OPTIONS = { placement: "aboveEditor" };
@@ -2541,6 +2655,8 @@ function createSubagentWidgetController(runtime) {
   let refreshTimer;
   let unsubscribeJobs;
   let publishedValue;
+  let settings = { ...DEFAULT_SUBAGENT_SETTINGS };
+  let clearWidget;
   const ownsSession = (ctx) => ctx.sessionManager === activeSession;
   const stop = () => {
     if (refreshTimer) clearInterval(refreshTimer);
@@ -2550,67 +2666,83 @@ function createSubagentWidgetController(runtime) {
   };
   const publish = (ctx) => {
     if (ctx.mode !== "tui" || !ownsSession(ctx)) return;
-    const jobs = runtime.activeJobsForDisplay();
-    const value = widgetValue(jobs);
+    const jobs = settings.showWidget ? runtime.activeJobsForDisplay() : [];
+    const value = `${JSON.stringify(settings)}
+${widgetValue(jobs)}`;
     if (value === publishedValue) return;
     if (jobs.length === 0) {
       ctx.ui.setWidget(SUBAGENT_WIDGET_KEY, void 0);
     } else {
       const snapshot = jobs.map(cloneDisplayJob);
+      const preferences = { ...settings };
       ctx.ui.setWidget(
         SUBAGENT_WIDGET_KEY,
-        (_tui, theme) => ({
-          render: (width) => renderSubagentWidget(snapshot, theme, width),
-          invalidate: () => {
-          }
-        }),
+        (_tui, theme) => createSubagentWidget(snapshot, theme, preferences),
         WIDGET_OPTIONS
       );
     }
     publishedValue = value;
   };
   return {
-    start(ctx) {
+    start(ctx, preferences = DEFAULT_SUBAGENT_SETTINGS) {
       stop();
+      clearWidget?.();
+      clearWidget = void 0;
+      settings = { ...preferences };
       activeSession = ctx.sessionManager;
       publishedValue = void 0;
       if (ctx.mode !== "tui") return;
-      ctx.ui.setWidget(SUBAGENT_WIDGET_KEY, void 0);
+      clearWidget = () => ctx.ui.setWidget(SUBAGENT_WIDGET_KEY, void 0);
+      clearWidget();
       unsubscribeJobs = runtime.subscribeJobs(() => publish(ctx));
       refreshTimer = setInterval(() => publish(ctx), SUBAGENT_WIDGET_REFRESH_INTERVAL_MS);
       refreshTimer.unref();
       publish(ctx);
     },
+    update(ctx, preferences) {
+      if (!ownsSession(ctx)) return;
+      settings = { ...preferences };
+      publish(ctx);
+    },
     shutdown(ctx) {
       if (!ownsSession(ctx)) return;
       stop();
-      if (ctx.mode === "tui") ctx.ui.setWidget(SUBAGENT_WIDGET_KEY, void 0);
+      clearWidget?.();
+      clearWidget = void 0;
       publishedValue = void 0;
       activeSession = void 0;
     }
   };
 }
-function renderSubagentWidget(jobs, theme, width) {
-  const renderWidth = Math.max(0, width);
-  const lines = [
-    theme.fg("borderMuted", "\u2500".repeat(renderWidth)),
-    theme.fg("muted", `Subagents \xB7 ${jobs.length} active`),
-    ...jobs.map((job) => renderJob(job, theme))
-  ];
-  return lines.map((line) => truncateToWidth(line, renderWidth, ""));
+function createSubagentWidget(jobs, theme, settings) {
+  return new EditorStatusWidget({
+    theme,
+    renderBody: () => [
+      theme.fg("muted", `Subagents \xB7 ${jobs.length} active`),
+      ...jobs.map((job) => renderJob(job, theme, settings))
+    ]
+  });
 }
-function renderJob(job, theme) {
+function renderJob(job, theme, settings) {
   const running = job.state === "running";
   const symbol = theme.fg(running ? "accent" : "dim", running ? "\u25B6 " : "\u25CB ");
   const state = theme.fg(running ? "accent" : "muted", job.state);
-  const jobId = sanitizeLabel(job.jobId);
-  const taskText = sanitizeTask(job.task);
+  const jobId = sanitizeSubagentDisplayText(job.jobId);
+  const taskText = sanitizeSubagentDisplayText(job.task);
   const task = stripTerminalSequences(truncateToWidth(taskText, TASK_PREVIEW_WIDTH, "\u2026"));
-  const preview = visibleWidth(task) > 0 ? ` \xB7 ${theme.fg("text", task)}` : "";
-  const tools = job.tools.length > 0 ? job.tools.map(sanitizeLabel).join(", ") : "none";
+  const labels = [
+    ...settings.showJobId ? [theme.fg("text", jobId)] : [],
+    ...visibleWidth(task) > 0 ? [theme.fg("text", task)] : [],
+    state
+  ];
+  const tools = job.tools.length > 0 ? job.tools.map(sanitizeSubagentDisplayText).join(", ") : "none";
   const timeout = job.timeout === void 0 ? "no timeout" : formatSeconds(job.timeout);
-  const detail = ` \xB7 ${formatSeconds(Math.floor(job.elapsedMs / 1e3))} / ${timeout} \xB7 tools: ${tools}`;
-  return `${symbol}${theme.fg("text", jobId)}${preview} \xB7 ${state}${theme.fg("muted", detail)}`;
+  const details = [
+    ...settings.showTiming ? [`${formatSeconds(Math.floor(job.elapsedMs / 1e3))} / ${timeout}`] : [],
+    ...settings.showTools ? [`tools: ${tools}`] : []
+  ];
+  const detail = details.length > 0 ? theme.fg("muted", ` \xB7 ${details.join(" \xB7 ")}`) : "";
+  return `${symbol}${labels.join(" \xB7 ")}${detail}`;
 }
 function widgetValue(jobs) {
   return jobs.map(
@@ -2620,17 +2752,6 @@ function widgetValue(jobs) {
 function cloneDisplayJob(job) {
   return { ...job, tools: [...job.tools] };
 }
-function sanitizeTask(value) {
-  const text = value.replace(
-    // biome-ignore lint/suspicious/noControlCharactersInRegex: Remove untrusted terminal escape sequences before display.
-    /(?:\u001b\[|\u009b)[0-?]*[ -/]*[@-~]|(?:\u001b[\]PX^_]|[\u0090\u0098\u009d-\u009f])[^\u0007\u001b\u0080-\u009f]*(?:\u0007|\u001b\\|\u009c)|\u001b[ -/]*[0-~]/gu,
-    ""
-  );
-  return sanitizeLabel(text.replace(/\p{Bidi_Control}/gu, ""));
-}
-function sanitizeLabel(value) {
-  return sanitizeTerminalText(value).replace(/\s+/gu, " ").trim();
-}
 function formatSeconds(value) {
   if (value < 60) return `${formatNumber(value)}s`;
   const wholeSeconds = Math.floor(value);
@@ -2646,24 +2767,133 @@ function formatNumber(value) {
 
 // src/subagents.ts
 function subagents(pi, dependencies = {}) {
-  registerCompletionRenderer(pi);
+  registerMessageRenderers(pi);
   const tools = registerSubagentTools(pi, dependencies);
   const widget = createSubagentWidgetController(tools.runtime);
-  let activeSession;
+  const store = dependencies.settingsStore ?? new SubagentSettingsStore(subagentSettingsPath());
+  let activeContext;
   let sessionGeneration = 0;
+  let owner = new AbortController();
+  let ready = false;
+  let menuOpen = false;
+  let settings = { ...DEFAULT_SUBAGENT_SETTINGS };
+  const menuTasks = /* @__PURE__ */ new Set();
+  const ownsSession = (ctx) => ctx.sessionManager === activeContext?.sessionManager;
+  const openSettings = async (ctx, signal, isCurrent) => {
+    if (signal.aborted || !isCurrent()) return "stale";
+    if (ctx.mode !== "tui") {
+      ctx.ui.notify(sanitizeSubagentDisplayText(`Edit user settings: ${store.userPath}. Then run /reload.`), "info");
+      return "back";
+    }
+    const { showSubagentSettings } = await import("./chunks/settings-ui-PSEYB6JX.ts");
+    if (signal.aborted || !isCurrent()) return "stale";
+    return showSubagentSettings(ctx, {
+      signal,
+      isCurrent,
+      get: () => ({ ...settings }),
+      save: (key, value, actionSignal) => {
+        actionSignal.throwIfAborted();
+        if (!isCurrent()) throw new Error("The subagents session changed.");
+        return store.save(key, value, actionSignal);
+      },
+      apply: (next) => {
+        if (!isCurrent()) return;
+        settings = { ...next };
+        widget.update(ctx, settings);
+      }
+    });
+  };
+  pi.registerCommand("subagents", {
+    description: "Manage subagent jobs and widget settings",
+    getArgumentCompletions: (prefix) => "settings".startsWith(prefix) ? [{ value: "settings", label: "settings", description: "Configure the subagent widget" }] : null,
+    handler: async (args, ctx) => {
+      if (!ctx.hasUI || ctx.mode !== "tui" && ctx.mode !== "rpc") {
+        throw new Error("/subagents requires TUI or RPC mode.");
+      }
+      const route = args.trim();
+      if (route !== "" && route !== "settings") {
+        ctx.ui.notify("Usage: /subagents | /subagents settings", "warning");
+        return;
+      }
+      if (!ownsSession(ctx) || !ready || menuOpen) {
+        ctx.ui.notify("Subagent controls are loading, unavailable, or already open.", "warning");
+        return;
+      }
+      menuOpen = true;
+      const generation = sessionGeneration;
+      const signal = owner.signal;
+      const isCurrent = () => generation === sessionGeneration && ownsSession(ctx) && !signal.aborted;
+      const task = (async () => {
+        if (route === "settings") {
+          await openSettings(ctx, signal, isCurrent);
+          return;
+        }
+        const { showSubagentsMenu } = await import("./chunks/menu-KAIUEWL7.ts");
+        if (!isCurrent()) return;
+        await showSubagentsMenu(ctx, {
+          signal,
+          isCurrent,
+          getState: () => ({
+            settings: { ...settings },
+            settingsPath: store.userPath,
+            ...tools.runtime.inspectJobs()
+          }),
+          cancelJob: async (jobId, actionSignal) => {
+            actionSignal.throwIfAborted();
+            if (!isCurrent()) throw new Error("The subagents session changed.");
+            await tools.runtime.cancel(jobId);
+          },
+          showSettings: (actionSignal) => openSettings(ctx, actionSignal, isCurrent)
+        });
+      })();
+      menuTasks.add(task);
+      try {
+        await task;
+      } catch (error) {
+        if (isCurrent()) {
+          ctx.ui.notify(sanitizeSubagentDisplayText(error instanceof Error ? error.message : String(error)), "error");
+        }
+      } finally {
+        menuTasks.delete(task);
+        if (isCurrent()) menuOpen = false;
+      }
+    }
+  });
   pi.on("session_start", async (_event, ctx) => {
-    activeSession = ctx.sessionManager;
+    owner.abort();
+    if (activeContext) widget.shutdown(activeContext);
+    owner = new AbortController();
+    activeContext = ctx;
+    ready = false;
+    menuOpen = false;
     const generation = ++sessionGeneration;
+    const isCurrent = () => generation === sessionGeneration && ownsSession(ctx) && !owner.signal.aborted;
     await tools.startSession();
-    if (generation !== sessionGeneration) return;
-    widget.start(ctx);
+    if (!isCurrent()) return;
+    await Promise.allSettled([...menuTasks]);
+    if (!isCurrent()) return;
+    const loaded = await store.load();
+    if (!isCurrent()) return;
+    settings = { ...loaded.settings };
+    ready = true;
+    widget.start(ctx, settings);
+    if (loaded.diagnostics.length > 0) {
+      const message = sanitizeSubagentDisplayText(`Subagent settings: ${loaded.diagnostics.join(" ")}`);
+      if (ctx.hasUI) ctx.ui.notify(message, "warning");
+      else throw new Error(message);
+    }
   });
   pi.on("session_shutdown", async (_event, ctx) => {
-    if (ctx.sessionManager !== activeSession) return;
+    if (!ownsSession(ctx)) return;
     sessionGeneration++;
-    activeSession = void 0;
+    owner.abort();
+    ready = false;
+    menuOpen = false;
+    activeContext = void 0;
     widget.shutdown(ctx);
-    await tools.shutdown();
+    const results = await Promise.allSettled([tools.shutdown(), ...menuTasks, store.flush()]);
+    const failed = results.find((result) => result.status === "rejected");
+    if (failed?.status === "rejected") throw failed.reason;
   });
 }
 export {