pi-sessions 0.14.1 → 0.14.2

package/extensions/shared/tmux.ts

@@ -2,6 +2,7 @@ import type { ExecOptions, ExecResult } from "@earendil-works/pi-coding-agent";
 
 const TMUX_COMMAND = "tmux";
 const TMUX_TIMEOUT_MS = 15_000;
+const CREATE_WINDOW_ATTEMPTS = 3;
 const SESSION_ID_OPTION = "@pi_session_id";
 const WINDOW_FORMAT = "#{window_id}\t#{window_name}\t#{@pi_session_id}";
 
@@ -103,15 +104,31 @@ export async function createTmuxWindow(
   }
 }
 
+// The server can exit between any two commands below; the next attempt starts a fresh one.
 async function createWindow(
   executor: TmuxExecutor,
   options: CreateTmuxWindowOptions,
 ): Promise<TmuxWindow> {
+  for (let attempt = 1; ; attempt += 1) {
+    const outcome = await attemptCreateWindow(executor, options);
+    if ("window" in outcome) {
+      return outcome.window;
+    }
+    if (attempt === CREATE_WINDOW_ATTEMPTS || !isMissingSession(outcome.result)) {
+      throw tmuxError(outcome.action, outcome.result);
+    }
+  }
+}
+
+async function attemptCreateWindow(
+  executor: TmuxExecutor,
+  options: CreateTmuxWindowOptions,
+): Promise<{ window: TmuxWindow } | { action: string; result: ExecResult }> {
   const existing = (await listTmuxWindows(executor, options.tmuxSession)).find(
     (window) => window.piSessionId === options.piSessionId,
   );
   if (existing) {
-    return existing;
+    return { window: existing };
   }
 
   const sessionExists = await hasTmuxSession(executor, options.tmuxSession);
@@ -149,7 +166,7 @@ async function createWindow(
     timeout: TMUX_TIMEOUT_MS,
   });
   if (created.code !== 0) {
-    throw tmuxError("create window", created);
+    return { action: "create window", result: created };
   }
 
   const windowId = created.stdout.trim();
@@ -165,10 +182,10 @@ async function createWindow(
     await executor.exec(TMUX_COMMAND, ["kill-window", "-t", windowId], {
       timeout: TMUX_TIMEOUT_MS,
     });
-    throw tmuxError("stamp window", stamped);
+    return { action: "stamp window", result: stamped };
   }
 
-  return { windowId, name: options.name, piSessionId: options.piSessionId };
+  return { window: { windowId, name: options.name, piSessionId: options.piSessionId } };
 }
 
 export async function killTmuxWindow(
@@ -215,8 +232,10 @@ function parseWindow(line: string): TmuxWindow | undefined {
   return { windowId, name, piSessionId };
 }
 
+// A server that is shutting down answers in-flight commands with `no current target` (its last
+// session is gone but it has not exited yet) or drops them with `server exited unexpectedly`.
 function isMissingSession(result: ExecResult): boolean {
-  return /can't find session|no server running|failed to connect to server|error connecting to .*no such file/i.test(
+  return /can't find session|no current target|no server running|server exited unexpectedly|failed to connect to server|error connecting to .*no such file/i.test(
     `${result.stderr}\n${result.stdout}`,
   );
 }

package/extensions/subagents/install.ts

