ccakashic 0.4.0 → 0.6.0

package/README.md

@@ -53,6 +53,8 @@ A local HTTP server starts and your browser opens automatically.
 - **Filter search** — Incremental filtering on list pages
 - **Keyboard navigation** — `j` / `k` to move between messages, `p` / `n` to move between your own prompts
 - **One-click resume in cmux** — `▶ Resume` spawns a [cmux](https://github.com/manaflow-ai/cmux) workspace that runs `cd <session cwd> && claude --resume <id>`; `📋 Copy` copies the same command for any terminal
+- **Reopen what you had open** — After a reboot or a hung cmux, `npx ccakashic restore` (or the dashboard banner) reopens the whole set of sessions you were working in, each in its own cmux workspace. See [below](#reopen-the-sessions-you-had-open)
+- **Read-only JSON feed** — `GET /api/sessions?limit=40&waiting=1` returns what the dashboard shows (title, project, branch, model, `status`, `waiting`, `detailUrl`, `resumeCommand`) so other local tools can reuse the waiting signal. `waiting=1` returns only the sessions asking for you, and is the cheap path — it looks those up by id instead of parsing a whole window of session files
 - **Zero dependencies** — Node.js built-in modules only
 
 ## cmux integration
@@ -73,6 +75,27 @@ Notes:
 - The `cmux` binary is found via `$PATH`, then the common Homebrew locations. If it lives elsewhere, point `CCAKASHIC_CMUX` at it (e.g. `CCAKASHIC_CMUX=/path/to/cmux npx ccakashic`)
 - Disable the integration with `--no-cmux` or `CCAKASHIC_NO_CMUX=1`
 
+## Reopen the sessions you had open
+
+After a reboot (memory pressure, an update) or a hung cmux you had to kill, every `claude` you had open is gone — cmux brings back its workspace tabs, but not the sessions inside them. One command reopens the last set you were working in.
+
+```bash
+# From a terminal inside cmux
+npx ccakashic restore            # lists the sessions you had open, then reopens them
+npx ccakashic restore --dry-run  # just list them
+
+# Optional: record open sessions every minute (launchd, macOS) for an exact list
+npx ccakashic install-agent
+```
+
+**No setup needed.** Without the agent, the list is estimated from the conversation logs: the most recent group of sessions that stopped together. When they were closed normally — including by a shutdown or reboot — each wrote an exit record at the same moment, so the group is precise. When cmux was force-quit nothing gets written, so it falls back to "active within 15 minutes of the last one", which misses sessions that sat idle. Install the agent if that case matters to you.
+
+Sessions are only offered when **none of the group is still running** alongside something older: if you closed one session while others kept going, nothing is offered. Sessions you have already reopened drop off the list, and once a group is fully reopened, older ones are not dug up.
+
+The dashboard shows the same list as a banner (`↺ N sessions you had open`) with checkboxes, `Reopen selected` and `Dismiss`. Each session opens in its own background cmux workspace, a moment apart so a dozen `claude` processes don't start at once. Without cmux, the command prints the `cd … && claude --resume …` lines to paste instead.
+
+With the agent, the list comes from Claude Code's live-session registry (`~/.claude/sessions/`, interactive sessions only), copied every minute into `~/.config/ccakashic/live-sessions.json`. The agent runs its own copy of the recorder from `~/.config/ccakashic/agent/`, not the npx cache, so clearing the cache or upgrading doesn't silently stop it; any later `npx ccakashic` run refreshes that copy. Remove it with `npx ccakashic uninstall-agent`.
+
 ## Options
 
 ```bash

package/dist/agent.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AGENT_DIR = exports.AGENT_PLIST = exports.AGENT_LABEL = void 0;
+exports.buildPlist = buildPlist;
+exports.refreshInstalledAgent = refreshInstalledAgent;
+exports.installAgent = installAgent;
+exports.uninstallAgent = uninstallAgent;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const snapshot_1 = require("./snapshot");
+// launchd agent that records live sessions every minute. It has to live
+// outside both cmux and the ccakashic server: a hung cmux takes the server
+// (usually started inside it) down with it, and the whole point is to have
+// recorded what was running before that happened.
+//
+// ccakashic is mostly run through npx, whose cache directory npm may clear or
+// replace on any version bump. Pointing launchd at it would make the agent stop
+// silently — noticed only after the next crash. So the agent runs its own copy
+// of the compiled snapshot module (Node built-ins only) under ~/.config.
+exports.AGENT_LABEL = 'com.ccakashic.snapshot';
+exports.AGENT_PLIST = path.join(os.homedir(), 'Library', 'LaunchAgents', `${exports.AGENT_LABEL}.plist`);
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'ccakashic');
+const LOG_FILE = path.join(CONFIG_DIR, 'snapshot.log');
+exports.AGENT_DIR = path.join(CONFIG_DIR, 'agent');
+const AGENT_MODULE = path.join(exports.AGENT_DIR, 'snapshot.js');
+const AGENT_RUNNER = path.join(exports.AGENT_DIR, 'run.js');
+const RUNNER_SOURCE = `// Written by \`ccakashic install-agent\`; run by launchd every minute.
+require('./snapshot.js').snapshotNow();
+`;
+const INTERVAL_SEC = 60;
+function xmlEscape(s) {
+    return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+function buildPlist(nodePath, runnerPath) {
+    const args = [nodePath, runnerPath].map((a) => `    <string>${xmlEscape(a)}</string>`).join('\n');
+    return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${exports.AGENT_LABEL}</string>
+  <key>ProgramArguments</key>
+  <array>
+${args}
+  </array>
+  <key>StartInterval</key>
+  <integer>${INTERVAL_SEC}</integer>
+  <key>RunAtLoad</key>
+  <true/>
+  <key>ProcessType</key>
+  <string>Background</string>
+  <key>StandardErrorPath</key>
+  <string>${xmlEscape(LOG_FILE)}</string>
+</dict>
+</plist>
+`;
+}
+function launchctl(args) {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)('launchctl', args, { timeout: 10_000 }, (err, stdout, stderr) => {
+            resolve({ ok: !err, out: `${stdout}${stderr}`.trim() });
+        });
+    });
+}
+// process.execPath is often version-pinned (e.g. ~/.volta/tools/image/node/24.x
+// or an nvm version dir) and vanishes on the next upgrade, silently stopping the
+// agent. A `node` elsewhere on PATH is usually a stable shim or symlink
+// (~/.volta/bin, /opt/homebrew/bin). Version managers put the pinned dir itself
+// first on PATH while running node, so that one is skipped.
+function stableNodePath() {
+    const pinnedDir = path.dirname(process.execPath);
+    for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+        if (!dir || path.resolve(dir) === pinnedDir)
+            continue;
+        const candidate = path.join(dir, 'node');
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            return candidate;
+        }
+        catch {
+            // not here
+        }
+    }
+    return process.execPath;
+}
+const domain = () => `gui/${process.getuid ? process.getuid() : 501}`;
+// The compiled snapshot module that shipped with this ccakashic.
+const bundledModule = () => path.join(__dirname, 'snapshot.js');
+// Write the agent's copy; returns true when anything changed. Atomic per file
+// so a tick firing mid-update never loads a truncated module.
+function writeAgentFiles() {
+    let changed = false;
+    fs.mkdirSync(exports.AGENT_DIR, { recursive: true });
+    for (const [dest, content] of [
+        [AGENT_MODULE, fs.readFileSync(bundledModule(), 'utf-8')],
+        [AGENT_RUNNER, RUNNER_SOURCE],
+    ]) {
+        try {
+            if (fs.readFileSync(dest, 'utf-8') === content)
+                continue;
+        }
+        catch {
+            // not written yet
+        }
+        const tmp = `${dest}.${process.pid}.tmp`;
+        fs.writeFileSync(tmp, content);
+        fs.renameSync(tmp, dest);
+        changed = true;
+    }
+    return changed;
+}
+// Keep an installed agent's copy in step with the ccakashic being run, so a
+// newer version's snapshot format reaches the agent without a reinstall. The
+// plist points at a fixed path, so launchd needs no reload.
+function refreshInstalledAgent() {
+    if (!fs.existsSync(exports.AGENT_PLIST))
+        return;
+    try {
+        writeAgentFiles();
+    }
+    catch {
+        // the previous copy keeps running
+    }
+}
+async function installAgent() {
+    if (process.platform !== 'darwin') {
+        throw new Error('The snapshot agent uses launchd and is macOS-only. Run `ccakashic snapshot` from cron instead.');
+    }
+    writeAgentFiles();
+    fs.mkdirSync(path.dirname(exports.AGENT_PLIST), { recursive: true });
+    const nodePath = stableNodePath();
+    fs.writeFileSync(exports.AGENT_PLIST, buildPlist(nodePath, AGENT_RUNNER));
+    // Re-install cleanly: bootout fails harmlessly when not loaded yet.
+    await launchctl(['bootout', `${domain()}/${exports.AGENT_LABEL}`]);
+    const res = await launchctl(['bootstrap', domain(), exports.AGENT_PLIST]);
+    if (!res.ok)
+        throw new Error(`launchctl bootstrap failed: ${res.out}`);
+    console.log(`Installed ${exports.AGENT_PLIST} (node: ${nodePath})`);
+    console.log(`Recording live sessions every ${INTERVAL_SEC}s → ${snapshot_1.SNAPSHOT_FILE}`);
+    console.log(`(runs its own copy in ${exports.AGENT_DIR}, so clearing the npx cache won't stop it)`);
+}
+async function uninstallAgent() {
+    await launchctl(['bootout', `${domain()}/${exports.AGENT_LABEL}`]);
+    fs.rmSync(exports.AGENT_DIR, { recursive: true, force: true });
+    try {
+        fs.unlinkSync(exports.AGENT_PLIST);
+        console.log(`Removed ${exports.AGENT_PLIST}`);
+    }
+    catch {
+        console.log('Agent was not installed');
+    }
+}

