@tekmidian/pai 0.30.1 → 0.31.0

package/dist/{pick-BcmBBfOF.mjs → pick-Bmz718uo.mjs}

@@ -1,5 +1,5 @@
 import { n as openRegistry } from "./db-BtuN768f.mjs";
-import { _ as warn$1, a as fmtDate, c as ok$1, d as scaffoldProjectDirs, f as shortenPath, i as err, l as renderTable, m as slugify, n as dim$1, o as header, p as slugFromPath, r as encodeDir, s as now, t as bold$1, u as resolvePath } from "./utils-BAxjW3j8.mjs";
+import { _ as warn$1, a as fmtDate, c as ok$1, d as scaffoldProjectDirs, f as shortenPath, h as smartDecodeDir, i as err, l as renderTable, m as slugify, n as dim$1, o as header, p as slugFromPath, r as encodeDir, s as now, t as bold$1, u as resolvePath } from "./utils-BAxjW3j8.mjs";
 import { a as slugify$1, i as parseSessionFilename } from "./migrate-fLD6rAdO.mjs";
 import { n as ensurePaiMarker } from "./pai-marker-B20KqhA8.mjs";
 import { n as openFederation } from "./db-CYmBWcjh.mjs";
@@ -11,9 +11,9 @@ import { _ as transcriptFiles, a as readBodyFile, c as loadScanConfig, d as save
 import { a as schedulerLogPath, i as paiSocketPath, n as daemonLogPath, r as daemonPidPath } from "./runtime-paths-B0P1TvUr.mjs";
 import { t as PaiClient } from "./ipc-client-aVKVERjJ.mjs";
 import { a as expandHome, c as UNROUTED, i as ensureConfigDir, n as CONFIG_FILE$2, o as loadConfig, s as OWNER_LABEL_PREFIX, t as CONFIG_DIR } from "./config-CcdkNSWa.mjs";
-import { t as createStorageBackend } from "./factory-BqAdO21B.mjs";
+import { i as humanDuration, t as createStorageBackend } from "./factory-BydJSrZJ.mjs";
 import { s as kgQuery } from "./kg-entity-r8duqhi9.mjs";
-import { a as renderDedupedSessions, c as fetchLiveSessions, d as fmtAge, f as resolveSessionByNameOrId, i as normalizeName$2, l as revealItermSession, o as printExitDir, p as scanSessions, r as buildDeduped, s as callAiBroker, u as sendToSession } from "./main-resolver-BfSL8zio.mjs";
+import { _ as scanSessions, a as renderDedupedSessions, c as probeResume, d as callAiBroker, f as fetchLiveSessions, g as resolveSessionByNameOrId, h as fmtAge, i as normalizeName$2, l as restoreTopLevel, m as sendToSession, o as hasConversation, p as revealItermSession, r as buildDeduped, s as launchInDir, u as printExitDir } from "./main-resolver-DjyUDJrv.mjs";
 import { appendFileSync, chmodSync, copyFileSync, createReadStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
 import { homedir, platform, tmpdir } from "node:os";
 import { basename, dirname, join, relative, resolve } from "node:path";
@@ -1303,7 +1303,7 @@ function cmdHealth$1(db, opts) {
 //#region src/cli/commands/project/projects-index.ts
 function registerProjectsCommands(projectsCmd, getDb) {
 	projectsCmd.command("list", { isDefault: true }).description("Show the unified deduped listing (same as `pai`).\nUse --all to include cold / zero-session / archived projects.").option("--all", "Show all entries including cold / zero-session / archived projects").option("-n, --n <count>", "Max rows to show", "20").action(async (opts) => {
-		const { cmdMain } = await import("./main-resolver-BfSL8zio.mjs").then((n) => n.n);
+		const { cmdMain } = await import("./main-resolver-DjyUDJrv.mjs").then((n) => n.n);
 		await cmdMain(getDb(), void 0, void 0, opts);
 	});
 	projectsCmd.command("list-raw").description("Raw registry listing with slug, path, status, last_active columns").option("--all", "Include archived projects (default: active only)").option("--status <status>", "Filter by status: active | archived").option("--tag <tag>", "Filter by tag").option("--type <type>", "Filter by type").action((opts) => {
@@ -2684,6 +2684,65 @@ function registerMcpCommands(mcpCmd) {
 	});
 }
 
+//#endregion
+//#region src/cli/commands/daemon-status.ts
+/**
+* Health lines to print above the index/DB figures, worst first.
+*
+* Empty when there is nothing wrong: a healthy daemon should not grow a
+* paragraph of reassurance, or the one time it says something real gets read as
+* more of the same.
+*/
+function formatStorageHealth(s, now = Date.now()) {
+	const lines = [];
+	const outage = s.backendOutage ?? null;
+	if (outage) {
+		lines.push({
+			severity: "error",
+			text: `BACKEND DOWN: ${outage.backend} unreachable for ${humanDuration(now - outage.since)}`
+		});
+		lines.push({
+			severity: "warn",
+			text: `${outage.attempts} attempts — ${outage.lastError}`
+		});
+	}
+	const queue = queueLine(s.workQueue, outage !== null);
+	if (queue) lines.push(queue);
+	if (outage) lines.push({
+		severity: "info",
+		text: "Indexing, session notes and the work queue are stalled until it returns."
+	});
+	return lines;
+}
+/**
+* The queue depth, when it means something.
+*
+* During an outage it always means something — including a depth of zero, which
+* says the backlog is not the reason nothing is happening. Otherwise it is only
+* worth a line when work is actually sitting there: a queue that is empty
+* because everything drained is the normal case, and printing it every time
+* teaches the reader to skip the line.
+*
+* `failed` is reported whenever it is non-zero, outage or not. Items that
+* exhausted their retries are the silent-loss case this whole status block
+* exists for — they will never be retried and nothing else surfaces them.
+*/
+function queueLine(q, duringOutage) {
+	if (!q) return null;
+	const pending = q.pending ?? 0;
+	const processing = q.processing ?? 0;
+	const failed = q.failed ?? 0;
+	const waiting = pending + processing;
+	if (!duringOutage && waiting === 0 && failed === 0) return null;
+	const parts = [`${pending} pending`];
+	if (processing > 0) parts.push(`${processing} processing`);
+	if (failed > 0) parts.push(`${failed} failed`);
+	return {
+		severity: failed > 0 ? "error" : duringOutage || waiting > 0 ? "warn" : "info",
+		text: `Work queue:  ${parts.join(", ")}`
+	};
+}
+
 //#endregion
 //#region src/cli/commands/daemon.ts
 const HOME$2 = homedir();
@@ -2755,14 +2814,13 @@ async function cmdStatus$2() {
 		console.log(ok$1(`  Daemon running`));
 		console.log(dim$1(`    Uptime:      ${s["uptime"]}s`));
 		console.log(dim$1(`    Socket:      ${s["socketPath"]}`));
-		const outage = s["backendOutage"];
-		if (outage) {
-			const mins = Math.max(1, Math.round((Date.now() - outage.since) / 6e4));
-			const forHow = mins < 60 ? `${mins} min` : `${(mins / 60).toFixed(1)} h`;
+		const health = formatStorageHealth(s);
+		if (health.length > 0) {
 			console.log();
-			console.log(err(`    BACKEND DOWN: ${outage.backend} unreachable for ${forHow}`));
-			console.log(warn$1(`    ${outage.attempts} attempts — ${outage.lastError}`));
-			console.log(dim$1(`    Indexing, session notes and the work queue are stalled until it returns.`));
+			for (const line of health) {
+				const paint = line.severity === "error" ? err : line.severity === "warn" ? warn$1 : dim$1;
+				console.log(paint(`    ${line.text}`));
+			}
 			console.log();
 		}
 		console.log(dim$1(`    Index:       ${s["indexInProgress"] ? "in progress" : "idle"}  (interval: ${s["indexIntervalSecs"]}s)`));
@@ -2946,7 +3004,7 @@ function cmdLogs(opts) {
 }
 function registerDaemonCommands(daemonCmd) {
 	daemonCmd.command("serve").description("Start the PAI daemon in the foreground").action(async () => {
-		const { serve } = await import("./daemon-mFGnPd8q.mjs").then((n) => n.t);
+		const { serve } = await import("./daemon-iNuNMMKd.mjs").then((n) => n.t);
 		const { loadConfig: lc, ensureConfigDir } = await import("./config-CcdkNSWa.mjs").then((n) => n.r);
 		ensureConfigDir();
 		await serve(lc());
@@ -7983,6 +8041,33 @@ function restoreDueString(recurrence, prevDue) {
 	return `${recurrence}${hasTime && !ruleCarriesTime ? ` at ${prevDue.slice(11, 16)}` : ""} starting ${date}`;
 }
 /**
+* When a restored slot actually falls due — the inverse of `restoreDueString`.
+*
+* Callers need this to decide whether putting the slot back is still useful.
+* Restoring one that has already passed writes a task that is overdue the
+* instant it lands, and the next tick dispatches it, which advances the date,
+* which restores it again: an unbounded loop that fires every tick for the rest
+* of the day. That is not hypothetical — it happened on 2026-08-04 with "every
+* day at 9am", which re-dispatched roughly every 30 minutes (two 900s ticks)
+* because the guard compared against the end of the day rather than 09:00.
+*
+* Both shapes `restoreDueString` can emit put the time after "at", so one match
+* covers "every day at 9am starting …" and "every week at 08:00 starting …".
+* A rule carrying no time at all is a genuine date-only occurrence, and for
+* those the slot really does run until the end of the day.
+*/
+function triggeredSlotMs(keep, date) {
+	const at = /\bat\s+(\d{1,2})(?::(\d{2}))?\s*([ap]m)?/i.exec(keep);
+	if (!at) return (/* @__PURE__ */ new Date(`${date}T23:59:59`)).getTime();
+	let hour = Number(at[1]);
+	const suffix = at[3]?.toLowerCase();
+	if (suffix === "pm" && hour < 12) hour += 12;
+	if (suffix === "am" && hour === 12) hour = 0;
+	const hh = String(hour).padStart(2, "0");
+	const mm = String(Number(at[2] ?? 0)).padStart(2, "0");
+	return (/* @__PURE__ */ new Date(`${date}T${hh}:${mm}:00`)).getTime();
+}
+/**
 * Expected runtime for a task.
 *
 * The mean rather than the max, deliberately: with a liveness probe available,
@@ -8577,7 +8662,7 @@ async function keepTriggeredSchedule(task, opts, state, now) {
 	delete state.triggeredRestore[task.id];
 	const date = /starting (\d{4}-\d{2}-\d{2})/.exec(keep)?.[1];
 	if (!date || !opts.provider.setDue) return "";
-	if ((/* @__PURE__ */ new Date(`${date}T23:59:59`)).getTime() <= now) return ", triggered-run slot already past — schedule left as it is";
+	if (triggeredSlotMs(keep, date) <= now) return ", triggered-run slot already past — schedule left as it is";
 	try {
 		await opts.provider.setDue(task.id, keep);
 		state.lastSeenDue[task.id] = date;
@@ -10683,7 +10768,7 @@ function cmdActive(db, opts) {
 async function cmdAutoRoute(opts) {
 	const { autoRoute, formatAutoRoute, formatAutoRouteJson } = await import("./auto-route-BWGvvpcP.mjs");
 	const { openRegistry } = await import("./db-BtuN768f.mjs").then((n) => n.t);
-	const { createStorageBackend } = await import("./factory-BqAdO21B.mjs").then((n) => n.n);
+	const { createStorageBackend } = await import("./factory-BydJSrZJ.mjs").then((n) => n.n);
 	const { loadConfig } = await import("./config-CcdkNSWa.mjs").then((n) => n.r);
 	const config = loadConfig();
 	const registryDb = openRegistry();
@@ -11453,43 +11538,6 @@ async function cmdRecent(db, opts) {
 
 //#endregion
 //#region src/cli/commands/session/goto.ts
-/**
-* Run  claude --resume <uuid> --print --output-format=json "_"  in the given cwd.
-* Returns ok=true if the session is resumable (exit 0 and no "No conversation found"
-* in stderr).  Timeout: 5 seconds.
-*/
-function probeResume$1(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 cmdGoto(db, query, opts) {
 	const allSessions = scanSessions(db, {
 		limit: 500,
@@ -11553,7 +11601,7 @@ function cmdGoto(db, query, opts) {
 		return;
 	}
 	if (resumableUuid) {
-		const probe = probeResume$1(resumableUuid, projectDir);
+		const probe = probeResume(resumableUuid, projectDir);
 		if (probe.ok) {
 			const result = spawnSync("claude", [
 				"--resume",
@@ -11609,12 +11657,229 @@ function cmdGoto(db, query, opts) {
 	}
 }
 
+//#endregion
+//#region src/cli/commands/session/restore.ts
+/**
+* pai session restore — put displaced transcripts back where resume looks.
+*
+* PAI moved session transcripts out of `~/.claude/projects/<dir>/` into
+* `<dir>/sessions/`, and `claude --resume <uuid>` reads only the former. The
+* archiver no longer does that (it hardlinks), but the sessions already moved
+* stayed moved — and every checkpoint PAI ever wrote ends with
+* "Resume with: claude --resume <uuid>". For a displaced session that line is an
+* instruction that cannot work, and nothing says so.
+*
+* One project measured 1 transcript at the project root against 52 underneath.
+*
+* So this is a repair, and it is deliberately a COMMAND rather than another hook.
+* Silently relinking dozens of a user's files during an unrelated session start is
+* the same class of mistake as silently moving them was. Dry run is the default;
+* `--execute` is the only thing that touches disk.
+*
+* The link logic itself is imported, not rewritten. Today's other bug was a fix
+* that landed in one of three copies of `probeResume`, so `restoreTopLevel` stays
+* the single implementation.
+*/
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Transcripts that exist under `sessions/` with no twin at the project root.
+*
+* A twin means nothing needs doing: the archiver hardlinks now, so the normal
+* state is both names pointing at one inode. Only the ones missing upstairs were
+* displaced by the old rename.
+*/
+function findDisplaced(projectsDir = claudeProjectsDir()) {
+	const out = [];
+	let encodedDirs;
+	try {
+		encodedDirs = readdirSync(projectsDir);
+	} catch {
+		return out;
+	}
+	for (const encodedDir of encodedDirs) {
+		const projectDir = join(projectsDir, encodedDir);
+		const sessionsDir = join(projectDir, "sessions");
+		if (!existsSync(sessionsDir)) continue;
+		let files;
+		try {
+			files = readdirSync(sessionsDir);
+		} catch {
+			continue;
+		}
+		for (const file of files) {
+			if (!file.endsWith(".jsonl")) continue;
+			const uuid = file.slice(0, -6);
+			if (!UUID_RE.test(uuid)) continue;
+			if (existsSync(join(projectDir, file))) continue;
+			let bytes = 0;
+			let mtime = 0;
+			try {
+				const st = statSync(join(sessionsDir, file));
+				bytes = st.size;
+				mtime = st.mtimeMs;
+			} catch {
+				continue;
+			}
+			out.push({
+				uuid,
+				projectDir,
+				encodedDir,
+				cwd: smartDecodeDir(encodedDir),
+				bytes,
+				mtime,
+				promisedBy: [],
+				hasConversation: hasConversation(join(sessionsDir, file))
+			});
+		}
+	}
+	return out.sort((a, b) => b.bytes - a.bytes);
+}
+/**
+* Notes that instruct the user to resume this id.
+*
+* Bounded on purpose — the project's own TODO.md and note files, never a search
+* from the home directory. The point is to name the specific promise each
+* restore makes true, so a count of files is not enough.
+*/
+function findResumePromises(uuid, cwd) {
+	if (!cwd) return [];
+	const candidates = [];
+	for (const notesDir of [
+		cwd,
+		join(cwd, "Notes"),
+		join(cwd, "notes")
+	]) try {
+		for (const entry of readdirSync(notesDir)) if (entry.endsWith(".md")) candidates.push(join(notesDir, entry));
+	} catch {}
+	const seen = /* @__PURE__ */ new Set();
+	const hits = [];
+	for (const file of candidates) {
+		let key;
+		try {
+			const st = statSync(file);
+			key = `${st.dev}:${st.ino}`;
+		} catch {
+			key = file.toLowerCase();
+		}
+		if (seen.has(key)) continue;
+		seen.add(key);
+		try {
+			if (readFileSync(file, "utf8").includes(uuid)) hits.push(file);
+		} catch {}
+	}
+	return hits;
+}
+function human(bytes) {
+	if (bytes >= 1024 * 1024) return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+	if (bytes >= 1024) return `${Math.round(bytes / 1024)} KB`;
+	return `${bytes} B`;
+}
+/** How many to list before the report stops being readable. */
+const LIST_LIMIT = 20;
+/**
+* Which of the displaced sessions a run is about, and which of those to link.
+*
+* Pure, and separate from the printing, for two reasons. The obvious one is that
+* it can be tested without pointing a test at the developer's real
+* `~/.claude/projects` — an earlier draft of the test did exactly that and would
+* have relinked live files. The other is that the report and the action must
+* agree: `--json` originally restored everything in scope while the formatted
+* path skipped stubs, so the two modes did different things with the same flags.
+*/
+function selectTargets(everything, opts) {
+	const inScope = everything.filter((d) => {
+		if (opts.promised && d.promisedBy.length === 0) return false;
+		if (opts.cwd && d.cwd !== opts.cwd) return false;
+		return true;
+	});
+	return {
+		inScope,
+		toRestore: opts.includeStubs ? inScope : inScope.filter((d) => d.hasConversation)
+	};
+}
+function cmdRestore(opts = {}) {
+	const everything = findDisplaced();
+	for (const d of everything) d.promisedBy = findResumePromises(d.uuid, d.cwd);
+	const { inScope: displaced, toRestore } = selectTargets(everything, opts);
+	if (opts.json) {
+		console.log(JSON.stringify({
+			displaced,
+			wouldRestore: toRestore.map((d) => d.uuid),
+			executed: Boolean(opts.execute)
+		}, null, 2));
+		if (opts.execute) for (const d of toRestore) restoreTopLevel(d.uuid, d.projectDir);
+		return;
+	}
+	console.log();
+	console.log(bold$1("  Displaced session transcripts"));
+	console.log();
+	if (displaced.length === 0) {
+		if (everything.length > 0) {
+			console.log(ok$1(`  Nothing displaced in this scope.`));
+			console.log(dim$1(`  ${everything.length} displaced elsewhere — drop the filters to see them.`));
+		} else {
+			console.log(ok$1("  Nothing displaced — every archived transcript has its twin at the"));
+			console.log(dim$1("  project root, which is where claude --resume looks."));
+		}
+		console.log();
+		return;
+	}
+	const promised = displaced.filter((d) => d.promisedBy.length > 0);
+	const totalBytes = displaced.reduce((n, d) => n + d.bytes, 0);
+	console.log(warn$1(`  ${displaced.length} transcript(s), ${human(totalBytes)}, currently unresumable.`));
+	if (displaced.length !== everything.length) console.log(dim$1(`  (filtered from ${everything.length} machine-wide)`));
+	if (promised.length > 0) console.log(err(`  ${promised.length} named in a checkpoint that tells you to resume them — those lines are lies today.`));
+	const stubs = displaced.filter((d) => !d.hasConversation);
+	if (stubs.length > 0) console.log(dim$1(`  ${stubs.length} of them hold no conversation at all — restoring those changes nothing.`));
+	console.log();
+	const ordered = [...promised, ...displaced.filter((d) => d.promisedBy.length === 0)];
+	const shown = opts.all ? ordered : ordered.slice(0, LIST_LIMIT);
+	for (const d of shown) {
+		const where = d.cwd ?? dim$1(`(undecodable: ${d.encodedDir})`);
+		const stub = d.hasConversation ? "" : warn$1("  [stub — no conversation]");
+		console.log(`  ${bold$1(d.uuid.slice(0, 8))}  ${human(d.bytes).padStart(8)}  ${where}${stub}`);
+		for (const file of d.promisedBy) console.log(d.hasConversation ? err(`      promised by  ${file}`) : dim$1(`      promised by  ${file}  (promise cannot be kept: empty transcript)`));
+	}
+	if (shown.length < ordered.length) {
+		console.log();
+		console.log(dim$1(`  … and ${ordered.length - shown.length} more. --all lists every one.`));
+	}
+	console.log();
+	if (!opts.execute) {
+		console.log(dim$1("  Dry run — nothing was touched."));
+		console.log(dim$1("  Restore hardlinks each transcript back to the project root: same inode,"));
+		console.log(dim$1("  no copy, and the sessions/ archive is left exactly where it is."));
+		console.log();
+		console.log(dim$1("    --promised --execute   just the ones a checkpoint promises (start here)"));
+		console.log(dim$1("    --cwd <path> --execute one project"));
+		console.log(dim$1("    --execute              everything in scope"));
+		console.log();
+		return;
+	}
+	const target = toRestore;
+	const skipped = displaced.length - target.length;
+	let restored = 0;
+	const failed = [];
+	for (const d of target) if (restoreTopLevel(d.uuid, d.projectDir)) restored++;
+	else failed.push(d.uuid);
+	console.log(ok$1(`  Restored ${restored} of ${target.length} recoverable.`));
+	if (skipped > 0) console.log(dim$1(`  Skipped ${skipped} stub(s) — nothing in them to resume. --include-stubs overrides.`));
+	if (failed.length > 0) {
+		console.log(warn$1(`  Could not restore ${failed.length}:`));
+		for (const uuid of failed) console.log(dim$1(`    ${uuid}`));
+	}
+	console.log();
+}
+
 //#endregion
 //#region src/cli/commands/session/index.ts
 function registerSessionCommands(sessionCmd, getDb) {
 	sessionCmd.command("list").description("Resumable sessions catalog — named sessions with resume status.\nShort form: pai sessions\nDefault shows all sessions you've named or that are resumable.\nUse --all to also show unnamed orphan sessions.").option("-n <count>", "Maximum sessions to show (default: 20)", "20").option("--all", "Include unnamed orphan sessions (not in clc registry)").option("--json", "Output raw JSON instead of formatted table").action(async (opts) => {
 		await cmdRecent(getDb(), opts);
 	});
+	sessionCmd.command("restore").description("Restore transcripts PAI displaced into sessions/ so claude --resume can find them again. Reports what is unresumable, which checkpoints promise it, and which transcripts are empty. Dry run unless --execute is given.").option("--execute", "Actually restore (hardlink back to the project root)").option("--promised", "Only sessions a checkpoint tells you to resume").option("--cwd <path>", "Only sessions belonging to this working directory").option("--all", "List every displaced session, not just the largest few").option("--include-stubs", "Also restore transcripts that hold no conversation").option("--json", "Output raw JSON instead of a formatted report").action((opts) => {
+		cmdRestore(opts);
+	});
 	sessionCmd.command("info <project-slug> <number>").description("Show full details for a specific session").action((projectSlug, number) => {
 		cmdInfo(getDb(), projectSlug, number);
 	});
@@ -12804,181 +13069,6 @@ async function cmdFind(query, opts) {
 	console.log();
 }
 
-//#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.
-*/
-/**
-* Does a transcript for this session exist on disk?
-*
-* 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 `-`. Finished sessions
-* are moved into a `sessions/` subdirectory by the stop hook, so both are checked.
-*/
-function transcriptOnDisk(uuid, cwd) {
-	try {
-		const encoded = cwd.replace(/[^a-zA-Z0-9]/g, "-");
-		const dir = join(homedir(), ".claude", "projects", encoded);
-		if (!existsSync(dir)) return null;
-		return existsSync(join(dir, `${uuid}.jsonl`)) || existsSync(join(dir, "sessions", `${uuid}.jsonl`));
-	} 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.
-*/
-function probeResume(uuid, cwd) {
-	const onDisk = transcriptOnDisk(uuid, cwd);
-	if (onDisk === true) return { ok: true };
-	if (onDisk === false) return {
-		ok: false,
-		reason: "No transcript on disk for this UUID"
-	};
-	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:    claude --resume ${opts.resumableUuid} --print --output-format=json "_"`);
-			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/commands/pick.ts
 function getProjects(db, includeArchived) {
@@ -13491,4 +13581,4 @@ async function cmdPick(db, opts = {}) {
 
 //#endregion
 export { registerProjectsCommands as A, registerRestoreCommands as C, registerIdentityCommands as D, registerMcpCommands as E, resolveIdentifier as M, registerMemoryCommands as O, registerSetupCommand as S, registerDaemonCommands as T, registerUpdateCommand as _, cmdEnd as a, registerZettelCommands as b, cmdGoto as c, registerHelpCommand as d, registerDbCommands as f, registerNotifyCommands as g, registerTaskCommands as h, cmdPauseAll as i, findMovedPath as j, registerRegistryCommands as k, cmdPause as l, registerTopicCommands as m, cmdFind as n, registerSessionCleanupCommand as o, registerKgCommands as p, cmdClearNames as r, registerSessionCommands as s, cmdPick as t, cmdList as u, registerSkillCommands as v, registerBackupCommands as w, registerObsidianCommands as x, registerObservationCommands as y };
-//# sourceMappingURL=pick-BcmBBfOF.mjs.map
+//# sourceMappingURL=pick-Bmz718uo.mjs.map