@generativereality/cctabs 0.2.0 → 0.3.1

package/dist/index.js

@@ -2,15 +2,16 @@
 import updateNotifier from "update-notifier";
 import { cli, define } from "gunshi";
 import { createConnection } from "net";
-import { execFileSync, spawnSync } from "child_process";
+import { execFileSync, spawn, spawnSync } from "child_process";
 import { randomUUID } from "crypto";
-import { homedir, tmpdir } from "os";
+import { homedir, platform, tmpdir } from "os";
 import { basename, dirname, extname, join, resolve } from "path";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
 import { consola } from "consola";
-import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import * as p from "@clack/prompts";
 //#region package.json
 var name = "@generativereality/cctabs";
-var version = "0.2.0";
+var version = "0.3.1";
 var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
 var package_default = {
 	name,
@@ -31,6 +32,8 @@ var package_default = {
 		"check": "npm run typecheck && npm run build",
 		"release": "bumpp && npm publish",
 		"sync-plugin": "bash scripts/sync-plugin.sh",
+		"build:tabby-plugin": "cd tabby-plugin && npm install && npm run build",
+		"publish:tabby-plugin": "cd tabby-plugin && npm publish --access public",
 		"prepack": "bash scripts/sync-plugin.sh --check && npm run build"
 	},
 	keywords: [
@@ -70,9 +73,10 @@ var package_default = {
 //#endregion
 //#region src/core/terminal.ts
 function detectTerminal() {
-	if (process.env.WAVETERM_JWT) return "wave";
 	const prog = process.env.TERM_PROGRAM ?? "";
 	const term = process.env.TERM ?? "";
+	if (prog === "Tabby") return "tabby";
+	if (process.env.WAVETERM_JWT) return "wave";
 	if (prog === "iTerm.app") return "iterm2";
 	if (prog === "ghostty" || process.env.GHOSTTY_RESOURCES_DIR) return "ghostty";
 	if (prog === "WarpTerminal") return "warp";
@@ -85,6 +89,7 @@ function detectTerminal() {
 }
 const TERMINAL_NAMES = {
 	wave: "Wave Terminal",
+	tabby: "Tabby",
 	iterm2: "iTerm2",
 	ghostty: "Ghostty",
 	warp: "Warp",
@@ -123,7 +128,89 @@ function adapterFileName(terminal) {
 	return `${terminal}.ts`;
 }
 //#endregion
+//#region src/core/wave-db.ts
+const WAVE_DB_PATH = process.env.CCTABS_WAVE_DB_PATH ?? join(homedir(), "Library", "Application Support", "waveterm", "db", "waveterm.db");
+const WSH_ORPHAN_TABID_PATTERN = /couldn't list blocks for workspace [0-9a-f-]+: not found/i;
+function sqliteRun(query, mode = "list") {
+	return execFileSync("sqlite3", [
+		"-readonly",
+		"-bail",
+		`-${mode}`,
+		WAVE_DB_PATH,
+		query
+	], { encoding: "utf-8" }).trim();
+}
+/** Inspect every workspace; report any tabids that point at non-existent rows in db_tab. */
+function findOrphanTabIds() {
+	if (!existsSync(WAVE_DB_PATH)) return [];
+	const rawWs = sqliteRun("SELECT oid AS oid, json_extract(data, '$.name') AS name, json_extract(data, '$.tabids') AS tabids FROM db_workspace;", "json");
+	const tabRows = sqliteRun("SELECT oid FROM db_tab;", "list");
+	const liveTabs = new Set(tabRows.split("\n").map((s) => s.trim()).filter(Boolean));
+	const wsRows = rawWs ? JSON.parse(rawWs) : [];
+	const reports = [];
+	for (const row of wsRows) {
+		if (!row.tabids) continue;
+		let tabids;
+		try {
+			tabids = JSON.parse(row.tabids);
+		} catch {
+			continue;
+		}
+		if (!Array.isArray(tabids)) continue;
+		const present = [];
+		const orphans = [];
+		for (const t of tabids) {
+			if (typeof t !== "string") continue;
+			if (liveTabs.has(t)) present.push(t);
+			else orphans.push(t);
+		}
+		if (orphans.length) reports.push({
+			workspaceId: row.oid,
+			workspaceName: row.name || row.oid.slice(0, 8),
+			presentTabIds: present,
+			orphanTabIds: orphans
+		});
+	}
+	return reports;
+}
+/** Copy the live DB to a timestamped backup next to it. Returns the backup path. */
+function backupWaveDb() {
+	const dest = `${WAVE_DB_PATH}.cctabs-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
+	copyFileSync(WAVE_DB_PATH, dest);
+	return dest;
+}
+/** Surgically strip orphan tabids from a workspace's tabids array.
+*
+* SQLite's json_remove evaluates each path against the *previous* result, so
+* we delete by descending index — that way each removal doesn't shift later
+* indices out from under us.
+*/
+function removeOrphanTabIds(report) {
+	if (!report.orphanTabIds.length) return;
+	const r = spawnSync("sqlite3", [WAVE_DB_PATH, `UPDATE db_workspace SET data = json_set(data, '$.tabids', json('${JSON.stringify(report.presentTabIds).replace(/'/g, "''")}')) WHERE oid = '${report.workspaceId}';`], { encoding: "utf-8" });
+	if (r.status !== 0) throw new Error(`sqlite3 update failed (status ${r.status}): ${r.stderr?.trim() || "unknown error"}`);
+}
+//#endregion
 //#region src/core/wave.ts
+var WaveOrphanTabidError = class extends Error {
+	reports;
+	wshStderr;
+	constructor(reports, wshStderr) {
+		const lines = [
+			"Wave Terminal's block listing aborted: a workspace's tabids list references a tab that no longer exists in db_tab.",
+			"wsh stderr: " + wshStderr.trim(),
+			"",
+			"Affected workspaces:",
+			...reports.map((r) => `  • "${r.workspaceName}" [${r.workspaceId.slice(0, 8)}] — ${r.orphanTabIds.length} orphan tabid(s): ${r.orphanTabIds.map((t) => t.slice(0, 8)).join(", ")}`),
+			"",
+			"Run `cctabs doctor` to back up the Wave DB and apply the fix."
+		];
+		super(lines.join("\n"));
+		this.name = "WaveOrphanTabidError";
+		this.reports = reports;
+		this.wshStderr = wshStderr;
+	}
+};
 const SOCK_PATH = join(homedir(), "Library", "Application Support", "waveterm", "wave.sock");
 var WaveSocket = class {
 	socket;
@@ -198,6 +285,7 @@ var WaveSocket = class {
 var WaveAdapter = class {
 	socket = null;
 	jwt;
+	lastBlocksListStderr = "";
 	constructor() {
 		this.jwt = process.env.WAVETERM_JWT ?? "";
 	}
@@ -211,13 +299,27 @@ var WaveAdapter = class {
 			"15000"
 		];
 		if (wsId) args.push("--workspace", wsId);
+		const r = spawnSync("wsh", args, { encoding: "utf-8" });
+		this.lastBlocksListStderr = r.stderr ?? "";
+		if (r.status !== 0 || !r.stdout?.trim()) return [];
 		try {
-			const out = execFileSync("wsh", args, { encoding: "utf-8" });
-			return JSON.parse(out);
+			return JSON.parse(r.stdout);
 		} catch {
 			return [];
 		}
 	}
+	/** If the most recent blocksList() looked like it hit Wave's orphan-tabid
+	* abort, run a sqlite3 self-check to confirm. Returns reports when orphans
+	* are found, otherwise null. */
+	diagnoseOrphanTabids() {
+		const stderr = this.lastBlocksListStderr;
+		if (!stderr || !WSH_ORPHAN_TABID_PATTERN.test(stderr)) return null;
+		const reports = findOrphanTabIds();
+		return reports.length ? reports : null;
+	}
+	getLastBlocksListStderr() {
+		return this.lastBlocksListStderr;
+	}
 	scrollback(blockId, lastN = 50) {
 		return spawnSync("wsh", [
 			"termscrollback",
@@ -233,7 +335,7 @@ var WaveAdapter = class {
 	async confirmScrollbackEmpty(blockId, attempts = 3, intervalMs = 500) {
 		for (let i = 0; i < attempts; i++) {
 			if (this.scrollback(blockId, 10).trim()) return false;
-			if (i < attempts - 1) await sleep(intervalMs);
+			if (i < attempts - 1) await sleep$1(intervalMs);
 		}
 		return true;
 	}
@@ -263,7 +365,7 @@ var WaveAdapter = class {
 	async newTab(focusWindowId) {
 		if (focusWindowId) {
 			await this.focusWindow(focusWindowId);
-			await sleep(300);
+			await sleep$1(300);
 		}
 		const r = spawnSync("osascript", ["-e", [
 			"tell application \"Wave\" to activate",
@@ -279,7 +381,7 @@ var WaveAdapter = class {
 	async waitForNewBlock(beforeIds, timeoutMs = 15e3) {
 		const deadline = Date.now() + timeoutMs;
 		while (Date.now() < deadline) {
-			await sleep(250);
+			await sleep$1(250);
 			for (const b of this.blocksList()) if (b.view === "term" && !beforeIds.has(b.blockid)) return {
 				blockId: b.blockid,
 				tabId: b.tabid
@@ -321,6 +423,13 @@ var WaveAdapter = class {
 	}
 	async getAllData() {
 		const blocks = this.blocksList();
+		if (!blocks.length) {
+			const orphans = this.diagnoseOrphanTabids();
+			if (orphans) {
+				this.closeSocket();
+				throw new WaveOrphanTabidError(orphans, this.lastBlocksListStderr);
+			}
+		}
 		const tabsById = /* @__PURE__ */ new Map();
 		for (const b of blocks) {
 			const arr = tabsById.get(b.tabid) ?? [];
@@ -379,6 +488,15 @@ var WaveAdapter = class {
 	resolveBlock(query, blocks) {
 		return blocks.filter((b) => b.blockid.startsWith(query));
 	}
+	currentTabId() {
+		return process.env.WAVETERM_TABID ?? "";
+	}
+	currentBlockId() {
+		return process.env.WAVETERM_BLOCKID ?? "";
+	}
+	currentWorkspaceId() {
+		return process.env.WAVETERM_WORKSPACEID ?? "";
+	}
 	resolveWorkspace(workspaces, query) {
 		const q = query.toLowerCase();
 		const exact = workspaces.filter(({ workspacedata: wd }) => (wd.name ?? "").toLowerCase() === q);
@@ -391,27 +509,609 @@ var WaveAdapter = class {
 		}));
 	}
 };
-function requireWaveAdapter() {
-	if (!process.env.WAVETERM_JWT) {
-		printUnsupportedTerminalError(detectTerminal());
-		process.exit(1);
-	}
-	return new WaveAdapter();
+function sleep$1(ms) {
+	return new Promise((r) => setTimeout(r, ms));
 }
+//#endregion
+//#region src/core/tabby.ts
+/**
+* Thrown when the cctabs Tabby plugin's HTTP API is unreachable.
+*
+* Failing loud here matters: if we silently returned empty data the
+* caller would conclude "no tabs" and act on it. The CLI's outer error
+* handler renders this with the install hint.
+*/
+var TabbyPluginUnreachableError = class extends Error {
+	constructor(host, port, underlying) {
+		const lines = [
+			`cctabs Tabby plugin not reachable at http://${host}:${port}.`,
+			underlying ? `  reason: ${underlying}` : "",
+			"",
+			"Install + restart Tabby in one shot from inside a Tabby tab:",
+			"  cctabs install-tabby-plugin",
+			"",
+			"Or do it by hand:",
+			`  npm install --legacy-peer-deps --prefix "$HOME/Library/Application Support/tabby/plugins" tabby-cctabs`,
+			"  # then quit Tabby (Cmd+Q) and reopen it.",
+			"",
+			"Verify with: cctabs doctor"
+		].filter(Boolean);
+		super(lines.join("\n"));
+		this.host = host;
+		this.port = port;
+		this.underlying = underlying;
+		this.name = "TabbyPluginUnreachableError";
+	}
+};
+/**
+* cctabs adapter for Tabby Terminal. Talks to the tabby-cctabs
+* plugin's HTTP API (default 127.0.0.1:3300).
+*
+* Tab identity: cctabs (running inside a Tabby tab) walks its own
+* process.pid → ppid chain via `ps`, POSTs the PID list to
+* /api/tabs/identify, and caches the resulting plugin UUID.
+*
+* In Tabby's data model there are no Wave-style "workspaces" or "blocks";
+* we project a single synthetic workspace and a 1:1 tab↔block mapping so
+* the rest of cctabs sees the same shape it does on Wave.
+*/
+var TabbyAdapter = class {
+	host;
+	port;
+	cachedSelfUuid = null;
+	healthChecked = false;
+	constructor() {
+		this.host = process.env.CCTABS_TABBY_HOST ?? "127.0.0.1";
+		this.port = Number(process.env.CCTABS_TABBY_PORT ?? "3300");
+	}
+	/**
+	* One-shot health check. Throws TabbyPluginUnreachableError on the
+	* first call if /api/health is unreachable. Subsequent calls are no-ops
+	* — once we've confirmed the plugin is up, we trust it for this process.
+	*/
+	ensureHealthy() {
+		if (this.healthChecked) return;
+		const r = spawnSync("curl", [
+			"-fsS",
+			"--max-time",
+			"3",
+			this.url("/api/health")
+		], { encoding: "utf-8" });
+		if (r.status !== 0 || !r.stdout) {
+			const reason = (r.stderr || "").trim() || `curl exit ${r.status}`;
+			throw new TabbyPluginUnreachableError(this.host, this.port, reason);
+		}
+		this.healthChecked = true;
+	}
+	url(path) {
+		return `http://${this.host}:${this.port}${path}`;
+	}
+	async http(method, path, body) {
+		const res = await fetch(this.url(path), {
+			method,
+			headers: body ? { "content-type": "application/json" } : void 0,
+			body: body ? JSON.stringify(body) : void 0
+		});
+		if (res.status === 404) return null;
+		if (!res.ok) throw new Error(`Tabby plugin ${method} ${path} failed: ${res.status}`);
+		return res.json();
+	}
+	closeSocket() {}
+	blocksList() {
+		this.ensureHealthy();
+		const out = spawnSync("curl", [
+			"-fsS",
+			"--max-time",
+			"5",
+			this.url("/api/tabs")
+		], { encoding: "utf-8" });
+		if (out.status !== 0 || !out.stdout) return [];
+		let parsed;
+		try {
+			parsed = JSON.parse(out.stdout);
+		} catch {
+			return [];
+		}
+		return parsed.tabs.filter((t) => t.type === "terminal").map((t) => ({
+			blockid: t.uuid,
+			tabid: t.uuid,
+			view: "term",
+			meta: t.cwd ? { "cmd:cwd": t.cwd } : void 0
+		}));
+	}
+	scrollback(blockId, lastN = 50) {
+		const out = spawnSync("curl", [
+			"-fsS",
+			"--max-time",
+			"5",
+			this.url(`/api/tabs/${blockId}/buffer?lines=${lastN}`)
+		], { encoding: "utf-8" });
+		if (out.status !== 0 || !out.stdout) return "";
+		try {
+			return JSON.parse(out.stdout).lines.join("\n");
+		} catch {
+			return "";
+		}
+	}
+	async confirmScrollbackEmpty(blockId, attempts = 3, intervalMs = 500) {
+		for (let i = 0; i < attempts; i++) {
+			if (this.scrollback(blockId, 10).trim()) return false;
+			if (i < attempts - 1) await sleep(intervalMs);
+		}
+		return true;
+	}
+	detectSessionStatus(blockId) {
+		const tail = this.scrollback(blockId, 200);
+		if (!tail.trim()) return "unknown";
+		const lastLine = tail.split("\n").map((l) => l.trim()).filter(Boolean).at(-1) ?? "";
+		if (/[$%>]\s*$/.test(lastLine) && !lastLine.includes("claude")) return "terminal";
+		const compact = tail.replace(/\s+/g, "");
+		if ([
+			"Claude Code",
+			"claude.ai/code",
+			"⏵⏵ bypass",
+			"⏵⏵ auto",
+			"Thinking",
+			"Hatching",
+			"Composing",
+			"Cogitating",
+			"Befuddling",
+			"Worked for",
+			"Baked for",
+			"Churned for",
+			"Cooked for",
+			"high effort"
+		].some((m) => compact.includes(m.replace(/\s+/g, "")))) return "active";
+		if (/[✻✽✶✳✢]/.test(tail)) return "active";
+		if (lastLine.toLowerCase().includes("claude")) return "idle";
+		return "terminal";
+	}
+	deleteBlock(blockId) {
+		spawnSync("curl", [
+			"-fsS",
+			"-X",
+			"POST",
+			"--max-time",
+			"5",
+			this.url(`/api/tabs/${blockId}/close`)
+		], { encoding: "utf-8" });
+	}
+	async newTab(_focusWindowId) {
+		const r = await this.http("POST", "/api/tabs/new", {});
+		return Boolean(r);
+	}
+	async waitForNewBlock(beforeIds, timeoutMs = 15e3) {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			await sleep(250);
+			for (const b of this.blocksList()) if (!beforeIds.has(b.blockid)) return {
+				blockId: b.blockid,
+				tabId: b.tabid
+			};
+		}
+		return null;
+	}
+	async renameTab(tabId, name) {
+		await this.http("PUT", `/api/tabs/${tabId}/title`, { title: name });
+	}
+	async sendInput(blockId, text) {
+		return this.http("POST", `/api/tabs/${blockId}/send`, { data: text });
+	}
+	async getAllData() {
+		const blocks = this.blocksList();
+		const tabsById = /* @__PURE__ */ new Map();
+		for (const b of blocks) {
+			const arr = tabsById.get(b.tabid) ?? [];
+			arr.push(b);
+			tabsById.set(b.tabid, arr);
+		}
+		const tabNames = /* @__PURE__ */ new Map();
+		try {
+			const res = await fetch(this.url("/api/tabs"));
+			if (res.ok) {
+				const data = await res.json();
+				for (const t of data.tabs) tabNames.set(t.uuid, t.customTitle || t.title || t.uuid.slice(0, 8));
+			}
+		} catch {}
+		return {
+			blocks,
+			tabsById,
+			workspaces: [{
+				workspacedata: {
+					oid: "tabby",
+					name: "tabby",
+					tabids: [...tabsById.keys()]
+				},
+				windowid: ""
+			}],
+			tabNames
+		};
+	}
+	resolveTab(query, tabsById, tabNames) {
+		const q = query.toLowerCase();
+		if (query === "." || query === "self") {
+			const self = this.identifySelf();
+			return self ? [self] : [];
+		}
+		const ids = [...tabsById.keys()];
+		const exact = ids.filter((tid) => (tabNames.get(tid) ?? "").toLowerCase() === q);
+		if (exact.length > 0) return exact;
+		return ids.filter((tid) => {
+			const name = tabNames.get(tid) ?? "";
+			return tid.startsWith(query) || name.toLowerCase().startsWith(q);
+		});
+	}
+	resolveBlock(query, blocks) {
+		return blocks.filter((b) => b.blockid.startsWith(query));
+	}
+	resolveWorkspace(workspaces, _query) {
+		return workspaces.map((w) => ({
+			data: w.workspacedata,
+			windowId: w.windowid
+		}));
+	}
+	currentTabId() {
+		return this.identifySelf() ?? "";
+	}
+	currentBlockId() {
+		return this.currentTabId();
+	}
+	currentWorkspaceId() {
+		return "tabby";
+	}
+	/**
+	* Walk the process tree from `process.pid` upwards collecting PIDs, then
+	* ask the plugin which tab owns any of them. Result is cached for the
+	* lifetime of this adapter.
+	*/
+	identifySelf() {
+		if (this.cachedSelfUuid !== null) return this.cachedSelfUuid;
+		const pids = walkAncestorPids(process.pid);
+		const out = spawnSync("curl", [
+			"-fsS",
+			"-X",
+			"POST",
+			"-H",
+			"content-type: application/json",
+			"--max-time",
+			"5",
+			"--data",
+			JSON.stringify({ pids }),
+			this.url("/api/tabs/identify")
+		], { encoding: "utf-8" });
+		if (out.status !== 0 || !out.stdout) {
+			this.cachedSelfUuid = "";
+			return null;
+		}
+		try {
+			const parsed = JSON.parse(out.stdout);
+			this.cachedSelfUuid = parsed.uuid ?? "";
+			return parsed.uuid ?? null;
+		} catch {
+			this.cachedSelfUuid = "";
+			return null;
+		}
+	}
+};
 function sleep(ms) {
 	return new Promise((r) => setTimeout(r, ms));
 }
+/**
+* Walk `pid → ppid → ...` via `ps`. Caps at 32 levels to avoid pathological
+* loops on misconfigured systems. Returns [pid, ppid, gppid, ...].
+*/
+function walkAncestorPids(startPid, cap = 32) {
+	const out = [startPid];
+	let cur = startPid;
+	for (let i = 0; i < cap; i++) {
+		const r = spawnSync("ps", [
+			"-o",
+			"ppid=",
+			"-p",
+			String(cur)
+		], { encoding: "utf-8" });
+		if (r.status !== 0) break;
+		const next = parseInt(r.stdout.trim(), 10);
+		if (!Number.isFinite(next) || next <= 1 || next === cur) break;
+		out.push(next);
+		cur = next;
+	}
+	return out;
+}
+//#endregion
+//#region src/core/adapter.ts
+/** Returns the adapter that matches the running terminal. Exits with a clear
+* error message if none is supported. */
+function requireAdapter() {
+	const terminal = detectTerminal();
+	if (terminal === "wave") return new WaveAdapter();
+	if (terminal === "tabby") return new TabbyAdapter();
+	printUnsupportedTerminalError(terminal);
+	process.exit(1);
+}
+//#endregion
+//#region src/core/session.ts
+/** Convert an absolute path to Claude Code's project slug.
+* Claude Code replaces any non-alphanumeric character (spaces, /, ., etc.) with '-'.
+* Hyphens are preserved. Example: "/Users/me/Remember This" → "-Users-me-Remember-This". */
+function pathToProjectSlug(dir) {
+	return resolve(dir).replace(/[^A-Za-z0-9-]/g, "-");
+}
+/** Find the most recent .jsonl session file in a Claude project directory */
+function latestJsonlIn(projectDir) {
+	if (!existsSync(projectDir)) return null;
+	const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl").map((f) => ({
+		name: f,
+		mtime: statSync(join(projectDir, f)).mtimeMs
+	})).sort((a, b) => b.mtime - a.mtime);
+	return files.length ? basename(files[0].name, ".jsonl") : null;
+}
+/**
+* Find the most recent Claude Code session ID for a directory.
+* Also checks worktree subdirectories (.claude/worktrees/*) since tabs
+* opened with --worktree run from a worktree path, not the repo root.
+*/
+function findLatestSessionId(dir) {
+	const projectsRoot = join(homedir(), ".claude", "projects");
+	const direct = latestJsonlIn(join(projectsRoot, pathToProjectSlug(dir)));
+	if (direct) return direct;
+	const worktreesDir = join(dir, ".claude", "worktrees");
+	if (existsSync(worktreesDir)) {
+		const candidates = [];
+		for (const entry of readdirSync(worktreesDir)) {
+			const projectDir = join(projectsRoot, pathToProjectSlug(join(worktreesDir, entry)));
+			const id = latestJsonlIn(projectDir);
+			if (id) {
+				const mtime = statSync(join(projectDir, id + ".jsonl")).mtimeMs;
+				candidates.push({
+					id,
+					mtime
+				});
+			}
+		}
+		if (candidates.length) {
+			candidates.sort((a, b) => b.mtime - a.mtime);
+			return candidates[0].id;
+		}
+	}
+	return null;
+}
+/**
+* Find all sessions with a given custom title (--name).
+* Returns them sorted by most recent first, with the first user prompt for context.
+*/
+function findSessionsByName(dir, name) {
+	const projectDir = join(join(homedir(), ".claude", "projects"), pathToProjectSlug(dir));
+	if (!existsSync(projectDir)) return [];
+	const matches = [];
+	const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
+	for (const f of files) {
+		const fullPath = join(projectDir, f);
+		try {
+			const lines = readFileSync(fullPath, "utf-8").split("\n");
+			let currentTitle = "";
+			let firstPrompt = "";
+			let lastActivity = "";
+			for (const line of lines) {
+				if (!line.trim()) continue;
+				try {
+					const entry = JSON.parse(line);
+					if (entry.customTitle !== void 0) currentTitle = entry.customTitle;
+					if (!firstPrompt && entry.type === "user" && entry.message?.content) {
+						const text = typeof entry.message.content === "string" ? entry.message.content : entry.message.content.find((c) => c.type === "text")?.text ?? "";
+						if (text.startsWith("<")) continue;
+						firstPrompt = text.slice(0, 120).replace(/\n/g, " ").trim();
+						if (text.length > 120) firstPrompt += "…";
+					}
+					if (entry.message?.role === "assistant" && entry.message?.content) {
+						const parts = Array.isArray(entry.message.content) ? entry.message.content : [{
+							type: "text",
+							text: entry.message.content
+						}];
+						for (const p of parts) if (p.type === "text" && p.text?.trim()) {
+							lastActivity = p.text.slice(0, 120).replace(/\n/g, " ").trim();
+							if (p.text.length > 120) lastActivity += "…";
+						}
+					}
+				} catch {}
+			}
+			if (currentTitle !== name) continue;
+			const stat = statSync(fullPath);
+			matches.push({
+				id: basename(f, ".jsonl"),
+				mtime: stat.mtimeMs,
+				size: stat.size,
+				firstPrompt,
+				lastActivity
+			});
+		} catch {}
+	}
+	return matches.sort((a, b) => b.mtime - a.mtime);
+}
+/**
+* Like findSessionsByName, but searches every project directory under
+* ~/.claude/projects. Each match carries the cwd recorded in the session.
+* Used by `cctabs restore` so callers don't have to guess the right dir.
+*/
+function findSessionsByNameGlobally(name) {
+	const projectsRoot = join(homedir(), ".claude", "projects");
+	if (!existsSync(projectsRoot)) return [];
+	const matches = [];
+	for (const slug of readdirSync(projectsRoot)) {
+		const projectDir = join(projectsRoot, slug);
+		let isDir = false;
+		try {
+			isDir = statSync(projectDir).isDirectory();
+		} catch {
+			continue;
+		}
+		if (!isDir) continue;
+		const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
+		for (const f of files) {
+			const fullPath = join(projectDir, f);
+			try {
+				const lines = readFileSync(fullPath, "utf-8").split("\n");
+				let currentTitle = "";
+				let cwd = "";
+				let firstPrompt = "";
+				let lastActivity = "";
+				for (const line of lines) {
+					if (!line.trim()) continue;
+					try {
+						const entry = JSON.parse(line);
+						if (entry.customTitle !== void 0) currentTitle = entry.customTitle;
+						if (!cwd && typeof entry.cwd === "string") cwd = entry.cwd;
+						if (!firstPrompt && entry.type === "user" && entry.message?.content) {
+							const text = typeof entry.message.content === "string" ? entry.message.content : entry.message.content.find((c) => c.type === "text")?.text ?? "";
+							if (text.startsWith("<")) continue;
+							firstPrompt = text.slice(0, 120).replace(/\n/g, " ").trim();
+							if (text.length > 120) firstPrompt += "…";
+						}
+						if (entry.message?.role === "assistant" && entry.message?.content) {
+							const parts = Array.isArray(entry.message.content) ? entry.message.content : [{
+								type: "text",
+								text: entry.message.content
+							}];
+							for (const p of parts) if (p.type === "text" && p.text?.trim()) {
+								lastActivity = p.text.slice(0, 120).replace(/\n/g, " ").trim();
+								if (p.text.length > 120) lastActivity += "…";
+							}
+						}
+					} catch {}
+				}
+				if (currentTitle !== name || !cwd) continue;
+				const stat = statSync(fullPath);
+				matches.push({
+					id: basename(f, ".jsonl"),
+					mtime: stat.mtimeMs,
+					size: stat.size,
+					firstPrompt,
+					lastActivity,
+					dir: cwd
+				});
+			} catch {}
+		}
+	}
+	return matches.sort((a, b) => b.mtime - a.mtime);
+}
+/**
+* List all unique session names (customTitle) in a project directory.
+* Used to show available names when a resume lookup fails.
+*/
+function listSessionNames(dir) {
+	const projectDir = join(join(homedir(), ".claude", "projects"), pathToProjectSlug(dir));
+	if (!existsSync(projectDir)) return [];
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
+	for (const f of files) {
+		const fullPath = join(projectDir, f);
+		try {
+			const firstLine = readFileSync(fullPath, "utf-8").split("\n")[0];
+			if (!firstLine) continue;
+			const title = JSON.parse(firstLine).customTitle;
+			if (!title || seen.has(title)) continue;
+			seen.add(title);
+			const stat = statSync(fullPath);
+			results.push({
+				name: title,
+				id: basename(f, ".jsonl"),
+				mtime: stat.mtimeMs
+			});
+		} catch {}
+	}
+	return results.sort((a, b) => b.mtime - a.mtime);
+}
+/**
+* Resolve a session ID prefix (e.g. "19aae7b4") to the full UUID by scanning
+* `~/.claude/projects/`. Returns the input unchanged if it already looks like
+* a full UUID, or null if no unique match exists. Pass `dir` to scope the
+* search to one project; otherwise every project is checked.
+*
+* `claude --resume <prefix>` does NOT accept truncated IDs — it treats them
+* as a search query and shows the picker. So callers must expand prefixes
+* before forwarding to claude.
+*/
+function expandSessionId(input, dir) {
+	if (!input) return null;
+	if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(input)) return input;
+	const projectsRoot = join(homedir(), ".claude", "projects");
+	if (!existsSync(projectsRoot)) return null;
+	const projectDirs = dir ? [join(projectsRoot, pathToProjectSlug(dir))] : readdirSync(projectsRoot).map((d) => join(projectsRoot, d)).filter((p) => {
+		try {
+			return statSync(p).isDirectory();
+		} catch {
+			return false;
+		}
+	});
+	const matches = [];
+	for (const pd of projectDirs) {
+		if (!existsSync(pd)) continue;
+		for (const f of readdirSync(pd)) {
+			if (extname(f) !== ".jsonl") continue;
+			const id = basename(f, ".jsonl");
+			if (id.startsWith(input) && !matches.includes(id)) matches.push(id);
+		}
+	}
+	return matches.length === 1 ? matches[0] : null;
+}
 //#endregion
 //#region src/commands/sessions.ts
 const sessionsCommand = define({
 	name: "sessions",
 	description: "List tabs with active/idle session status",
-	args: {},
-	async run() {
-		const adapter = requireWaveAdapter();
+	args: { json: {
+		type: "boolean",
+		short: "j",
+		description: "Emit machine-readable JSON. Output can be piped to `cctabs restore --manifest -` on another machine."
+	} },
+	async run(ctx) {
+		const adapter = requireAdapter();
 		const { tabsById, workspaces, tabNames } = await adapter.getAllData();
-		const currentTab = process.env.WAVETERM_TABID ?? "";
-		const currentWs = process.env.WAVETERM_WORKSPACEID ?? "";
+		const currentTab = adapter.currentTabId();
+		const currentWs = adapter.currentWorkspaceId();
+		if (ctx.values.json ?? false) {
+			const out = { workspaces: [] };
+			for (const wsp of workspaces) {
+				const { oid, name: wsName, tabids } = wsp.workspacedata;
+				const tabIds = tabids.filter((t) => tabsById.has(t));
+				if (!tabIds.length) continue;
+				const wsRow = {
+					id: oid,
+					name: wsName,
+					current: oid === currentWs,
+					sessions: []
+				};
+				for (const tabId of tabIds) {
+					const termBlocks = (tabsById.get(tabId) ?? []).filter((b) => b.view === "term");
+					if (!termBlocks.length) continue;
+					const tabName = tabNames.get(tabId) ?? tabId.slice(0, 8);
+					const b = termBlocks[0];
+					const cwd = b.meta?.["cmd:cwd"] ?? "";
+					const status = adapter.detectSessionStatus(b.blockid);
+					const lastLine = adapter.scrollback(b.blockid, 5).split("\n").map((l) => l.trim()).filter(Boolean).at(-1) ?? "";
+					let sessionId = null;
+					if (cwd) try {
+						const matches = findSessionsByName(cwd, tabName);
+						if (matches.length) sessionId = matches[0].id;
+					} catch {}
+					wsRow.sessions.push({
+						block_id: b.blockid,
+						tab_id: tabId,
+						name: tabName,
+						cwd,
+						current: tabId === currentTab,
+						status,
+						last_line: lastLine.slice(0, 200),
+						session_id: sessionId
+					});
+				}
+				out.workspaces.push(wsRow);
+			}
+			adapter.closeSocket?.();
+			console.log(JSON.stringify(out, null, 2));
+			return;
+		}
 		console.log("Sessions");
 		console.log("=".repeat(50));
 		for (const wsp of workspaces) {
@@ -446,10 +1146,11 @@ const listCommand = define({
 	description: "List all workspaces, tabs, and blocks",
 	args: {},
 	async run() {
-		const { tabsById, workspaces, tabNames } = await requireWaveAdapter().getAllData();
-		const currentBlock = process.env.WAVETERM_BLOCKID ?? "";
-		const currentTab = process.env.WAVETERM_TABID ?? "";
-		const currentWs = process.env.WAVETERM_WORKSPACEID ?? "";
+		const adapter = requireAdapter();
+		const { tabsById, workspaces, tabNames } = await adapter.getAllData();
+		const currentBlock = adapter.currentBlockId();
+		const currentTab = adapter.currentTabId();
+		const currentWs = adapter.currentWorkspaceId();
 		for (const wsp of workspaces) {
 			const { oid, name, tabids } = wsp.workspacedata;
 			const noWindow = !wsp.windowid ? "  (no window)" : "";
@@ -566,7 +1267,7 @@ async function openSession(opts) {
 		process.exit(1);
 	}
 	const config = loadConfig();
-	const adapter = requireWaveAdapter();
+	const adapter = requireAdapter();
 	let focusWindowId;
 	if (workspaceQuery) {
 		const { workspaces } = await adapter.getAllData();
@@ -828,6 +1529,11 @@ const newCommand = define({
 			short: "p",
 			description: "Send initial prompt text once Claude is ready"
 		},
+		resume: {
+			type: "string",
+			short: "r",
+			description: "Resume an existing Claude session ID (passes --resume <id> to claude). Mutually exclusive with --prompt/--file."
+		},
 		backend: {
 			type: "string",
 			short: "b",
@@ -846,12 +1552,31 @@ const newCommand = define({
 		const useWorktree = ctx.values.worktree ?? false;
 		const promptFile = ctx.values.file;
 		const promptText = ctx.values.prompt;
+		const resumeId = ctx.values.resume;
 		const backendName = ctx.values.backend;
 		const modelOverride = ctx.values.model;
 		if (!name) {
 			consola.error("Tab name is required");
 			process.exit(1);
 		}
+		if (resumeId && (promptText || promptFile)) {
+			consola.error("--resume cannot be combined with --prompt or --file (you cannot send an initial prompt to a resumed session via this path).");
+			process.exit(1);
+		}
+		let resolvedSessionId;
+		if (resumeId) {
+			const absDir = resolve(dir.replace(/^~/, homedir()));
+			const expanded = expandSessionId(resumeId, absDir) ?? expandSessionId(resumeId);
+			if (expanded) resolvedSessionId = expanded;
+			else {
+				const slug = pathToProjectSlug(absDir);
+				if (existsSync(join(homedir(), ".claude", "projects", slug, `${resumeId}.jsonl`))) resolvedSessionId = resumeId;
+				else {
+					consola.warn(`Session ID "${resumeId}" not found in ~/.claude/projects/ — proceeding anyway (claude will error if invalid).`);
+					resolvedSessionId = resumeId;
+				}
+			}
+		}
 		let envVars;
 		let resolvedModel = modelOverride;
 		if (backendName) {
@@ -860,255 +1585,35 @@ const newCommand = define({
 				consola.error(`Unknown backend "${backendName}". Available:`);
 				for (const b of listBackends()) consola.log(`  ${b.name.padEnd(22)} ${b.description}`);
 				process.exit(1);
-			}
-			envVars = backend.env;
-			resolvedModel ??= backend.model || void 0;
-		}
-		let initialPromptFile;
-		if (promptText) {
-			initialPromptFile = join(tmpdir(), `cctabs-prompt-${Date.now()}.txt`);
-			writeFileSync(initialPromptFile, promptText);
-		} else if (promptFile) initialPromptFile = promptFile;
-		const tabId = await openSession({
-			tabName: name,
-			dir,
-			claudeCmd: useWorktree ? `claude --worktree ${JSON.stringify(name)}` : "claude",
-			workspaceQuery: workspace,
-			initialPromptFile,
-			envVars,
-			modelOverride: resolvedModel
-		});
-		const wt = useWorktree ? ` (worktree: .claude/worktrees/${name})` : "";
-		const be = backendName ? ` [backend: ${backendName}${resolvedModel ? ` → ${resolvedModel}` : ""}]` : "";
-		consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude at ${dir}${wt}${be}`);
-	}
-});
-//#endregion
-//#region src/core/session.ts
-/** Convert an absolute path to Claude Code's project slug.
-* Claude Code replaces any non-alphanumeric character (spaces, /, ., etc.) with '-'.
-* Hyphens are preserved. Example: "/Users/me/Remember This" → "-Users-me-Remember-This". */
-function pathToProjectSlug(dir) {
-	return resolve(dir).replace(/[^A-Za-z0-9-]/g, "-");
-}
-/** Find the most recent .jsonl session file in a Claude project directory */
-function latestJsonlIn(projectDir) {
-	if (!existsSync(projectDir)) return null;
-	const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl").map((f) => ({
-		name: f,
-		mtime: statSync(join(projectDir, f)).mtimeMs
-	})).sort((a, b) => b.mtime - a.mtime);
-	return files.length ? basename(files[0].name, ".jsonl") : null;
-}
-/**
-* Find the most recent Claude Code session ID for a directory.
-* Also checks worktree subdirectories (.claude/worktrees/*) since tabs
-* opened with --worktree run from a worktree path, not the repo root.
-*/
-function findLatestSessionId(dir) {
-	const projectsRoot = join(homedir(), ".claude", "projects");
-	const direct = latestJsonlIn(join(projectsRoot, pathToProjectSlug(dir)));
-	if (direct) return direct;
-	const worktreesDir = join(dir, ".claude", "worktrees");
-	if (existsSync(worktreesDir)) {
-		const candidates = [];
-		for (const entry of readdirSync(worktreesDir)) {
-			const projectDir = join(projectsRoot, pathToProjectSlug(join(worktreesDir, entry)));
-			const id = latestJsonlIn(projectDir);
-			if (id) {
-				const mtime = statSync(join(projectDir, id + ".jsonl")).mtimeMs;
-				candidates.push({
-					id,
-					mtime
-				});
-			}
-		}
-		if (candidates.length) {
-			candidates.sort((a, b) => b.mtime - a.mtime);
-			return candidates[0].id;
-		}
-	}
-	return null;
-}
-/**
-* Find all sessions with a given custom title (--name).
-* Returns them sorted by most recent first, with the first user prompt for context.
-*/
-function findSessionsByName(dir, name) {
-	const projectDir = join(join(homedir(), ".claude", "projects"), pathToProjectSlug(dir));
-	if (!existsSync(projectDir)) return [];
-	const matches = [];
-	const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
-	for (const f of files) {
-		const fullPath = join(projectDir, f);
-		try {
-			const lines = readFileSync(fullPath, "utf-8").split("\n");
-			let currentTitle = "";
-			let firstPrompt = "";
-			let lastActivity = "";
-			for (const line of lines) {
-				if (!line.trim()) continue;
-				try {
-					const entry = JSON.parse(line);
-					if (entry.customTitle !== void 0) currentTitle = entry.customTitle;
-					if (!firstPrompt && entry.type === "user" && entry.message?.content) {
-						const text = typeof entry.message.content === "string" ? entry.message.content : entry.message.content.find((c) => c.type === "text")?.text ?? "";
-						if (text.startsWith("<")) continue;
-						firstPrompt = text.slice(0, 120).replace(/\n/g, " ").trim();
-						if (text.length > 120) firstPrompt += "…";
-					}
-					if (entry.message?.role === "assistant" && entry.message?.content) {
-						const parts = Array.isArray(entry.message.content) ? entry.message.content : [{
-							type: "text",
-							text: entry.message.content
-						}];
-						for (const p of parts) if (p.type === "text" && p.text?.trim()) {
-							lastActivity = p.text.slice(0, 120).replace(/\n/g, " ").trim();
-							if (p.text.length > 120) lastActivity += "…";
-						}
-					}
-				} catch {}
-			}
-			if (currentTitle !== name) continue;
-			const stat = statSync(fullPath);
-			matches.push({
-				id: basename(f, ".jsonl"),
-				mtime: stat.mtimeMs,
-				size: stat.size,
-				firstPrompt,
-				lastActivity
-			});
-		} catch {}
-	}
-	return matches.sort((a, b) => b.mtime - a.mtime);
-}
-/**
-* Like findSessionsByName, but searches every project directory under
-* ~/.claude/projects. Each match carries the cwd recorded in the session.
-* Used by `cctabs restore` so callers don't have to guess the right dir.
-*/
-function findSessionsByNameGlobally(name) {
-	const projectsRoot = join(homedir(), ".claude", "projects");
-	if (!existsSync(projectsRoot)) return [];
-	const matches = [];
-	for (const slug of readdirSync(projectsRoot)) {
-		const projectDir = join(projectsRoot, slug);
-		let isDir = false;
-		try {
-			isDir = statSync(projectDir).isDirectory();
-		} catch {
-			continue;
-		}
-		if (!isDir) continue;
-		const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
-		for (const f of files) {
-			const fullPath = join(projectDir, f);
-			try {
-				const lines = readFileSync(fullPath, "utf-8").split("\n");
-				let currentTitle = "";
-				let cwd = "";
-				let firstPrompt = "";
-				let lastActivity = "";
-				for (const line of lines) {
-					if (!line.trim()) continue;
-					try {
-						const entry = JSON.parse(line);
-						if (entry.customTitle !== void 0) currentTitle = entry.customTitle;
-						if (!cwd && typeof entry.cwd === "string") cwd = entry.cwd;
-						if (!firstPrompt && entry.type === "user" && entry.message?.content) {
-							const text = typeof entry.message.content === "string" ? entry.message.content : entry.message.content.find((c) => c.type === "text")?.text ?? "";
-							if (text.startsWith("<")) continue;
-							firstPrompt = text.slice(0, 120).replace(/\n/g, " ").trim();
-							if (text.length > 120) firstPrompt += "…";
-						}
-						if (entry.message?.role === "assistant" && entry.message?.content) {
-							const parts = Array.isArray(entry.message.content) ? entry.message.content : [{
-								type: "text",
-								text: entry.message.content
-							}];
-							for (const p of parts) if (p.type === "text" && p.text?.trim()) {
-								lastActivity = p.text.slice(0, 120).replace(/\n/g, " ").trim();
-								if (p.text.length > 120) lastActivity += "…";
-							}
-						}
-					} catch {}
-				}
-				if (currentTitle !== name || !cwd) continue;
-				const stat = statSync(fullPath);
-				matches.push({
-					id: basename(f, ".jsonl"),
-					mtime: stat.mtimeMs,
-					size: stat.size,
-					firstPrompt,
-					lastActivity,
-					dir: cwd
-				});
-			} catch {}
-		}
-	}
-	return matches.sort((a, b) => b.mtime - a.mtime);
-}
-/**
-* List all unique session names (customTitle) in a project directory.
-* Used to show available names when a resume lookup fails.
-*/
-function listSessionNames(dir) {
-	const projectDir = join(join(homedir(), ".claude", "projects"), pathToProjectSlug(dir));
-	if (!existsSync(projectDir)) return [];
-	const results = [];
-	const seen = /* @__PURE__ */ new Set();
-	const files = readdirSync(projectDir).filter((f) => extname(f) === ".jsonl");
-	for (const f of files) {
-		const fullPath = join(projectDir, f);
-		try {
-			const firstLine = readFileSync(fullPath, "utf-8").split("\n")[0];
-			if (!firstLine) continue;
-			const title = JSON.parse(firstLine).customTitle;
-			if (!title || seen.has(title)) continue;
-			seen.add(title);
-			const stat = statSync(fullPath);
-			results.push({
-				name: title,
-				id: basename(f, ".jsonl"),
-				mtime: stat.mtimeMs
-			});
-		} catch {}
-	}
-	return results.sort((a, b) => b.mtime - a.mtime);
-}
-/**
-* Resolve a session ID prefix (e.g. "19aae7b4") to the full UUID by scanning
-* `~/.claude/projects/`. Returns the input unchanged if it already looks like
-* a full UUID, or null if no unique match exists. Pass `dir` to scope the
-* search to one project; otherwise every project is checked.
-*
-* `claude --resume <prefix>` does NOT accept truncated IDs — it treats them
-* as a search query and shows the picker. So callers must expand prefixes
-* before forwarding to claude.
-*/
-function expandSessionId(input, dir) {
-	if (!input) return null;
-	if (/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(input)) return input;
-	const projectsRoot = join(homedir(), ".claude", "projects");
-	if (!existsSync(projectsRoot)) return null;
-	const projectDirs = dir ? [join(projectsRoot, pathToProjectSlug(dir))] : readdirSync(projectsRoot).map((d) => join(projectsRoot, d)).filter((p) => {
-		try {
-			return statSync(p).isDirectory();
-		} catch {
-			return false;
-		}
-	});
-	const matches = [];
-	for (const pd of projectDirs) {
-		if (!existsSync(pd)) continue;
-		for (const f of readdirSync(pd)) {
-			if (extname(f) !== ".jsonl") continue;
-			const id = basename(f, ".jsonl");
-			if (id.startsWith(input) && !matches.includes(id)) matches.push(id);
+			}
+			envVars = backend.env;
+			resolvedModel ??= backend.model || void 0;
 		}
+		let initialPromptFile;
+		if (promptText) {
+			initialPromptFile = join(tmpdir(), `cctabs-prompt-${Date.now()}.txt`);
+			writeFileSync(initialPromptFile, promptText);
+		} else if (promptFile) initialPromptFile = promptFile;
+		let claudeCmd;
+		if (resolvedSessionId) {
+			const worktreePart = useWorktree ? ` --worktree ${JSON.stringify(name)}` : "";
+			claudeCmd = `claude --resume ${resolvedSessionId}${worktreePart} --name ${JSON.stringify(name)}`;
+		} else claudeCmd = useWorktree ? `claude --worktree ${JSON.stringify(name)}` : "claude";
+		const tabId = await openSession({
+			tabName: name,
+			dir,
+			claudeCmd,
+			workspaceQuery: workspace,
+			initialPromptFile,
+			envVars,
+			modelOverride: resolvedModel
+		});
+		const wt = useWorktree ? ` (worktree: .claude/worktrees/${name})` : "";
+		const be = backendName ? ` [backend: ${backendName}${resolvedModel ? ` → ${resolvedModel}` : ""}]` : "";
+		const rs = resolvedSessionId ? ` --resume ${resolvedSessionId.slice(0, 8)}…` : "";
+		consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude${rs} at ${dir}${wt}${be}`);
 	}
-	return matches.length === 1 ? matches[0] : null;
-}
+});
 //#endregion
 //#region src/commands/resume.ts
 function shellQuoteEnv(env) {
@@ -1207,7 +1712,7 @@ const resumeCommand = define({
 				process.exit(1);
 			}
 		}
-		const adapter = requireWaveAdapter();
+		const adapter = requireAdapter();
 		const { tabsById, tabNames } = await adapter.getAllData();
 		const matchingTabs = adapter.resolveTab(name, tabsById, tabNames);
 		if (matchingTabs.length > 1) {
@@ -1329,7 +1834,7 @@ const forkCommand = define({
 			consola.error("Source tab name is required");
 			process.exit(1);
 		}
-		const adapter = requireWaveAdapter();
+		const adapter = requireAdapter();
 		const { tabsById, tabNames } = await adapter.getAllData();
 		const matches = adapter.resolveTab(sourceQuery, tabsById, tabNames);
 		if (!matches.length) {
@@ -1380,7 +1885,7 @@ const closeCommand = define({
 			consola.error("Tab name or ID is required");
 			process.exit(1);
 		}
-		const adapter = requireWaveAdapter();
+		const adapter = requireAdapter();
 		const { tabsById, tabNames } = await adapter.getAllData();
 		const matches = adapter.resolveTab(query, tabsById, tabNames);
 		if (!matches.length) {
@@ -1421,7 +1926,7 @@ const renameCommand = define({
 			consola.error("Usage: cctabs rename <tab> <new-name>");
 			process.exit(1);
 		}
-		const adapter = requireWaveAdapter();
+		const adapter = requireAdapter();
 		const { tabsById, tabNames } = await adapter.getAllData();
 		const matches = adapter.resolveTab(query, tabsById, tabNames);
 		if (!matches.length) {
@@ -1462,7 +1967,7 @@ const scrollbackCommand = define({
 			consola.error("Tab name or block ID is required");
 			process.exit(1);
 		}
-		const adapter = requireWaveAdapter();
+		const adapter = requireAdapter();
 		const { tabsById, tabNames } = await adapter.getAllData();
 		const tabMatches = adapter.resolveTab(query, tabsById, tabNames);
 		let blockId;
@@ -1520,6 +2025,15 @@ const sendCommand = define({
 			type: "boolean",
 			short: "e",
 			description: "Append newline after text (default: true)"
+		},
+		"wait-for-prompt": {
+			type: "boolean",
+			short: "w",
+			description: "Poll the buffer until a shell prompt ($, %, >, ❯) is visible before sending. Useful for freshly-spawned tabs."
+		},
+		"wait-timeout": {
+			type: "number",
+			description: "Timeout in seconds for --wait-for-prompt (default: 10)"
 		}
 	},
 	async run(ctx) {
@@ -1527,6 +2041,8 @@ const sendCommand = define({
 		const inlineText = ctx.positionals[2];
 		const filePath = ctx.values.file;
 		const appendEnter = ctx.values.enter ?? true;
+		const waitForPrompt = ctx.values["wait-for-prompt"] ?? false;
+		const waitTimeoutSec = ctx.values["wait-timeout"] ?? 10;
 		if (!query) {
 			consola.error("Usage: cctabs send <tab-or-block> [text]");
 			process.exit(1);
@@ -1536,7 +2052,7 @@ const sendCommand = define({
 		else if (filePath) rawText = readFileSync(filePath, "utf-8").replace(/\n/g, "\r");
 		else rawText = (await readStdin()).replace(/\n/g, "\r");
 		if (appendEnter && !rawText.endsWith("\r")) rawText += "\r";
-		const adapter = requireWaveAdapter();
+		const adapter = requireAdapter();
 		const { tabsById, tabNames } = await adapter.getAllData();
 		const tabMatches = adapter.resolveTab(query, tabsById, tabNames);
 		let blockId;
@@ -1565,6 +2081,23 @@ const sendCommand = define({
 			}
 			blockId = blockMatches[0].blockid;
 		}
+		if (waitForPrompt) {
+			const deadline = Date.now() + waitTimeoutSec * 1e3;
+			let ready = false;
+			while (Date.now() < deadline) {
+				const lastLine = adapter.scrollback(blockId, 5).split("\n").map((l) => l.trim()).filter(Boolean).at(-1) ?? "";
+				if (/[$%>❯]\s*$/.test(lastLine)) {
+					ready = true;
+					break;
+				}
+				await new Promise((r) => setTimeout(r, 250));
+			}
+			if (!ready) {
+				adapter.closeSocket();
+				consola.error(`Timed out after ${waitTimeoutSec}s waiting for shell prompt in ${blockId.slice(0, 8)}`);
+				process.exit(1);
+			}
+		}
 		const resp = await adapter.sendInput(blockId, rawText);
 		adapter.closeSocket();
 		if (resp && resp.error) {
@@ -1592,154 +2125,378 @@ const configCommand = define({
 });
 //#endregion
 //#region src/commands/restore.ts
+function readStdinSync() {
+	if (process.stdin.isTTY) return "";
+	try {
+		return readFileSync(0, "utf-8");
+	} catch {
+		return "";
+	}
+}
+function parseManifest(raw) {
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch (err) {
+		throw new Error(`Manifest is not valid JSON: ${err.message}`);
+	}
+	const collected = [];
+	if (Array.isArray(parsed)) collected.push(...parsed);
+	else if (parsed && typeof parsed === "object") {
+		const p = parsed;
+		if (Array.isArray(p.sessions)) collected.push(...p.sessions);
+		if (Array.isArray(p.workspaces)) {
+			for (const ws of p.workspaces) if (ws && typeof ws === "object" && Array.isArray(ws.sessions)) collected.push(...ws.sessions);
+		}
+	}
+	const entries = [];
+	for (const item of collected) {
+		if (!item || typeof item !== "object") continue;
+		const it = item;
+		const name = typeof it.name === "string" ? it.name : null;
+		const dir = typeof it.dir === "string" ? it.dir : typeof it.cwd === "string" ? it.cwd : null;
+		if (!name || !dir) continue;
+		const sid = typeof it.session_id === "string" ? it.session_id : void 0;
+		entries.push({
+			name,
+			dir: resolve(dir.replace(/^~/, homedir())),
+			session_id: sid
+		});
+	}
+	return entries;
+}
 const restoreCommand = define({
 	name: "restore",
-	description: "Resume Claude sessions in all terminal-state tabs (e.g. after a reboot). Searches every Claude project dir by default; pass an explicit dir to scope the search.",
-	args: { dry: {
-		type: "boolean",
-		short: "n",
-		description: "Show what would be resumed without actually doing it"
-	} },
+	description: "Resume Claude sessions in terminal-state tabs (e.g. after a reboot). With --manifest, drive from an explicit list and optionally spawn missing tabs.",
+	args: {
+		dry: {
+			type: "boolean",
+			short: "n",
+			description: "Show what would be resumed without actually doing it"
+		},
+		manifest: {
+			type: "string",
+			short: "m",
+			description: "Path to a JSON manifest of {name, dir, session_id?} entries (use \"-\" for stdin). Accepts cctabs sessions --json output directly."
+		},
+		"create-missing": {
+			type: "boolean",
+			short: "c",
+			description: "When using --manifest, spawn new tabs for entries that have no existing tab"
+		}
+	},
 	async run(ctx) {
-		const rawDir = ctx.positionals[1];
-		const scopedDir = rawDir ? resolve(rawDir.replace(/^~/, homedir())) : null;
 		const dryRun = ctx.values.dry;
-		const adapter = requireWaveAdapter();
-		const { tabsById, workspaces, tabNames } = await adapter.getAllData();
-		const currentTab = process.env.WAVETERM_TABID ?? "";
-		const tabs = [];
-		for (const wsp of workspaces) for (const tabId of wsp.workspacedata.tabids) {
-			if (tabId === currentTab) continue;
-			const blocks = (tabsById.get(tabId) ?? []).filter((b) => b.view === "term");
-			if (!blocks.length) continue;
-			const name = tabNames.get(tabId) ?? tabId.slice(0, 8);
-			const status = adapter.detectSessionStatus(blocks[0].blockid);
-			tabs.push({
-				tabId,
-				name,
-				blockId: blocks[0].blockid,
-				status
+		const manifestPath = ctx.values.manifest;
+		const createMissing = ctx.values["create-missing"] ?? false;
+		if (manifestPath) {
+			await runManifestMode(manifestPath, createMissing, !!dryRun);
+			return;
+		}
+		if (createMissing) consola.warn("--create-missing has no effect without --manifest; ignoring.");
+		await runLegacyMode(ctx.positionals[1], !!dryRun);
+	}
+});
+async function runManifestMode(manifestPath, createMissing, dryRun) {
+	let raw;
+	if (manifestPath === "-") {
+		raw = readStdinSync();
+		if (!raw.trim()) {
+			consola.error("--manifest - was given but stdin is empty");
+			process.exit(1);
+		}
+	} else {
+		if (!existsSync(manifestPath)) {
+			consola.error(`Manifest file not found: ${manifestPath}`);
+			process.exit(1);
+		}
+		raw = readFileSync(manifestPath, "utf-8");
+	}
+	let entries;
+	try {
+		entries = parseManifest(raw);
+	} catch (err) {
+		consola.error(err.message);
+		process.exit(1);
+	}
+	if (!entries.length) {
+		consola.error("Manifest contained no usable entries (need at minimum {name, dir} per entry).");
+		process.exit(1);
+	}
+	consola.info(`Manifest: ${entries.length} entry/entries`);
+	const adapter = requireAdapter();
+	const { tabsById, tabNames, workspaces } = await adapter.getAllData();
+	const currentWs = adapter.currentWorkspaceId();
+	const currentTab = adapter.currentTabId();
+	const currentWsData = workspaces.find((w) => w.workspacedata.oid === currentWs);
+	const wsTabIds = currentWsData ? new Set(currentWsData.workspacedata.tabids) : new Set(tabsById.keys());
+	const results = [];
+	const toSpawn = [];
+	const extraFlags = loadConfig().claude.flags.join(" ");
+	for (const entry of entries) {
+		let resolvedSessionId = entry.session_id;
+		if (entry.session_id) {
+			const expanded = expandSessionId(entry.session_id, entry.dir) ?? expandSessionId(entry.session_id);
+			if (expanded) resolvedSessionId = expanded;
+		} else {
+			const sessions = findSessionsByName(entry.dir, entry.name);
+			if (sessions.length === 1) resolvedSessionId = sessions[0].id;
+			else if (sessions.length > 1) resolvedSessionId = sessions[0].id;
+		}
+		const matchingTabs = adapter.resolveTab(entry.name, tabsById, tabNames).filter((tid) => wsTabIds.has(tid) && tid !== currentTab);
+		if (matchingTabs.length > 1) {
+			consola.log(`  ${entry.name} — multiple matching tabs, skipping`);
+			results.push({
+				name: entry.name,
+				result: "ambiguous (multiple tabs)"
 			});
+			continue;
 		}
-		const toResume = tabs.filter((t) => t.status === "terminal" || t.status === "unknown");
-		const alreadyActive = tabs.filter((t) => t.status === "active" || t.status === "idle");
-		if (alreadyActive.length) consola.info(`Already running: ${alreadyActive.map((t) => t.name).join(", ")}`);
-		if (!toResume.length) {
-			consola.info("No terminal-state tabs to restore.");
-			adapter.closeSocket();
-			return;
+		if (matchingTabs.length === 1) {
+			const tabId = matchingTabs[0];
+			const termBlock = (tabsById.get(tabId) ?? []).find((b) => b.view === "term");
+			if (!termBlock) {
+				results.push({
+					name: entry.name,
+					result: "no terminal block in tab"
+				});
+				continue;
+			}
+			const status = adapter.detectSessionStatus(termBlock.blockid);
+			if (status === "active" || status === "idle") {
+				consola.log(`  ${entry.name} — already running, skipping`);
+				results.push({
+					name: entry.name,
+					result: "already running"
+				});
+				continue;
+			}
+			if (!resolvedSessionId) {
+				consola.log(`  ${entry.name} — no session ID and none found in ${entry.dir}, skipping`);
+				results.push({
+					name: entry.name,
+					result: "no matching session"
+				});
+				continue;
+			}
+			if (dryRun) {
+				consola.log(`  ${entry.name} → would resume ${resolvedSessionId.slice(0, 8)}… in existing tab`);
+				results.push({
+					name: entry.name,
+					result: `dry run: attach ${resolvedSessionId.slice(0, 8)}…`
+				});
+				continue;
+			}
+			consola.log(`  ${entry.name} → resuming ${resolvedSessionId.slice(0, 8)}… in existing tab`);
+			const cmd = `cd ${JSON.stringify(entry.dir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${resolvedSessionId} --name ${JSON.stringify(entry.name)}\r`;
+			await adapter.sendInput(termBlock.blockid, cmd);
+			await new Promise((r) => setTimeout(r, 500));
+			results.push({
+				name: entry.name,
+				result: "sent"
+			});
+			continue;
 		}
-		consola.info(`Found ${toResume.length} tab(s) to restore:`);
-		const extraFlags = loadConfig().claude.flags.join(" ");
-		const results = [];
-		const toRecreate = [];
-		for (const tab of toResume) {
-			let sessionId = null;
-			let sessionDir = null;
-			if (scopedDir) {
-				const sessions = findSessionsByName(scopedDir, tab.name);
-				if (sessions.length === 0) {
-					consola.log(`  ${tab.name} — no session named "${tab.name}" found in ${scopedDir}, skipping`);
-					results.push({
-						name: tab.name,
-						result: "no matching session"
-					});
-					continue;
-				}
-				if (sessions.length > 1) {
-					consola.log(`  ${tab.name} — multiple sessions found, skipping (use cctabs resume --session to pick one)`);
-					results.push({
-						name: tab.name,
-						result: "ambiguous (multiple sessions)"
-					});
-					continue;
-				}
-				sessionId = sessions[0].id;
-				sessionDir = scopedDir;
-			} else {
-				const sessions = findSessionsByNameGlobally(tab.name);
-				if (sessions.length === 0) {
-					consola.log(`  ${tab.name} — no session named "${tab.name}" found in any project, skipping`);
-					results.push({
-						name: tab.name,
-						result: "no matching session"
-					});
+		if (!createMissing) {
+			consola.log(`  ${entry.name} — no existing tab; pass --create-missing to spawn one`);
+			results.push({
+				name: entry.name,
+				result: "missing (skipped, no --create-missing)"
+			});
+			continue;
+		}
+		if (dryRun) {
+			const sid = resolvedSessionId ? `${resolvedSessionId.slice(0, 8)}…` : "fresh";
+			consola.log(`  ${entry.name} → would spawn new tab in ${entry.dir} (${sid})`);
+			results.push({
+				name: entry.name,
+				result: `dry run: spawn (${sid})`
+			});
+			continue;
+		}
+		toSpawn.push({
+			...entry,
+			session_id: resolvedSessionId
+		});
+	}
+	if (!dryRun) {
+		const sent = results.filter((r) => r.result === "sent");
+		if (sent.length) {
+			consola.info("Waiting for sessions to start…");
+			await new Promise((r) => setTimeout(r, 1e4));
+			for (const r of sent) {
+				const tabId = adapter.resolveTab(r.name, tabsById, tabNames).filter((tid) => wsTabIds.has(tid) && tid !== currentTab)[0];
+				const termBlock = tabId ? (tabsById.get(tabId) ?? []).find((b) => b.view === "term") : void 0;
+				if (!termBlock) {
+					r.result = "? tab disappeared";
 					continue;
 				}
-				if (sessions.length > 1) consola.log(`  ${tab.name} — multiple sessions found across projects, picking newest (${sessions[0].dir})`);
-				sessionId = sessions[0].id;
-				sessionDir = sessions[0].dir;
+				const status = adapter.detectSessionStatus(termBlock.blockid);
+				if (status === "active" || status === "idle") r.result = "✔ running";
+				else if (status === "unknown") r.result = "? scrollback unavailable";
+				else r.result = "✘ may not have started";
 			}
-			if (dryRun) {
-				const mode = tab.status === "unknown" ? "recreate" : "send";
-				consola.log(`  ${tab.name} → would ${mode} session ${sessionId.slice(0, 8)}… in ${sessionDir}`);
+		}
+	}
+	adapter.closeSocket();
+	for (const entry of toSpawn) try {
+		const claudeCmd = entry.session_id ? `claude --resume ${entry.session_id} --name ${JSON.stringify(entry.name)}` : "claude";
+		const newTabId = await openSession({
+			tabName: entry.name,
+			dir: entry.dir,
+			claudeCmd
+		});
+		const sid = entry.session_id ? entry.session_id.slice(0, 8) + "…" : "fresh";
+		results.push({
+			name: entry.name,
+			result: `✔ spawned [${newTabId.slice(0, 8)}] (${sid})`
+		});
+	} catch (err) {
+		results.push({
+			name: entry.name,
+			result: `✘ spawn failed: ${err.message}`
+		});
+	}
+	console.log("\nRestore summary:");
+	for (const r of results) console.log(`  ${r.name}: ${r.result}`);
+}
+async function runLegacyMode(rawDir, dryRun) {
+	const scopedDir = rawDir ? resolve(rawDir.replace(/^~/, homedir())) : null;
+	const adapter = requireAdapter();
+	const { tabsById, workspaces, tabNames } = await adapter.getAllData();
+	const currentTab = adapter.currentTabId();
+	const tabs = [];
+	for (const wsp of workspaces) for (const tabId of wsp.workspacedata.tabids) {
+		if (tabId === currentTab) continue;
+		const blocks = (tabsById.get(tabId) ?? []).filter((b) => b.view === "term");
+		if (!blocks.length) continue;
+		const name = tabNames.get(tabId) ?? tabId.slice(0, 8);
+		const status = adapter.detectSessionStatus(blocks[0].blockid);
+		tabs.push({
+			tabId,
+			name,
+			blockId: blocks[0].blockid,
+			status
+		});
+	}
+	const toResume = tabs.filter((t) => t.status === "terminal" || t.status === "unknown");
+	const alreadyActive = tabs.filter((t) => t.status === "active" || t.status === "idle");
+	if (alreadyActive.length) consola.info(`Already running: ${alreadyActive.map((t) => t.name).join(", ")}`);
+	if (!toResume.length) {
+		consola.info("No terminal-state tabs to restore.");
+		adapter.closeSocket();
+		return;
+	}
+	consola.info(`Found ${toResume.length} tab(s) to restore:`);
+	const extraFlags = loadConfig().claude.flags.join(" ");
+	const results = [];
+	const toRecreate = [];
+	for (const tab of toResume) {
+		let sessionId = null;
+		let sessionDir = null;
+		if (scopedDir) {
+			const sessions = findSessionsByName(scopedDir, tab.name);
+			if (sessions.length === 0) {
+				consola.log(`  ${tab.name} — no session named "${tab.name}" found in ${scopedDir}, skipping`);
 				results.push({
 					name: tab.name,
-					result: `dry run: ${sessionId.slice(0, 8)}…`
+					result: "no matching session"
 				});
 				continue;
 			}
-			if (tab.status === "unknown") {
-				if (await adapter.confirmScrollbackEmpty(tab.blockId)) {
-					const blockIds = (tabsById.get(tab.tabId) ?? []).map((b) => b.blockid);
-					toRecreate.push({
-						name: tab.name,
-						sessionId,
-						sessionDir,
-						blockIds,
-						tabId: tab.tabId
-					});
-					results.push({
-						name: tab.name,
-						result: "queued for recreate"
-					});
-					continue;
-				}
+			if (sessions.length > 1) {
+				consola.log(`  ${tab.name} — multiple sessions found, skipping (use cctabs resume --session to pick one)`);
+				results.push({
+					name: tab.name,
+					result: "ambiguous (multiple sessions)"
+				});
+				continue;
 			}
-			consola.log(`  ${tab.name} → resuming session ${sessionId.slice(0, 8)}… in ${sessionDir} (send)`);
-			const cmd = `cd ${JSON.stringify(sessionDir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(tab.name)}\r`;
-			await adapter.sendInput(tab.blockId, cmd);
-			await new Promise((r) => setTimeout(r, 500));
+			sessionId = sessions[0].id;
+			sessionDir = scopedDir;
+		} else {
+			const sessions = findSessionsByNameGlobally(tab.name);
+			if (sessions.length === 0) {
+				consola.log(`  ${tab.name} — no session named "${tab.name}" found in any project, skipping`);
+				results.push({
+					name: tab.name,
+					result: "no matching session"
+				});
+				continue;
+			}
+			if (sessions.length > 1) consola.log(`  ${tab.name} — multiple sessions found across projects, picking newest (${sessions[0].dir})`);
+			sessionId = sessions[0].id;
+			sessionDir = sessions[0].dir;
+		}
+		if (dryRun) {
+			const mode = tab.status === "unknown" ? "recreate" : "send";
+			consola.log(`  ${tab.name} → would ${mode} session ${sessionId.slice(0, 8)}… in ${sessionDir}`);
 			results.push({
 				name: tab.name,
-				result: "sent"
+				result: `dry run: ${sessionId.slice(0, 8)}…`
 			});
+			continue;
 		}
-		if (!dryRun) {
-			const sent = results.filter((r) => r.result === "sent");
-			if (sent.length) {
-				consola.info("Waiting for sessions to start…");
-				await new Promise((r) => setTimeout(r, 1e4));
-				for (const r of sent) {
-					const tab = toResume.find((t) => t.name === r.name);
-					const status = adapter.detectSessionStatus(tab.blockId);
-					if (status === "active" || status === "idle") r.result = "✔ running";
-					else if (status === "unknown") r.result = "? scrollback unavailable";
-					else r.result = "✘ may not have started";
-				}
+		if (tab.status === "unknown") {
+			if (await adapter.confirmScrollbackEmpty(tab.blockId)) {
+				const blockIds = (tabsById.get(tab.tabId) ?? []).map((b) => b.blockid);
+				toRecreate.push({
+					name: tab.name,
+					sessionId,
+					sessionDir,
+					blockIds,
+					tabId: tab.tabId
+				});
+				results.push({
+					name: tab.name,
+					result: "queued for recreate"
+				});
+				continue;
 			}
 		}
-		if (!dryRun && toRecreate.length) {
-			for (const t of toRecreate) for (const bid of t.blockIds) adapter.deleteBlock(bid);
-			adapter.closeSocket();
-			consola.info(`Recreating ${toRecreate.length} dead tab(s)…`);
-			for (const t of toRecreate) try {
-				const newTabId = await openSession({
-					tabName: t.name,
-					dir: t.sessionDir,
-					claudeCmd: `claude --resume ${t.sessionId} --name ${JSON.stringify(t.name)}`
-				});
-				const r = results.find((x) => x.name === t.name);
-				r.result = `✔ recreated [${newTabId.slice(0, 8)}]`;
-			} catch (err) {
-				const r = results.find((x) => x.name === t.name);
-				r.result = `✘ recreate failed: ${err.message}`;
+		consola.log(`  ${tab.name} → resuming session ${sessionId.slice(0, 8)}… in ${sessionDir} (send)`);
+		const cmd = `cd ${JSON.stringify(sessionDir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(tab.name)}\r`;
+		await adapter.sendInput(tab.blockId, cmd);
+		await new Promise((r) => setTimeout(r, 500));
+		results.push({
+			name: tab.name,
+			result: "sent"
+		});
+	}
+	if (!dryRun) {
+		const sent = results.filter((r) => r.result === "sent");
+		if (sent.length) {
+			consola.info("Waiting for sessions to start…");
+			await new Promise((r) => setTimeout(r, 1e4));
+			for (const r of sent) {
+				const tab = toResume.find((t) => t.name === r.name);
+				const status = adapter.detectSessionStatus(tab.blockId);
+				if (status === "active" || status === "idle") r.result = "✔ running";
+				else if (status === "unknown") r.result = "? scrollback unavailable";
+				else r.result = "✘ may not have started";
 			}
-		} else adapter.closeSocket();
-		console.log("\nRestore summary:");
-		for (const r of results) console.log(`  ${r.name}: ${r.result}`);
+		}
 	}
-});
+	if (!dryRun && toRecreate.length) {
+		for (const t of toRecreate) for (const bid of t.blockIds) adapter.deleteBlock(bid);
+		adapter.closeSocket();
+		consola.info(`Recreating ${toRecreate.length} dead tab(s)…`);
+		for (const t of toRecreate) try {
+			const newTabId = await openSession({
+				tabName: t.name,
+				dir: t.sessionDir,
+				claudeCmd: `claude --resume ${t.sessionId} --name ${JSON.stringify(t.name)}`
+			});
+			const r = results.find((x) => x.name === t.name);
+			r.result = `✔ recreated [${newTabId.slice(0, 8)}]`;
+		} catch (err) {
+			const r = results.find((x) => x.name === t.name);
+			r.result = `✘ recreate failed: ${err.message}`;
+		}
+	} else adapter.closeSocket();
+	console.log("\nRestore summary:");
+	for (const r of results) console.log(`  ${r.name}: ${r.result}`);
+}
 //#endregion
 //#region src/commands/backends.ts
 const backendsCommand = define({
@@ -1754,6 +2511,341 @@ const backendsCommand = define({
 	}
 });
 //#endregion
+//#region src/commands/doctor.ts
+const STATUS_GLYPH = {
+	ok: "✔",
+	warn: "⚠",
+	fail: "✘",
+	skip: "–"
+};
+function printResult(r) {
+	const line = `  ${STATUS_GLYPH[r.status]}  ${r.name}${r.detail ? " — " + r.detail : ""}`;
+	console.log(line);
+	if (r.hint) console.log(`       ↳ ${r.hint}`);
+}
+function checkTerminal(terminal) {
+	if (terminal === "wave" || terminal === "tabby") return {
+		name: "Terminal",
+		status: "ok",
+		detail: terminal
+	};
+	return {
+		name: "Terminal",
+		status: "fail",
+		detail: terminal === "unknown" ? "unrecognised" : terminal,
+		hint: "cctabs supports Wave Terminal and Tabby. Switch to one of those."
+	};
+}
+function checkWaveAccessibility() {
+	const r = spawnSync("osascript", ["-e", "tell application \"System Events\" to count processes"], {
+		encoding: "utf-8",
+		timeout: 2e3
+	});
+	const stderr = (r.stderr ?? "").trim();
+	if (r.status === 0) return {
+		name: "Wave Accessibility permission",
+		status: "ok"
+	};
+	if (stderr.includes("not allowed") || stderr.includes("1002") || stderr.includes("-1719")) return {
+		name: "Wave Accessibility permission",
+		status: "fail",
+		detail: "osascript denied",
+		hint: "System Settings → Privacy & Security → Accessibility → enable Wave Terminal"
+	};
+	return {
+		name: "Wave Accessibility permission",
+		status: "warn",
+		detail: stderr || `osascript exit ${r.status}`,
+		hint: "Could not verify automatically. If `cctabs new` errors, check Privacy & Security → Accessibility."
+	};
+}
+function probeTabbyPlugin(host, port) {
+	const r = spawnSync("curl", [
+		"-fsS",
+		"--max-time",
+		"3",
+		`http://${host}:${port}/api/health`
+	], { encoding: "utf-8" });
+	if (r.status !== 0 || !r.stdout) return {
+		ok: false,
+		error: (r.stderr || "").trim() || `exit ${r.status}`
+	};
+	try {
+		const parsed = JSON.parse(r.stdout);
+		return {
+			ok: !!parsed.ok,
+			version: parsed.version,
+			raw: r.stdout
+		};
+	} catch {
+		return {
+			ok: false,
+			error: "non-JSON response",
+			raw: r.stdout
+		};
+	}
+}
+function checkTabbyPlugin() {
+	const host = process.env.CCTABS_TABBY_HOST ?? "127.0.0.1";
+	const port = Number(process.env.CCTABS_TABBY_PORT ?? "3300");
+	const health = probeTabbyPlugin(host, port);
+	if (health.ok) return {
+		name: "Tabby cctabs plugin",
+		status: "ok",
+		detail: `${host}:${port}, version ${health.version ?? "unknown"}`
+	};
+	return {
+		name: "Tabby cctabs plugin",
+		status: "fail",
+		detail: `${host}:${port} unreachable (${health.error ?? "unknown"})`,
+		hint: "Run `cctabs install-tabby-plugin` from inside a Tabby tab — it npm-installs the plugin and reopens Tabby. Or do it by hand: `npm install --legacy-peer-deps --prefix \"$HOME/Library/Application Support/tabby/plugins\" tabby-cctabs`, then quit + reopen Tabby."
+	};
+}
+function checkWaveDb() {
+	if (!existsSync(WAVE_DB_PATH)) return { result: {
+		name: "Wave DB",
+		status: "skip",
+		detail: "not found — Wave Terminal not installed?"
+	} };
+	let reports;
+	try {
+		reports = findOrphanTabIds();
+	} catch (err) {
+		return { result: {
+			name: "Wave DB orphan-tabid scan",
+			status: "fail",
+			detail: err.message,
+			hint: "sqlite3 CLI must be on PATH (ships with macOS by default)."
+		} };
+	}
+	if (!reports.length) return { result: {
+		name: "Wave DB orphan-tabid scan",
+		status: "ok",
+		detail: "no orphans"
+	} };
+	return {
+		result: {
+			name: "Wave DB orphan-tabid scan",
+			status: "warn",
+			detail: `${reports.length} workspace(s) affected`,
+			hint: "Run `cctabs doctor --fix` (after quitting Wave) to clean up."
+		},
+		reports
+	};
+}
+async function fixWaveDb(reports, yes) {
+	console.log("");
+	consola.warn(`${reports.length} workspace(s) with orphan tabids:`);
+	for (const r of reports) {
+		console.log(`  • "${r.workspaceName}" [${r.workspaceId.slice(0, 8)}]`);
+		console.log(`      present: ${r.presentTabIds.length} tab(s)`);
+		console.log(`      orphan : ${r.orphanTabIds.length} tabid(s) → ${r.orphanTabIds.map((t) => t.slice(0, 8)).join(", ")}`);
+	}
+	console.log("");
+	console.log("These tabids point at rows that no longer exist in db_tab. Wave's");
+	console.log("BlocksList RPC aborts on the first missing tab, so `wsh blocks list`");
+	console.log("currently fails with: \"couldn't list blocks for workspace …: not found\".");
+	console.log("");
+	console.log("Fix steps:");
+	console.log("  1. Copy the Wave DB to a timestamped backup next to it.");
+	console.log("  2. For each affected workspace, rewrite `data.tabids` to drop the orphan IDs.");
+	console.log("  3. Leave Wave's db_tab untouched.");
+	console.log("");
+	console.log("IMPORTANT: Quit Wave Terminal first — otherwise Wave may overwrite the");
+	console.log("fix on its next save. (Cmd+Q on the Wave app, then re-run this command.)");
+	console.log("");
+	let proceed = yes;
+	if (!yes) {
+		const ans = await p.confirm({
+			message: "Apply the fix now?",
+			initialValue: false
+		});
+		if (p.isCancel(ans)) {
+			consola.info("Cancelled.");
+			return;
+		}
+		proceed = Boolean(ans);
+	}
+	if (!proceed) {
+		consola.info("Aborted. No changes made.");
+		return;
+	}
+	const backup = backupWaveDb();
+	consola.success(`Backup written: ${backup}`);
+	for (const r of reports) try {
+		removeOrphanTabIds(r);
+		consola.success(`Cleaned "${r.workspaceName}" [${r.workspaceId.slice(0, 8)}] — removed ${r.orphanTabIds.length} orphan tabid(s)`);
+	} catch (err) {
+		consola.error(`Failed to clean ${r.workspaceId}: ${err.message}`);
+		consola.info(`Restore from backup if anything looks wrong: cp ${JSON.stringify(backup)} ${JSON.stringify(WAVE_DB_PATH)}`);
+		process.exit(1);
+	}
+	consola.success("All orphan tabids removed. Start Wave Terminal again and re-run `cctabs sessions`.");
+}
+const doctorCommand = define({
+	name: "doctor",
+	description: "Run environment checks (terminal detection, plugin reachability, Wave DB orphan scan, Wave Accessibility) and offer fixes for known problems.",
+	args: {
+		yes: {
+			type: "boolean",
+			short: "y",
+			description: "Apply the fix without an interactive confirmation prompt"
+		},
+		fix: {
+			type: "boolean",
+			description: "Apply available fixes (currently: Wave DB orphan-tabids)"
+		}
+	},
+	async run(ctx) {
+		const yes = Boolean(ctx.values.yes);
+		const fix = Boolean(ctx.values.fix) || yes;
+		const terminal = detectTerminal();
+		console.log("cctabs doctor — environment checks");
+		console.log("─".repeat(40));
+		const results = [];
+		let waveDb = null;
+		results.push(checkTerminal(terminal));
+		if (terminal === "tabby") results.push(checkTabbyPlugin());
+		if (terminal === "wave") {
+			results.push(checkWaveAccessibility());
+			waveDb = checkWaveDb();
+			results.push(waveDb.result);
+		} else if (existsSync(WAVE_DB_PATH)) {
+			waveDb = checkWaveDb();
+			results.push({
+				...waveDb.result,
+				name: "Wave DB orphan-tabid scan (offline)"
+			});
+		}
+		for (const r of results) printResult(r);
+		const failed = results.some((r) => r.status === "fail");
+		const orphans = waveDb?.reports ?? [];
+		if (orphans.length && fix) await fixWaveDb(orphans, yes);
+		else if (orphans.length) {
+			console.log("");
+			consola.info("Re-run with `cctabs doctor --fix` to clean up orphan tabids (a DB backup is made first).");
+		}
+		if (failed) process.exit(1);
+	}
+});
+//#endregion
+//#region src/commands/install-tabby-plugin.ts
+function pluginsDir() {
+	if (platform() === "darwin") return join(homedir(), "Library", "Application Support", "tabby", "plugins");
+	if (platform() === "linux") return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "tabby", "plugins");
+	if (platform() === "win32") return join(process.env.APPDATA ?? join(homedir(), "AppData", "Roaming"), "tabby", "plugins");
+	throw new Error(`unsupported platform: ${platform()}`);
+}
+function shellQuote(s) {
+	return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+const installTabbyPluginCommand = define({
+	name: "install-tabby-plugin",
+	description: "Install the tabby-cctabs plugin via npm, then quit + reopen Tabby in the background and resume the current claude session in a new tab. Must be run from inside Tabby.",
+	args: {
+		yes: {
+			type: "boolean",
+			short: "y",
+			description: "Skip the \"this will restart Tabby\" confirmation"
+		},
+		"no-restart": {
+			type: "boolean",
+			description: "Install the plugin only; do not quit Tabby. You restart it yourself."
+		}
+	},
+	async run(ctx) {
+		const yes = Boolean(ctx.values.yes);
+		const noRestart = Boolean(ctx.values["no-restart"]);
+		if (detectTerminal() !== "tabby") {
+			consola.error("cctabs install-tabby-plugin must be run from inside a Tabby tab.");
+			consola.info("On Wave Terminal you don't need this — Wave works without a plugin.");
+			process.exit(1);
+		}
+		if (platform() !== "darwin" && platform() !== "linux") {
+			consola.error(`Auto-restart isn't implemented for ${platform()} yet. Run the manual install snippet from \`cctabs doctor\` and restart Tabby yourself.`);
+			process.exit(1);
+		}
+		const dir = pluginsDir();
+		consola.info(`Tabby plugins dir: ${dir}`);
+		mkdirSync(dir, { recursive: true });
+		const pkgPath = join(dir, "package.json");
+		if (!existsSync(pkgPath)) writeFileSync(pkgPath, "{\"private\":true}\n");
+		consola.info("Installing tabby-cctabs from npm…");
+		const npm = spawnSync("npm", [
+			"install",
+			"--legacy-peer-deps",
+			"--silent",
+			"--prefix",
+			dir,
+			"tabby-cctabs"
+		], { stdio: "inherit" });
+		if (npm.status !== 0) {
+			consola.error("npm install failed. Bail out before touching Tabby.");
+			process.exit(npm.status ?? 1);
+		}
+		consola.success("Plugin installed.");
+		if (noRestart) {
+			consola.info("Skipping restart (--no-restart). Quit and reopen Tabby manually, then run `cctabs doctor`.");
+			return;
+		}
+		const cwd = process.cwd();
+		const sessionId = findLatestSessionId(cwd);
+		if (!sessionId) consola.warn(`No prior Claude session found for ${cwd}. The restart will reopen Tabby with a plain shell tab; you can launch claude yourself.`);
+		else consola.info(`Will resume session ${sessionId.slice(0, 8)}… via --fork-session after restart.`);
+		if (!yes) {
+			consola.warn("About to quit Tabby and reopen it. ALL Tabby tabs will close.");
+			consola.warn("Tabby's session recovery may or may not restore other tabs.");
+			consola.info("Re-run with --yes to suppress this prompt.");
+			if (!await consola.prompt("Proceed?", {
+				type: "confirm",
+				initial: false
+			})) {
+				consola.info("Aborted.");
+				return;
+			}
+		}
+		const claudeBin = (spawnSync("which", ["claude"], { encoding: "utf-8" }).stdout || "").trim() || "claude";
+		const stamp = Date.now();
+		const restartScript = join("/tmp", `cctabs-tabby-restart-${stamp}.sh`);
+		const launcherScript = join("/tmp", `cctabs-tabby-launcher-${stamp}.sh`);
+		writeFileSync(launcherScript, sessionId ? `#!/bin/zsh -l
+cd ${shellQuote(cwd)} || exit 1
+exec ${claudeBin} --resume ${sessionId} --fork-session
+` : `#!/bin/zsh -l
+cd ${shellQuote(cwd)} || exit 1
+exec /bin/zsh -l
+`);
+		chmodSync(launcherScript, 493);
+		const isDarwin = platform() === "darwin";
+		writeFileSync(restartScript, `#!/usr/bin/env bash
+set -e
+exec >/tmp/cctabs-tabby-restart-${stamp}.log 2>&1
+echo "[$(date)] sleeping 2s before quitting Tabby"
+sleep 2
+echo "[$(date)] quitting Tabby"
+${isDarwin ? `osascript -e 'tell application "Tabby" to quit' >/dev/null 2>&1 || true` : `pkill -TERM -f Tabby || true`}
+echo "[$(date)] waiting for Tabby to exit"
+for i in \$(seq 1 30); do pgrep -f "Tabby" >/dev/null || break; sleep 0.5; done
+echo "[$(date)] reopening Tabby"
+${isDarwin ? `open -a Tabby` : `nohup tabby >/dev/null 2>&1 &`}
+sleep 5
+echo "[$(date)] activating + launching resume tab"
+${isDarwin ? `osascript -e 'tell application "Tabby" to activate' >/dev/null 2>&1 || true` : `:`}
+sleep 1
+${isDarwin ? `/Applications/Tabby.app/Contents/MacOS/Tabby` : `tabby`} run ${shellQuote(launcherScript)}
+echo "[$(date)] done"
+`);
+		chmodSync(restartScript, 493);
+		spawn("/bin/bash", [restartScript], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		consola.success("Restart worker dispatched.");
+		consola.info(`Logs: /tmp/cctabs-tabby-restart-${stamp}.log`);
+		consola.info("Tabby will quit in ~2 seconds. After it reopens, your session resumes via --fork-session in a new tab.");
+	}
+});
+//#endregion
 //#region src/commands/index.ts
 const defaultCommand = define({
 	name: "cctabs",
@@ -1776,14 +2868,17 @@ const subCommands = new Map([
 	["send", sendCommand],
 	["config", configCommand],
 	["restore", restoreCommand],
-	["backends", backendsCommand]
+	["backends", backendsCommand],
+	["doctor", doctorCommand],
+	["install-tabby-plugin", installTabbyPluginCommand]
 ]);
 async function run() {
 	await cli(process.argv.slice(2), defaultCommand, {
 		name,
 		version,
 		description,
-		subCommands
+		subCommands,
+		renderHeader: null
 	});
 }
 //#endregion