@usebitl/cli 0.1.13 → 0.1.15

package/adapters/bitl-cc-watch.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// Claude Code interrupt watcher. bitl-hook.mjs spawns it separately on each UserPromptSubmit (Claude Code doesn't wait).
+//
+//   node bitl-cc-watch.mjs <session id> <transcript path> <cwd>
+//
+// Claude Code sends no hook when the user interrupts a turn, so the card would stay "running". Follow the transcript
+// until the turn ends; if it was interrupted, send bitl:Interrupted (ends the turn on the board). Only the event goes
+// out — no transcript content. Exits quietly on a normal end, after 2 hours, or on any error. Always exit 0.
+
+import { sendRecord } from './send.mjs';
+
+async function main() {
+  const [sessionId, transcriptPath, cwd] = process.argv.slice(2);
+  if (!sessionId || !transcriptPath) return;
+  const { watchClaudeTurn } = await import('./dist/core.mjs');
+  const mark = await watchClaudeTurn(transcriptPath);
+  if (mark?.mark !== 'interrupted') return;
+  await sendRecord({
+    source: 'claude-code',
+    receivedAt: mark.at ?? new Date().toISOString(),
+    payload: { hook_event_name: 'bitl:Interrupted', session_id: sessionId, transcript_path: transcriptPath, ...(cwd ? { cwd } : {}) },
+  });
+}
+
+main()
+  .catch(() => {})
+  .finally(() => process.exit(0));

package/adapters/bitl-hook.mjs

@@ -56,6 +56,22 @@ function watchAgyPermission(payload) {
   }
 }
 
