@generativereality/cctabs 0.3.0 → 0.3.1

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "cctabs",
   "description": "Claude Code tab manager. Terminal tabs as the UI, no tmux. Claude can orchestrate its own sibling sessions.",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "author": {
     "name": "generativereality",
     "url": "https://cctabs.com"

package/README.md

@@ -67,15 +67,17 @@ curl -fsSL https://raw.githubusercontent.com/generativereality/cctabs/main/skill
 ## Usage
 
 ```
-cctabs sessions                          what's running (active/idle status)
+cctabs sessions [--json]                 what's running (active/idle status)
 cctabs list                              all workspaces, tabs, and blocks
 cctabs new <name> [dir] [-w workspace]   open tab, start claude
+cctabs new <name> [dir] -r <session-id>  open tab, resume an existing session by ID
 cctabs resume <name> [dir]               open tab, run claude --continue
 cctabs fork <tab> [-n new-name]          fork a session into a new tab
 cctabs close <tab>                       close a tab
 cctabs rename <tab> <new-name>           rename a tab
 cctabs scrollback <tab> [lines]          read terminal output (default: 50 lines)
-cctabs send <tab> [text]                 send input — arg, --file, or stdin pipe
+cctabs send <tab> [text] [--wait-for-prompt]   send input — arg, --file, or stdin pipe
+cctabs restore [--manifest <file|->] [--create-missing]   reattach or spawn from a manifest
 cctabs config                            show config path and values
 ```
 
@@ -114,6 +116,31 @@ cctabs scrollback auth          # last 50 lines
 cctabs scrollback auth 200      # last 200 lines
 ```
 
+### Resume a specific session in a new tab
+
+```bash
+# Useful when multiple sessions share the same dir — pass the exact session ID
+cctabs new auth ~/Dev/myapp -r 19aae7b4-1234-…
+
+# Combines with --worktree to resume inside an existing worktree
+cctabs new auth ~/Dev/myapp -W -r 19aae7b4-…
+```
+
+`cctabs resume <name>` is the right tool when there's only one session for a dir. Use `cctabs new ... --resume` when you need to disambiguate by session ID.
+
+### Migrate a fleet between terminals
+
+```bash
+# On the source terminal, dump everything as a manifest
+cctabs sessions --json > /tmp/fleet.json
+
+# On the destination terminal, attach to any existing tabs and spawn the rest
+cctabs restore --manifest /tmp/fleet.json --create-missing
+
+# Or pipe directly
+cctabs sessions --json | cctabs restore --manifest - --create-missing
+```
+
 ### Fork a session
 
 ```bash

package/dist/index.js

@@ -11,7 +11,7 @@ import { consola } from "consola";
 import * as p from "@clack/prompts";
 //#region package.json
 var name = "@generativereality/cctabs";
-var version = "0.3.0";
+var version = "0.3.1";
 var description = "Claude Code tab manager. Terminal tabs as the UI, no tmux.";
 var package_default = {
 	name,
@@ -641,17 +641,28 @@ var TabbyAdapter = class {
 		return true;
 	}
 	detectSessionStatus(blockId) {
-		const tail = this.scrollback(blockId, 10);
+		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",
-			"✻ Thinking",
-			"✽ Hatching",
-			"⏵⏵ bypass"
-		].some((s) => tail.includes(s))) return "active";
+			"⏵⏵ 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";
 	}
@@ -819,16 +830,288 @@ function requireAdapter() {
 	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() {
+	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 = 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) {
@@ -1246,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",
@@ -1264,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) {
@@ -1287,10 +1594,15 @@ const newCommand = define({
 			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: useWorktree ? `claude --worktree ${JSON.stringify(name)}` : "claude",
+			claudeCmd,
 			workspaceQuery: workspace,
 			initialPromptFile,
 			envVars,
@@ -1298,236 +1610,11 @@ const newCommand = define({
 		});
 		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}`);
+		const rs = resolvedSessionId ? ` --resume ${resolvedSessionId.slice(0, 8)}…` : "";
+		consola.success(`Tab "${name}" [${tabId.slice(0, 8)}] → claude${rs} 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);
-		}
-	}
-	return matches.length === 1 ? matches[0] : null;
-}
-//#endregion
 //#region src/commands/resume.ts
 function shellQuoteEnv(env) {
 	const entries = Object.entries(env);
@@ -1938,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) {
@@ -1945,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);
@@ -1983,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) {
@@ -2010,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 = 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 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({
@@ -2538,7 +2877,8 @@ async function run() {
 		name,
 		version,
 		description,
-		subCommands
+		subCommands,
+		renderHeader: null
 	});
 }
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@generativereality/cctabs",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Claude Code tab manager. Terminal tabs as the UI, no tmux.",
   "type": "module",
   "bin": {

package/skills/cctabs/SKILL.md

@@ -1,6 +1,13 @@
 ---
 name: cctabs
-description: Manage Claude Code sessions across terminal tabs (NOT browser tabs) — list running sessions, open new ones, fork, close, inspect output, and send input. Use this when working with multiple parallel Claude Code sessions in terminal tabs.
+description: |
+  Manage Claude Code sessions across terminal tabs (Wave Terminal or Tabby) — list, open, fork, close, inspect output, send input. Each terminal tab runs its own Claude Code session.
+
+  TRIGGER when the user says any of: "open a new tab", "open a new cctab" (singular alias), "spawn a tab", "a new cctabs session", "in another tab", "in a separate tab", "fork this tab", "list my tabs", "close that tab", "send to <tab>", "resume <name>" — anything that refers to a terminal tab running Claude Code. ALSO trigger for: "/cctabs", or when the user mentions Wave Terminal / Tabby tab management for Claude Code.
+
+  DO NOT confuse with the Agent tool (background subagents): if the user explicitly says "tab" / "cctab" / "cctabs" they want a separate Claude Code session in a real terminal tab — call this skill, not Agent. The Agent tool is correct when the user says "subagent", "background agent", "spawn an agent", "do this in parallel without a new tab", or when the work is interconnected with the current session's filesystem state.
+
+  NOT for: browser tabs (use playwright/browser-automation), tmux panes, screen sessions, or non-Claude terminals.
 ---
 
 You are managing Claude Code sessions using the `cctabs` CLI.