@generativereality/cctabs 0.1.0

package/dist/index.js

@@ -0,0 +1,1341 @@
+#!/usr/bin/env node
+import updateNotifier from "update-notifier";
+import { cli, define } from "gunshi";
+import { createConnection } from "net";
+import { execFileSync, spawnSync } from "child_process";
+import { randomUUID } from "crypto";
+import { homedir, tmpdir } from "os";
+import { basename, dirname, extname, join, resolve } from "path";
+import { consola } from "consola";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+//#region package.json
+var name = "@generativereality/cctabs";
+var version = "0.1.0";
+var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
+var package_default = {
+	name,
+	version,
+	description,
+	type: "module",
+	bin: { "cctabs": "dist/index.js" },
+	files: [
+		"dist",
+		".claude-plugin",
+		"skills"
+	],
+	scripts: {
+		"dev": "bun run ./src/index.ts",
+		"build": "tsdown",
+		"typecheck": "tsc --noEmit",
+		"lint": "eslint src/",
+		"check": "bun run typecheck && bun run build",
+		"release": "bumpp && npm publish",
+		"sync-plugin": "bash scripts/sync-plugin.sh",
+		"prepack": "bash scripts/sync-plugin.sh --check && bun run build"
+	},
+	keywords: [
+		"claude-code",
+		"ai-agents",
+		"session-manager",
+		"wave-terminal",
+		"cctabs",
+		"agentherder"
+	],
+	author: "motin",
+	license: "MIT",
+	repository: {
+		"type": "git",
+		"url": "git+https://github.com/generativereality/cctabs.git"
+	},
+	homepage: "https://cctabs.com",
+	engines: { "node": ">=20.19.4" },
+	publishConfig: {
+		"registry": "https://registry.npmjs.org",
+		"access": "public"
+	},
+	dependencies: {
+		"@clack/prompts": "^0.9.1",
+		"consola": "^3.4.0",
+		"gunshi": "^0.23.0",
+		"update-notifier": "^7.3.1"
+	},
+	devDependencies: {
+		"@types/node": "^22.0.0",
+		"@types/update-notifier": "^6.0.8",
+		"bumpp": "^9.11.1",
+		"tsdown": "^0.12.0",
+		"typescript": "^5.8.0"
+	}
+};
+//#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 === "iTerm.app") return "iterm2";
+	if (prog === "ghostty" || process.env.GHOSTTY_RESOURCES_DIR) return "ghostty";
+	if (prog === "WarpTerminal") return "warp";
+	if (prog === "vscode") return "vscode";
+	if (prog === "Hyper") return "hyper";
+	if (prog === "Apple_Terminal") return "apple-terminal";
+	if (term === "xterm-kitty" || process.env.KITTY_WINDOW_ID) return "kitty";
+	if (term === "alacritty") return "alacritty";
+	return "unknown";
+}
+const TERMINAL_NAMES = {
+	wave: "Wave Terminal",
+	iterm2: "iTerm2",
+	ghostty: "Ghostty",
+	warp: "Warp",
+	kitty: "Kitty",
+	vscode: "VS Code terminal",
+	hyper: "Hyper",
+	alacritty: "Alacritty",
+	"apple-terminal": "Terminal.app",
+	unknown: "an unrecognised terminal"
+};
+function printUnsupportedTerminalError(terminal) {
+	const name = TERMINAL_NAMES[terminal];
+	const lines = [
+		"",
+		`  cctabs currently requires Wave Terminal.`,
+		`  You appear to be running in: ${name}`,
+		"",
+		`  Option 1 — Switch to Wave Terminal (full support today):`,
+		`    brew install --cask wave`,
+		`    https://waveterm.dev`,
+		"",
+		`  Option 2 — Add ${name} support (one adapter file, PRs welcome):`,
+		`    git clone https://github.com/generativereality/cctabs`,
+		`    cd cctabs`,
+		`    claude   # ask Claude to implement the ${name} adapter`,
+		"",
+		`    Claude will find src/core/wave.ts, use it as the reference`,
+		`    implementation, create src/core/${adapterFileName(terminal)},`,
+		`    wire it up, and open a PR — all in one session.`,
+		""
+	];
+	console.error(lines.join("\n"));
+}
+function adapterFileName(terminal) {
+	if (terminal === "unknown") return "<terminal>.ts";
+	return `${terminal}.ts`;
+}
+//#endregion
+//#region src/core/wave.ts
+const SOCK_PATH = join(homedir(), "Library", "Application Support", "waveterm", "wave.sock");
+var WaveSocket = class {
+	socket;
+	buffer = "";
+	pendingReaders = [];
+	routeId = "";
+	jwt;
+	constructor(jwt) {
+		this.jwt = jwt;
+		this.socket = createConnection(SOCK_PATH);
+		this.socket.on("data", (chunk) => {
+			this.buffer += chunk.toString();
+			let nl;
+			while ((nl = this.buffer.indexOf("\n")) !== -1) {
+				const line = this.buffer.slice(0, nl).trim();
+				this.buffer = this.buffer.slice(nl + 1);
+				if (!line) continue;
+				try {
+					const msg = JSON.parse(line);
+					this.pendingReaders.shift()?.(msg);
+				} catch {}
+			}
+		});
+	}
+	waitForMessage(timeoutMs = 8e3) {
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				const idx = this.pendingReaders.indexOf(resolve);
+				if (idx !== -1) this.pendingReaders.splice(idx, 1);
+				reject(/* @__PURE__ */ new Error("Wave socket timeout"));
+			}, timeoutMs);
+			this.pendingReaders.push((msg) => {
+				clearTimeout(timer);
+				resolve(msg);
+			});
+		});
+	}
+	send(msg) {
+		this.socket.write(JSON.stringify(msg) + "\n");
+	}
+	async connect() {
+		await new Promise((resolve, reject) => {
+			this.socket.once("connect", resolve);
+			this.socket.once("error", reject);
+		});
+		this.send({
+			command: "authenticate",
+			reqid: randomUUID(),
+			route: "$control",
+			data: this.jwt
+		});
+		this.routeId = (await this.waitForMessage()).data.routeid;
+	}
+	async command(command, data, route = "wavesrv") {
+		this.send({
+			command,
+			reqid: randomUUID(),
+			route,
+			source: this.routeId,
+			data
+		});
+		try {
+			return await this.waitForMessage();
+		} catch {
+			return null;
+		}
+	}
+	destroy() {
+		this.socket.destroy();
+	}
+};
+var WaveAdapter = class {
+	socket = null;
+	jwt;
+	constructor() {
+		this.jwt = process.env.WAVETERM_JWT ?? "";
+	}
+	blocksList() {
+		try {
+			const out = execFileSync("wsh", [
+				"blocks",
+				"list",
+				"--json"
+			], { encoding: "utf-8" });
+			return JSON.parse(out);
+		} catch {
+			return [];
+		}
+	}
+	scrollback(blockId, lastN = 50) {
+		return spawnSync("wsh", [
+			"termscrollback",
+			"-b",
+			blockId,
+			"--start",
+			`-${lastN}`
+		], { encoding: "utf-8" }).stdout ?? "";
+	}
+	/** Detect whether a Claude session is running in a terminal block */
+	detectSessionStatus(blockId) {
+		const tail = this.scrollback(blockId, 10);
+		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";
+		if ([
+			"Claude Code",
+			"claude.ai/code",
+			"✻ Thinking",
+			"✽ Hatching",
+			"⏵⏵ bypass"
+		].some((s) => tail.includes(s))) return "active";
+		if (lastLine.toLowerCase().includes("claude")) return "idle";
+		return "terminal";
+	}
+	deleteBlock(blockId) {
+		spawnSync("wsh", [
+			"deleteblock",
+			"-b",
+			blockId
+		], { encoding: "utf-8" });
+	}
+	async newTab(focusWindowId) {
+		if (focusWindowId) {
+			await this.focusWindow(focusWindowId);
+			await sleep(300);
+		}
+		const r = spawnSync("osascript", ["-e", [
+			"tell application \"Wave\" to activate",
+			"delay 0.25",
+			"tell application \"System Events\" to keystroke \"t\" using command down"
+		].join("\n")], { encoding: "utf-8" });
+		if (r.status !== 0) {
+			const msg = r.stderr?.trim();
+			throw new Error(msg ? `osascript failed: ${msg}` : "Failed to open new tab — ensure Wave Terminal has Accessibility permission:\n  System Settings → Privacy & Security → Accessibility → Wave ✓");
+		}
+		return true;
+	}
+	async waitForNewBlock(beforeIds, timeoutMs = 5e3) {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			await sleep(250);
+			for (const b of this.blocksList()) if (b.view === "term" && !beforeIds.has(b.blockid)) return {
+				blockId: b.blockid,
+				tabId: b.tabid
+			};
+		}
+		return null;
+	}
+	async sock() {
+		if (!this.socket) {
+			const s = new WaveSocket(this.jwt);
+			await s.connect();
+			this.socket = s;
+		}
+		return this.socket;
+	}
+	closeSocket() {
+		this.socket?.destroy();
+		this.socket = null;
+	}
+	async getTab(tabId) {
+		return (await (await this.sock()).command("gettab", tabId))?.data ?? {};
+	}
+	async workspaceList() {
+		return (await (await this.sock()).command("workspacelist", null))?.data ?? [];
+	}
+	async focusWindow(windowId) {
+		await (await this.sock()).command("focuswindow", windowId, "electron");
+	}
+	async renameTab(tabId, name) {
+		await (await this.sock()).command("updatetabname", { args: [tabId, name] });
+	}
+	async sendInput(blockId, text) {
+		const s = await this.sock();
+		const inputdata64 = Buffer.from(text).toString("base64");
+		return s.command("controllerinput", {
+			blockid: blockId,
+			inputdata64
+		});
+	}
+	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();
+		let workspaces = [];
+		try {
+			for (const tabId of tabsById.keys()) {
+				const td = await this.getTab(tabId);
+				tabNames.set(tabId, td.name ?? tabId.slice(0, 8));
+			}
+			workspaces = await this.workspaceList();
+		} catch {} finally {
+			this.closeSocket();
+		}
+		if (!workspaces.length) {
+			const wsId = process.env.WAVETERM_WORKSPACEID ?? "";
+			workspaces = [{
+				workspacedata: {
+					oid: wsId,
+					name: wsId.slice(0, 8) || "default",
+					tabids: [...tabsById.keys()]
+				},
+				windowid: ""
+			}];
+		}
+		return {
+			blocks,
+			tabsById,
+			workspaces,
+			tabNames
+		};
+	}
+	resolveTab(query, tabsById, tabNames) {
+		const q = query.toLowerCase();
+		return [...tabsById.keys()].filter((tid) => {
+			const name = tabNames.get(tid) ?? "";
+			return name.toLowerCase() === q || tid.startsWith(query) || name.toLowerCase().startsWith(q);
+		});
+	}
+	resolveBlock(query, blocks) {
+		return blocks.filter((b) => b.blockid.startsWith(query));
+	}
+	resolveWorkspace(workspaces, query) {
+		const q = query.toLowerCase();
+		return workspaces.filter(({ workspacedata: wd }) => {
+			const name = wd.name ?? "";
+			return name.toLowerCase() === q || wd.oid.startsWith(query) || name.toLowerCase().startsWith(q);
+		}).map((w) => ({
+			data: w.workspacedata,
+			windowId: w.windowid
+		}));
+	}
+};
+function requireWaveAdapter() {
+	if (!process.env.WAVETERM_JWT) {
+		printUnsupportedTerminalError(detectTerminal());
+		process.exit(1);
+	}
+	return new WaveAdapter();
+}
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+//#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();
+		const { tabsById, workspaces, tabNames } = await adapter.getAllData();
+		const currentTab = process.env.WAVETERM_TABID ?? "";
+		const currentWs = process.env.WAVETERM_WORKSPACEID ?? "";
+		console.log("Sessions");
+		console.log("=".repeat(50));
+		for (const wsp of workspaces) {
+			const { oid, name, tabids } = wsp.workspacedata;
+			const wsMarker = oid === currentWs ? " (current)" : "";
+			const tabIds = tabids.filter((t) => tabsById.has(t));
+			if (!tabIds.length) continue;
+			console.log(`\nWorkspace: ${name}${wsMarker}`);
+			for (const tabId of tabIds) {
+				const termBlocks = (tabsById.get(tabId) ?? []).filter((b) => b.view === "term");
+				if (!termBlocks.length) continue;
+				const name = tabNames.get(tabId) ?? tabId.slice(0, 8);
+				const cur = tabId === currentTab ? " ◄" : "";
+				const b = termBlocks[0];
+				const cwd = (b.meta?.["cmd:cwd"] ?? "").replace(process.env.HOME ?? "", "~");
+				const status = adapter.detectSessionStatus(b.blockid);
+				const statusLabel = status === "active" ? "● active" : status === "idle" ? "○ idle" : status === "unknown" ? "? unknown" : "  terminal";
+				console.log(`  [${tabId.slice(0, 8)}] "${name}"${cur}  ${cwd}`);
+				console.log(`    ${statusLabel}`);
+				if (status === "terminal") {
+					const lastLine = adapter.scrollback(b.blockid, 5).split("\n").map((l) => l.trim()).filter(Boolean).at(-1) ?? "";
+					if (lastLine) console.log(`    last: ${lastLine.slice(0, 80)}`);
+				}
+			}
+		}
+	}
+});
+//#endregion
+//#region src/commands/list.ts
+const listCommand = define({
+	name: "list",
+	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 ?? "";
+		for (const wsp of workspaces) {
+			const { oid, name, tabids } = wsp.workspacedata;
+			const noWindow = !wsp.windowid ? "  (no window)" : "";
+			const wsMarker = oid === currentWs ? "  ◄ current" : noWindow;
+			console.log(`Workspace: ${name}  [${oid.slice(0, 8)}]${wsMarker}`);
+			console.log();
+			const tabIds = tabids.filter((t) => tabsById.has(t));
+			if (!tabIds.length) {
+				console.log("  (no open tabs)");
+				console.log();
+				continue;
+			}
+			for (const tabId of tabIds) {
+				const tabName = tabNames.get(tabId) ?? tabId.slice(0, 8);
+				const cur = tabId === currentTab ? "  ◄" : "";
+				console.log(`  Tab  "${tabName}"  [${tabId.slice(0, 8)}]${cur}`);
+				for (const b of tabsById.get(tabId) ?? []) {
+					const here = b.blockid === currentBlock ? "  ◄ here" : "";
+					const cwd = b.meta?.["cmd:cwd"] ?? "";
+					console.log(`    ${b.view.padEnd(8)}  ${b.blockid.slice(0, 8)}${cwd ? `  ${cwd}` : ""}${here}`);
+				}
+				console.log();
+			}
+		}
+	}
+});
+//#endregion
+//#region src/core/config.ts
+const CONFIG_PATH = join(homedir(), ".config", "cctabs", "config.toml");
+const DEFAULT_CONFIG = {
+	claude: { flags: ["--allow-dangerously-skip-permissions"] },
+	defaults: { workspace: "" }
+};
+const DEFAULT_CONFIG_FILE = `# cctabs configuration
+# https://cctabs.com
+
+[claude]
+# Extra flags passed to every \`claude\` invocation.
+flags = ["--allow-dangerously-skip-permissions"]
+
+[defaults]
+# Default Wave workspace to open new sessions in.
+# workspace = ""
+`;
+function parseToml(text) {
+	const result = {};
+	let section = null;
+	for (const raw of text.split("\n")) {
+		const line = raw.trim();
+		if (!line || line.startsWith("#")) continue;
+		if (line.startsWith("[") && line.endsWith("]")) {
+			section = line.slice(1, -1).trim();
+			result[section] ??= {};
+			continue;
+		}
+		if (section && line.includes("=")) {
+			const [rawKey, ...rest] = line.split("=");
+			const key = rawKey.trim();
+			const val = rest.join("=").trim();
+			if (val.startsWith("[")) {
+				const items = [...val.matchAll(/"([^"]*)"/g)].map((m) => m[1]);
+				result[section][key] = items;
+			} else if (val.startsWith("\"") && val.endsWith("\"")) result[section][key] = val.slice(1, -1);
+			else if (val === "true" || val === "false") result[section][key] = val === "true";
+		}
+	}
+	return result;
+}
+function loadConfig() {
+	const config = {
+		claude: { ...DEFAULT_CONFIG.claude },
+		defaults: { ...DEFAULT_CONFIG.defaults }
+	};
+	if (!existsSync(CONFIG_PATH)) return config;
+	try {
+		const parsed = parseToml(readFileSync(CONFIG_PATH, "utf-8"));
+		if (parsed.claude) Object.assign(config.claude, parsed.claude);
+		if (parsed.defaults) Object.assign(config.defaults, parsed.defaults);
+	} catch {}
+	return config;
+}
+function ensureConfigExists() {
+	if (!existsSync(CONFIG_PATH)) {
+		mkdirSync(dirname(CONFIG_PATH), { recursive: true });
+		writeFileSync(CONFIG_PATH, DEFAULT_CONFIG_FILE);
+	}
+	return CONFIG_PATH;
+}
+//#endregion
+//#region src/core/open-session.ts
+/** Poll scrollback until a pattern is visible, then return. Rejects on timeout. */
+async function waitForScrollbackMatch(adapter, blockId, pattern, label, timeoutMs, pollInterval = 1e3) {
+	const deadline = Date.now() + timeoutMs;
+	while (Date.now() < deadline) {
+		await new Promise((r) => setTimeout(r, pollInterval));
+		try {
+			const lines = adapter.scrollback(blockId, 10);
+			if (!lines) continue;
+			if (typeof pattern === "string" ? lines.includes(pattern) : pattern.test(lines)) return;
+		} catch {}
+	}
+	throw new Error(`Timed out waiting for ${label}`);
+}
+async function openSession(opts) {
+	const { tabName, claudeCmd, workspaceQuery, initialPromptFile } = opts;
+	const dir = resolve(opts.dir.replace(/^~/, homedir()));
+	if (!existsSync(dir)) {
+		consola.error(`Directory does not exist: ${dir}`);
+		process.exit(1);
+	}
+	const config = loadConfig();
+	const adapter = requireWaveAdapter();
+	let focusWindowId;
+	if (workspaceQuery) {
+		const { workspaces } = await adapter.getAllData();
+		const matches = adapter.resolveWorkspace(workspaces, workspaceQuery);
+		if (!matches.length) {
+			consola.error(`No workspace matching '${workspaceQuery}'`);
+			process.exit(1);
+		}
+		const { data, windowId } = matches[0];
+		if (!windowId) {
+			consola.error(`Workspace '${data.name}' has no open window`);
+			process.exit(1);
+		}
+		focusWindowId = windowId;
+		consola.info(`Workspace: ${data.name}`);
+	}
+	const beforeIds = new Set(adapter.blocksList().filter((b) => b.view === "term").map((b) => b.blockid));
+	await adapter.newTab(focusWindowId);
+	const result = await adapter.waitForNewBlock(beforeIds);
+	if (!result) {
+		consola.error("Timed out waiting for new terminal block");
+		process.exit(1);
+	}
+	const { blockId, tabId } = result;
+	await adapter.renameTab(tabId, tabName);
+	try {
+		await waitForScrollbackMatch(adapter, blockId, /[$%>]\s*$/, "shell prompt", 1e4, 250);
+	} catch {
+		consola.error("Shell prompt never appeared in new tab — aborting. Check your shell profile (e.g. nvm default alias).");
+		process.exit(1);
+	}
+	const extraFlags = config.claude.flags.join(" ");
+	const namePart = claudeCmd.includes("--resume") ? "" : ` --name ${JSON.stringify(tabName)}`;
+	const cmd = `cd ${JSON.stringify(dir)} && claude${extraFlags ? " " + extraFlags : ""} ${claudeCmd.replace(/^claude\s*/, "")}${namePart}\r`;
+	await adapter.sendInput(blockId, cmd);
+	if (initialPromptFile) {
+		try {
+			await waitForScrollbackMatch(adapter, blockId, "❯", "Claude prompt", 3e4);
+		} catch {
+			consola.error("Claude prompt (❯) never appeared — not sending initial prompt. Check that claude started successfully.");
+			adapter.closeSocket();
+			process.exit(1);
+		}
+		const prompt = readFileSync(initialPromptFile, "utf-8").trimEnd();
+		await adapter.sendInput(blockId, prompt);
+		await new Promise((r) => setTimeout(r, 100));
+		await adapter.sendInput(blockId, "\r");
+	}
+	await new Promise((r) => setTimeout(r, 2e3));
+	adapter.closeSocket();
+	return tabId;
+}
+//#endregion
+//#region src/commands/new.ts
+const newCommand = define({
+	name: "new",
+	description: "Open a new tab and launch claude",
+	args: {
+		name: {
+			type: "positional",
+			description: "Tab name"
+		},
+		dir: {
+			type: "positional",
+			description: "Working directory / repo root (default: cwd)"
+		},
+		workspace: {
+			type: "string",
+			short: "w",
+			description: "Target workspace"
+		},
+		worktree: {
+			type: "boolean",
+			short: "W",
+			description: "Launch claude with --worktree <name> for isolated branch work"
+		},
+		file: {
+			type: "string",
+			short: "f",
+			description: "Send initial prompt from file once Claude is ready"
+		},
+		prompt: {
+			type: "string",
+			short: "p",
+			description: "Send initial prompt text once Claude is ready"
+		}
+	},
+	async run(ctx) {
+		const name = ctx.positionals[1];
+		const dir = ctx.positionals[2] ?? process.cwd();
+		const workspace = ctx.values.workspace;
+		const useWorktree = ctx.values.worktree ?? false;
+		const promptFile = ctx.values.file;
+		const promptText = ctx.values.prompt;
+		if (!name) {
+			consola.error("Tab name is required");
+			process.exit(1);
+		}
+		let initialPromptFile;
+		if (promptText) {
+			initialPromptFile = join(tmpdir(), `herd-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
+		});
+		const suffix = useWorktree ? ` (worktree: .claude/worktrees/${name})` : "";
+		consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude at ${dir}${suffix}`);
+	}
+});
+//#endregion
+//#region src/core/session.ts
+/** Convert an absolute path to Claude's project slug (/ and . → -) */
+function pathToProjectSlug(dir) {
+	return resolve(dir).replace(/[/.]/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);
+}
+/**
+* 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);
+}
+//#endregion
+//#region src/commands/resume.ts
+function formatAge(mtimeMs) {
+	const mins = Math.round((Date.now() - mtimeMs) / 6e4);
+	if (mins < 60) return `${mins}m ago`;
+	const hours = Math.round(mins / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.round(hours / 24)}d ago`;
+}
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes}B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
+	return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+}
+const resumeCommand = define({
+	name: "resume",
+	description: "Resume a claude session by name — reuses existing tab or creates a new one",
+	args: {
+		name: {
+			type: "positional",
+			description: "Tab / session name"
+		},
+		dir: {
+			type: "positional",
+			description: "Working directory (default: cwd)"
+		},
+		session: {
+			type: "string",
+			short: "s",
+			description: "Session ID to resume (use when multiple sessions share the same name)"
+		}
+	},
+	async run(ctx) {
+		const name = ctx.positionals[1];
+		const dir = resolve((ctx.positionals[2] ?? process.cwd()).replace(/^~/, homedir()));
+		if (!name) {
+			consola.error("Tab name is required");
+			process.exit(1);
+		}
+		const explicitSession = ctx.values.session;
+		let sessionId;
+		if (explicitSession) sessionId = explicitSession;
+		else {
+			const sessions = findSessionsByName(dir, name);
+			if (sessions.length === 0) {
+				consola.error(`No session named "${name}" in ${dir}`);
+				const available = listSessionNames(dir);
+				if (available.length) {
+					consola.info("Available session names:");
+					for (const s of available.slice(0, 15)) consola.log(`  ${s.name}  (${s.id.slice(0, 8)}…)`);
+				} else consola.info(`Looked in ~/.claude/projects/${pathToProjectSlug(dir)}/`);
+				process.exit(1);
+			} else if (sessions.length === 1) sessionId = sessions[0].id;
+			else {
+				consola.error(`Multiple "${name}" sessions found. Use --session <id> to pick one:\n`);
+				for (const s of sessions) {
+					consola.log(`  ${s.id}  ${formatAge(s.mtime)}  ${formatSize(s.size)}`);
+					if (s.firstPrompt) consola.log(`    start: "${s.firstPrompt}"`);
+					if (s.lastActivity) consola.log(`    last:  "${s.lastActivity}"`);
+				}
+				process.exit(1);
+			}
+		}
+		const adapter = requireWaveAdapter();
+		const { tabsById, tabNames } = await adapter.getAllData();
+		const matchingTabs = adapter.resolveTab(name, tabsById, tabNames);
+		if (matchingTabs.length > 1) {
+			consola.error(`Multiple tabs match '${name}':`);
+			for (const tid of matchingTabs) consola.error(`  "${tabNames.get(tid)}"  [${tid.slice(0, 8)}]`);
+			process.exit(1);
+		}
+		if (matchingTabs.length === 1) {
+			if (!sessionId) {
+				consola.error(`Tab "${name}" exists but no Claude session found to resume in ${dir}`);
+				process.exit(1);
+			}
+			const tabId = matchingTabs[0];
+			const termBlock = (tabsById.get(tabId) ?? []).find((b) => b.view === "term");
+			if (!termBlock) {
+				consola.error(`No terminal block found in tab '${name}'`);
+				process.exit(1);
+			}
+			const status = adapter.detectSessionStatus(termBlock.blockid);
+			if (status === "active" || status === "idle") {
+				adapter.closeSocket();
+				consola.warn(`Claude is already running in tab "${name}" (${status}) — skipping resume`);
+				process.exit(0);
+			}
+			if (status === "unknown") consola.warn(`Scrollback unavailable for tab "${name}" — cannot confirm shell is ready. Proceeding anyway.`);
+			const extraFlags = loadConfig().claude.flags.join(" ");
+			const cmd = `cd ${JSON.stringify(dir)} && claude${extraFlags ? " " + extraFlags : ""} --resume ${sessionId} --name ${JSON.stringify(name)}\r`;
+			await adapter.sendInput(termBlock.blockid, cmd);
+			let verified = false;
+			const deadline = Date.now() + 15e3;
+			while (Date.now() < deadline) {
+				await new Promise((r) => setTimeout(r, 1500));
+				const newStatus = adapter.detectSessionStatus(termBlock.blockid);
+				if (newStatus === "active" || newStatus === "idle") {
+					verified = true;
+					break;
+				}
+			}
+			adapter.closeSocket();
+			if (verified) consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude --resume ${sessionId.slice(0, 8)}… at ${dir}`);
+			else consola.warn(`Tab "${name}" [${tabId.slice(0, 8)}] — command sent but Claude may not have started (scrollback check inconclusive)`);
+		} else if (sessionId) {
+			adapter.closeSocket();
+			const tabId = await openSession({
+				tabName: name,
+				dir,
+				claudeCmd: `claude --resume ${sessionId} --name ${JSON.stringify(name)}`
+			});
+			consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude --resume ${sessionId.slice(0, 8)}… at ${dir} (new tab)`);
+		} else {
+			adapter.closeSocket();
+			const tabId = await openSession({
+				tabName: name,
+				dir,
+				claudeCmd: "claude"
+			});
+			consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude at ${dir} (new tab, no prior session found)`);
+		}
+	}
+});
+//#endregion
+//#region src/commands/fork.ts
+/** If dir is inside .claude/worktrees/<name>, return the repo root instead */
+function resolveSessionDir(dir) {
+	const worktreeMarker = `${join(".claude", "worktrees")}/`;
+	const idx = dir.indexOf(worktreeMarker);
+	if (idx !== -1) {
+		const repoRoot = dir.slice(0, idx - 1);
+		return {
+			sessionLookupDir: repoRoot,
+			openDir: repoRoot
+		};
+	}
+	return {
+		sessionLookupDir: dir,
+		openDir: dir
+	};
+}
+const forkCommand = define({
+	name: "fork",
+	description: "Fork a session into a new tab via --resume <id> --fork-session",
+	args: {
+		tab: {
+			type: "positional",
+			description: "Source tab name or ID prefix"
+		},
+		name: {
+			type: "string",
+			short: "n",
+			description: "Name for the new tab"
+		}
+	},
+	async run(ctx) {
+		const sourceQuery = ctx.positionals[1];
+		const customName = ctx.values.name;
+		if (!sourceQuery) {
+			consola.error("Source tab name is required");
+			process.exit(1);
+		}
+		const adapter = requireWaveAdapter();
+		const { tabsById, tabNames } = await adapter.getAllData();
+		const matches = adapter.resolveTab(sourceQuery, tabsById, tabNames);
+		if (!matches.length) {
+			consola.error(`No tab matching '${sourceQuery}' (tabs in workspaces with no open window are not visible — open that workspace first)`);
+			process.exit(1);
+		}
+		if (matches.length > 1) {
+			consola.error(`Multiple tabs match '${sourceQuery}':`);
+			for (const tid of matches) consola.log(`  "${tabNames.get(tid)}"  [${tid.slice(0, 8)}]`);
+			process.exit(1);
+		}
+		const tabId = matches[0];
+		const tabName = tabNames.get(tabId) ?? tabId.slice(0, 8);
+		const newName = customName ?? `${tabName}-fork`;
+		const termBlocks = (tabsById.get(tabId) ?? []).filter((b) => b.view === "term");
+		if (!termBlocks.length) {
+			consola.error(`Tab "${tabName}" has no terminal block`);
+			process.exit(1);
+		}
+		const { sessionLookupDir, openDir } = resolveSessionDir(termBlocks[0].meta?.["cmd:cwd"] ?? process.cwd());
+		const sessionId = findLatestSessionId(sessionLookupDir);
+		if (!sessionId) {
+			consola.error(`No Claude session found for ${sessionLookupDir}`);
+			consola.info(`Looked in ~/.claude/projects/${pathToProjectSlug(sessionLookupDir)}/`);
+			process.exit(1);
+		}
+		const newTabId = await openSession({
+			tabName: newName,
+			dir: openDir,
+			claudeCmd: `claude --resume ${sessionId} --fork-session`
+		});
+		consola.success(`Forked "${tabName}" → "${newName}" [${newTabId.slice(0, 8)}]`);
+		consola.info(`session: ${sessionId}`);
+	}
+});
+//#endregion
+//#region src/commands/close.ts
+const closeCommand = define({
+	name: "close",
+	description: "Close a tab by name or ID prefix",
+	args: { tab: {
+		type: "positional",
+		description: "Tab name or ID prefix"
+	} },
+	async run(ctx) {
+		const query = ctx.positionals[1];
+		if (!query) {
+			consola.error("Tab name or ID is required");
+			process.exit(1);
+		}
+		const adapter = requireWaveAdapter();
+		const { tabsById, tabNames } = await adapter.getAllData();
+		const matches = adapter.resolveTab(query, tabsById, tabNames);
+		if (!matches.length) {
+			consola.error(`No tab matching '${query}' (tabs in workspaces with no open window are not visible — open that workspace first)`);
+			process.exit(1);
+		}
+		if (matches.length > 1) {
+			consola.error(`Multiple tabs match '${query}':`);
+			for (const tid of matches) consola.log(`  "${tabNames.get(tid)}"  [${tid.slice(0, 8)}]`);
+			process.exit(1);
+		}
+		const tabId = matches[0];
+		const name = tabNames.get(tabId) ?? tabId.slice(0, 8);
+		for (const b of tabsById.get(tabId) ?? []) adapter.deleteBlock(b.blockid);
+		adapter.closeSocket();
+		consola.success(`Closed "${name}" [${tabId.slice(0, 8)}]`);
+	}
+});
+//#endregion
+//#region src/commands/rename.ts
+const renameCommand = define({
+	name: "rename",
+	description: "Rename a tab",
+	args: {
+		tab: {
+			type: "positional",
+			description: "Tab name or ID prefix"
+		},
+		newName: {
+			type: "positional",
+			description: "New name"
+		}
+	},
+	async run(ctx) {
+		const query = ctx.positionals[1];
+		const newName = ctx.positionals[2];
+		if (!query || !newName) {
+			consola.error("Usage: herd rename <tab> <new-name>");
+			process.exit(1);
+		}
+		const adapter = requireWaveAdapter();
+		const { tabsById, tabNames } = await adapter.getAllData();
+		const matches = adapter.resolveTab(query, tabsById, tabNames);
+		if (!matches.length) {
+			consola.error(`No tab matching '${query}'`);
+			process.exit(1);
+		}
+		if (matches.length > 1) {
+			consola.error(`Multiple tabs match '${query}':`);
+			for (const tid of matches) consola.log(`  "${tabNames.get(tid)}"  [${tid.slice(0, 8)}]`);
+			process.exit(1);
+		}
+		const oldName = tabNames.get(matches[0]) ?? matches[0].slice(0, 8);
+		await adapter.renameTab(matches[0], newName);
+		adapter.closeSocket();
+		consola.success(`Renamed "${oldName}" → "${newName}"`);
+	}
+});
+//#endregion
+//#region src/commands/scrollback.ts
+const scrollbackCommand = define({
+	name: "scrollback",
+	description: "Show terminal output for a tab or block (default: last 50 lines)",
+	args: {
+		target: {
+			type: "positional",
+			description: "Tab name, tab ID prefix, or block ID prefix"
+		},
+		lines: {
+			type: "number",
+			description: "Number of lines to show",
+			default: 50
+		}
+	},
+	async run(ctx) {
+		const query = ctx.positionals[1];
+		const lines = ctx.values.lines ?? 50;
+		if (!query) {
+			consola.error("Tab name or block ID is required");
+			process.exit(1);
+		}
+		const adapter = requireWaveAdapter();
+		const { tabsById, tabNames } = await adapter.getAllData();
+		const tabMatches = adapter.resolveTab(query, tabsById, tabNames);
+		let blockId;
+		if (tabMatches.length === 1) {
+			const blocks = (tabsById.get(tabMatches[0]) ?? []).filter((b) => b.view === "term");
+			if (!blocks.length) {
+				consola.error(`Tab "${tabNames.get(tabMatches[0])}" has no terminal block`);
+				process.exit(1);
+			}
+			blockId = blocks[0].blockid;
+		} else if (tabMatches.length > 1) {
+			consola.error(`Multiple tabs match '${query}':`);
+			for (const tid of tabMatches) consola.log(`  "${tabNames.get(tid)}"  [${tid.slice(0, 8)}]`);
+			process.exit(1);
+		} else {
+			const allBlocks = adapter.blocksList();
+			const blockMatches = adapter.resolveBlock(query, allBlocks);
+			if (!blockMatches.length) {
+				consola.error(`No tab or block matching '${query}' (tabs in workspaces with no open window are not visible — open that workspace first)`);
+				process.exit(1);
+			}
+			if (blockMatches.length > 1) {
+				consola.error(`Multiple blocks match '${query}':`);
+				for (const b of blockMatches) consola.log(`  ${b.blockid}`);
+				process.exit(1);
+			}
+			blockId = blockMatches[0].blockid;
+		}
+		process.stdout.write(adapter.scrollback(blockId, lines));
+	}
+});
+//#endregion
+//#region src/commands/send.ts
+function readStdin() {
+	return new Promise((resolve) => {
+		const chunks = [];
+		process.stdin.on("data", (c) => chunks.push(c));
+		process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString()));
+	});
+}
+const sendCommand = define({
+	name: "send",
+	description: "Send input to a tab or block (text arg, --file, or stdin pipe)",
+	args: {
+		target: {
+			type: "positional",
+			description: "Tab name, tab ID prefix, or block ID prefix"
+		},
+		file: {
+			type: "string",
+			short: "f",
+			description: "Read text from file"
+		},
+		enter: {
+			type: "boolean",
+			short: "e",
+			description: "Append newline after text (default: true)"
+		}
+	},
+	async run(ctx) {
+		const query = ctx.positionals[1];
+		const inlineText = ctx.positionals[2];
+		const filePath = ctx.values.file;
+		const appendEnter = ctx.values.enter ?? true;
+		if (!query) {
+			consola.error("Usage: herd send <tab-or-block> [text]");
+			process.exit(1);
+		}
+		let rawText;
+		if (inlineText !== void 0) rawText = inlineText.replace(/\\n/g, "\r").replace(/\\r/g, "\r").replace(/\\t/g, "	");
+		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 { tabsById, tabNames } = await adapter.getAllData();
+		const tabMatches = adapter.resolveTab(query, tabsById, tabNames);
+		let blockId;
+		if (tabMatches.length === 1) {
+			const blocks = (tabsById.get(tabMatches[0]) ?? []).filter((b) => b.view === "term");
+			if (!blocks.length) {
+				consola.error(`Tab "${tabNames.get(tabMatches[0])}" has no terminal block`);
+				process.exit(1);
+			}
+			blockId = blocks[0].blockid;
+		} else if (tabMatches.length > 1) {
+			consola.error(`Multiple tabs match '${query}':`);
+			for (const tid of tabMatches) consola.log(`  "${tabNames.get(tid)}"  [${tid.slice(0, 8)}]`);
+			process.exit(1);
+		} else {
+			const allBlocks = adapter.blocksList();
+			const blockMatches = adapter.resolveBlock(query, allBlocks);
+			if (!blockMatches.length) {
+				consola.error(`No tab or block matching '${query}' (tabs in workspaces with no open window are not visible — open that workspace first)`);
+				process.exit(1);
+			}
+			if (blockMatches.length > 1) {
+				consola.error(`Multiple blocks match '${query}':`);
+				for (const b of blockMatches) consola.log(`  ${b.blockid}`);
+				process.exit(1);
+			}
+			blockId = blockMatches[0].blockid;
+		}
+		const resp = await adapter.sendInput(blockId, rawText);
+		adapter.closeSocket();
+		if (resp && resp.error) {
+			consola.error(String(resp.error));
+			process.exit(1);
+		}
+		const preview = rawText.slice(0, 80).replace(/\n/g, "↵").replace(/\t/g, "→");
+		consola.success(`Sent to ${blockId.slice(0, 8)}: ${JSON.stringify(preview)}${rawText.length > 80 ? "…" : ""}`);
+	}
+});
+//#endregion
+//#region src/commands/config-cmd.ts
+const configCommand = define({
+	name: "config",
+	description: "Show config file path and current values",
+	args: {},
+	async run() {
+		ensureConfigExists();
+		const config = loadConfig();
+		consola.info(`Config: ${CONFIG_PATH}`);
+		console.log();
+		console.log(`claude.flags    = ${config.claude.flags.length ? JSON.stringify(config.claude.flags) : "(none)"}`);
+		console.log(`defaults.workspace = ${config.defaults.workspace || "(none)"}`);
+	}
+});
+//#endregion
+//#region src/commands/restore.ts
+const restoreCommand = define({
+	name: "restore",
+	description: "Resume Claude sessions in all terminal-state tabs (e.g. after a reboot)",
+	args: {
+		dir: {
+			type: "positional",
+			description: "Working directory (default: cwd)"
+		},
+		dry: {
+			type: "boolean",
+			short: "n",
+			description: "Show what would be resumed without actually doing it"
+		}
+	},
+	async run(ctx) {
+		const dir = resolve((ctx.positionals[1] ?? process.cwd()).replace(/^~/, homedir()));
+		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 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 = [];
+		for (const tab of toResume) {
+			const sessions = findSessionsByName(dir, tab.name);
+			if (sessions.length === 0) {
+				consola.log(`  ${tab.name} — no session named "${tab.name}" found, skipping`);
+				results.push({
+					name: tab.name,
+					result: "no matching session"
+				});
+				continue;
+			}
+			if (sessions.length > 1) {
+				consola.log(`  ${tab.name} — multiple sessions found, skipping (use herd resume --session to pick one)`);
+				results.push({
+					name: tab.name,
+					result: "ambiguous (multiple sessions)"
+				});
+				continue;
+			}
+			const sessionId = sessions[0].id;
+			if (dryRun) {
+				consola.log(`  ${tab.name} → would resume session ${sessionId.slice(0, 8)}…`);
+				results.push({
+					name: tab.name,
+					result: `dry run: ${sessionId.slice(0, 8)}…`
+				});
+				continue;
+			}
+			consola.log(`  ${tab.name} → resuming session ${sessionId.slice(0, 8)}…`);
+			const cmd = `cd ${JSON.stringify(dir)} && 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";
+				}
+			}
+		}
+		adapter.closeSocket();
+		console.log("\nRestore summary:");
+		for (const r of results) console.log(`  ${r.name}: ${r.result}`);
+	}
+});
+//#endregion
+//#region src/commands/index.ts
+const defaultCommand = define({
+	name: "cctabs",
+	description,
+	args: {},
+	async run() {
+		await sessionsCommand.run?.call(this, { args: {} });
+	}
+});
+const subCommands = new Map([
+	["sessions", sessionsCommand],
+	["list", listCommand],
+	["ls", listCommand],
+	["new", newCommand],
+	["resume", resumeCommand],
+	["fork", forkCommand],
+	["close", closeCommand],
+	["rename", renameCommand],
+	["scrollback", scrollbackCommand],
+	["send", sendCommand],
+	["config", configCommand],
+	["restore", restoreCommand]
+]);
+async function run() {
+	await cli(process.argv.slice(2), defaultCommand, {
+		name,
+		version,
+		description,
+		subCommands
+	});
+}
+//#endregion
+//#region src/index.ts
+updateNotifier({ pkg: package_default }).notify();
+run().catch((err) => {
+	console.error(err instanceof Error ? err.message : String(err));
+	process.exit(1);
+});
+//#endregion
+export {};