+/**
+ * Claude Code sends no hook when the user interrupts a turn → on each prompt, spawn a watcher that reads the transcript
+ * until the turn ends and reports an interrupt (bitl-cc-watch.mjs). Only ids and the path are passed, never the prompt
+ */
+function watchClaudeTurn(payload) {
+  try {
+    const { session_id: sessionId, transcript_path: transcriptPath, cwd } = payload;
+    if (typeof sessionId !== 'string' || typeof transcriptPath !== 'string') return;
+    const script = join(import.meta.dirname, 'bitl-cc-watch.mjs');
+    const args = [script, sessionId, transcriptPath, typeof cwd === 'string' ? cwd : ''];
+    spawn(process.execPath, args, { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+  } catch {
+    // the hook carries on even if the watcher can't start
+  }
+}
+
 /**
  * Claude Code agent view (`claude agents`): the daemon keeps pre-warmed sessions parked as spares (CLAUDE_BG_SOURCE=spare).
  * A parked spare fires SessionStart but gets no prompt until a task is dispatched to it, and is retired after an hour idle
@@ -84,6 +100,7 @@ async function main() {
   const event = argValue('--event');
   if (event && payload && typeof payload === 'object' && payload.hook_event_name === undefined) payload.hook_event_name = event;
   if (source === 'antigravity' && event === 'PreToolUse') watchAgyPermission(payload);
+  if (source === 'claude-code' && payload?.hook_event_name === 'UserPromptSubmit') watchClaudeTurn(payload);
   if (isParkedSpareStart(source, payload)) return;
   await sendRecord({ source, receivedAt, payload });
 }

package/adapters/dist/core.mjs

@@ -153,6 +153,8 @@ function normalizeHook(source, raw, receivedAt) {
     }
     case "Stop":
     case "Interrupt":
+    // Codex: the in-progress turn was interrupted
+    case "bitl:Interrupted":
       type = "turn_end";
       text = str(raw.last_assistant_message);
       break;
@@ -326,7 +328,8 @@ function activityOf(e) {
   const base = e.tool.summary ? `${e.tool.name}: ${e.tool.summary}` : e.tool.name;
   return e.agentId && e.agentType ? `[${e.agentType}] ${base}` : base;
 }
-function splitEvent(e, extra = {}) {
+function splitEvent(e, enrichment = {}) {
+  const { resumedFrom, ...extra } = enrichment;
   const newCwd = e.nativeType === "CwdChanged" && typeof e.raw.new_cwd === "string" ? e.raw.new_cwd : void 0;
   const signal = {
     source: e.source,
@@ -338,7 +341,8 @@ function splitEvent(e, extra = {}) {
     agentId: e.agentId,
     agentNamed: e.agentId || e.agentType !== void 0 ? Boolean(e.agentType) : void 0,
     waitingReason: e.waitingReason,
-    toolFailed: e.tool?.failed || void 0
+    toolFailed: e.tool?.failed || void 0,
+    resumedFrom
   };
   const content = {
     title: e.type === "prompt" && e.text ? oneLine(e.text, TITLE_LIMIT) : void 0,
@@ -467,7 +471,7 @@ function readCloudConfig(home = bitlHome()) {
   }
 }
 function clientVersionHeader() {
-  const v = "0.1.13";
+  const v = "0.1.15";
   return v ? { "x-bitl-client": v } : {};
 }
 function resolveTarget(home = bitlHome()) {
@@ -490,11 +494,73 @@ function resolveTarget(home = bitlHome()) {
 
 // ../../shared/src/node/enrich.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { readFile as readFile3, stat as stat3 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import { basename, join as join3 } from "node:path";
-var BRANCH_TTL_MS = 6e4;
+import { basename as basename2, join as join4 } from "node:path";
+
+// ../../shared/src/node/resume.ts
+import { readdir, readFile as readFile2, stat as stat2, writeFile } from "node:fs/promises";
+import { basename, dirname as dirname3, join as join3 } from "node:path";
 var MAX_TRANSCRIPT_BYTES2 = 20 * 1024 * 1024;
+var MAX_CANDIDATES = 200;
+var CACHE_FILE = "resume-links.json";
+var CACHE_LIMIT = 200;
+var UUID = /"uuid":"([0-9a-f-]{36})"/g;
+var messageIds = (text) => [...text.matchAll(UUID)].map((m) => m[1]);
+async function findResumedFrom(transcriptPath) {
+  const own = basename(transcriptPath, ".jsonl");
+  if ((await stat2(transcriptPath)).size > MAX_TRANSCRIPT_BYTES2) return null;
+  const ids = messageIds(await readFile2(transcriptPath, "utf8"));
+  if (ids.length === 0) return void 0;
+  const dir = dirname3(transcriptPath);
+  const candidates = [];
+  const names = (await readdir(dir)).filter((n) => n.endsWith(".jsonl") && basename(n, ".jsonl") !== own);
+  for (const name of names.slice(0, MAX_CANDIDATES)) {
+    try {
+      const file = join3(dir, name);
+      const info2 = await stat2(file);
+      if (info2.size > MAX_TRANSCRIPT_BYTES2) continue;
+      const list = messageIds(await readFile2(file, "utf8"));
+      if (list.length) candidates.push({ id: basename(name, ".jsonl"), ids: new Set(list), last: list.at(-1), mtime: info2.mtimeMs });
+    } catch {
+    }
+  }
+  const ourLast = ids.at(-1);
+  const earlier = candidates.filter((c) => !(c.ids.has(ourLast) && c.last !== ourLast));
+  for (let i = ids.length - 1; i >= 0; i--) {
+    const id = ids[i];
+    const holders = earlier.filter((c) => c.ids.has(id));
+    if (!holders.length) continue;
+    const ended = holders.find((c) => c.last === id);
+    return (ended ?? holders.sort((a, b) => b.mtime - a.mtime)[0]).id;
+  }
+  return null;
+}
+async function readCache(home) {
+  try {
+    return JSON.parse(await readFile2(join3(home, CACHE_FILE), "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function resumedFromFor(e, home) {
+  if (e.source !== "claude-code" || !e.transcriptPath) return void 0;
+  const cache = await readCache(home);
+  const hit = cache[e.sessionId];
+  if (hit && !hit.pending) return hit.from;
+  const resumed = e.nativeType === "SessionStart" && e.raw.source === "resume";
+  if (!resumed && !(hit?.pending && e.type === "prompt")) return void 0;
+  const found = await findResumedFrom(e.transcriptPath).catch(() => null);
+  cache[e.sessionId] = found === void 0 ? { pending: true, at: e.at } : { ...found ? { from: found } : {}, at: e.at };
+  const kept = Object.entries(cache).sort((a, b) => b[1].at.localeCompare(a[1].at)).slice(0, CACHE_LIMIT);
+  await writeFile(join3(home, CACHE_FILE), JSON.stringify(Object.fromEntries(kept))).catch(() => {
+  });
+  return found ?? void 0;
+}
+
+// ../../shared/src/node/enrich.ts
+var BRANCH_TTL_MS = 6e4;
+var MAX_TRANSCRIPT_BYTES3 = 20 * 1024 * 1024;
 var branchCache = /* @__PURE__ */ new Map();
 function gitBranch(cwd) {
   const hit = branchCache.get(cwd);
@@ -509,8 +575,8 @@ function gitBranch(cwd) {
 }
 async function titleFromTranscript(path) {
   try {
-    if ((await stat2(path)).size > MAX_TRANSCRIPT_BYTES2) return void 0;
-    const text = await readFile2(path, "utf8");
+    if ((await stat3(path)).size > MAX_TRANSCRIPT_BYTES3) return void 0;
+    const text = await readFile3(path, "utf8");
     let aiTitle;
     let customTitle;
     for (const line of text.split("\n")) {
@@ -527,12 +593,12 @@ async function titleFromTranscript(path) {
     return void 0;
   }
 }
-async function codexThreadName(threadId, codexHome = process.env.CODEX_HOME?.trim() || join3(homedir2(), ".codex")) {
+async function codexThreadName(threadId, codexHome = process.env.CODEX_HOME?.trim() || join4(homedir2(), ".codex")) {
   try {
-    const file = join3(codexHome, "session_index.jsonl");
-    if ((await stat2(file)).size > MAX_TRANSCRIPT_BYTES2) return void 0;
+    const file = join4(codexHome, "session_index.jsonl");
+    if ((await stat3(file)).size > MAX_TRANSCRIPT_BYTES3) return void 0;
     let name;
-    for (const line of (await readFile2(file, "utf8")).split("\n")) {
+    for (const line of (await readFile3(file, "utf8")).split("\n")) {
       if (!line.includes(threadId)) continue;
       try {
         const rec = JSON.parse(line);
@@ -557,9 +623,9 @@ async function importSqliteQuietly() {
     process.emitWarning = emitWarning;
   }
 }
-async function antigravityTitle(conversationId, dbPath = join3(homedir2(), ".gemini", "antigravity-cli", "conversation_summaries.db")) {
+async function antigravityTitle(conversationId, dbPath = join4(homedir2(), ".gemini", "antigravity-cli", "conversation_summaries.db")) {
   try {
-    await stat2(dbPath);
+    await stat3(dbPath);
     const { DatabaseSync } = await importSqliteQuietly();
     const db = new DatabaseSync(dbPath, { readOnly: true });
     try {
@@ -586,9 +652,9 @@ function gitRoot(cwd) {
 var rootCache = /* @__PURE__ */ new Map();
 async function projectName(cwd) {
   const root = await gitRoot(cwd);
-  return basename((root ?? cwd).replace(/[\\/]+$/, ""));
+  return basename2((root ?? cwd).replace(/[\\/]+$/, ""));
 }
-async function enrichEvent(e) {
+async function enrichEvent(e, home = bitlHome()) {
   const extra = {};
   const newCwd = e.nativeType === "CwdChanged" && typeof e.raw.new_cwd === "string" ? e.raw.new_cwd : void 0;
   const cwd = newCwd ?? e.cwd;
@@ -610,6 +676,11 @@ async function enrichEvent(e) {
         })
       );
   }
+  tasks.push(
+    resumedFromFor(e, home).then((from) => {
+      if (from) extra.resumedFrom = from;
+    })
+  );
   await Promise.all(tasks.map((t) => t.catch(() => {
   })));
   return extra;
@@ -746,12 +817,71 @@ async function requestRemoteApproval(payload, opts = {}) {
   return null;
 }
 
+// ../../shared/src/node/claude-watch.ts
+import { open as open2, stat as stat4 } from "node:fs/promises";
+var INTERRUPTED = "[Request interrupted by user";
+function claudeTurnMark(line) {
+  if (!line.includes(INTERRUPTED) && !line.includes('"turn_duration"')) return null;
+  let rec;
+  try {
+    rec = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (rec.isSidechain) return null;
+  const at = typeof rec.timestamp === "string" ? rec.timestamp : void 0;
+  if (rec.type === "system" && rec.subtype === "turn_duration") return { mark: "ended", at };
+  if (rec.type !== "user" || rec.isMeta) return null;
+  const c = rec.message?.content;
+  const text = typeof c === "string" ? c : Array.isArray(c) && c[0]?.type === "text" ? String(c[0].text ?? "") : "";
+  return text.startsWith(INTERRUPTED) ? { mark: "interrupted", at } : null;
+}
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+async function watchClaudeTurn(path, opts = {}) {
+  const pollMs = opts.pollMs ?? 1500;
+  const until = Date.now() + (opts.maxMs ?? 2 * 60 * 6e4);
+  let offset;
+  try {
+    offset = (await stat4(path)).size;
+  } catch {
+    return null;
+  }
+  let rest = "";
+  while (Date.now() < until) {
+    await sleep2(pollMs);
+    let size;
+    try {
+      size = (await stat4(path)).size;
+    } catch {
+      return null;
+    }
+    if (size < offset) return null;
+    if (size === offset) continue;
+    const file = await open2(path, "r");
+    try {
+      const buf = Buffer.alloc(size - offset);
+      await file.read(buf, 0, buf.length, offset);
+      offset = size;
+      const lines = (rest + buf.toString("utf8")).split("\n");
+      rest = lines.pop() ?? "";
+      for (const line of lines) {
+        const mark = claudeTurnMark(line);
+        if (mark?.mark === "interrupted") return mark;
+        if (mark?.mark === "ended") return null;
+      }
+    } finally {
+      await file.close();
+    }
+  }
+  return null;
+}
+
 // ../../shared/src/node/index.ts
 async function prepareRaw(rec, opts = {}) {
   const filled = rec.source === "antigravity" && opts.enrich !== false ? { ...rec, payload: await fillAntigravityText(rec.payload) } : rec;
   const e = normalizeRecord(filled);
   if (!e) return null;
-  const extra = opts.enrich === false ? {} : await enrichEvent(e);
+  const extra = opts.enrich === false ? {} : await enrichEvent(e, opts.home ?? bitlHome());
   const keys = opts.keys ?? await loadKeys(opts.home ?? bitlHome());
   return prepareRecord(e, sealerFor(keys), extra);
 }
@@ -765,5 +895,6 @@ export {
   agyWatchStep,
   prepareForTarget,
   prepareRaw,
-  requestRemoteApproval
+  requestRemoteApproval,
+  watchClaudeTurn
 };

package/dist/chunks/{chunk-VVNOFPMO.mjs → chunk-65TI66EM.mjs}

@@ -19997,7 +19997,8 @@ var SignalSchema = external_exports.object({
   agentNamed: external_exports.boolean().optional(),
   waitingReason: WaitingReason.optional(),
   toolFailed: external_exports.boolean().optional(),
-  requestTag: external_exports.string().max(100).optional()
+  requestTag: external_exports.string().max(100).optional(),
+  resumedFrom: id.optional()
 });
 var WireRecordSchema = external_exports.object({
   v: external_exports.literal(WIRE_VERSION),
@@ -20061,7 +20062,7 @@ function removeCloudLogin(home = bitlHome()) {
   rmSync(cloudKeyPath(home), { force: true });
 }
 function clientVersionHeader() {
-  const v = "0.1.13";
+  const v = "0.1.15";
   return v ? { "x-bitl-client": v } : {};
 }
 function resolveTarget(home = bitlHome()) {
@@ -20118,7 +20119,7 @@ async function latestVersion(home, now) {
   return latest;
 }
 var updateCommand = (install = process.env.BITL_INSTALL) => install === "npx" ? "npx @usebitl/cli@latest start" : "npm i -g @usebitl/cli";
-async function checkCliUpdate(current = "0.1.13", opts = {}) {
+async function checkCliUpdate(current = "0.1.15", opts = {}) {
   if (!current || process.env.BITL_NO_UPDATE_CHECK === "1") return void 0;
   const latest = await latestVersion(opts.home ?? bitlHome(), opts.now ?? Date.now());
   if (!latest || compareVersions(latest, current) <= 0) return void 0;
@@ -20128,9 +20129,12 @@ async function checkCliUpdate(current = "0.1.13", opts = {}) {
 // ../../shared/src/node/antigravity.ts
 var MAX_TRANSCRIPT_BYTES = 20 * 1024 * 1024;
 
-// ../../shared/src/node/enrich.ts
+// ../../shared/src/node/resume.ts
 var MAX_TRANSCRIPT_BYTES2 = 20 * 1024 * 1024;
 
+// ../../shared/src/node/enrich.ts
+var MAX_TRANSCRIPT_BYTES3 = 20 * 1024 * 1024;
+
 // ../../shared/src/node/approve.ts
 var DEFAULT_APPROVAL_WAIT_MS = 10 * 6e4;
 

package/dist/chunks/{src-MWG3MA6Y.mjs → src-TJPPU3TC.mjs}

@@ -11,7 +11,7 @@ import {
   isEmptySession,
   parseWireRecord,
   sessionKey
-} from "./chunk-VVNOFPMO.mjs";
+} from "./chunk-65TI66EM.mjs";
 
 // ../../../node_modules/.pnpm/bn.js@4.12.5/node_modules/bn.js/lib/bn.js
 var require_bn = __commonJS({
@@ -9232,8 +9232,21 @@ var SqlStore = class _SqlStore {
       return session2;
     }, _SqlStore.lockKey(accountId, key));
     this.emit({ type: "session", accountId, session, prevStatus });
+    if (e.resumedFrom) return await this.linkResumed(accountId, session, sessionKey(e.source, e.resumedFrom)) ?? session;
     return session;
   }
+  /**
+   * `--resume` that started a new session: the earlier card leaves the board (replacedBy) and its history shows in the
+   * new card's detail (resumedFrom, carrying the earlier card's own predecessors). Content can't move between cards —
+   * it is sealed with each session's key — so the cards stay apart and are read together
+   */
+  async linkResumed(accountId, session, oldKey) {
+    if (oldKey === session.key || session.resumedFrom?.includes(oldKey)) return void 0;
+    const old = await this.update(accountId, oldKey, (cur) => cur.replacedBy === session.key ? null : { ...cur, replacedBy: session.key });
+    if (!old) return void 0;
+    const chain = [oldKey, ...old.resumedFrom ?? []].filter((k) => k !== session.key);
+    return this.update(accountId, session.key, (cur) => ({ ...cur, resumedFrom: [.../* @__PURE__ */ new Set([...chain, ...cur.resumedFrom ?? []])] }));
+  }
   getSession(accountId, key) {
     return _SqlStore.read(this.db.query, accountId, key);
   }
@@ -9293,37 +9306,42 @@ var SqlStore = class _SqlStore {
   acknowledge(accountId, key, now3 = /* @__PURE__ */ new Date()) {
     return this.update(accountId, key, (cur) => acknowledge(cur, now3));
   }
-  async deleteSession(accountId, key) {
+  /** Deletes one session with its turns and events (onlyEnded: only if it is still ended, checked under lock) */
+  async remove(accountId, key, onlyEnded = false) {
     const deleted = await this.db.transaction(async (q) => {
-      const { changes } = await q("DELETE FROM sessions WHERE account_id = ? AND key = ?", [accountId, key]);
+      const { changes } = await q(`DELETE FROM sessions WHERE account_id = ? AND key = ?${onlyEnded ? ` AND status = 'ended'` : ""}`, [accountId, key]);
+      if (changes === 0) return false;
       await q("DELETE FROM turns WHERE account_id = ? AND session_key = ?", [accountId, key]);
       await q("DELETE FROM events WHERE account_id = ? AND session_key = ?", [accountId, key]);
-      return changes > 0;
+      return true;
     }, _SqlStore.lockKey(accountId, key));
     if (deleted) this.emit({ type: "removed", accountId, key });
     return deleted;
   }
+  /** The earlier sessions a card continues go with it — they are off the board and only shown through it */
+  async removePredecessors(accountId, s) {
+    for (const key of s.resumedFrom ?? []) await this.remove(accountId, key);
+  }
+  async deleteSession(accountId, key) {
+    const cur = await this.getSession(accountId, key);
+    const deleted = await this.remove(accountId, key);
+    if (deleted && cur) await this.removePredecessors(accountId, cur);
+    return deleted;
+  }
   /**
    * Deletes ended cards with their history (the board's "Ended → Clear all"). With keys, only the ended ones among them (goal-filtered view).
    * To spare cards revived by a new event after the list was read, the status is rechecked under lock while deleting. Returns the number deleted
    */
   async deleteEnded(accountId, keys) {
-    const { rows } = await this.db.query(`SELECT key FROM sessions WHERE account_id = ? AND status = 'ended' AND archived = 0`, [accountId]);
+    const { rows } = await this.db.query(`SELECT data FROM sessions WHERE account_id = ? AND status = 'ended' AND archived = 0`, [accountId]);
     const only = keys ? new Set(keys) : null;
     let n = 0;
     for (const r of rows) {
-      const key = r.key;
-      if (only && !only.has(key)) continue;
-      const deleted = await this.db.transaction(async (q) => {
-        const { changes } = await q(`DELETE FROM sessions WHERE account_id = ? AND key = ? AND status = 'ended'`, [accountId, key]);
-        if (changes === 0) return false;
-        await q("DELETE FROM turns WHERE account_id = ? AND session_key = ?", [accountId, key]);
-        await q("DELETE FROM events WHERE account_id = ? AND session_key = ?", [accountId, key]);
-        return true;
-      }, _SqlStore.lockKey(accountId, key));
-      if (deleted) {
+      const s = JSON.parse(r.data);
+      if (s.replacedBy || only && !only.has(s.key)) continue;
+      if (await this.remove(accountId, s.key, true)) {
         n++;
-        this.emit({ type: "removed", accountId, key });
+        await this.removePredecessors(accountId, s);
       }
     }
     return n;
@@ -9334,7 +9352,7 @@ var SqlStore = class _SqlStore {
     let cleared = 0;
     for (const r of rows) {
       await this.update(accountId, r.key, (cur) => {
-        if (cur.cleared || cur.archived) return null;
+        if (cur.cleared || cur.archived || cur.replacedBy) return null;
         cleared++;
         return { ...cur, cleared: true };
       });
@@ -12129,10 +12147,10 @@ async function ingestRecord(store, accountId, body) {
   const rec = parseWireRecord(body);
   return rec ? store.ingest(accountId, rec) : null;
 }
-function createApp({ store, webDist, account, push, approvals, goals, access = allowAll, extension }) {
+function createApp({ store, webDist, account, push, approvals, goals, access = allowAll, extension, build }) {
   const app = new Hono2();
   const resolve2 = account ?? (() => LOCAL_ACCOUNT);
-  app.get("/api/health", (c) => c.json({ ok: true }));
+  app.get("/api/health", (c) => c.json(build ? { ok: true, build } : { ok: true }));
   app.get("/api/me", async (c) => c.json(extension?.me ? await extension.me(c) : { mode: "local" }));
   extension?.mountPublic?.(app);
   app.get("/api/push/key", (c) => c.json({ publicKey: push?.publicKey ?? null }));
@@ -12178,6 +12196,11 @@ function createApp({ store, webDist, account, push, approvals, goals, access = a
     const session = await store.getSession(accountId, key);
     if (!session) return c.json({ error: "not found" }, 404);
     const [turns, timeline] = await Promise.all([store.listTurns(accountId, key), store.listTimeline(accountId, key)]);
+    for (const prev of session.resumedFrom ?? []) {
+      const [t, items] = await Promise.all([store.listTurns(accountId, prev), store.listTimeline(accountId, prev)]);
+      turns.push(...t);
+      timeline.push(...items.map((item) => ({ ...item, sessionKey: prev })));
+    }
     return c.json({ session, turns, timeline });
   });
   const found = (c, s) => s ? c.json(s) : c.json({ error: "not found" }, 404);
@@ -12380,13 +12403,13 @@ function startPushNotifier(opts) {
   };
   const notify = async (accountId, s) => {
     if (!(await push.list(accountId)).length) return;
-    const attention = (await store.listSessions(accountId)).filter((x) => ALERT.has(x.status) && !isEmptySession(x) && !x.cleared).length;
+    const attention = (await store.listSessions(accountId)).filter((x) => ALERT.has(x.status) && !isEmptySession(x) && !x.cleared && !x.replacedBy).length;
     await sendAll(accountId, buildPayload(s, attention), topicOf(s.key));
   };
   const off = store.subscribe((change) => {
     if (change.type !== "session") return;
     const s = change.session;
-    if (!ALERT.has(s.status) || change.prevStatus === s.status || isEmptySession(s) || s.cleared) return;
+    if (!ALERT.has(s.status) || change.prevStatus === s.status || isEmptySession(s) || s.cleared || s.replacedBy) return;
     const id = `${change.accountId}
 ${s.key}`;
     const t = Date.now();

package/dist/cli.mjs

@@ -21,7 +21,7 @@ import {
   unwrapMasterKey,
   verifyPublicKey,
   wrapMasterKey
-} from "./chunks/chunk-VVNOFPMO.mjs";
+} from "./chunks/chunk-65TI66EM.mjs";
 
 // ../src/index.ts
 import { homedir as homedir2 } from "node:os";
@@ -453,7 +453,7 @@ async function logout() {
 }
 
 // ../src/update.ts
-async function updateNotice(current = "0.1.13") {
+async function updateNotice(current = "0.1.15") {
   const u = await checkCliUpdate(current);
   return u && `${t("update.available", { ...u })}
 ${t("update.changelog")}`;
@@ -609,7 +609,7 @@ async function main(argv) {
         if (String(typeof warning === "string" ? warning : warning.message).startsWith("SQLite is an experimental feature")) return;
         emitWarning(warning, ...rest2);
       });
-      const { startServer } = await import("./chunks/src-MWG3MA6Y.mjs");
+      const { startServer } = await import("./chunks/src-TJPPU3TC.mjs");
       await startServer();
       console.log(t("start.pair", { url: localPairUrl() }));
       return;
@@ -631,7 +631,7 @@ async function main(argv) {
     case "--version":
     case "-v":
     case "version":
-      console.log("0.1.13");
+      console.log("0.1.15");
       return;
     case "remote":
     case "away":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebitl/cli",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "BITL — see which of your AI coding agents (Claude Code, Codex, Antigravity) are waiting for you. Local board or usebitl.com",
   "type": "module",
   "bin": {