package/dist/api.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SESSION_LIMIT = exports.DEFAULT_SESSION_LIMIT = void 0;
+exports.toSessionRow = toSessionRow;
+exports.parseSessionLimit = parseSessionLimit;
+exports.orderSessionRows = orderSessionRows;
+const dashboard_1 = require("./dashboard");
+const cmux_1 = require("./cmux");
+// Read-only JSON view of what the dashboard already computes, so other local
+// tools can treat ccakashic as the source of truth for "which session is
+// waiting for me" instead of re-deriving it from ~/.claude. The waiting signal
+// in particular cannot be rebuilt elsewhere: it maps cmux's unread
+// notifications through ccakashic's own resume map.
+exports.DEFAULT_SESSION_LIMIT = 40;
+// Each row costs a full session-file read, so cap what one request can ask for.
+exports.MAX_SESSION_LIMIT = 100;
+const PREVIEW_MAX = 200;
+function toSessionRow(session, waiting) {
+    return {
+        id: session.id,
+        projectRawName: session.projectRawName,
+        projectName: session.projectName,
+        cwd: session.cwd,
+        title: (0, dashboard_1.paneTitle)(session),
+        preview: (session.preview || '').slice(0, PREVIEW_MAX),
+        gitBranch: session.gitBranch,
+        model: session.model,
+        lastModified: session.lastModified,
+        status: (0, dashboard_1.paneStatus)(session.lastModified),
+        waiting,
+        detailUrl: `/project/${encodeURIComponent(session.projectRawName)}/session/${encodeURIComponent(session.id)}`,
+        // /api/resume is POST-only and requires the CSRF token, so there is no GET
+        // URL to hand out — and publishing that token from an unauthenticated
+        // endpoint would defeat it. Callers that want to act on a session either
+        // open detailUrl and press Resume, or run resumeCommand themselves.
+        resumeUrl: null,
+        resumeCommand: session.cwd ? (0, cmux_1.buildResumeCommand)(session.cwd, session.id) : null,
+    };
+}
+function parseSessionLimit(raw) {
+    const n = parseInt(raw || '', 10);
+    if (!Number.isFinite(n) || n <= 0)
+        return exports.DEFAULT_SESSION_LIMIT;
+    return Math.min(n, exports.MAX_SESSION_LIMIT);
+}
+function orderSessionRows(rows, limit) {
+    return rows.slice().sort((a, b) => b.lastModified - a.lastModified).slice(0, limit);
+}

package/dist/bin/ccakashic.js

@@ -38,13 +38,18 @@ const http = __importStar(require("http"));
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
 const child_process_1 = require("child_process");
 const util_1 = require("../util");
 const discover_1 = require("../discover");
+const api_1 = require("../api");
 const parser_1 = require("../parser");
 const html_generator_1 = require("../html-generator");
 const pages_1 = require("../pages");
 const dashboard_1 = require("../dashboard");
+const snapshot_1 = require("../snapshot");
+const restore_1 = require("../restore");
+const agent_1 = require("../agent");
 const cmux_1 = require("../cmux");
 // Published at dist/bin/ccakashic.js, so ../../package.json resolves from dist/
 const pkg = __importStar(require("../../package.json"));
@@ -100,16 +105,25 @@ async function buildResumeContext() {
     }
     return { token: RESUME_TOKEN, cmuxAvailable, openSessionIds };
 }
