@tekmidian/pai 0.30.1 → 0.31.0

package/dist/{main-resolver-BfSL8zio.mjs → main-resolver-DjyUDJrv.mjs}

@@ -1,7 +1,7 @@
 import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
 import { _ as warn, c as ok, h as smartDecodeDir, i as err, l as renderTable, n as dim, o as header } from "./utils-BAxjW3j8.mjs";
 import { t as aibrokerSocketPath } from "./runtime-paths-B0P1TvUr.mjs";
-import { createReadStream, existsSync, readFileSync, readdirSync, realpathSync, statSync } from "node:fs";
+import { closeSync, copyFileSync, createReadStream, existsSync, linkSync, openSync, readFileSync, readSync, readdirSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, join } from "node:path";
 import chalk from "chalk";
@@ -179,6 +179,9 @@ function resolveFilter(opts) {
 * Scan ~/.claude/projects/ for all Claude Code sessions.
 *
 * Pass 1: walk top-level <project>/<uuid>.jsonl files (the resumability source).
+* Pass 1b: walk <project>/sessions/<uuid>.jsonl — where the stop hook moves a
+*         session's transcript once it ends. These are resumable too, and
+*         skipping them made every cleanly-stopped session unfindable by name.
 * Pass 2: handle clc registry entries whose cached UUID was not found in Pass 1.
 *         For each such entry, scan the entry's project dir for the FRESHEST session
 *         and attach the registry name to it. This fixes the stale-UUID bug where
@@ -271,6 +274,47 @@ function scanSessions(db, opts = {}) {
 			if (inRegistry) attachedClcUuids.add(uuid);
 			if (passesFilter) results.push(session);
 		}
+		const sessionsDir = join(projectDir, "sessions");
+		let finished = [];
+		try {
+			finished = readdirSync(sessionsDir);
+		} catch {
+			finished = [];
+		}
+		for (const file of finished) {
+			if (!file.endsWith(".jsonl")) continue;
+			const uuid = file.slice(0, -6);
+			if (!UUID_RE.test(uuid)) continue;
+			if (seenUuids.has(uuid)) continue;
+			const sessionJsonlPath = join(sessionsDir, file);
+			const transcript = parseTranscript(sessionJsonlPath);
+			const clcInfo = clcInfoMap.get(uuid);
+			const session = {
+				uuid,
+				shortId: uuid.slice(0, 8),
+				encodedDir,
+				decodedPath,
+				topLevelPath: "",
+				topLevelSystemLines: 0,
+				topLevelSize: 0,
+				resumable: true,
+				sessionStatus: "resumable",
+				sessionJsonlPath,
+				userLines: transcript.userLines,
+				lastUserPrompt: transcript.lastUserPrompt,
+				msgCount: transcript.msgCount,
+				aiTitle: transcript.aiTitle,
+				mtime: transcript.mtime,
+				friendlyName: clcInfo?.name ?? transcript.aiTitle ?? projectBasename ?? void 0,
+				clcDirectory: clcInfo?.directory,
+				registryRootPath
+			};
+			if (!sessionsByEncodedDir.has(encodedDir)) sessionsByEncodedDir.set(encodedDir, []);
+			sessionsByEncodedDir.get(encodedDir).push(session);
+			seenUuids.add(uuid);
+			if (clcInfo) attachedClcUuids.add(uuid);
+			results.push(session);
+		}
 	}
 	if (filterMode !== "resumable") for (const [cachedUuid, clcInfo] of clcInfoMap) {
 		if (attachedClcUuids.has(cachedUuid)) continue;
@@ -742,6 +786,296 @@ function printExitDir(dir) {
 	process.stdout.write(`\n\x1b[2m📂 Working directory:\x1b[0m ${dir}\n\x1b[2m   cd "${dir}"\x1b[0m\n`);
 }
 
+//#endregion
+//#region src/cli/lib/launch.ts
+/**
+* launch.ts — Launch Claude Code in a directory, in the CURRENT terminal.
+*
+* Shared by the interactive picker (pick.ts). Deliberately does NOT switch
+* iTerm tabs (aibroker_switch): switching jumps the user to a different — and
+* sometimes wrong — terminal, which is confusing. Picking a place should start
+* a session right here, in the chosen directory.
+*
+* Behaviour:
+*   resume-or-fresh  → if a resumable UUID is given, probe it; on success
+*                      `claude --resume`, otherwise fall back to a fresh session
+*                      in the same dir. With no UUID, start fresh.
+*
+* The `claude` child inherits the tty (stdio: "inherit"), so the session runs
+* in the terminal that launched `pai`. On exit we print the working directory.
+*/
+/**
+* Put a transcript back where `claude --resume` looks for it.
+*
+* `claude --resume <uuid>` reads ~/.claude/projects/<encoded-cwd>/<uuid>.jsonl
+* and ONLY that path. A copy under `sessions/` is invisible to it — measured
+* 2026-08-04, both directions:
+*
+*   b3462801  867 KB, sessions/ only  → "No conversation found with session ID"
+*   a9ecdc1c  top level               → found
+*
+* Location is one of two factors, and this function addresses that one. PAI
+* displaced these files itself, from FOUR movers — a SessionStart hook, a
+* UserPromptSubmit hook, the stop hook, and the work-queue worker — of which
+* the UserPromptSubmit one did most of the damage, because it ran on every
+* prompt of every session and excluded only the caller's own transcript. All
+* four now hardlink (project-utils/paths.ts). So this restores a file PAI
+* displaced rather than inventing a layout Claude Code does not use.
+*
+* The other factor is content, and no amount of relinking helps there — see
+* `hasConversation`.
+*
+* A hard link is preferred over a copy: same inode, no second megabyte on disk,
+* and the archive under `sessions/` keeps working for everything that reads it.
+* Returns whether the top-level path exists afterwards.
+*/
+function restoreTopLevel(uuid, dir) {
+	const topLevel = join(dir, `${uuid}.jsonl`);
+	if (existsSync(topLevel)) return true;
+	const archived = join(dir, "sessions", `${uuid}.jsonl`);
+	if (!existsSync(archived)) return false;
+	try {
+		linkSync(archived, topLevel);
+		return true;
+	} catch {
+		try {
+			copyFileSync(archived, topLevel);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+}
+/**
+* Does this transcript hold an exchange, or only session metadata?
+*
+* The second reason `claude --resume` says "No conversation found": the file is
+* there and readable and still holds no conversation. Measured 2026-08-04 on
+* 046bb712 — 537 bytes of last-prompt, custom-title, agent-name, mode and
+* permission-mode, no user line, no assistant line. It was restored to the top
+* level, verified same-inode, and still refused. It was never resumable, and
+* relinking cannot make it so. 30 of PAI's own 50 displaced transcripts are
+* this shape, one of them 745 KB — size proves nothing, because hook context
+* attachments are large.
+*
+* This scans the WHOLE file, and a bounded head will not do. It is tempting —
+* "a real session's first assistant line lands within the first few KB" — and
+* it is false. Measured on b3462801, a session `claude --resume` accepts:
+*
+*   file size            866953
+*   length of LINE 1     762977      <- one hook context attachment
+*   first "type":"user"     766830
+*
+* The first exchange sits past 766 KB because line 1 is a single enormous
+* attachment blob. Any head shorter than that reports a 867 KB working session
+* as an empty stub, which is the exact false negative this function exists to
+* prevent — and it is the shape that produced today's whole incident.
+*
+* Chunked so that a large transcript costs a scan rather than a resident copy,
+* with an overlap so the marker cannot hide across a chunk boundary. Reading a
+* few MB to answer a question about resumability is cheap; being wrong is not.
+*
+* Unreadable counts as real. Claiming a session is empty when it cannot be
+* inspected would talk the caller out of a resume that might have worked.
+*/
+const CONVERSATION_MARKERS = [
+	"\"type\":\"assistant\"",
+	"\"type\": \"assistant\"",
+	"\"type\":\"user\"",
+	"\"type\": \"user\""
+];
+const OVERLAP = 32;
+function hasConversation(path, chunkBytes = 1 << 20) {
+	let fd;
+	try {
+		fd = openSync(path, "r");
+		const buf = Buffer.alloc(chunkBytes);
+		let carry = "";
+		let pos = 0;
+		for (;;) {
+			const read = readSync(fd, buf, 0, chunkBytes, pos);
+			if (read <= 0) return false;
+			pos += read;
+			const text = carry + buf.subarray(0, read).toString("utf8");
+			if (CONVERSATION_MARKERS.some((m) => text.includes(m))) return true;
+			carry = text.slice(-OVERLAP);
+		}
+	} catch {
+		return true;
+	} finally {
+		if (fd !== void 0) try {
+			closeSync(fd);
+		} catch {}
+	}
+}
+/**
+* Can this session be resumed — and if the only thing standing in the way is
+* where its transcript sits, put it back so that the answer is yes.
+*
+* Returns true/false when it can tell, and null when it cannot — the caller
+* must treat null as "ask something else", never as "no". A path this function
+* fails to recognise would otherwise silently veto a perfectly good resume.
+*
+* Claude Code stores transcripts at ~/.claude/projects/<encoded-cwd>/, where the
+* encoding replaces every non-alphanumeric character with `-`.
+*/
+function transcriptOnDisk(uuid, cwd, home = homedir()) {
+	try {
+		const dir = join(home, ".claude", "projects", cwd.replace(/[^a-zA-Z0-9]/g, "-"));
+		if (!existsSync(dir)) return null;
+		if (!restoreTopLevel(uuid, dir)) return "missing";
+		return hasConversation(join(dir, `${uuid}.jsonl`)) ? true : "stub";
+	} catch {
+		return null;
+	}
+}
+/**
+* Probe whether a session UUID is resumable from `cwd`.
+*
+* The filesystem is asked first, and usually answers.
+*
+* This used to run `claude --resume <uuid> --print --output-format=json "_"`
+* with a 5s timeout, which is not a probe: it resumes the session AND sends a
+* prompt to the model, then waits for a complete JSON reply. That costs a model
+* round-trip per probe, and 5s is not enough time for one — for a LARGE session
+* least of all, because the transcript has to be loaded first.
+*
+* So the check failed precisely for the sessions most worth resuming, and the
+* caller's fallback quietly started a fresh session in their place. Observed
+* 2026-08-04: `pai Paperfull` reported `spawn error: spawnSync claude ETIMEDOUT`
+* for fb76a6c3 and started over, while
+* `~/.claude/projects/…-Paperfull/sessions/fb76a6c3-….jsonl` sat on disk the
+* whole time.
+*
+* A transcript on disk is what resumable MEANS, and reading a directory entry is
+* free. The spawn remains only for the case the filesystem cannot answer, and
+* now gets a timeout that a real answer can fit inside.
+*
+* "On disk" had to be tightened once. It first accepted a transcript sitting
+* only under `sessions/`, which claude --resume does not read — so the probe
+* swapped a 5s false negative for a confident false positive, and the caller
+* spawned a resume that died with "No conversation found" instead of falling
+* back to a fresh session. `restoreTopLevel` is what makes the permissive
+* reading true rather than merely optimistic.
+*/
+function probeResume(uuid, cwd, home) {
+	const onDisk = transcriptOnDisk(uuid, cwd, home);
+	if (onDisk === true) return { ok: true };
+	if (onDisk === "missing") return {
+		ok: false,
+		reason: "No transcript on disk for this UUID"
+	};
+	if (onDisk === "stub") return {
+		ok: false,
+		reason: "Transcript holds only session metadata — no conversation to resume"
+	};
+	const result = spawnSync("claude", [
+		"--resume",
+		uuid,
+		"--print",
+		"--output-format=json",
+		"_"
+	], {
+		cwd,
+		timeout: 3e4,
+		env: process.env,
+		stdio: [
+			"ignore",
+			"ignore",
+			"pipe"
+		]
+	});
+	if (result.error) return {
+		ok: false,
+		reason: `spawn error: ${result.error.message}`
+	};
+	const stderr = result.stderr?.toString("utf8") ?? "";
+	if (stderr.toLowerCase().includes("no conversation found") || stderr.toLowerCase().includes("session not found")) return {
+		ok: false,
+		reason: "No conversation found for this UUID"
+	};
+	if (result.status !== 0) return {
+		ok: false,
+		reason: `claude exited ${result.status ?? "signal"}${stderr ? `: ${stderr.slice(0, 120).trim()}` : ""}`
+	};
+	return { ok: true };
+}
+/**
+* Launch `claude` in `dir` in the current terminal. `name` is used for both the
+* Claude session label (--name) and the /Name slash command (tab/statusline).
+* Never returns on the live path — it exits the process after claude exits.
+*/
+function launchInDir(dir, name, opts = {}) {
+	let cwd;
+	try {
+		cwd = realpathSync(dir);
+	} catch {
+		console.error(err(`Directory does not exist or cannot be resolved:\n  ${dir}\n  The folder may have moved or been deleted.`));
+		process.exit(1);
+		return;
+	}
+	const promptArg = `/Name ${name}\ngo`;
+	const wantResume = !opts.forceFresh && !!opts.resumableUuid;
+	if (opts.dryRun) {
+		if (wantResume) {
+			console.log("\n" + chalk.bold("Dry run — would probe then exec (RESUME path):") + "\n");
+			console.log(`  cwd:      ${chalk.cyan(cwd)}`);
+			console.log(`  probe:    transcript on disk for ${opts.resumableUuid.slice(0, 8)}?`);
+			console.log(`  argv:     claude --resume ${opts.resumableUuid} --name "${name}" "/Name ${name}\\ngo"`);
+			console.log(`  fallback: claude --name "${name}" "/Name ${name}\\ngo"`);
+		} else {
+			console.log("\n" + chalk.bold("Dry run — would exec (FRESH path):") + "\n");
+			console.log(`  cwd:  ${chalk.cyan(cwd)}`);
+			console.log(`  argv: claude --name "${name}" "/Name ${name}\\ngo"`);
+		}
+		console.log();
+		return;
+	}
+	const fresh = () => {
+		const result = spawnSync("claude", [
+			"--name",
+			name,
+			promptArg
+		], {
+			cwd,
+			stdio: "inherit",
+			env: process.env
+		});
+		if (result.error) {
+			console.error(err(`Failed to launch claude: ${result.error.message}`));
+			process.exit(1);
+		}
+		printExitDir(cwd);
+		process.exit(result.status ?? 0);
+	};
+	if (wantResume) {
+		const probe = probeResume(opts.resumableUuid, cwd);
+		if (probe.ok) {
+			const result = spawnSync("claude", [
+				"--resume",
+				opts.resumableUuid,
+				"--name",
+				name,
+				promptArg
+			], {
+				cwd,
+				stdio: "inherit",
+				env: process.env
+			});
+			if (result.error) {
+				console.error(err(`Failed to launch claude: ${result.error.message}`));
+				process.exit(1);
+			}
+			printExitDir(cwd);
+			process.exit(result.status ?? 0);
+		}
+		process.stderr.write(chalk.yellow(`\n  Resume failed for ${opts.resumableUuid.slice(0, 8)}: ${probe.reason ?? "unknown error"}\n  Starting fresh session in same directory.\n\n`));
+		fresh();
+		return;
+	}
+	fresh();
+}
+
 //#endregion
 //#region src/cli/lib/history-search.ts
 /**
@@ -848,6 +1182,57 @@ function slugToWords(slug) {
 *
 * @param showAll  When true, include cold / zero-session / archived projects.
 */
+/**
+* Which of two sessions of equal status should represent a name.
+*
+* Recency alone was the rule, and recency is exactly the wrong instinct here.
+* A resume that FAILS still creates a session file, and that file is newer than
+* the transcript it failed to open. So the tie-break reliably handed back the
+* artefact of a bug in preference to the work.
+*
+* Measured on Paperfull, 2026-08-04:
+*
+*   b3462801  867 KB  32 lines  3 user  15:41:57   <- the actual work
+*   7fdbb9a8   82 KB  25 lines  2 user  15:41:59   <- empty, Ctrl-C'd, WON by 2s
+*   a9ecdc1c   82 KB  25 lines  2 user  15:49:40   <- a second failed resume
+*
+* `pai Paperfull` therefore resolved to 7fdbb9a8 — 82 KB of hook context in
+* `attachment` lines, with no assistant turn anywhere in it — while 867 KB of
+* real work sat one second older and unchosen.
+*
+* WHAT THIS DOES NOT FIX, measured before claiming otherwise: the reported
+* failure was `No conversation found with session ID: 7fdbb9a8`, and that error
+* is about WHERE the transcript is, not what is in it. Both transcripts live
+* only in sessions/, and `claude --resume b3462801` — the good one, the one this
+* change now selects — fails with the identical message. Verified directly, and
+* again on a second project. So this stops dedup preferring the artefact of a
+* bug, which is worth doing on its own, and `pai <Name>` still cannot resume a
+* cleanly-stopped session until the sessions/ relocation is addressed. That part
+* is tracked in Notes/TODO.md and belongs to session-scan/the stop hook.
+*
+* Conversation volume comes first because an empty artefact is small BY
+* CONSTRUCTION — nobody spoke into it — whereas an artefact can be newer by
+* mere milliseconds. Recency only decides between transcripts that recorded the
+* same amount, where it is a reasonable guess again.
+*
+* HONEST LIMIT: the exact signal is "did the assistant ever reply", and this is
+* not that — it is a proxy that happens to separate the measured case by one
+* user line and seven total lines, which is a thin margin. The real predicate
+* belongs in `parseTranscript` (session-scan.ts) as an `assistantLines` count,
+* which is free there since it already reads every line of the file. That file
+* was mid-edit in another session when this landed, so this stays out of it.
+* Move to the exact signal when it exists; the tests below should keep passing
+* unchanged, since they assert the outcome and not the proxy.
+*/
+function winsTiebreak(candidate, incumbent) {
+	const c = candidate.diskSession;
+	const i = incumbent.diskSession;
+	if (c && i) {
+		if (c.userLines !== i.userLines) return c.userLines > i.userLines;
+		if (c.msgCount !== i.msgCount) return c.msgCount > i.msgCount;
+	}
+	return candidate.lastActivity > incumbent.lastActivity;
+}
 function buildDeduped(liveSessions, diskSessions, registeredProjects, showAll = false) {
 	const byName = /* @__PURE__ */ new Map();
 	for (const s of liveSessions) {
@@ -886,7 +1271,7 @@ function buildDeduped(liveSessions, diskSessions, registeredProjects, showAll =
 		else {
 			const ep = STATUS_PRIORITY[existing.status];
 			const np = STATUS_PRIORITY[status];
-			if (np < ep || np === ep && entry.lastActivity > existing.lastActivity) byName.set(key, entry);
+			if (np < ep || np === ep && winsTiebreak(entry, existing)) byName.set(key, entry);
 		}
 	}
 	const COLD_THRESHOLD_MS = 2160 * 60 * 60 * 1e3;
@@ -985,38 +1370,6 @@ function renderDedupedSessions(entries, maxRows) {
 //#endregion
 //#region src/cli/commands/main-resolver.ts
 var main_resolver_exports = /* @__PURE__ */ __exportAll({ cmdMain: () => cmdMain });
-function probeResume(uuid, cwd) {
-	const result = spawnSync("claude", [
-		"--resume",
-		uuid,
-		"--print",
-		"--output-format=json",
-		"_"
-	], {
-		cwd,
-		timeout: 5e3,
-		env: process.env,
-		stdio: [
-			"ignore",
-			"ignore",
-			"pipe"
-		]
-	});
-	if (result.error) return {
-		ok: false,
-		reason: `spawn error: ${result.error.message}`
-	};
-	const stderr = result.stderr?.toString("utf8") ?? "";
-	if (stderr.toLowerCase().includes("no conversation found") || stderr.toLowerCase().includes("session not found")) return {
-		ok: false,
-		reason: "No conversation found for this UUID"
-	};
-	if (result.status !== 0) return {
-		ok: false,
-		reason: `claude exited ${result.status ?? "signal"}${stderr ? `: ${stderr.slice(0, 120).trim()}` : ""}`
-	};
-	return { ok: true };
-}
 function launchSession(session, allSessions, dryRun) {
 	let resumableUuid;
 	if (session.resumable) resumableUuid = session.uuid;
@@ -1034,13 +1387,13 @@ function launchSession(session, allSessions, dryRun) {
 		process.exit(1);
 		return;
 	}
-	const name = session.friendlyName ?? session.shortId;
+	const name = session.friendlyName ?? (basename(projectDir) || session.shortId);
 	const promptArg = `/Name ${name}\ngo`;
 	if (dryRun) {
 		if (resumableUuid) {
 			console.log("\n" + chalk.bold("Dry run — would probe then exec (RESUME path):") + "\n");
 			console.log(`  cwd:      ${chalk.cyan(projectDir)}`);
-			console.log(`  probe:    claude --resume ${resumableUuid} --print --output-format=json "_"`);
+			console.log(`  probe:    transcript on disk for ${resumableUuid.slice(0, 8)}?`);
 			console.log(`  argv:     claude --resume ${resumableUuid} --name "${name}" "/Name ${name}\\ngo"`);
 			console.log(`  fallback: claude --name "${name}" "/Name ${name}\\ngo"`);
 		} else {
@@ -1172,6 +1525,34 @@ async function doSwitch(entry, dryRun) {
 	console.error(warn(`Could not switch via AIBroker: ${result.error ?? "unknown error"}`));
 	return false;
 }
+/**
+* Act on a matched catalog entry: switch to it, resume it, or start it.
+*
+* The third case is the one that was missing. A registered project whose
+* sessions have all ended matches by name perfectly well, but carries no
+* `diskSession`, and the old code simply ran off the end of both the exact and
+* the partial branch — past the picker, into a free-text search of prompt
+* history. So `pai Paperfull` answered a request to open a project with a list
+* of five old conversations that merely mentioned the word, while the project's
+* own directory was sitting in `entry.project` the whole time.
+*
+* Returns false only when there is genuinely nothing to open, which is the one
+* case where falling through to a history search is the right thing to do.
+*/
+async function openMatch(entry, allSessions, dryRun) {
+	if (entry.status === "live") {
+		if (await doSwitch(entry, dryRun)) return true;
+	}
+	if (entry.diskSession) {
+		launchSession(entry.diskSession, allSessions, dryRun);
+		return true;
+	}
+	if (entry.project && existsSync(entry.project)) {
+		launchInDir(entry.project, entry.name, { dryRun });
+		return true;
+	}
+	return false;
+}
 function getRegisteredProjects(db, all = false) {
 	try {
 		const statusClause = all ? "" : "WHERE p.status = 'active'";
@@ -1230,24 +1611,11 @@ async function cmdMain(db, query, pickN, opts) {
 		const nameIncludes = (e, q) => e.name.toLowerCase().includes(q) || e.slug !== void 0 && e.slug.toLowerCase().includes(qSlug);
 		const exactMatch = deduped.find((e) => nameMatches(e, qNorm));
 		if (exactMatch) {
-			if (exactMatch.status === "live") {
-				if (await doSwitch(exactMatch, opts.dryRun ?? false)) return;
-			}
-			if (exactMatch.diskSession) {
-				launchSession(exactMatch.diskSession, allSessions, opts.dryRun ?? false);
-				return;
-			}
+			if (await openMatch(exactMatch, allSessions, opts.dryRun ?? false)) return;
 		}
 		const partialMatches = deduped.filter((e) => nameIncludes(e, qNorm));
 		if (partialMatches.length === 1) {
-			const match = partialMatches[0];
-			if (match.status === "live") {
-				if (await doSwitch(match, opts.dryRun ?? false)) return;
-			}
-			if (match.diskSession) {
-				launchSession(match.diskSession, allSessions, opts.dryRun ?? false);
-				return;
-			}
+			if (await openMatch(partialMatches[0], allSessions, opts.dryRun ?? false)) return;
 		}
 		if (partialMatches.length > 1) {
 			console.log("\n" + header(`Sessions matching "${query}"`) + "\n");
@@ -1272,11 +1640,9 @@ async function cmdMain(db, query, pickN, opts) {
 			console.log(renderTable(headers, rows));
 			console.log();
 			const pickMatch = async (match) => {
-				if (match.status === "live") {
-					await doSwitch(match, opts.dryRun ?? false);
-					return;
-				}
-				if (match.diskSession) launchSession(match.diskSession, allSessions, opts.dryRun ?? false);
+				if (await openMatch(match, allSessions, opts.dryRun ?? false)) return;
+				console.error(err(`Nothing to open for "${match.name}" — no live session, no transcript, no directory.`));
+				process.exitCode = 1;
 			};
 			if (pickN !== void 0) {
 				const idx = pickN - 1;
@@ -1365,5 +1731,5 @@ async function cmdMain(db, query, pickN, opts) {
 }
 
 //#endregion
-export { renderDedupedSessions as a, fetchLiveSessions as c, fmtAge as d, resolveSessionByNameOrId as f, normalizeName as i, revealItermSession as l, main_resolver_exports as n, printExitDir as o, scanSessions as p, buildDeduped as r, callAiBroker as s, cmdMain as t, sendToSession as u };
-//# sourceMappingURL=main-resolver-BfSL8zio.mjs.map
+export { scanSessions as _, renderDedupedSessions as a, probeResume as c, callAiBroker as d, fetchLiveSessions as f, resolveSessionByNameOrId as g, fmtAge as h, normalizeName as i, restoreTopLevel as l, sendToSession as m, main_resolver_exports as n, hasConversation as o, revealItermSession as p, buildDeduped as r, launchInDir as s, cmdMain as t, printExitDir as u };
+//# sourceMappingURL=main-resolver-DjyUDJrv.mjs.map