ccakashic 0.6.0 → 0.6.1

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

@@ -38,6 +38,7 @@ 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.
 //
@@ -131,7 +132,7 @@ function listLogFiles(root, since) {
     }
     return out.sort((a, b) => b.mtime - a.mtime);
 }
-function inferLastStop(live, now = Date.now(), root = discover_1.CLAUDE_DIR, readFacts = readLogFacts) {
+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) => {
@@ -140,29 +141,34 @@ function inferLastStop(live, now = Date.now(), root = discover_1.CLAUDE_DIR, rea
             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)
+    const dead = listLogFiles(root, now - LOOKBACK_MS)
+        .filter((f) => !liveIds.has(f.sessionId) && facts(f).interactive && facts(f).cwd);
+    if (!dead.length)
         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.
+    // 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 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;
+    const sessions = group
         // 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 });
-    }
+        .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

@@ -53,7 +53,8 @@ const STAGGER_MS = 1500;
 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));
+    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);
     }
@@ -64,23 +65,26 @@ function detectLastStop(now = Date.now()) {
 }
 // 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) {
+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, lastEstimatedStopAt: inferred.stoppedAt }, stop: inferred };
+    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));

package/dist/snapshot.js

@@ -40,6 +40,7 @@ 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"));
@@ -56,18 +57,25 @@ const path = __importStar(require("path"));
 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;
+// 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, lastEstimatedStopAt: null, dismissedStopAt: null, sessions: {} };
+    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') {
-            return { ...emptyState(), ...data };
+            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 {
@@ -150,24 +158,45 @@ function recordLive(state, live, now) {
 // 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) {
+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))
+        if (!liveIds.has(sessionId) && resumable(sessionId))
             dead.push({ sessionId, ...e });
     }
     if (!dead.length)
         return null;
-    const stoppedAt = Math.max(...dead.map((d) => d.lastSeenAlive));
+    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;
     }
-    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 };
+    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).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ccakashic",
-  "version": "0.6.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"