pisesh 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file.
 
+## [0.3.0] - 2026-08-22
+
+### Changed
+- Make `/sesh` return the selected session to its extension and switch through pi's official `ctx.switchSession()` API instead of launching a nested pi process. Standalone `pisesh` still launches pi.
+- Preserve `Enter` current-default and `o` session-recorded model and thinking behavior across native session switches.
+
+### Fixed
+- Forward custom cwd overrides when supported by pi, warn when pi ignores them, and skip switching when the selected session is already active.
+- Keep interrupted-tool-call repair after confirming pi does not synthesize missing results during session loading.
+
 ## [0.2.0] - 2026-08-01
 
 ### Added

package/README.md

@@ -73,6 +73,8 @@ pi install npm:pisesh
 
 This registers pisesh as a pi extension. Inside any pi session, type `/sesh`. The extension runs its bundled CLI, so a global npm installation is not required.
 
+`/sesh` does not start a second pi process. The picker returns the selected session and options to the extension, which calls pi's official `ctx.switchSession()` API. Standalone `pisesh` keeps its shell behavior and starts `pi --session`. Custom cwd overrides require a pi version that supports `cwdOverride` on extension session switches; pisesh warns if pi ignores one.
+
 ### Install the standalone CLI
 
 ```bash
@@ -142,10 +144,10 @@ pisesh --help
 | Alt screen buffer   | `\x1b[?1049h` / `\x1b[?1049l`, the same primitive `vim`, `less`, `htop`, and droid CLI use         |
 | Input               | Node's `readline.emitKeypressEvents` in raw mode                                                 |
 | Width calculation   | UAX #11 East Asian Width ranges, compressed to ~10 inline range checks                           |
-| Pi extension        | TypeScript factory using `@earendil-works/pi-coding-agent` extension API (`ui.custom`, `tui.stop`) |
+| Pi extension        | TypeScript factory using `ui.custom`, `tui.stop`, and `ctx.switchSession()`                       |
 | Storage             | Two JSON files under `$PI_AGENT_DIR`: `favorites.json` and `pisesh-meta.json`                 |
 | Session discovery   | Direct filesystem scan of `~/.pi/agent/sessions/<projectSlug>/*.jsonl`; first 96 KB parsed       |
-| Process model       | Slash command pauses pi's TUI, spawns pisesh with inherited stdio, restarts pi on exit           |
+| Process model       | `/sesh` runs pisesh as a selector and switches the current runtime; standalone starts `pi`        |
 | Resume settings     | `Enter` uses current defaults; `o` preserves the model and thinking recorded in the session         |
 | Custom paths        | Honors `PI_AGENT_DIR` and `PI_SESSION_DIR`, including a flat custom session directory                |
 | Title generation    | Ephemeral `pi --print --no-session` call using the model and effort selected in pisesh            |
@@ -198,7 +200,7 @@ Korean / Chinese / Japanese / fullwidth characters render **2 cells wide** in te
   - Windows: **Windows Terminal**, **WezTerm**, **Alacritty** ✅
   - macOS: **iTerm2**, **Terminal.app**, **WezTerm**, **Alacritty**, **Kitty** ✅
   - Linux: **GNOME Terminal**, **Konsole**, **xterm**, **Alacritty**, **Kitty** ✅
-- [`pi`](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) on `$PATH` for the `Enter`-to-resume action
+- [`pi`](https://www.npmjs.com/package/@earendil-works/pi-coding-agent) on `$PATH` when using standalone `pisesh`
 
 ## Contributing
 

package/bin/pisesh

@@ -24,6 +24,12 @@ function piAgentEnv(baseEnv = process.env, agentDir = AGENT_DIR) {
   return { ...baseEnv, PI_CODING_AGENT_DIR: agentDir };
 }
 const PI_ENV = piAgentEnv();
+// The /sesh extension gives the picker a private result pipe. Standalone
+// pisesh has no such fd and keeps launching pi itself.
+const SELECT_FD = (() => {
+  const fd = Number(process.env.PISESH_SELECT_FD);
+  return Number.isInteger(fd) && fd >= 3 ? fd : null;
+})();
 const VERSION = (() => {
   for (const file of [
     path.resolve(__dirname, '../package.json'),
@@ -1477,6 +1483,38 @@ function loadResumeDefaults(settingsFile = SETTINGS_FILE) {
   } catch { return null; }
 }
 
+function loadSessionSettings(file) {
+  try {
+    const entries = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean).flatMap(line => {
+      try { return [JSON.parse(line)]; } catch { return []; }
+    }).filter(entry => entry && entry.type !== 'session');
+    const byId = new Map(entries.filter(entry => entry.id).map(entry => [entry.id, entry]));
+    const branch = [];
+    const visited = new Set();
+    let entry = entries[entries.length - 1];
+    while (entry && !visited.has(entry.id)) {
+      branch.push(entry);
+      visited.add(entry.id);
+      entry = entry.parentId ? byId.get(entry.parentId) : undefined;
+    }
+    branch.reverse();
+
+    let model = '';
+    let thinking = '';
+    for (const item of branch) {
+      if (item.type === 'thinking_level_change' && typeof item.thinkingLevel === 'string') {
+        thinking = item.thinkingLevel;
+      } else if (item.type === 'model_change' && typeof item.provider === 'string' && typeof item.modelId === 'string') {
+        model = `${item.provider}/${item.modelId}`;
+      } else if (item.type === 'message' && item.message?.role === 'assistant'
+        && typeof item.message.provider === 'string' && typeof item.message.model === 'string') {
+        model = `${item.message.provider}/${item.message.model}`;
+      }
+    }
+    return { model, thinking };
+  } catch { return null; }
+}
+
 function buildResumeArgs(s, useCurrentDefaults = true, settingsFile = SETTINGS_FILE) {
   const args = ['--session', s.id, '--session-dir', path.dirname(s.file)];
   const defaults = useCurrentDefaults && loadResumeDefaults(settingsFile);
@@ -1485,27 +1523,70 @@ function buildResumeArgs(s, useCurrentDefaults = true, settingsFile = SETTINGS_F
   return args;
 }
 
+function buildSelection(s, useCurrentDefaults = true, repaired = 0, settingsFile = SETTINGS_FILE) {
+  const defaults = loadResumeDefaults(settingsFile);
+  const recorded = useCurrentDefaults ? null : loadSessionSettings(s.file);
+  const settings = useCurrentDefaults ? defaults : {
+    model: recorded?.model || defaults?.model || '',
+    thinking: recorded?.thinking || defaults?.thinking || '',
+  };
+  return {
+    version: 1,
+    sessionPath: path.resolve(s.file),
+    resumeMode: useCurrentDefaults ? 'defaults' : 'session',
+    ...(s.cwdOverride ? { cwdOverride: s.cwdOverride } : {}),
+    ...(settings?.model ? { model: settings.model } : {}),
+    ...(settings?.thinking ? { thinking: settings.thinking } : {}),
+    ...(repaired > 0 ? { repaired } : {}),
+  };
+}
+
+function leaveTui() {
+  process.stdout.write(A.exitAlt + A.showC);
+  if (process.stdin.isTTY) process.stdin.setRawMode(false);
+  process.stdin.pause();
+}
+
+function returnSelection(selection) {
+  try {
+    fs.writeSync(SELECT_FD, `${JSON.stringify(selection)}\n`);
+  } catch (error) {
+    throw new Error(`could not return selection to pi: ${error.message}`);
+  }
+}
+
 function resumeSession(s, useCurrentDefaults = true) {
   if (!s) return;
-  // A resumed pi takes over this terminal, so stop background title work first
-  // and suppress any final render from its asynchronous close handler.
+  // A resumed pi or the parent extension takes over this terminal, so stop
+  // background title work and suppress its asynchronous final render.
   handingOff = true;
   cancelGeneration();
-  // Heal orphaned tool calls before handing off, so resume can't crash the
-  // spawned pi (see healOrphanedToolCalls).
+
+  // Selecting the already-active session must not rewrite its live transcript.
+  if (SELECT_FD !== null && s.isCurrent) {
+    leaveTui();
+    try { returnSelection(buildSelection(s, useCurrentDefaults)); }
+    catch (error) { console.error(`pisesh: ${error.message}`); process.exit(1); }
+    process.exit(0);
+  }
+
+  // Pi still preserves a valid unfinished toolCall without adding its missing
+  // result, so repair it before either native switching or standalone resume.
   let repaired;
   try { repaired = healOrphanedToolCalls(s.file); }
   catch (error) {
-    process.stdout.write(A.exitAlt + A.showC);
-    if (process.stdin.isTTY) process.stdin.setRawMode(false);
+    leaveTui();
     console.error(`pisesh: ${error.message}`);
     process.exit(1);
   }
-  // Leave alt screen + show cursor so the spawned pi takes over a clean
-  // main-buffer terminal (it will manage its own alt screen).
-  process.stdout.write(A.exitAlt + A.showC);
-  if (process.stdin.isTTY) process.stdin.setRawMode(false);
-  process.stdin.pause();
+  leaveTui();
+
+  if (SELECT_FD !== null) {
+    try { returnSelection(buildSelection(s, useCurrentDefaults, repaired)); }
+    catch (error) { console.error(`pisesh: ${error.message}`); process.exit(1); }
+    process.exit(0);
+  }
+
   if (repaired > 0) {
     console.log(`pisesh: repaired ${repaired} orphaned session entr${repaired === 1 ? 'y' : 'ies'}; backup: ${s.file}.bak-orphanheal`);
   }
@@ -1640,11 +1721,13 @@ function main() {
 if (require.main === module) main();
 else module.exports = {
   buildResumeArgs,
+  buildSelection,
   buildTitlePrompt,
   cleanGeneratedTitle,
   cleanStaleFavorites,
   healOrphanedToolCalls,
   loadResumeDefaults,
+  loadSessionSettings,
   parseModelEntries,
   parseModelList,
   piAgentEnv,

package/extensions/sesh.ts

@@ -1,97 +1,269 @@
 /**
  * pisesh slash command
  *
- * Registers `/sesh` inside pi.
- *
- * Behavior:
- *   1. Pauses pi's TUI (releases the terminal)
- *   2. Spawns the external `pisesh` TUI (bookmark/resume picker)
- *   3. When pisesh exits — whether the user resumed a nested session and quit it,
- *      or just pressed `q` — control returns to the original pi session and the
- *      TUI is restored.
- *
- * Bundled CLI tool: ../bin/pisesh   (single-file Node TUI, no deps)
- * Favorites file:     ~/.pi/agent/favorites.json
+ * `/sesh` temporarily hands the terminal to the bundled picker. The picker
+ * returns a session path on a private fd; this extension then asks pi to switch
+ * its current runtime. Standalone `pisesh` still launches pi itself.
  */
 
 import { spawn } from "node:child_process";
 import path from "node:path";
+import type { Readable } from "node:stream";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
 // Static package path, no user-controlled segments.
 const PISESH_CLI = path.resolve(__dirname, "../bin/pisesh"); // pi-lens-ignore: ts-path-traversal
+const THINKING_LEVELS = [
+	"off",
+	"minimal",
+	"low",
+	"medium",
+	"high",
+	"xhigh",
+	"max",
+] as const;
+type ThinkingLevel = (typeof THINKING_LEVELS)[number];
+
+type PiseshSelection = {
+	version: 1;
+	sessionPath: string;
+	resumeMode: "defaults" | "session";
+	cwdOverride?: string;
+	model?: string;
+	thinking?: ThinkingLevel;
+	repaired?: number;
+};
+
+type PickerResult = {
+	code: number | null;
+	selection?: PiseshSelection;
+	error?: string;
+};
+
+type PendingSwitch = Pick<
+	PiseshSelection,
+	"sessionPath" | "cwdOverride" | "model" | "thinking" | "repaired"
+>;
 
-function runPisesh(
-	currentSessionId: string | undefined,
-): Promise<number | null> {
+const processState = globalThis as typeof globalThis & {
+	__piseshPendingSwitch?: PendingSwitch;
+};
+
+function parseSelection(raw: string): PiseshSelection | undefined {
+	if (!raw.trim()) return undefined;
+
+	let value: unknown;
+	try {
+		value = JSON.parse(raw);
+	} catch {
+		throw new Error("picker returned invalid JSON");
+	}
+	if (!value || typeof value !== "object") {
+		throw new Error("picker returned a non-object selection");
+	}
+	const data = value as Record<string, unknown>;
+	if (
+		data.version !== 1 ||
+		typeof data.sessionPath !== "string" ||
+		!path.isAbsolute(data.sessionPath) ||
+		(data.resumeMode !== "defaults" && data.resumeMode !== "session")
+	) {
+		throw new Error("picker returned an invalid session selection");
+	}
+	if (data.cwdOverride !== undefined && typeof data.cwdOverride !== "string") {
+		throw new Error("picker returned an invalid cwd override");
+	}
+	if (data.model !== undefined && typeof data.model !== "string") {
+		throw new Error("picker returned an invalid model");
+	}
+	if (
+		data.thinking !== undefined &&
+		!THINKING_LEVELS.includes(data.thinking as ThinkingLevel)
+	) {
+		throw new Error("picker returned an invalid thinking level");
+	}
+	if (
+		data.repaired !== undefined &&
+		(!Number.isInteger(data.repaired) || (data.repaired as number) < 0)
+	) {
+		throw new Error("picker returned an invalid repair count");
+	}
+	return data as PiseshSelection;
+}
+
+function runPisesh(currentSessionId: string | undefined): Promise<PickerResult> {
 	return new Promise((resolve) => {
-		// stdio:"inherit" hands the real TTY to pisesh. pi's tui.stop() has
-		// already detached so this is safe.
-		// PISESH_CURRENT_SESSION lets pisesh flag the row that belongs to the
-		// pi instance that just spawned it (rendered with a [NOW] badge).
+		let output = "";
+		let settled = false;
+		const finish = (result: PickerResult) => {
+			if (settled) return;
+			settled = true;
+			resolve(result);
+		};
+
+		// fd 3 carries one small JSON result while stdin/stdout/stderr remain the
+		// real terminal used by the full-screen picker.
 		const child = spawn("node", [PISESH_CLI], {
-			stdio: "inherit",
+			stdio: ["inherit", "inherit", "inherit", "pipe"],
 			env: {
 				...process.env,
-				// Forward pi's cwd so pisesh's "Here" tab can show only the sessions
-				// that belong to the directory this pi instance is attached to.
+				PISESH_SELECT_FD: "3",
 				PISESH_CWD: process.cwd(),
 				...(currentSessionId
 					? { PISESH_CURRENT_SESSION: currentSessionId }
 					: {}),
 			},
 		});
-		child.on("exit", (code) => resolve(code));
-		child.on("error", (err) => {
-			// Surface a readable error in the terminal before we re-render.
+		const resultPipe = child.stdio[3] as Readable | null;
+		resultPipe?.setEncoding("utf8");
+		resultPipe?.on("data", (chunk: string) => {
+			output += chunk;
+		});
+		child.on("close", (code) => {
+			if (code !== 0) return finish({ code });
+			try {
+				finish({ code, selection: parseSelection(output) });
+			} catch (error) {
+				finish({
+					code,
+					error: error instanceof Error ? error.message : String(error),
+				});
+			}
+		});
+		child.on("error", (error) => {
 			process.stdout.write(
-				`\x1b[31mpisesh failed to launch: ${err.message}\x1b[0m\n`,
+				`\x1b[31mpisesh failed to launch: ${error.message}\x1b[0m\n`,
 			);
-			resolve(127);
+			finish({ code: 127, error: error.message });
 		});
 	});
 }
 
+function sameSession(left: string | undefined, right: string): boolean {
+	return left ? path.resolve(left) === path.resolve(right) : false;
+}
+
 export default function (pi: ExtensionAPI) {
+	// A successful switch loads a fresh extension instance before the old command
+	// returns. Plain pending data on globalThis lets that new instance apply the
+	// selected model and thinking without touching stale pre-switch pi/ctx objects.
+	pi.on("session_start", async (event, ctx) => {
+		const pending = processState.__piseshPendingSwitch;
+		if (
+			event.reason !== "resume" ||
+			!pending ||
+			!sameSession(ctx.sessionManager.getSessionFile(), pending.sessionPath)
+		) {
+			return;
+		}
+		processState.__piseshPendingSwitch = undefined;
+
+		if (pending.model) {
+			const separator = pending.model.indexOf("/");
+			const model =
+				separator > 0
+					? ctx.modelRegistry.find(
+							pending.model.slice(0, separator),
+							pending.model.slice(separator + 1),
+						)
+					: undefined;
+			if (!model || !(await pi.setModel(model))) {
+				ctx.ui.notify(
+					`Could not apply resume model: ${pending.model}`,
+					"warning",
+				);
+			}
+		}
+		if (pending.thinking) {
+			pi.setThinkingLevel(
+				pending.thinking as Parameters<typeof pi.setThinkingLevel>[0],
+			);
+		}
+		if (pending.repaired) {
+			ctx.ui.notify(
+				`Repaired ${pending.repaired} interrupted tool call${pending.repaired === 1 ? "" : "s"} before resume`,
+				"warning",
+			);
+		}
+		if (
+			pending.cwdOverride &&
+			path.resolve(ctx.cwd) !== path.resolve(pending.cwdOverride)
+		) {
+			ctx.ui.notify(
+				"This pi version did not apply the selected cwd override; update pi to a version that supports it",
+				"warning",
+			);
+		}
+	});
+
 	pi.registerCommand("sesh", {
 		description: "Browse, star, and resume pi sessions (opens pisesh TUI)",
 		handler: async (_args, ctx) => {
-			if (!ctx.hasUI) {
-				ctx.ui?.notify?.("/sesh requires interactive UI", "warning");
+			if (ctx.mode !== "tui") {
+				ctx.ui.notify("/sesh requires pi's interactive TUI", "warning");
 				return;
 			}
 
-			let currentId: string | undefined;
-			try {
-				currentId = ctx.sessionManager?.getSessionId?.();
-			} catch {
-				currentId = undefined;
-			}
-
-			const code = await ctx.ui.custom<number | null>(
-				(tui, _theme, _kb, done) => {
-					// Hand over the terminal
+			const currentId = ctx.sessionManager.getSessionId();
+			const result = await ctx.ui.custom<PickerResult>(
+				(tui, _theme, _keybindings, done) => {
 					tui.stop();
 					process.stdout.write("\x1b[2J\x1b[H");
-
-					runPisesh(currentId).then((exitCode) => {
-						// Restore pi's TUI
+					void runPisesh(currentId).then((pickerResult) => {
 						tui.start();
 						tui.requestRender(true);
-						done(exitCode);
+						done(pickerResult);
 					});
-
-					// Return a no-op component (custom() requires one synchronously)
 					return { render: () => [], invalidate: () => {} };
 				},
 			);
 
-			if (code === 0 || code === null) {
-				ctx.ui.notify("Returned from pisesh", "info");
-			} else if (code === 127) {
-				ctx.ui.notify("pisesh failed to launch", "error");
-			} else {
-				ctx.ui.notify(`pisesh exited with code ${code}`, "warning");
+			if (!result) return;
+			if (result.error) {
+				ctx.ui.notify(`pisesh: ${result.error}`, "error");
+				return;
+			}
+			if (result.code !== 0 && result.code !== null) {
+				ctx.ui.notify(`pisesh exited with code ${result.code}`, "warning");
+				return;
+			}
+			const selection = result.selection;
+			if (!selection) return;
+
+			const currentFile = ctx.sessionManager.getSessionFile();
+			if (sameSession(currentFile, selection.sessionPath)) {
+				ctx.ui.notify("That session is already active", "info");
+				return;
+			}
+
+			const pending: PendingSwitch = {
+				sessionPath: selection.sessionPath,
+				cwdOverride: selection.cwdOverride,
+				model: selection.model,
+				thinking: selection.thinking,
+				repaired: selection.repaired,
+			};
+			processState.__piseshPendingSwitch = pending;
+
+			try {
+				const switchSession = ctx.switchSession as (
+					sessionPath: string,
+					options?: { cwdOverride?: string },
+				) => Promise<{ cancelled: boolean }>;
+				const switched = await switchSession(
+					selection.sessionPath,
+					selection.cwdOverride
+						? { cwdOverride: selection.cwdOverride }
+						: undefined,
+				);
+				if (switched.cancelled) {
+					processState.__piseshPendingSwitch = undefined;
+					ctx.ui.notify("Resume cancelled", "info");
+				}
+			} finally {
+				if (processState.__piseshPendingSwitch === pending) {
+					processState.__piseshPendingSwitch = undefined;
+				}
 			}
 		},
 	});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pisesh",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Bookmark, search, and resume pi coding-agent sessions with a fast keyboard-driven TUI.",
   "keywords": [
     "pi-package",
@@ -27,7 +27,7 @@
   "author": "Blue-B <source_vs@naver.com>",
   "type": "commonjs",
   "bin": {
-    "pisesh": "./bin/pisesh"
+    "pisesh": "bin/pisesh"
   },
   "files": [
     "bin/",