ai-or-die 0.1.72 → 0.1.74

package/bin/ai-or-die.js

@@ -142,7 +142,7 @@ async function main() {
     }
 
     const app = new ClaudeCodeWebServer(serverOptions);
-    const httpServer = await app.start();
+    await app.start();
 
     const protocol = options.https ? 'https' : 'http';
     const baseUrl = `${protocol}://localhost:${port}`;
@@ -187,17 +187,15 @@ async function main() {
 
     console.log('\nPress Ctrl+C to stop the server\n');
 
-    const shutdown = async () => {
-      console.log('\nShutting down server...');
-      if (tunnel) await tunnel.stop();
-      httpServer.close(() => {
-        console.log('Server closed');
-        process.exit(0);
-      });
-    };
-
-    process.on('SIGINT', () => { shutdown(); });
-    process.on('SIGTERM', () => { shutdown(); });
+    // Shutdown is owned by the server's single SIGINT/SIGTERM handler
+    // (ClaudeCodeWebServer.handleShutdown), which performs the ordered graceful
+    // teardown: cooperative disposal of the local-LLM (sticky-note) and STT
+    // native worker threads, tunnel stop, session save, then server close.
+    // A second handler here used to race it — its httpServer.close() callback
+    // fires immediately when there are no open connections and called
+    // process.exit(0) before the worker threads could dispose their ggml-based
+    // native models, which aborted the process (SIGABRT / exit 134) on Ctrl+C.
+    // So we deliberately do NOT register a SIGINT/SIGTERM handler here.
 
   } catch (error) {
     console.error('Error starting server:', error.message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-or-die",
-  "version": "0.1.72",
+  "version": "0.1.74",
   "description": "Universal AI coding terminal — Claude, Copilot, Gemini & more in your browser",
   "main": "src/server.js",
   "bin": {

package/src/base-bridge.js

@@ -262,7 +262,8 @@ class BaseBridge {
       onExit = () => {},
       onError = () => {},
       cols = 80,
-      rows = 24
+      rows = 24,
+      extraEnv = null
     } = options;
 
     try {
@@ -280,7 +281,8 @@ class BaseBridge {
         ...process.env,
         TERM: 'xterm-256color',
         FORCE_COLOR: '1',
-        COLORTERM: 'truecolor'
+        COLORTERM: 'truecolor',
+        ...((extraEnv && typeof extraEnv === 'object') ? extraEnv : {})
       };
 
       const ptyProcess = spawn(this.command, args, {

package/src/server.js

@@ -277,6 +277,8 @@ class ClaudeCodeWebServer {
         }
       }
       this._capClaudeNotes();
+      // Remove orphan claude-bind sidecars whose tab no longer exists.
+      this._sweepClaudeBindSidecars();
       if (sessions.size > 0) {
         console.log(`Loaded ${sessions.size} persisted sessions`);
       }
@@ -475,13 +477,31 @@ class ClaudeCodeWebServer {
     forceExitTimer.unref();
 
     console.log(`\nGracefully shutting down (exit code: ${exitCode})...`);
+    // Persist sessions FIRST, before the (bounded but potentially multi-second)
+    // native-engine teardown below. If a pathological native teardown ever blew
+    // the 15s force-exit budget, sessions would already be safe on disk. close()
+    // saves again at the end of a normal shutdown.
+    try { await this.saveSessionsToDisk(true); } catch (_) { /* ignore */ }
     // Tear down the local-LLM summariser + worker so the model/worker thread
     // don't keep the process alive (and don't hold a GGUF file lock on Windows).
     if (this._stickyInitTimer) { clearTimeout(this._stickyInitTimer); this._stickyInitTimer = null; }
     if (this._stickyJsonlPoll) { clearInterval(this._stickyJsonlPoll); this._stickyJsonlPoll = null; }
     this._stickyJsonl.clear();
     try { this.stickyNoteSummarizer.shutdown(); } catch (_) { /* ignore */ }
-    try { await this.stickyNoteEngine.shutdown(); } catch (_) { /* ignore */ }
+    // Tear down both local native worker engines (sticky-note = node-llama-cpp,
+    // STT = sherpa-onnx) concurrently. Each disposes its loaded model/recognizer
+    // on its worker thread before exiting; force-tearing them down via
+    // process.exit() while a model is loaded/loading aborts the process (SIGABRT)
+    // during native cleanup. Running them in parallel keeps total shutdown well
+    // inside the 15s force-exit budget above. STT shutdown was previously missing
+    // entirely. The CLI dev tunnel (only set in --tunnel mode) used to be stopped
+    // by a second SIGINT handler in bin/ai-or-die.js, now removed to avoid a
+    // shutdown race; its stop moves here onto the single graceful path.
+    await Promise.allSettled([
+      Promise.resolve().then(() => this.stickyNoteEngine.shutdown()),
+      Promise.resolve().then(() => this.sttEngine.shutdown()),
+      Promise.resolve().then(() => (this.tunnelManager ? this.tunnelManager.stop() : undefined)),
+    ]);
     await this.close();
     clearTimeout(forceExitTimer);
     process.exit(exitCode);
@@ -1333,6 +1353,7 @@ class ClaudeCodeWebServer {
       // Stop + tear down the summariser so an in-flight inference is discarded.
       this.stickyNoteSummarizer.cancel(sessionId);
       this._stickyJsonl.delete(sessionId);
+      this._removeClaudeBindSidecar(session);
       if (this._foregroundSessionId === sessionId) this._foregroundSessionId = null;
 
       this.claudeSessions.delete(sessionId);
@@ -3945,6 +3966,12 @@ class ClaudeCodeWebServer {
       // process; their session.liveCwd stays null. We pass the OSC 7
       // hooks only when starting a Terminal session so the other bridges
       // remain a true no-op.
+      const terminalExtraEnv = {};
+      if (toolName === 'terminal') {
+        const sidecarPath = this._prepareClaudeBindSidecar(sessionId, session);
+        if (sidecarPath) terminalExtraEnv.AIORDIE_CLAUDE_BIND = sidecarPath;
+      }
+
       const osc7Hooks = (toolName === 'terminal') ? {
         validatePath: (p) => this.validatePath(p),
         onCwdChange: (cwd, prev) => {
@@ -4021,7 +4048,13 @@ class ClaudeCodeWebServer {
           this.broadcastToSession(sessionId, { type: 'error', message: error.message });
           this.broadcastSessionActivity(sessionId, 'session_error');
         },
-        ...options
+        ...options,
+        extraEnv: toolName === 'terminal'
+          ? {
+              ...((options.extraEnv && typeof options.extraEnv === 'object') ? options.extraEnv : {}),
+              ...terminalExtraEnv,
+            }
+          : options.extraEnv
       });
 
       session.lastActivity = new Date();
@@ -4238,13 +4271,57 @@ class ClaudeCodeWebServer {
   async _pumpStickyJsonl(sessionId, cwd) {
     let binding = this._stickyJsonl.get(sessionId);
     binding && (binding._ticks = (binding._ticks || 0) + 1);
+    const session = this.claudeSessions.get(sessionId);
 
-    // Periodically (or while unbound) reconcile the binding. A tab STAYS on its
-    // bound session while that file is alive and not owned by another tab; it
-    // only moves to a newer unowned session once its own has gone quiet (an
-    // in-session /resume) — so a third, unrelated session can't steal an active
-    // tab. agent-*.jsonl is excluded by findActiveSessions.
-    if (!binding || binding._ticks % 5 === 0) {
+    // DETERMINISTIC SIDECAR BINDING (terminal tabs launched via github-router).
+    // ai-or-die set AIORDIE_CLAUDE_BIND=<sidecar> on the shell; github-router's
+    // SessionStart/SessionEnd hook writes the ACTIVE claude session id +
+    // transcript path there on every startup / resume / clear / compact. When a
+    // sidecar exists it is AUTHORITATIVE: bind directly to that transcript by
+    // exact path and skip the cwd+mtime inference entirely. Survives in-session
+    // /resume, /clear and exit→relaunch, and works even when liveCwd is null
+    // (cmd.exe / no OSC 7) — the case the inference path gets wrong.
+    const sidecar = session ? await this._readClaudeBindSidecar(session) : null;
+    if (sidecar) {
+      session._sidecarSeen = true;
+      // A SessionEnd record is intentionally NOT acted on: an in-session /resume
+      // or /clear writes end-then-start, and the following start drives the
+      // rebind; a terminal end (logout / prompt_input_exit) means claude exited,
+      // and the PTY onExit flips session.active=false so _pollStickyJsonl stops
+      // pumping this tab. So we keep the current binding (note frozen at its last
+      // state) and only (re)bind on a start with a NEW claude session id.
+      if (
+        sidecar.event !== 'end' &&
+        sidecar.claudeSessionId &&
+        sidecar.transcriptPath &&
+        (!binding || binding.claudeSessionId !== sidecar.claudeSessionId)
+      ) {
+        const stp = await this._statQuiet(sidecar.transcriptPath);
+        if (stp) {
+          this._bindStickyJsonl(sessionId, {
+            file: sidecar.transcriptPath,
+            sessionId: sidecar.claudeSessionId,
+            mtimeMs: stp.mtimeMs,
+            size: stp.size,
+          });
+          binding = this._stickyJsonl.get(sessionId);
+          session.claudePinnedSessionId = sidecar.claudeSessionId;
+          this.sessionStore.markDirty();
+        }
+        // transcript not created yet → wait for a later tick (never inference).
+      }
+      // Pinned tabs never run the mtime inference / resume-follow below.
+    } else if (session && session._sidecarSeen) {
+      // Previously sidecar-managed but the file is momentarily absent/unreadable
+      // → keep the current binding; do NOT fall back to mtime inference (which
+      // could grab a stranger session). Wait for the next sidecar write.
+    } else if (!binding || binding._ticks % 5 === 0) {
+      // INFERENCE FALLBACK (no sidecar — e.g. claude launched without
+      // github-router). Periodically (or while unbound) reconcile the binding. A
+      // tab STAYS on its bound session while that file is alive and not owned by
+      // another tab; it only moves to a newer unowned session once its own has
+      // gone quiet (an in-session /resume) — so a third, unrelated session can't
+      // steal an active tab. agent-*.jsonl is excluded by findActiveSessions.
       const candidates = await StickyNoteJsonl.findActiveSessions(cwd, { projectsDir: this._stickyProjectsDir });
       const ownedByOthers = this._ownedClaudeSessions(sessionId);
       // Only (re)bind to a session being ACTIVELY written (recent mtime). A fresh
@@ -4257,7 +4334,6 @@ class ClaudeCodeWebServer {
       // the recency gate, so a restart / lost binding can re-resume an idle-but-
       // live session. A FRESH tab has no own-session, so it still won't adopt a
       // stale stranger session in the project.
-      const session = this.claudeSessions.get(sessionId);
       const ownClaudeSession = session && session.stickyClaudeSessionId;
       const eligible = (c) => !ownedByOthers.has(c.sessionId) && (freshlyActive(c) || c.sessionId === ownClaudeSession);
       const currentValid =
@@ -4366,9 +4442,99 @@ class ClaudeCodeWebServer {
     for (const [sid, b] of this._stickyJsonl) {
       if (sid !== exceptSessionId && b && b.claudeSessionId) owned.add(b.claudeSessionId);
     }
+    // Also reserve every OTHER tab's pinned (sidecar) claude session, so an
+    // unpinned tab's inference fallback can never adopt a pinned tab's session
+    // even in the window before that tab has finished binding.
+    for (const [sid, s] of this.claudeSessions) {
+      if (sid !== exceptSessionId && s && s.claudePinnedSessionId) owned.add(s.claudePinnedSessionId);
+    }
     return owned;
   }
 
+  /** Absolute path to this server's per-tab claude-bind sidecar directory. */
+  _claudeBindSidecarDir() {
+    const base = (this.sessionStore && this.sessionStore.storageDir) || path.join(os.homedir(), '.ai-or-die');
+    return path.join(base, 'claude-bindings');
+  }
+
+  /**
+   * Allocate (and record on the session) the per-tab sidecar path that
+   * github-router's SessionStart/SessionEnd hook writes the active claude
+   * session id + transcript path into. Returns the absolute path, or null on
+   * failure (the tab then degrades to the inference fallback). Best-effort mkdir.
+   */
+  _prepareClaudeBindSidecar(sessionId, session) {
+    try {
+      const dir = this._claudeBindSidecarDir();
+      try { fs.mkdirSync(dir, { recursive: true }); } catch (_) { /* best-effort */ }
+      const file = path.join(dir, `${sessionId}.json`);
+      // Clear any stale sidecar from a previous run/launch so this fresh terminal
+      // start waits for github-router's next SessionStart write instead of binding
+      // to a dead session's transcript. (Runs before any github-router launch in
+      // this shell, so it can't race the hook.)
+      try { fs.unlinkSync(file); } catch (_) { /* none / best-effort */ }
+      if (session) {
+        session.claudeBindSidecar = file;
+        session._sidecarSeen = false;
+      }
+      return file;
+    } catch (_) {
+      return null;
+    }
+  }
+
+  /**
+   * Read + parse the tab's sidecar (written atomically by github-router's hook).
+   * Returns the parsed record `{claudeSessionId, transcriptPath, cwd, event,
+   * source?, reason?}` or null (no file / unreadable / malformed). The file is
+   * tiny, so we re-read every tick (no mtime cache: a SessionEnd→SessionStart
+   * rewrite on /resume can land in the same mtime tick, and a cache keyed on
+   * mtime would then serve the stale record and never rebind). Never throws — any
+   * error yields null so the poll is unaffected.
+   */
+  async _readClaudeBindSidecar(session) {
+    if (!session || !session.claudeBindSidecar) return null;
+    let raw;
+    try {
+      raw = await fs.promises.readFile(session.claudeBindSidecar, 'utf8');
+    } catch (_) {
+      return null; // no sidecar yet (claude not launched via github-router, or pending)
+    }
+    try {
+      const obj = JSON.parse(raw);
+      if (!obj || typeof obj !== 'object' || typeof obj.claudeSessionId !== 'string') return null;
+      return obj;
+    } catch (_) {
+      return null; // mid-write / malformed → skip this tick
+    }
+  }
+
+  /** Best-effort: delete a tab's sidecar file (on session close). */
+  _removeClaudeBindSidecar(session) {
+    const file = session && session.claudeBindSidecar;
+    if (!file) return;
+    try { fs.unlinkSync(file); } catch (_) { /* already gone / best-effort */ }
+  }
+
+  /**
+   * Startup sweep: remove orphan sidecar files (`<sessionId>.json`) whose tab is
+   * no longer in the active session set. Best-effort, bounded, never fatal.
+   */
+  _sweepClaudeBindSidecars() {
+    try {
+      const dir = this._claudeBindSidecarDir();
+      let entries;
+      try { entries = fs.readdirSync(dir); } catch (_) { return; } // no dir → nothing to sweep
+      for (const name of entries) {
+        if (!name.endsWith('.json')) continue;
+        const sid = name.slice(0, -'.json'.length);
+        if (this.claudeSessions.has(sid)) continue; // live tab → keep
+        try { fs.unlinkSync(path.join(dir, name)); } catch (_) { /* best-effort */ }
+      }
+    } catch (_) { /* never fatal */ }
+  }
+
+
   /**
    * Bind a tab to a claude transcript and resume its durable note. Binds near the
    * end of the file so the first summary uses recent context, not the whole
@@ -5286,6 +5452,20 @@ class ClaudeCodeWebServer {
     // Save sessions before closing
     await this.saveSessionsToDisk(true);
 
+    // Tear down the STT (sherpa-onnx) native worker. close() is the cleanup path
+    // shared by the signal handler (handleShutdown -> close) AND direct close()
+    // callers (e.g. the e2e test servers, which construct a ClaudeCodeWebServer
+    // and call server.close()). Without this, a server that has loaded the STT
+    // model leaks its worker thread past close() and keeps the process alive —
+    // this hung the Windows e2e jobs once the model was cached/present. The
+    // shutdown is cooperative (graceful message, no terminate()) so native
+    // teardown can't abort the process, and idempotent (handleShutdown already
+    // ran it on the signal path, so this is then a no-op). The sticky-note engine
+    // is torn down by handleShutdown only: it is disabled in the e2e test
+    // servers, and its teardown must precede close()'s session-output flush to
+    // avoid re-triggering a summary, so it stays out of this shared path.
+    try { await this.sttEngine.shutdown(); } catch (_) { /* ignore */ }
+
     // Clear all intervals
     if (this.autoSaveInterval) {
       clearInterval(this.autoSaveInterval);

package/src/sticky-note-engine.js

@@ -30,6 +30,7 @@ class StickyNoteEngine {
 
     this._status = 'unavailable';
     this._worker = null;
+    this._spawningWorker = null;
     this._queue = [];
     this._currentRequest = null;
     this._requestIdCounter = 0;
@@ -88,6 +89,11 @@ class StickyNoteEngine {
       });
     }
     this._status = 'loading';
+    // If shutdown began while we were checking/downloading the model, do NOT
+    // spawn a worker we'd immediately have to kill mid-native-load (which aborts
+    // the process). shutdown() awaits this in-flight init, so bailing here lets
+    // it complete cleanly with no worker.
+    if (this._stopping) return;
     await this._spawnWorker();
   }
 
@@ -198,6 +204,11 @@ class StickyNoteEngine {
   _spawnWorker() {
     return new Promise((resolve, reject) => {
       const worker = this._createWorker();
+      // Track the worker from the moment it's created (not just after 'ready')
+      // so shutdown() can stop it cooperatively even while it's still loading the
+      // model. Cleared once it becomes this._worker or fails to boot.
+      this._spawningWorker = worker;
+      const clearPending = () => { if (this._spawningWorker === worker) this._spawningWorker = null; };
 
       const onReady = (msg) => {
         if (!msg) return;
@@ -205,6 +216,16 @@ class StickyNoteEngine {
           worker.off('message', onReady);
           worker.off('error', onError);
           worker.off('exit', onBootExit);
+          clearPending();
+          // If shutdown started while this worker was still loading, do NOT
+          // promote it to the active worker — that would resurrect a torn-down
+          // engine. Ask it to dispose + exit and resolve init as cancelled.
+          if (this._stopping) {
+            this._status = 'unavailable';
+            try { worker.postMessage({ type: 'shutdown' }); } catch { /* ignore */ }
+            resolve();
+            return;
+          }
           this._worker = worker;
           this._status = 'ready';
           this._restartAttempts = 0;
@@ -217,6 +238,7 @@ class StickyNoteEngine {
           worker.off('message', onReady);
           worker.off('error', onError);
           worker.off('exit', onBootExit);
+          clearPending();
           if (msg.code === 'MODULE_NOT_FOUND') this._lastSpawnError = 'MODULE_NOT_FOUND';
           this._status = 'unavailable';
           reject(new Error(msg.message || 'worker error'));
@@ -226,6 +248,7 @@ class StickyNoteEngine {
         worker.off('message', onReady);
         worker.off('error', onError);
         worker.off('exit', onBootExit);
+        clearPending();
         if (err && (err.code === 'MODULE_NOT_FOUND' || (err.message && err.message.includes('node-llama-cpp')))) {
           this._lastSpawnError = 'MODULE_NOT_FOUND';
         }
@@ -238,6 +261,7 @@ class StickyNoteEngine {
         worker.off('message', onReady);
         worker.off('error', onError);
         worker.off('exit', onBootExit);
+        clearPending();
         this._status = 'unavailable';
         reject(new Error(`sticky-note worker exited during init (code ${code})`));
       };
@@ -263,6 +287,32 @@ class StickyNoteEngine {
 
   async shutdown() {
     this._stopping = true;
+
+    // Shared time budget: the init-wait + cooperative-exit waits below together
+    // stay within this window so the whole engine teardown (run concurrently with
+    // the STT engine by handleShutdown) finishes inside handleShutdown's 15s
+    // force-exit budget, leaving room for close(). Realistic teardown is a few
+    // hundred ms; this only caps pathological hangs.
+    const deadline = Date.now() + 10000;
+    const remaining = () => Math.max(0, deadline - Date.now());
+
+    // If a worker is mid model-LOAD (status 'loading' = the native model is being
+    // constructed in the worker thread), wait — bounded — for it to settle so we
+    // can dispose it cooperatively; a worker killed mid-native-load aborts the
+    // process (SIGABRT / exit 134). We do NOT wait during 'downloading' (no native
+    // worker is loaded yet, so process.exit can't abort, and the download can take
+    // minutes — _doInitialize bails before spawning once _stopping is set, so a
+    // Ctrl+C during a first-run download still exits promptly).
+    if (this._initPromise && this._status === 'loading') {
+      await Promise.race([
+        Promise.resolve(this._initPromise).catch(() => {}),
+        new Promise((resolve) => {
+          const t = setTimeout(resolve, remaining());
+          if (t.unref) t.unref();
+        }),
+      ]);
+    }
+
     if (this._restartTimer) {
       clearTimeout(this._restartTimer);
       this._restartTimer = null;
@@ -273,38 +323,31 @@ class StickyNoteEngine {
     }
     this._queue = [];
     this._currentRequest = null;
-    if (this._worker) {
-      const w = this._worker;
-      this._worker = null;
-      try {
-        // Ask the worker to dispose the native model/context cleanly, then
-        // terminate only if it didn't exit on its own. A bare terminate() with
-        // the model loaded can abort the process during native cleanup.
-        let exited = false;
-        await new Promise((resolve) => {
-          let done = false;
-          const finish = () => {
-            if (!done) {
-              done = true;
-              resolve();
-            }
-          };
-          w.once('exit', () => {
-            exited = true;
-            finish();
-          });
-          try {
-            w.postMessage({ type: 'shutdown' });
-          } catch {
-            finish();
-          }
-          const t = setTimeout(finish, 3000);
-          if (t.unref) t.unref();
-        });
-        if (!exited) await w.terminate();
-      } catch {
-        /* ignore */
-      }
+    // Cooperatively stop the worker — the live one, or one still booting (tracked
+    // from creation in _spawnWorker). Ask it to dispose its native model/context
+    // and exit on its own. We deliberately do NOT call worker.terminate():
+    // force-killing a thread that is inside native ggml code (mid model-load or
+    // mid-inference) throws an uncaught Napi error during worker-env teardown and
+    // ggml's set_terminate aborts the whole process (SIGABRT / exit 134) — the
+    // bug this fixes. The wait is bounded (shared deadline) so handleShutdown can
+    // still save sessions + close(); a worker that never exits is reaped by
+    // handleShutdown's 15s force-exit backstop.
+    const w = this._worker || this._spawningWorker;
+    this._worker = null;
+    this._spawningWorker = null;
+    if (w) {
+      await new Promise((resolve) => {
+        let done = false;
+        const finish = () => { if (!done) { done = true; resolve(); } };
+        w.once('exit', finish);
+        try {
+          w.postMessage({ type: 'shutdown' });
+        } catch {
+          finish();
+        }
+        const t = setTimeout(finish, Math.max(1000, remaining()));
+        if (t.unref) t.unref();
+      });
     }
     this._status = 'unavailable';
   }

package/src/sticky-note-jsonl.js

@@ -2,10 +2,20 @@
 
 // Read clean conversation turns from a Claude Code session JSONL transcript.
 //
-// `github-router claude` runs the normal claude CLI with CLAUDE_CONFIG_DIR=$HOME/.claude,
-// so each session writes ~/.claude/projects/<cwd-slug>/<sessionId>.jsonl — a complete,
-// structured log (the same source claude uses for --resume). We summarise THIS instead
-// of scraping the Ink TUI (which repaints in place and can't be scraped).
+// claude writes ~/.claude/projects/<cwd-slug>/<sessionId>.jsonl — a complete,
+// structured log (the same source claude uses for --resume). We summarise THIS
+// instead of scraping the Ink TUI (which repaints in place and can't be scraped).
+// When launched under github-router, CLAUDE_CONFIG_DIR points at a per-launch
+// mirror whose `projects` subdir is a junction back to the real ~/.claude/projects,
+// so transcripts still land here.
+//
+// Binding a tab to ITS transcript is done two ways (see src/server.js
+// `_pumpStickyJsonl`): (1) PRIMARY — a per-tab sidecar written by github-router's
+// SessionStart/SessionEnd hook names the exact active session id + transcript
+// path (deterministic; survives /resume, /clear, relaunch); (2) FALLBACK — when
+// no sidecar exists (claude launched without github-router), newest-mtime
+// inference over the cwd's project dir. This module only READS a resolved file;
+// `findActiveSessions`/`findActiveSession` serve the fallback path.
 //
 // Signal we keep: user `string`/`text` prompts, assistant `text` replies, and the NAMES
 // of tools the assistant ran. We skip `thinking`, `tool_result`, metadata line types, and
@@ -39,9 +49,16 @@ function cleanProse(s) {
     .trim();
 }
 
-/** Claude's project-dir slug for a cwd: all path separators → '-'. */
+/**
+ * Claude's project-dir slug for a cwd: every non-alphanumeric char → '-'
+ * (drive-letter colon, path separators, spaces, dots, etc.). Matches the folder
+ * claude writes under ~/.claude/projects/. A separator-only replace leaves the
+ * Windows drive-letter colon in place (`C:-Users-...`) and never matches claude's
+ * `C--Users-...`, so the transcript binding — and with it the tab title and the
+ * sticky note — silently fail on Windows.
+ */
 function slugForCwd(cwd) {
-  return String(cwd || '').replace(/[\\/]/g, '-');
+  return String(cwd || '').replace(/[^a-zA-Z0-9]/g, '-');
 }
 
 /** The claude session id is the JSONL basename (the --resume key). */

package/src/sticky-note-worker.js

@@ -90,8 +90,15 @@ parentPort.on('message', (msg) => {
     _inferChain
       .catch(() => {})
       .then(async () => {
+        // Dispose in dependency order: context + model, then the top-level
+        // llama backend. Disposing the backend (await llama.dispose()) is what
+        // actually drains node-llama-cpp's native async work; without it the
+        // worker-thread env teardown that follows process.exit() can hit a
+        // pending Napi completion and ggml's set_terminate aborts the whole
+        // process (SIGABRT / exit 134) on Ctrl+C.
         try { if (context) await context.dispose(); } catch { /* ignore */ }
         try { if (model) await model.dispose(); } catch { /* ignore */ }
+        try { if (llama) await llama.dispose(); } catch { /* ignore */ }
       })
       .finally(() => process.exit(0));
   }

package/src/stt-engine.js

@@ -17,11 +17,13 @@ class SttEngine {
     this._numThreads = options.numThreads || Math.min(4, os.cpus().length);
     this._status = 'unavailable';
     this._worker = null;
+    this._spawningWorker = null;
     this._queue = [];
     this._currentRequest = null;
     this._requestIdCounter = 0;
     this._restartAttempts = 0;
     this._lastSpawnError = null;
+    this._stopping = false;
     this._initPromise = null;
     this._modelManager = new ModelManager({
       modelsDir: options.modelsDir
@@ -62,6 +64,11 @@ class SttEngine {
     }
 
     this._status = 'loading';
+    // If shutdown began while we were checking/downloading the model, do NOT
+    // spawn a worker we'd immediately have to kill mid-native-load (which aborts
+    // the process). shutdown() awaits this in-flight init, so bailing here lets
+    // it complete cleanly with no worker.
+    if (this._stopping) return;
     await this._spawnWorker();
   }
 
@@ -275,6 +282,11 @@ class SttEngine {
 
   _restartWorker(delay) {
     setTimeout(async () => {
+      // Don't respawn if shutdown started after this restart was scheduled.
+      if (this._stopping) {
+        this._status = 'unavailable';
+        return;
+      }
       try {
         await this._spawnWorker();
       } catch (err) {
@@ -294,11 +306,29 @@ class SttEngine {
           nodeModulesDir: path.resolve(__dirname, '..', 'node_modules')
         }
       });
+      // Track the worker from creation (not just after 'ready') so shutdown() can
+      // stop it cooperatively even while it is still loading the recognizer.
+      this._spawningWorker = worker;
+      const clearPending = () => { if (this._spawningWorker === worker) this._spawningWorker = null; };
+      const detach = () => {
+        worker.off('message', onReady);
+        worker.off('error', onError);
+        worker.off('exit', onBootExit);
+      };
 
       const onReady = (msg) => {
         if (msg.type === 'ready') {
-          worker.off('message', onReady);
-          worker.off('error', onError);
+          detach();
+          clearPending();
+          // If shutdown started while this worker was still loading, do NOT
+          // promote it to the active worker — that would resurrect a torn-down
+          // engine. Ask it to exit and resolve init as cancelled.
+          if (this._stopping) {
+            this._status = 'unavailable';
+            try { worker.postMessage({ type: 'shutdown' }); } catch { /* ignore */ }
+            resolve();
+            return;
+          }
           this._worker = worker;
           this._status = 'ready';
           this._restartAttempts = 0;
@@ -311,15 +341,15 @@ class SttEngine {
           this._processQueue();
           resolve();
         } else if (msg.type === 'error') {
-          worker.off('message', onReady);
-          worker.off('error', onError);
+          detach();
+          clearPending();
           reject(new Error(msg.message));
         }
       };
 
       const onError = (err) => {
-        worker.off('message', onReady);
-        worker.off('error', onError);
+        detach();
+        clearPending();
         // Tag dependency errors so _onWorkerExit can skip futile retries
         if (err.code === 'MODULE_NOT_FOUND' || (err.message && err.message.includes('sherpa-onnx-node'))) {
           this._lastSpawnError = 'MODULE_NOT_FOUND';
@@ -327,8 +357,19 @@ class SttEngine {
         reject(err);
       };
 
+      // If the worker dies before emitting ready/error, neither listener above
+      // fires — without this the init Promise would hang forever (and shutdown
+      // would burn its full bounded wait on it).
+      const onBootExit = (code) => {
+        detach();
+        clearPending();
+        this._status = 'unavailable';
+        reject(new Error(`STT worker exited during init (code ${code})`));
+      };
+
       worker.on('message', onReady);
       worker.on('error', onError);
+      worker.on('exit', onBootExit);
     });
   }
 
@@ -421,6 +462,31 @@ class SttEngine {
     // See docs/audits/proc-child-processes.md gap 1.
     this._stopping = true;
 
+    // Shared time budget for the init-wait + cooperative-exit waits below, so the
+    // whole engine teardown (run concurrently with the sticky-note engine by
+    // handleShutdown) finishes inside handleShutdown's 15s force-exit budget,
+    // leaving room for close(). Realistic teardown is sub-second; this only caps
+    // pathological hangs.
+    const deadline = Date.now() + 10000;
+    const remaining = () => Math.max(0, deadline - Date.now());
+
+    // If a worker is mid model-LOAD (status 'loading' = the recognizer is being
+    // constructed in the worker thread), wait — bounded — for it to settle so we
+    // can tear it down cooperatively; a worker killed mid-native-load aborts the
+    // process (SIGABRT / exit 134). We do NOT wait during 'downloading' (no native
+    // worker is loaded yet, and the download can take minutes — _doInitialize
+    // bails before spawning once _stopping is set, so a Ctrl+C during a first-run
+    // download still exits promptly).
+    if (this._initPromise && this._status === 'loading') {
+      await Promise.race([
+        Promise.resolve(this._initPromise).catch(() => {}),
+        new Promise((resolve) => {
+          const t = setTimeout(resolve, remaining());
+          if (t.unref) t.unref();
+        }),
+      ]);
+    }
+
     // Reject all queued requests
     for (const req of this._queue) {
       clearTimeout(req.timer);
@@ -429,9 +495,31 @@ class SttEngine {
     this._queue = [];
     this._currentRequest = null;
 
-    if (this._worker) {
-      await this._worker.terminate();
-      this._worker = null;
+    // Cooperatively stop the worker — the live one, or one still booting (tracked
+    // from creation in _spawnWorker). Ask it to exit on its own. We deliberately
+    // do NOT call worker.terminate(): force-killing a thread inside native
+    // sherpa-onnx code (mid-load or mid-transcribe) throws an uncaught Napi error
+    // during worker-env teardown and ggml's set_terminate aborts the whole
+    // process (SIGABRT / exit 134) — the bug this fixes. The wait is bounded
+    // (shared deadline) so handleShutdown can still save sessions + close(); a
+    // worker that never exits is reaped by handleShutdown's 15s force-exit
+    // backstop.
+    const w = this._worker || this._spawningWorker;
+    this._worker = null;
+    this._spawningWorker = null;
+    if (w) {
+      await new Promise((resolve) => {
+        let done = false;
+        const finish = () => { if (!done) { done = true; resolve(); } };
+        w.once('exit', finish);
+        try {
+          w.postMessage({ type: 'shutdown' });
+        } catch {
+          finish();
+        }
+        const t = setTimeout(finish, Math.max(1000, remaining()));
+        if (t.unref) t.unref();
+      });
     }
 
     this._status = 'unavailable';

package/src/stt-worker.js

@@ -72,8 +72,22 @@ try {
   process.exit(1);
 }
 
+let _shuttingDown = false;
 parentPort.on('message', (msg) => {
+  if (!msg) return;
+  if (msg.type === 'shutdown') {
+    // Graceful teardown. sherpa-onnx-node exposes no dispose API (the recognizer
+    // is GC/finalizer-managed), and transcribe runs synchronously here, so when
+    // this message is processed nothing is in flight. Exit cleanly while idle so
+    // the worker-env teardown doesn't race a pending native op — a bare
+    // terminate() with the recognizer loaded can abort the process during native
+    // cleanup (SIGABRT / exit 134) on Ctrl+C.
+    _shuttingDown = true;
+    process.exit(0);
+    return;
+  }
   if (msg.type === 'transcribe') {
+    if (_shuttingDown) return;
     try {
       // Two input shapes:
       //  - msg.pcm16: raw 16-bit PCM (Int16Array). Conversion to Float32 runs

package/src/usage-reader.js

@@ -321,8 +321,11 @@ class UsageReader {
     try {
       // Get the current working directory to find the right project folder
       const cwd = process.cwd();
-      // Claude uses format: -home-user-Development-project
-      const projectDirName = cwd.replace(/[\\/]/g, '-'); // Handle both Unix / and Windows \ separators
+      // Claude uses format: -home-user-Development-project. It replaces EVERY
+      // non-alphanumeric char with '-', so on Windows the drive-letter colon
+      // becomes a dash too (`C:\Users\me` -> `C--Users-me`). A separator-only
+      // replace leaves the colon and never matches the real folder.
+      const projectDirName = cwd.replace(/[^a-zA-Z0-9]/g, '-');
       let projectPath = path.join(this.claudeProjectsPath, projectDirName);
       
       // Check if the project directory exists

package/src/utils/session-store.js

@@ -232,6 +232,11 @@ class SessionStore {
                 // the durable per-claude-session note store can be rebuilt after a
                 // restart and resume when that session reopens.
                 stickyClaudeSessionId: session.stickyClaudeSessionId || null,
+                // The claude sessionId pinned via the github-router SessionStart
+                // hook sidecar (terminal tabs). Persisted so the ownership
+                // reservation (_ownedClaudeSessions) survives a restart; the
+                // durable note itself resumes via stickyClaudeSessionId above.
+                claudePinnedSessionId: session.claudePinnedSessionId || null,
                 autoTitle: session.autoTitle || null,
                 nameIsUserSet: session.nameIsUserSet || false,
                 stickyNotesEnabled: session.stickyNotesEnabled !== false