@@ -1,4 +1,8 @@
-import type { ExtensionAPI, SessionTreeNode } from "@earendil-works/pi-coding-agent";
+import type {
+  ExtensionAPI,
+  ExtensionUIContext,
+  SessionTreeNode,
+} from "@earendil-works/pi-coding-agent";
 import type { HandoffLaunchTarget } from "../session-handoff/launch-target.ts";
 import type {
   MessagingHandle,
@@ -23,7 +27,7 @@ import {
   SUBAGENT_REPORT_MESSAGE_SCHEMA,
   SUBAGENT_REPORT_RECEIVED_CUSTOM_TYPE,
 } from "./ledger.ts";
-import { openReconcileSession, SubagentReconciler } from "./reconcile.ts";
+import { openReconcileSession, type ReconcileResult, SubagentReconciler } from "./reconcile.ts";
 import {
   buildIncomingSubagentReport,
   createSubmitTaskReportTool,
@@ -51,6 +55,7 @@ interface ParentSessionState extends SubagentParentSession {
   getTree(): SessionTreeNode[];
   hasPendingMessages(): boolean;
   shutdown(): void;
+  reportError(error: unknown): void;
 }
 
 interface CurrentSubagentSession {
@@ -178,9 +183,15 @@ export function installSubagents(
     if (!session || session.parent.sessionId !== ctx.sessionManager.getSessionId()) {
       return;
     }
-    const reconciliation = hasSubagentLaunchEntries(session.parent.getBranch())
-      ? await reconciler.reconcile()
-      : undefined;
+    let reconciliation: ReconcileResult | undefined;
+    try {
+      reconciliation = hasSubagentLaunchEntries(session.parent.getBranch())
+        ? await reconciler.reconcile()
+        : undefined;
+    } catch (error) {
+      notifySubagentFailure(ctx.ui, error);
+      return;
+    }
     if (session.child) {
       await contextLimit.compactIfOverLimit(ctx);
       await settledChildLifecycle.settle(session.parent, session.child, reconciliation);
@@ -233,11 +244,15 @@ export function installSubagents(
     );
   };
 
-  pi.on("session_tree", async () => {
+  pi.on("session_tree", async (_event, ctx) => {
     settledChildLifecycle.cancel();
     refreshChildSession();
     registerMessagingTools();
-    await reconciler.reconcileAndRestoreSuspended();
+    try {
+      await reconciler.reconcileAndRestoreSuspended();
+    } catch (error) {
+      notifySubagentFailure(ctx.ui, error);
+    }
   });
 
   const handle: SubagentsHandle = {
@@ -283,6 +298,7 @@ export function installSubagents(
         epoch,
         launchState: { sessionId, depth: identity?.depth ?? 0, epoch },
         tmuxInstalled: await isTmuxInstalled(pi, ctx.cwd),
+        reportError: (error) => notifySubagentFailure(ctx.ui, error),
       };
       reconciler.beginSession();
       current = { parent };
@@ -290,16 +306,24 @@ export function installSubagents(
       if (identity) {
         registerMessagingTools();
       }
-      if (_event.reason === "reload") {
-        await reconciler.reconcile();
-      } else {
-        await reconciler.reconcileAndRestoreSuspended();
+      try {
+        if (_event.reason === "reload") {
+          await reconciler.reconcile();
+        } else {
+          await reconciler.reconcileAndRestoreSuspended();
+        }
+      } catch (error) {
+        notifySubagentFailure(ctx.ui, error);
       }
     },
-    async onSessionShutdown(event) {
+    async onSessionShutdown(event, ctx) {
       settledChildLifecycle.cancel();
       if (current && event.reason !== "reload") {
-        await reconciler.suspendForShutdown();
+        try {
+          await reconciler.suspendForShutdown();
+        } catch (error) {
+          notifySubagentFailure(ctx.ui, error);
+        }
       }
       epoch += 1;
       current = undefined;
@@ -307,3 +331,12 @@ export function installSubagents(
   };
   return handle;
 }
+
+// Lifecycle hooks and timers run outside any tool call. Pi renders a thrown error's full stack
+// over the conversation, so report only the message.
+function notifySubagentFailure(ui: ExtensionUIContext, error: unknown): void {
+  ui.notify(
+    `Subagent lifecycle failed: ${error instanceof Error ? error.message : String(error)}`,
+    "error",
+  );
+}

package/extensions/subagents/settle.ts

@@ -25,6 +25,7 @@ export interface SettledChildParentSession {
   hasPendingMessages(): boolean;
   isIdle(): boolean;
   shutdown(): void;
+  reportError(error: unknown): void;
 }
 
 export interface SettledChildLifecycle {
@@ -72,7 +73,11 @@ export function createSettledChildLifecycle(
       const schedule = (delayMs: number): void => {
         timer = setTimeout(() => {
           timer = undefined;
-          void advance();
+          advance().catch((error: unknown) => {
+            if (isCurrentSession(parent.epoch)) {
+              parent.reportError(error);
+            }
+          });
         }, delayMs);
       };
       const advance = async (): Promise<void> => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-sessions",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "type": "module",
   "description": "Pi session search, ask, handoff, messaging, auto-titling, and indexing tools",
   "license": "MIT",