-// sessionId → wait reason, from cmux's unread notifications mapped through the
-// resume map. Only covers ccakashic-resumed sessions; others fall back to the
-// jsonl-derived activity below. Empty when cmux is unavailable/disabled.
+// sessionId → wait reason, from cmux's unread notifications resolved through
+// two independent workspace→session sources. Empty when cmux is
+// unavailable/disabled.
 async function buildCmuxWaitMap() {
     const result = new Map();
     if (NO_CMUX || !(await (0, cmux_1.isCmuxAvailable)()))
         return result;
     try {
         const waiting = await (0, cmux_1.listWaitingWorkspacesCached)();
+        // The resume map only covers sessions ccakashic resumed, which left every
+        // hand-started session permanently unbadged. The live map reads
+        // CMUX_WORKSPACE_ID from each running session's own process and covers
+        // those. They complement each other — the resume map still resolves
+        // sessions that have since exited — so the live one is layered on top,
+        // winning conflicts because it reflects the process attached right now.
         const wsToSession = (0, cmux_1.loadWorkspaceToSession)();
+        for (const [wsId, sessionId] of await (0, cmux_1.liveWorkspaceToSessionCached)()) {
+            wsToSession.set(wsId, sessionId);
+        }
         for (const [wsId, reason] of waiting) {
             const sessionId = wsToSession.get(wsId);
             if (sessionId)
@@ -214,6 +228,58 @@ async function handleResume(req, res) {
         });
     }
 }
+// The stopped group the dashboard offers to bring back, unless dismissed.
+async function buildRestoreBanner() {
+    try {
+        const { state, stop } = (0, restore_1.detectLastStop)();
+        if (!stop || !stop.sessions.length || stop.stoppedAt === state.dismissedStopAt)
+            return undefined;
+        const cmuxAvailable = !NO_CMUX && await (0, cmux_1.isCmuxAvailable)();
+        return {
+            token: RESUME_TOKEN,
+            stoppedAt: stop.stoppedAt,
+            estimated: !!stop.estimated,
+            cmuxAvailable,
+            items: await (0, restore_1.describeStopped)(stop.sessions),
+        };
+    }
+    catch {
+        return undefined; // the banner is an extra; never break the dashboard over it
+    }
+}
+async function handleRestore(req, res, action) {
+    const respond = (status, body) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(body));
+    };
+    if (req.method !== 'POST')
+        return respond(405, { error: 'POST only' });
+    if (req.headers['x-ccakashic-token'] !== RESUME_TOKEN)
+        return respond(403, { error: 'Invalid token' });
+    let body;
+    try {
+        body = await readJsonBody(req);
+    }
+    catch (err) {
+        return respond(400, { error: err?.message || 'Bad request' });
+    }
+    // Recompute rather than trust the page: sessions may have been resumed in the
+    // meantime, and resuming a live one again would fork it.
+    const { state, stop } = (0, restore_1.detectLastStop)();
+    if (!stop || stop.stoppedAt !== body?.stoppedAt) {
+        return respond(409, { error: 'The list is out of date — reload the dashboard' });
+    }
+    if (action === 'dismiss') {
+        (0, snapshot_1.saveSnapshot)({ ...state, dismissedStopAt: stop.stoppedAt });
+        return respond(200, { ok: true });
+    }
+    if (NO_CMUX || !(await (0, cmux_1.isCmuxAvailable)()))
+        return respond(503, { error: 'cmux is not reachable' });
+    const wanted = Array.isArray(body.sessions) ? new Set(body.sessions) : null;
+    const chosen = stop.sessions.filter((s) => !wanted || wanted.has(s.sessionId));
+    const outcomes = await (0, restore_1.restoreAll)(await (0, restore_1.describeStopped)(chosen));
+    return respond(200, { outcomes });
+}
 // Only accept loopback Host headers. The server binds 127.0.0.1, but without
 // this check a malicious site could DNS-rebind its hostname to 127.0.0.1 and
 // become same-origin, defeating the resume token and reading session content.
@@ -241,6 +307,10 @@ const server = http.createServer(async (req, res) => {
             await handleResume(req, res);
             return;
         }
+        if (pathname === '/api/restore' || pathname === '/api/restore/dismiss') {
+            await handleRestore(req, res, pathname === '/api/restore' ? 'run' : 'dismiss');
+            return;
+        }
         if (pathname === '/' || pathname === '') {
             const requested = parseInt(url.searchParams.get('n') || '') || dashboard_1.DEFAULT_PANE_COUNT;
             const paneCount = dashboard_1.PANE_COUNTS.includes(requested) ? requested : dashboard_1.DEFAULT_PANE_COUNT;
@@ -252,7 +322,7 @@ const server = http.createServer(async (req, res) => {
                 waiting: resolveWaiting(session.id, cmuxWait),
             })));
             res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
