ccakashic 0.5.0 → 0.6.1

package/README.md

@@ -53,6 +53,7 @@ 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
 
@@ -74,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/bin/ccakashic.js

@@ -38,6 +38,7 @@ 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");
@@ -46,6 +47,9 @@ 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"));
@@ -224,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.
@@ -251,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;
@@ -262,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') {
@@ -469,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/dashboard.js

@@ -6,11 +6,13 @@ 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.
@@ -68,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 }) => {
@@ -111,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>
@@ -252,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; }
@@ -322,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

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CLAUDE_DIR = void 0;
+exports.listKnownSessionIds = listKnownSessionIds;
 exports.decodeDirName = decodeDirName;
 exports.listProjects = listProjects;
 exports.listSessions = listSessions;
@@ -46,6 +47,32 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const readline = __importStar(require("readline"));
 exports.CLAUDE_DIR = path.join(os.homedir(), '.claude', 'projects');
+// Every session id that has a conversation log, by filename only (no parsing).
+// A session with no log cannot be resumed, so restore uses this to skip them.
+function listKnownSessionIds(root = exports.CLAUDE_DIR) {
+    const ids = new Set();
+    let dirs;
+    try {
+        dirs = fs.readdirSync(root);
+    }
+    catch {
+        return ids;
+    }
+    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'))
+                ids.add(f.slice(0, -'.jsonl'.length));
+        }
+    }
+    return ids;
+}
 function decodeDirName(dirName) {
     // Directory names encode paths: /Users/foo/bar → -Users-foo-bar
     // This is lossy (dots become dashes too), but good enough for display

package/dist/infer.js

@@ -0,0 +1,174 @@
+"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");
+const snapshot_1 = require("./snapshot");
+// 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, notOlderThan = 0) {
+    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;
+    };
+    const dead = listLogFiles(root, now - LOOKBACK_MS)
+        .filter((f) => !liveIds.has(f.sessionId) && facts(f).interactive && facts(f).cwd);
+    if (!dead.length)
+        return null;
+    // Same shape as the recorded path: prefer a group that stopped together over a
+    // lone session that happens to be newer (a scheduled run, a quick question).
+    // Without exit records the times are "last active", so they spread out more.
+    const anchor = dead[0];
+    const gap = facts(anchor).exited ? EXIT_BURST_WINDOW_MS : ACTIVITY_WINDOW_MS;
+    const group = (0, snapshot_1.pickStoppedGroup)(dead, (f) => f.mtime, gap);
+    const burst = facts(group[0]).exited;
+    const stoppedAt = Math.floor(group[0].mtime); // an integer survives the round trip through the page
+    if (stoppedAt < notOlderThan)
+        return null;
+    // A session started before the stop and still running means the others were
+    // closed on purpose, not taken down together.
+    if (live.some((s) => s.startedAt !== undefined && s.startedAt <= stoppedAt))
+        return null;
+    const sessions = group
+        // In a shutdown burst, only sessions that actually exited belong to it.
+        .filter((f) => !burst || facts(f).exited)
+        .map((f) => ({
+        sessionId: f.sessionId,
+        cwd: facts(f).cwd,
+        name: null,
+        proc: 'log',
+        aliveSince: f.mtime,
+        lastSeenAlive: f.mtime,
+    }));
+    return { stoppedAt, sessions, estimated: true };
+}

package/dist/restore.js

@@ -0,0 +1,130 @@
+"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 known = (0, discover_1.listKnownSessionIds)();
+    const { state, stop } = chooseStop((0, snapshot_1.recordLive)((0, snapshot_1.loadSnapshot)(), live, now), live, agentInstalled, (notOlderThan) => (0, infer_1.inferLastStop)(live, now, undefined, undefined, notOlderThan), (id) => known.has(id));
+    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, resumable = () => true) {
+    // Never dig further back than the last group offered: once those are reopened,
+    // the group before them is just history, not something that stopped on you.
+    const floor = state.lastOfferedStopAt ?? 0;
+    const liveIds = new Set(live.map((s) => s.sessionId));
+    const stop = (agentInstalled ? (0, snapshot_1.findLastStop)(state, liveIds, resumable, floor) : null)
+        // Within the recorded period the agent's records are the truth, so the log
+        // estimate is only for stops from before recording began.
+        ?? inferBeforeRecording(state, agentInstalled, infer, floor);
+    if (!stop)
+        return { state, stop: null };
+    return { state: { ...state, lastOfferedStopAt: Math.max(floor, stop.stoppedAt) }, stop };
+}
+function inferBeforeRecording(state, agentInstalled, infer, floor) {
+    const inferred = infer(floor);
+    if (!inferred)
+        return null;
+    if (agentInstalled && state.recordingSince !== null && inferred.stoppedAt >= state.recordingSince)
+        return null;
+    return 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,205 @@
+"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.pickStoppedGroup = pickStoppedGroup;
+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 the
+// run that was in progress while they went down. Measured between consecutive
+// sightings, not from the newest one: a session that was opened and closed after
+// the stop must not push the real group out of a fixed window.
+const GROUP_GAP_MS = 150_000;
+const RETENTION_MS = 14 * 24 * 60 * 60_000;
+function emptyState() {
+    return { version: 1, lastRunAt: 0, recordingSince: null, lastOfferedStopAt: 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') {
+            const state = { ...emptyState(), ...data };
+            // 0.6.0 called it lastEstimatedStopAt, when only the log estimate used it.
+            if (state.lastOfferedStopAt === null && typeof data.lastEstimatedStopAt === 'number') {
+                state.lastOfferedStopAt = data.lastEstimatedStopAt;
+            }
+            return state;
+        }
+    }
+    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, 
+// Sessions without a conversation log can't be resumed; leaving them in would
+// let a throwaway session started after the stop stand in for the group.
+resumable = () => true, notOlderThan = 0) {
+    const dead = [];
+    for (const [sessionId, e] of Object.entries(state.sessions)) {
+        if (!liveIds.has(sessionId) && resumable(sessionId))
+            dead.push({ sessionId, ...e });
+    }
+    if (!dead.length)
+        return null;
+    dead.sort((a, b) => b.lastSeenAlive - a.lastSeenAlive || a.cwd.localeCompare(b.cwd));
+    const group = pickStoppedGroup(dead, (d) => d.lastSeenAlive);
+    const stoppedAt = group[0].lastSeenAlive;
+    if (stoppedAt < notOlderThan)
+        return null;
+    // Something running from before the stop means the rest were closed one by
+    // one on purpose, not taken down together.
+    for (const id of liveIds) {
+        const e = state.sessions[id];
+        if (e && e.aliveSince <= stoppedAt)
+            return null;
+    }
+    return { stoppedAt, sessions: group };
+}
+// The most recent group that went down together, newest first. Sessions come
+// and go all day — a scheduled run, a quick question — and any of them would
+// otherwise stand in for the last stop just by being the newest. So a group of
+// several wins over a lone session, even a more recent one.
+function pickStoppedGroup(deadNewestFirst, at, gapMs = GROUP_GAP_MS) {
+    const clusters = [];
+    for (const item of deadNewestFirst) {
+        const current = clusters[clusters.length - 1];
+        if (current && at(current[current.length - 1]) - at(item) <= gapMs)
+            current.push(item);
+        else
+            clusters.push([item]);
+    }
+    return clusters.find((c) => c.length > 1) ?? clusters[0];
+}
+// 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.5.0",
+  "version": "0.6.1",
   "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"