-            res.end((0, dashboard_1.generateDashboard)(panes, paneCount, await buildResumeContext()));
+            res.end((0, dashboard_1.generateDashboard)(panes, paneCount, await buildResumeContext(), await buildRestoreBanner()));
             return;
         }
         if (pathname === '/projects') {
@@ -291,6 +361,24 @@ const server = http.createServer(async (req, res) => {
             res.end(JSON.stringify({ changed: true, mtime, status, ago, waiting, html: (0, dashboard_1.renderPaneBody)(parsed) }));
             return;
         }
+        // Read-only feed of the dashboard's own view, for other local tools.
+        if (pathname === '/api/sessions') {
+            const limit = (0, api_1.parseSessionLimit)(url.searchParams.get('limit'));
+            const waitingOnly = url.searchParams.get('waiting') === '1';
+            const cmuxWait = await buildCmuxWaitMap();
+            // Waiting sessions are fetched by id rather than filtered out of the
+            // recent window: a session can sit waiting while other projects churn
+            // past it, and reading a wide window means parsing every file in it.
+            const sessions = waitingOnly
+                ? await (0, discover_1.findRecentSessionsByIds)([...cmuxWait.keys()])
+                : await (0, discover_1.listRecentSessions)(limit);
+            const rows = (0, api_1.orderSessionRows)(sessions
+                .map((s) => (0, api_1.toSessionRow)(s, resolveWaiting(s.id, cmuxWait)))
+                .filter((r) => !waitingOnly || r.waiting !== null), limit);
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(rows));
+            return;
+        }
         const projectMatch = pathname.match(/^\/project\/(.+)$/);
         if (projectMatch && !pathname.includes('/session/')) {
             const rawName = decodeURIComponent(projectMatch[1]);
@@ -441,7 +529,91 @@ async function startServer(startPort) {
     }
     throw new Error(`No available port after ${MAX_PORT_TRIES} tries starting at ${startPort}`);
 }
+function formatClock(ms) {
+    const d = new Date(ms);
+    const pad = (n) => String(n).padStart(2, '0');
+    return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+function askYesNo(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(/^(y|yes|)$/i.test(answer.trim()));
+        });
+    });
+}
+async function runRestoreCommand() {
+    const dryRun = process.argv.includes('--dry-run');
+    const yes = process.argv.includes('--yes') || process.argv.includes('-y');
+    const previousRun = (0, snapshot_1.loadSnapshot)().lastRunAt;
+    const { stop, agentInstalled } = (0, restore_1.detectLastStop)();
+    if (stop?.estimated) {
+        console.log('Note: estimated from conversation logs. Sessions left idle before cmux was force-quit may be missing.');
+        console.log(agentInstalled
+            ? '      (these closed before the snapshot agent started recording)\n'
+            : '      Run `npx ccakashic install-agent` to record live sessions every minute for an exact list.\n');
+    }
+    else if (!agentInstalled) {
+        console.log('Tip: `npx ccakashic install-agent` records open sessions every minute for an exact list.\n');
+    }
+    else if (previousRun && Date.now() - previousRun > 5 * 60_000) {
+        console.log(`Note: the last snapshot before this one was at ${formatClock(previousRun)}.\n`);
+    }
+    if (!stop || !stop.sessions.length) {
+        console.log('Nothing to reopen: no closed sessions found (or some from that time are still running).');
+        return;
+    }
+    const items = await (0, restore_1.describeStopped)(stop.sessions);
+    console.log(`${items.length} session(s) you had open until ${formatClock(stop.stoppedAt)}${stop.estimated ? ' (estimated)' : ''}:\n`);
+    for (const it of items)
+        console.log(`  • ${it.title}\n    ${it.cwd}`);
+    console.log('');
+    if (dryRun)
+        return;
+    if (NO_CMUX || !(await (0, cmux_1.isCmuxAvailable)())) {
+        console.log('cmux is not reachable (run this from a terminal inside cmux). Commands to resume by hand:\n');
+        for (const it of items)
+            console.log((0, cmux_1.buildResumeCommand)(it.cwd, it.sessionId));
+        return;
+    }
+    if (!yes && !(await askYesNo(`Reopen all ${items.length} in new cmux workspaces? [Y/n] `)))
+        return;
+    const outcomes = await (0, restore_1.restoreAll)(items, (o) => {
+        console.log(o.ok ? `  ✓ ${o.title}` : `  ✗ ${o.title} — ${o.message}`);
+    });
+    const failed = outcomes.filter((o) => !o.ok).length;
+    console.log(`\nReopened ${outcomes.length - failed} / ${outcomes.length}.`);
+}
+async function runSubcommand(name) {
+    switch (name) {
+        case 'snapshot': {
+            // One-off record; the launchd agent runs its own copy of the same code.
+            (0, snapshot_1.snapshotNow)();
+            return true;
+        }
+        case 'restore':
+            await runRestoreCommand();
+            return true;
+        case 'install-agent':
+            await (0, agent_1.installAgent)();
+            return true;
+        case 'uninstall-agent':
+            await (0, agent_1.uninstallAgent)();
+            return true;
+        default:
+            return false;
+    }
+}
 async function main() {
+    (0, agent_1.refreshInstalledAgent)();
+    const sub = process.argv[2];
+    if (sub && !sub.startsWith('-')) {
+        if (await runSubcommand(sub))
+            return;
+        console.error(`Unknown command: ${sub}\nUsage: ccakashic [restore [--dry-run] [--yes] | install-agent | uninstall-agent | snapshot]`);
+        process.exit(1);
+    }
     const existing = await findExistingCcakashic(PORT);
     if (existing) {
         const url = `http://127.0.0.1:${existing}`;

package/dist/cmux.js

@@ -49,6 +49,10 @@ exports.openInCmuxBrowser = openInCmuxBrowser;
 exports.loadResumeMap = loadResumeMap;
 exports.saveResumeMapEntry = saveResumeMapEntry;
 exports.loadWorkspaceToSession = loadWorkspaceToSession;
+exports.loadSessionRegistry = loadSessionRegistry;
+exports.parseWorkspaceEnv = parseWorkspaceEnv;
+exports.liveWorkspaceToSession = liveWorkspaceToSession;
+exports.liveWorkspaceToSessionCached = liveWorkspaceToSessionCached;
 exports.findLiveWorkspaceForSession = findLiveWorkspaceForSession;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
@@ -260,6 +264,124 @@ function loadWorkspaceToSession() {
     }
     return inv;
 }
+// --- Live workspace mapping, read from the running processes themselves ---
+//
+// The resume map only knows about sessions ccakashic itself resumed, so a
+// session you started by hand inside cmux has no workspace mapping and never
+// gets a waiting badge. Claude Code registers every running session in
+// ~/.claude/sessions/<pid>.json, and a session launched inside cmux inherits
+// CMUX_WORKSPACE_ID in its environment — together those give the same mapping
+// without ccakashic having been involved.
+//
+// The two sources are complements, not replacements: this one sees only live
+// processes, while the resume map still covers sessions that have since exited.
+const SESSION_REGISTRY_DIR = path.join(os.homedir(), '.claude', 'sessions');
+function loadSessionRegistry() {
+    let names;
+    try {
+        names = fs.readdirSync(SESSION_REGISTRY_DIR);
+    }
+    catch {
+        return []; // no registry (older Claude Code, or nothing has run yet)
+    }
+    const out = [];
+    for (const f of names) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const o = JSON.parse(fs.readFileSync(path.join(SESSION_REGISTRY_DIR, f), 'utf-8'));
+            if (typeof o?.pid === 'number' && typeof o?.sessionId === 'string') {
+                out.push({ pid: o.pid, sessionId: o.sessionId, procStart: o.procStart });
+            }
+        }
+        catch {
+            // a half-written or stale record; skip it
+        }
+    }
+    return out;
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0); // signal 0 only probes; it does not signal
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// `ps eww` prints one line per process: pid, then the command, then the
+// process's ENTIRE environment — which routinely holds API keys and tokens.
+// Only CMUX_WORKSPACE_ID is ever pulled out of it; no other variable is
+// stored, returned or logged, and the raw output is not retained.
+function parseWorkspaceEnv(psOutput) {
+    const byPid = new Map();
+    for (const line of psOutput.split('\n')) {
+        const pid = line.match(/^\s*(\d+)\s/);
+        if (!pid)
+            continue;
+        const ws = line.match(/\bCMUX_WORKSPACE_ID=([A-Za-z0-9-]+)/);
+        if (ws)
+            byPid.set(parseInt(pid[1], 10), ws[1].toUpperCase());
+    }
+    return byPid;
+}
+function runPlain(bin, args, timeoutMs = 3000) {
+    return new Promise((resolve) => {
+        (0, child_process_1.execFile)(bin, args, { timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024 }, (err, stdout) => {
+            resolve(err ? '' : stdout);
+        });
+    });
+}
+// A process's environment is fixed at exec time, so a pid only ever needs
+// looking up once. Keyed with procStart as well so a recycled pid can't
+// inherit the previous process's answer. null means "checked, not a cmux
+// process" — cached too, so those aren't re-probed on every poll.
+const workspaceEnvCache = new Map();
+const envKey = (r) => `${r.pid}:${r.procStart ?? ''}`;
+async function liveWorkspaceToSession() {
+    const live = loadSessionRegistry().filter((r) => isProcessAlive(r.pid));
+    const result = new Map();
+    const unknown = [];
+    for (const r of live) {
+        const key = envKey(r);
+        if (workspaceEnvCache.has(key)) {
+            const ws = workspaceEnvCache.get(key);
+            if (ws)
+                result.set(ws, r.sessionId);
+        }
+        else {
+            unknown.push(r);
+        }
+    }
+    if (unknown.length) {
+        // One ps for every new pid at once, not one spawn per session.
+        const out = await runPlain('ps', ['eww', '-p', unknown.map((r) => r.pid).join(',')]);
+        const byPid = parseWorkspaceEnv(out);
+        for (const r of unknown) {
+            const ws = byPid.get(r.pid) ?? null;
+            workspaceEnvCache.set(envKey(r), ws);
+            if (ws)
+                result.set(ws, r.sessionId);
+        }
+    }
+    // Drop entries for processes that are gone, so a long-lived server doesn't
+    // accumulate one per session ever started.
+    const alive = new Set(live.map(envKey));
+    for (const key of workspaceEnvCache.keys()) {
+        if (!alive.has(key))
+            workspaceEnvCache.delete(key);
+    }
+    return result;
+}
+let cachedLiveWorkspaces = null;
+async function liveWorkspaceToSessionCached() {
+    if (cachedLiveWorkspaces && Date.now() - cachedLiveWorkspaces.at < 5_000) {
+        return cachedLiveWorkspaces.value;
+    }
+    const value = await liveWorkspaceToSession();
+    cachedLiveWorkspaces = { value, at: Date.now() };
+    return value;
+}
 async function findLiveWorkspaceForSession(sessionId) {
     const mapped = loadResumeMap()[sessionId];
     if (!mapped)

package/dist/dashboard.js

@@ -4,12 +4,15 @@ exports.DEFAULT_PANE_COUNT = exports.PANE_COUNTS = void 0;
 exports.timeAgo = timeAgo;
 exports.paneStatus = paneStatus;
 exports.renderPaneBody = renderPaneBody;
+exports.paneTitle = paneTitle;
 exports.waitBadgeHtml = waitBadgeHtml;
+exports.restoreBannerHtml = restoreBannerHtml;
 exports.generateDashboard = generateDashboard;
 const template_assets_1 = require("./template-assets");
 const html_generator_1 = require("./html-generator");
 const resume_ui_1 = require("./resume-ui");
 const util_1 = require("./util");
+const cmux_1 = require("./cmux");
 // Multi-pane dashboard: the N most recently active sessions across all
 // projects, each pane showing the last 24h of conversation as a scrollable
 // thread, refreshed by polling /api/pane.
@@ -67,7 +70,30 @@ function waitBadgeHtml(waiting) {
     const label = waiting === 'permission' ? '\u{1F510} Permission' : '⏳ Your turn';
     return `<span class="dash-wait-badge dash-wait-${waiting}">${label}</span>`;
 }
-function generateDashboard(panes, paneCount, resume) {
+function restoreBannerHtml(banner) {
+    if (!banner || !banner.items.length)
+        return '';
+    const n = banner.items.length;
+    const rows = banner.items.map((it) => {
+        const title = it.projectRawName
+            ? `<a href="/project/${encodeURIComponent(it.projectRawName)}/session/${encodeURIComponent(it.sessionId)}">${(0, util_1.escapeHtml)(it.title)}</a>`
+            : (0, util_1.escapeHtml)(it.title);
+        return `<li><label><input type="checkbox" class="dash-restore-check" value="${(0, util_1.escapeHtml)(it.sessionId)}" data-cmd="${(0, util_1.escapeHtml)((0, cmux_1.buildResumeCommand)(it.cwd, it.sessionId))}" checked> ${title}</label> <span class="dash-restore-cwd">${(0, util_1.escapeHtml)(it.cwd)}</span></li>`;
+    }).join('');
+    const action = banner.cmuxAvailable
+        ? `<button type="button" class="dash-restore-run">&#9654; Reopen selected</button>`
+        : `<button type="button" class="dash-restore-copy">&#128203; Copy commands</button>`;
+    return `<div class="dash-restore" data-stopped-at="${banner.stoppedAt}" data-token="${(0, util_1.escapeHtml)(banner.token)}">
+  <div class="dash-restore-head">
+    <span>&#8634; <b>${n} session${n === 1 ? '' : 's'}</b> you had open until <span class="dash-restore-at" data-ts="${banner.stoppedAt}"></span>${banner.estimated ? ' <span class="dash-restore-est" title="Estimated from conversation logs; sessions left idle before cmux was force-quit may be missing. Run `npx ccakashic install-agent` for an exact list.">(estimated)</span>' : ''}</span>
+    ${action}
+    <button type="button" class="dash-restore-dismiss">Dismiss</button>
+    <span class="dash-restore-status"></span>
+  </div>
+  <ul class="dash-restore-list">${rows}</ul>
+</div>`;
+}
+function generateDashboard(panes, paneCount, resume, restore) {
     const cols = paneCount <= 4 ? Math.max(panes.length, 1) : Math.ceil(paneCount / 2);
     const rows = paneCount <= 4 ? 1 : 2;
     const panesHtml = panes.map(({ session: s, bodyHtml, waiting }) => {
@@ -110,6 +136,7 @@ ${dashboardCSS(cols, rows)}
   <span class="dash-counts">Panes: ${countLinks}</span>
   <a class="dash-nav-link" href="/projects">All projects &rarr;</a>
 </div>
+${restoreBannerHtml(restore)}
 <div class="dash-grid">
 ${panesHtml || '<div class="empty">No sessions found</div>'}
 </div>
@@ -251,6 +278,36 @@ function dashboardCSS(cols, rows) {
 }
 .empty { text-align: center; color: var(--text-muted); padding: 40px; }
 
+.dash-restore {
+  flex-shrink: 0;
+  max-height: 40vh;
+  overflow-y: auto;
+  margin: 8px 8px 0;
+  padding: 8px 12px;
+  border: 1px solid #f97316;
+  border-radius: 8px;
+  background: rgba(249, 115, 22, 0.08);
+  font-size: 0.82rem;
+}
+.dash-restore-head { display: flex; align-items: center; gap: 10px; flex-wrap: wrap; }
+.dash-restore-head button {
+  font-size: 0.75rem;
+  font-weight: 600;
+  padding: 3px 10px;
+  border-radius: 5px;
+  border: 1px solid var(--border);
+  background: var(--tool-bg);
+  color: var(--text);
+  cursor: pointer;
+}
+.dash-restore-head .dash-restore-run { border-color: #f97316; }
+.dash-restore-head button:disabled { opacity: 0.5; cursor: wait; }
+.dash-restore-status, .dash-restore-est { color: var(--text-muted); }
+.dash-restore-list { list-style: none; margin: 6px 0 0; padding: 0; columns: 2 360px; }
+.dash-restore-list li { white-space: nowrap; overflow: hidden; text-overflow: ellipsis; padding: 1px 0; }
+.dash-restore-list a { color: var(--text); }
+.dash-restore-cwd { color: var(--text-muted); font-size: 0.72rem; margin-left: 4px; }
+
 @media (max-width: 900px) {
   .dash-page { height: auto; overflow: auto; }
   .dash-grid { grid-template-columns: 1fr; grid-template-rows: none; grid-auto-rows: 70vh; }
@@ -321,6 +378,46 @@ function dashboardJS() {
     }).catch(function() { /* server briefly unavailable; retry next tick */ });
   }
 
+  var restore = document.querySelector('.dash-restore');
+  if (restore) {
+    var at = restore.querySelector('.dash-restore-at');
+    if (at) at.textContent = new Date(Number(at.dataset.ts)).toLocaleString();
+    var status = restore.querySelector('.dash-restore-status');
+    var checked = function() {
+      return Array.prototype.slice.call(restore.querySelectorAll('.dash-restore-check:checked'));
+    };
+    var post = function(path, body) {
+      body.stoppedAt = Number(restore.dataset.stoppedAt);
+      return fetch(path, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'X-Ccakashic-Token': restore.dataset.token },
+        body: JSON.stringify(body)
+      }).then(function(res) { return res.json(); });
+    };
+    restore.addEventListener('click', function(e) {
+      var btn = e.target.closest ? e.target.closest('button') : null;
+      if (!btn) return;
+      if (btn.classList.contains('dash-restore-dismiss')) {
+        post('/api/restore/dismiss', {}).then(function() { restore.remove(); });
+      } else if (btn.classList.contains('dash-restore-copy')) {
+        var cmds = checked().map(function(c) { return c.dataset.cmd; }).join('\n');
+        navigator.clipboard.writeText(cmds).then(function() { status.textContent = 'Copied'; });
+      } else if (btn.classList.contains('dash-restore-run')) {
+        var ids = checked().map(function(c) { return c.value; });
+        if (!ids.length) return;
+        btn.disabled = true;
+        status.textContent = 'Reopening ' + ids.length + '…';
+        post('/api/restore', { sessions: ids }).then(function(data) {
+          if (!data.outcomes) { btn.disabled = false; status.textContent = data.error || 'Reopen failed'; return; }
+          var failed = data.outcomes.filter(function(o) { return !o.ok; });
+          if (!failed.length) { restore.remove(); return; }
+          btn.disabled = false;
+          status.textContent = 'Failed: ' + failed.map(function(o) { return o.title + ' (' + o.message + ')'; }).join(', ');
+        }).catch(function() { btn.disabled = false; status.textContent = 'Reopen failed: server unreachable'; });
+      }
+    });
+  }
+
   syncWaitingIndicator();
   setInterval(function() {
     document.querySelectorAll('.dash-pane').forEach(refreshPane);

package/dist/discover.js

@@ -38,6 +38,7 @@ exports.decodeDirName = decodeDirName;
 exports.listProjects = listProjects;
 exports.listSessions = listSessions;
 exports.listRecentSessions = listRecentSessions;
+exports.findRecentSessionsByIds = findRecentSessionsByIds;
 exports.readCwdFromSession = readCwdFromSession;
 exports.findSessionForCwd = findSessionForCwd;
 const fs = __importStar(require("fs"));
@@ -232,6 +233,32 @@ async function listRecentSessions(limit) {
         projectName: top[i].scan.name,
     }));
 }
+// Locate specific sessions by id. scanProjects only stats filenames, so this
+// parses just the matched files — unlike listRecentSessions, which parses every
+// file in its window (getSessionPreview reads a session end to end to total its
+// tokens). Callers that know which ids they want should use this: a session can
+// sit waiting for you while other projects churn past it, so it is not
+// necessarily inside any "most recent N" window.
+async function findRecentSessionsByIds(ids) {
+    const wanted = new Set(ids);
+    if (!wanted.size)
+        return [];
+    const scans = await scanProjects();
+    const hits = [];
+    for (const scan of scans) {
+        for (const f of scan.files) {
+            if (wanted.has(f.file.replace(/\.jsonl$/, ''))) {
+                hits.push({ file: path.join(scan.dir, f.file), scan });
+            }
+        }
+    }
+    const previews = await Promise.all(hits.map((h) => getSessionPreview(h.file)));
+    return previews.map((s, i) => ({
+        ...s,
+        projectRawName: hits[i].scan.rawName,
+        projectName: hits[i].scan.name,
+    }));
+}
 function readCwdFromSession(filePath) {
     return new Promise((resolve) => {
         const rl = readline.createInterface({

package/dist/infer.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLogFacts = readLogFacts;
+exports.inferLastStop = inferLastStop;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const discover_1 = require("./discover");
+// Best-effort "what was running before the crash" from the conversation logs
+// alone, for when the snapshot agent is not installed.
+//
+// What the logs can and cannot tell:
+// - A session that exits (including during a normal shutdown/reboot) appends a
+//   `cost-state` record, usually followed by a line or two of bookkeeping. A
+//   burst of those right before a gap is a reliable signature.
+// - A session killed outright (cmux force-quit while hung) writes nothing. All
+//   that is left is when it was last active, so a session idling for hours
+//   before the hang is missed. Results are therefore marked `estimated`.
+// Sessions that exit on the same shutdown finish within seconds of each other.
+const EXIT_BURST_WINDOW_MS = 3 * 60_000;
+// Without exit records, "recently active before the newest one" is the best proxy.
+const ACTIVITY_WINDOW_MS = 15 * 60_000;
+const LOOKBACK_MS = 7 * 24 * 60 * 60_000;
+const CHUNK = 64 * 1024;
+function readChunk(file, fromEnd) {
+    let fd;
+    try {
+        fd = fs.openSync(file, 'r');
+        const size = fs.fstatSync(fd).size;
+        const len = Math.min(CHUNK, size);
+        const buf = Buffer.alloc(len);
+        fs.readSync(fd, buf, 0, len, fromEnd ? size - len : 0);
+        return buf.toString('utf-8');
+    }
+    catch {
+        return '';
+    }
+    finally {
+        if (fd !== undefined)
+            fs.closeSync(fd);
+    }
+}
+function parseLines(text) {
+    const out = [];
+    for (const line of text.split('\n')) {
+        try {
+            out.push(JSON.parse(line));
+        }
+        catch {
+            // partial first/last line of the chunk
+        }
+    }
+    return out;
+}
+function readLogFacts(file) {
+    let entrypoint = null;
+    let cwd = null;
+    for (const o of parseLines(readChunk(file, false))) {
+        entrypoint ??= typeof o?.entrypoint === 'string' ? o.entrypoint : null;
+        cwd ??= typeof o?.cwd === 'string' ? o.cwd : null;
+        if (entrypoint && cwd)
+            break;
+    }
+    // Only the last few records: an exit writes cost-state and then a little
+    // bookkeeping (e.g. artifact-comment-monitor), so it isn't always the last line.
+    const exited = parseLines(readChunk(file, true)).slice(-8).some((o) => o?.type === 'cost-state');
+    return { interactive: !entrypoint || entrypoint === 'cli', cwd, exited };
+}
+function listLogFiles(root, since) {
+    const out = [];
+    let dirs;
+    try {
+        dirs = fs.readdirSync(root);
+    }
+    catch {
+        return out;
+    }
+    for (const d of dirs) {
+        let names;
+        try {
+            names = fs.readdirSync(path.join(root, d));
+        }
+        catch {
+            continue;
+        }
+        for (const f of names) {
+            if (!f.endsWith('.jsonl'))
+                continue;
+            const file = path.join(root, d, f);
+            try {
+                const mtime = fs.statSync(file).mtimeMs;
+                if (mtime >= since)
+                    out.push({ sessionId: f.slice(0, -'.jsonl'.length), file, mtime });
+            }
+            catch {
+                // vanished mid-scan
+            }
+        }
+    }
+    return out.sort((a, b) => b.mtime - a.mtime);
+}
+function inferLastStop(live, now = Date.now(), root = discover_1.CLAUDE_DIR, readFacts = readLogFacts) {
+    const liveIds = new Set(live.map((s) => s.sessionId));
+    const factsCache = new Map();
+    const facts = (f) => {
+        let v = factsCache.get(f.file);
+        if (!v)
+            factsCache.set(f.file, (v = readFacts(f.file)));
+        return v;
+    };
+    // Newest interactive session that is no longer running marks the stop.
+    const dead = listLogFiles(root, now - LOOKBACK_MS).filter((f) => !liveIds.has(f.sessionId));
+    const newest = dead.find((f) => facts(f).interactive && facts(f).cwd);
+    if (!newest)
+        return null;
+    const stoppedAt = Math.floor(newest.mtime); // an integer survives the round trip through the page
+    // Same rule as the recorded path: a session started before the stop and still
+    // running means the others were closed on purpose, not killed together.
+    if (live.some((s) => s.startedAt !== undefined && s.startedAt <= stoppedAt))
+        return null;
+    const burst = facts(newest).exited;
+    const window = burst ? EXIT_BURST_WINDOW_MS : ACTIVITY_WINDOW_MS;
+    const sessions = [];
+    for (const f of dead) {
+        if (f.mtime < stoppedAt - window)
+            break; // sorted newest first
+        const x = facts(f);
+        if (!x.interactive || !x.cwd)
+            continue;
+        // In a shutdown burst, only sessions that actually exited belong to it.
+        if (burst && !x.exited)
+            continue;
+        sessions.push({ sessionId: f.sessionId, cwd: x.cwd, name: null, proc: 'log', aliveSince: f.mtime, lastSeenAlive: f.mtime });
+    }
+    return { stoppedAt, sessions, estimated: true };
+}

package/dist/restore.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectLastStop = detectLastStop;
+exports.chooseStop = chooseStop;
+exports.describeStopped = describeStopped;
+exports.restoreAll = restoreAll;
+const fs = __importStar(require("fs"));
+const discover_1 = require("./discover");
+const cmux_1 = require("./cmux");
+const snapshot_1 = require("./snapshot");
+const infer_1 = require("./infer");
+const agent_1 = require("./agent");
+// Starting a dozen `claude` processes at once is what tends to cause the memory
+// pressure this feature recovers from, so space them out a little.
+const STAGGER_MS = 1500;
+// The stop to offer. The agent's records are exact but only reach back to when
+// it started recording; anything else (no agent, or a stop that predates it)
+// is guessed from the conversation logs. Either way the current registry is
+// recorded first so already-resumed sessions count as running.
+function detectLastStop(now = Date.now()) {
+    const live = (0, snapshot_1.readLiveSessions)();
+    const agentInstalled = fs.existsSync(agent_1.AGENT_PLIST);
+    const { state, stop } = chooseStop((0, snapshot_1.recordLive)((0, snapshot_1.loadSnapshot)(), live, now), live, agentInstalled, () => (0, infer_1.inferLastStop)(live, now));
+    try {
+        (0, snapshot_1.saveSnapshot)(state);
+    }
+    catch {
+        // read-only use still works from the in-memory state
+    }
+    return { state, stop, agentInstalled };
+}
+// Pure decision between the agent's records and a log estimate; returns the
+// state to persist alongside it.
+function chooseStop(state, live, agentInstalled, infer) {
+    if (agentInstalled) {
+        const recorded = (0, snapshot_1.findLastStop)(state, new Set(live.map((s) => s.sessionId)));
+        if (recorded)
+            return { state, stop: recorded };
+    }
+    const inferred = infer();
+    if (!inferred)
+        return { state, stop: null };
+    // Within the recorded period the agent saw no stop, so trust it over a guess.
+    if (agentInstalled && state.recordingSince !== null && inferred.stoppedAt >= state.recordingSince) {
+        return { state, stop: null };
+    }
+    if (state.lastEstimatedStopAt !== null && inferred.stoppedAt < state.lastEstimatedStopAt) {
+        return { state, stop: null };
+    }
+    return { state: { ...state, lastEstimatedStopAt: inferred.stoppedAt }, stop: inferred };
+}
+async function describeStopped(sessions) {
+    const previews = await (0, discover_1.findRecentSessionsByIds)(sessions.map((s) => s.sessionId));
+    const byId = new Map(previews.map((p) => [p.id, p]));
+    return sessions.map((s) => {
+        const p = byId.get(s.sessionId);
+        return {
+            sessionId: s.sessionId,
+            cwd: s.cwd,
+            title: p?.customTitle || p?.aiTitle || s.name || p?.slug || s.sessionId.slice(0, 8),
+            projectRawName: p?.projectRawName ?? null,
+        };
+    });
+}
+async function restoreAll(items, onProgress) {
+    const outcomes = [];
+    for (let i = 0; i < items.length; i++) {
+        const it = items[i];
+        let outcome;
+        if (!it.projectRawName) {
+            outcome = { sessionId: it.sessionId, title: it.title, ok: false, message: 'no conversation log (nothing to resume)' };
+        }
+        else if (!fs.existsSync(it.cwd)) {
+            outcome = { sessionId: it.sessionId, title: it.title, ok: false, message: `directory no longer exists: ${it.cwd}` };
+        }
+        else {
+            try {
+                // Background: keep focus where it is instead of flicking through every tab.
+                const { workspaceId } = await (0, cmux_1.resumeInNewWorkspace)(it.cwd, it.sessionId, it.title, true);
+                (0, cmux_1.saveResumeMapEntry)(it.sessionId, workspaceId);
+                outcome = { sessionId: it.sessionId, title: it.title, ok: true };
+            }
+            catch (err) {
+                outcome = { sessionId: it.sessionId, title: it.title, ok: false, message: err?.message || String(err) };
+            }
+            if (i < items.length - 1)
+                await new Promise((r) => setTimeout(r, STAGGER_MS));
+        }
+        outcomes.push(outcome);
+        onProgress?.(outcome);
+    }
+    return outcomes;
+}

package/dist/snapshot.js

@@ -0,0 +1,176 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SNAPSHOT_FILE = void 0;
+exports.emptyState = emptyState;
+exports.loadSnapshot = loadSnapshot;
+exports.saveSnapshot = saveSnapshot;
+exports.readLiveSessions = readLiveSessions;
+exports.recordLive = recordLive;
+exports.findLastStop = findLastStop;
+exports.snapshotNow = snapshotNow;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+// "What was running before the crash?" — a record of live Claude Code sessions
+// that outlives the processes, so they can be brought back in one go after a
+// reboot or a hung cmux.
+//
+// Claude Code keeps ~/.claude/sessions/<pid>.json only while a session runs and
+// removes it on exit (stale ones are swept at the next launch), so the registry
+// itself is gone by the time you need it. `ccakashic snapshot` copies it into
+// our own file on a timer (a launchd agent, see agent.ts) and keeps, per
+// session, when it was last seen alive.
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'ccakashic');
+exports.SNAPSHOT_FILE = path.join(CONFIG_DIR, 'live-sessions.json');
+const SESSION_REGISTRY_DIR = path.join(os.homedir(), '.claude', 'sessions');
+// Sessions killed by the same event share their last sighting, give or take a
+// run that was in progress while they went down.
+const GROUP_WINDOW_MS = 150_000;
+const RETENTION_MS = 14 * 24 * 60 * 60_000;
+function emptyState() {
+    return { version: 1, lastRunAt: 0, recordingSince: null, lastEstimatedStopAt: null, dismissedStopAt: null, sessions: {} };
+}
+function loadSnapshot(file = exports.SNAPSHOT_FILE) {
+    try {
+        const data = JSON.parse(fs.readFileSync(file, 'utf-8'));
+        if (data && data.version === 1 && data.sessions && typeof data.sessions === 'object') {
+            return { ...emptyState(), ...data };
+        }
+    }
+    catch {
+        // not recorded yet
+    }
+    return emptyState();
+}
+function saveSnapshot(state, file = exports.SNAPSHOT_FILE) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    // Atomic: this file is exactly what a crash must not leave half-written.
+    const tmp = `${file}.${process.pid}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
+    fs.renameSync(tmp, file);
+}
+function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err?.code === 'EPERM'; // exists, just not ours
+    }
+}
+// Interactive sessions whose process is running right now. Headless `claude -p`
+// runs (git hooks, scripts) register too but are not something to resume.
+function readLiveSessions(dir = SESSION_REGISTRY_DIR) {
+    let names;
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    const out = new Map();
+    for (const f of names) {
+        if (!f.endsWith('.json'))
+            continue;
+        try {
+            const o = JSON.parse(fs.readFileSync(path.join(dir, f), 'utf-8'));
+            if (typeof o?.pid !== 'number' || typeof o?.sessionId !== 'string' || typeof o?.cwd !== 'string')
+                continue;
+            if (o.kind && o.kind !== 'interactive')
+                continue;
+            if (!isProcessAlive(o.pid))
+                continue;
+            out.set(o.sessionId, {
+                sessionId: o.sessionId,
+                cwd: o.cwd,
+                name: typeof o.name === 'string' ? o.name : null,
+                proc: `${o.pid}:${o.procStart ?? ''}`,
+                ...(typeof o.startedAt === 'number' ? { startedAt: o.startedAt } : {}),
+            });
+        }
+        catch {
+            // half-written record
+        }
+    }
+    return [...out.values()];
+}
+function recordLive(state, live, now) {
+    const sessions = {};
+    for (const [id, e] of Object.entries(state.sessions)) {
+        if (now - e.lastSeenAlive < RETENTION_MS)
+            sessions[id] = e;
+    }
+    for (const s of live) {
+        const prev = sessions[s.sessionId];
+        const sameProcess = prev && prev.proc === s.proc;
+        sessions[s.sessionId] = {
+            cwd: s.cwd,
+            name: s.name ?? prev?.name ?? null,
+            proc: s.proc,
+            aliveSince: sameProcess ? prev.aliveSince : now,
+            lastSeenAlive: now,
+        };
+    }
+    return { ...state, lastRunAt: now, recordingSince: state.recordingSince ?? now, sessions };
+}
+// The most recent group of sessions that went down together and has not been
+// brought back. A group only counts as a stop when nothing survived it: if some
+// session was alive both before and after, the others were closed one by one on
+// purpose (/exit, closing a tab), not killed by a reboot or a hung cmux.
+function findLastStop(state, liveIds) {
+    const dead = [];
+    for (const [sessionId, e] of Object.entries(state.sessions)) {
+        if (!liveIds.has(sessionId))
+            dead.push({ sessionId, ...e });
+    }
+    if (!dead.length)
+        return null;
+    const stoppedAt = Math.max(...dead.map((d) => d.lastSeenAlive));
+    for (const id of liveIds) {
+        const e = state.sessions[id];
+        if (e && e.aliveSince <= stoppedAt)
+            return null;
+    }
+    const sessions = dead
+        .filter((d) => d.lastSeenAlive >= stoppedAt - GROUP_WINDOW_MS)
+        .sort((a, b) => b.lastSeenAlive - a.lastSeenAlive || a.cwd.localeCompare(b.cwd));
+    return { stoppedAt, sessions };
+}
+// One launchd tick. Kept free of any import beyond Node built-ins: the agent
+// runs a copy of this compiled file, not the installed package (see agent.ts).
+function snapshotNow(now = Date.now()) {
+    saveSnapshot(recordLive(loadSnapshot(), readLiveSessions(), now));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccakashic",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "A cross-project dashboard for your Claude Code sessions (~/.claude/projects/) — browse logs as beautiful HTML, see which sessions are waiting for you, and resume any of them in one click via cmux",
   "bin": {
     "ccakashic": "dist/bin/ccakashic.js"