claude-code-session-manager 0.104.1 → 0.105.0

package/src/main/lib/queueHistory.cjs

@@ -236,11 +236,96 @@ async function readHistoryFile(target, cap) {
 let historyCacheKey = null;
 let historyCacheMap = null;
 
+// Per-file byte-offset cache backing historyTerminalBySlug's incremental
+// read: path -> { ino, size, offset, map }. `map` is this file's own
+// slug -> record result as of `offset` bytes; `offset` always sits on a
+// line boundary (the byte right after the last consumed '\n') so a partial
+// trailing line never gets counted as consumed.
+const perFileCache = new Map();
+
+/**
+ * needs_review_entry/needs_review_resolution lines (needsReviewLedger.cjs)
+ * share this file but aren't a job's terminal record — skip them, or a
+ * needs_review episode logged for a slug AFTER its real terminal row (e.g.
+ * it re-parked on a later run) would overwrite a true 'completed' with a
+ * kind-less, status-less row read as "not terminal".
+ */
+function applyTerminalLines(text, map) {
+  if (!text) return;
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const j = JSON.parse(line);
+      if (j?.kind && j.kind !== 'terminal') continue;
+      if (j?.slug) map.set(j.slug, { status: j.status, finishedAt: j.finishedAt, landedCommit: j.landedCommit ?? null });
+    } catch {
+      // corrupt/partial line — ignore
+    }
+  }
+}
+
+/**
+ * Returns this one file's slug -> record map, reading only the bytes
+ * appended since the last call when possible. Falls back to a full
+ * re-parse when the file is new to the cache, its inode changed, or its
+ * size went backwards (rotation/truncation).
+ */
+async function readFileTerminalMap(target, stat) {
+  const cached = perFileCache.get(target);
+  const { ino, size } = stat;
+
+  if (cached && cached.ino === ino && size >= cached.size) {
+    if (size === cached.size) return cached.map;
+
+    const len = size - cached.offset;
+    const fh = await fsp.open(target, 'r');
+    let buf;
+    try {
+      buf = Buffer.alloc(len);
+      await fh.read(buf, 0, len, cached.offset);
+    } finally {
+      await fh.close();
+    }
+
+    // Stop at the last complete newline — a partial trailing line (still
+    // being written) is left unconsumed so the next pass re-reads it once
+    // it's whole, instead of permanently skipping or mis-parsing it.
+    const lastNl = buf.lastIndexOf(0x0a);
+    const map = new Map(cached.map);
+    let offset = cached.offset;
+    if (lastNl !== -1) {
+      applyTerminalLines(buf.subarray(0, lastNl + 1).toString('utf8'), map);
+      offset = cached.offset + lastNl + 1;
+    }
+    const updated = { ino, size, offset, map };
+    perFileCache.set(target, updated);
+    return map;
+  }
+
+  // Full (re)parse: first time seeing this path, its inode changed, or it
+  // shrank (log rotation/truncation) — the existing offset is no longer
+  // trustworthy.
+  let text = '';
+  try {
+    text = await fsp.readFile(target, 'utf8');
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e;
+  }
+  const map = new Map();
+  applyTerminalLines(text, map);
+  const lastNl = Buffer.from(text, 'utf8').lastIndexOf(0x0a);
+  const offset = lastNl === -1 ? 0 : lastNl + 1;
+  perFileCache.set(target, { ino, size, offset, map });
+  return map;
+}
+
 /**
  * Full-file scan of history.jsonl, returning slug -> { status, finishedAt }
  * for the most recently appended record of each slug. O(H) where H is the
  * line count of history.jsonl; cached by the file's mtime so a reconcile()
- * pass with no new archives since the last call is O(1).
+ * pass with no new archives since the last call is O(1). When the mtime
+ * check misses, each file is re-read incrementally via readFileTerminalMap
+ * rather than re-parsed from byte zero.
  *
  * Exists so reconcile() can tell "this on-disk PRD's job row already left
  * jobs[] into history — do not resurrect it as a fresh pending job" apart
@@ -248,36 +333,22 @@ let historyCacheMap = null;
  */
 async function historyTerminalBySlug() {
   const paths = historyPaths();
-  const mtimes = await Promise.all(paths.map(async (p2) => {
-    try { return (await fsp.stat(p2)).mtimeMs; } catch { return -1; }
+  const stats = await Promise.all(paths.map(async (p2) => {
+    try { return await fsp.stat(p2); } catch { return null; }
   }));
-  const cacheKey = paths.map((p2, i) => `${p2}:${mtimes[i]}`).join('|');
+  const cacheKey = paths.map((p2, i) => `${p2}:${stats[i] ? stats[i].mtimeMs : -1}`).join('|');
   if (cacheKey === historyCacheKey && historyCacheMap) return historyCacheMap;
 
   const map = new Map();
-  for (const p2 of paths) {
-    let text = '';
-    try {
-      text = await fsp.readFile(p2, 'utf8');
-    } catch (e) {
-      if (e.code !== 'ENOENT') throw e;
-    }
-    if (!text) continue;
-    for (const line of text.split('\n')) {
-      if (!line.trim()) continue;
-      try {
-        const j = JSON.parse(line);
-        // needs_review_entry/needs_review_resolution lines (needsReviewLedger.cjs)
-        // share this file but aren't a job's terminal record — skip them, or a
-        // needs_review episode logged for a slug AFTER its real terminal row
-        // (e.g. it re-parked on a later run) would overwrite a true 'completed'
-        // with a kind-less, status-less row read as "not terminal".
-        if (j?.kind && j.kind !== 'terminal') continue;
-        if (j?.slug) map.set(j.slug, { status: j.status, finishedAt: j.finishedAt, landedCommit: j.landedCommit ?? null });
-      } catch {
-        // corrupt/partial line — ignore
-      }
+  for (let i = 0; i < paths.length; i++) {
+    const p2 = paths[i];
+    const stat = stats[i];
+    if (!stat) {
+      perFileCache.delete(p2);
+      continue;
     }
+    const fileMap = await readFileTerminalMap(p2, stat);
+    for (const [slug, rec] of fileMap) map.set(slug, rec);
   }
   historyCacheKey = cacheKey;
   historyCacheMap = map;

package/src/main/lib/rcaReport.cjs

@@ -50,6 +50,7 @@ const VERDICT_LABELS = {
   no_verdict_sentinel: 'no commit or verdict sentinel',
   abandoned_background_task: 'abandoned auto-backgrounded task',
   pass_no_commit: 'PASS sentinel but no commit landed',
+  sentinel_fail: 'executor reported SCHEDULER_VERDICT: FAIL',
   pass_no_commit_already_shipped: 'PASS with no commit — deliverables already shipped',
   pass_no_commit_prior_run_verified: 'PASS with no commit — prior run of this slug already landed the work',
   silent_no_op: 'no commit, clean tree — no evidence of work',

package/src/main/lib/reaperHelpers.cjs

@@ -30,9 +30,11 @@ const { pidAlive } = require('./pidAlive.cjs');
  * Conservative by design: a false negative (live process treated as dead) is
  * far worse than a late reap.
  */
-function claudePidAlive(pid) {
+function claudePidAlive(pid, { platform = process.platform } = {}) {
   if (!pid || typeof pid !== 'number' || pid <= 1) return false;
   if (!pidAlive(pid)) return false;
+  // Windows has no /proc — cannot verify identity, so never call it dead.
+  if (platform === 'win32') return true;
   try {
     const cmd = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf8').replace(/\0/g, ' ');
     return /\bclaude\b/.test(cmd);
@@ -73,7 +75,8 @@ function claudePidAlive(pid) {
  * — i.e. exactly today's behaviour (fail toward terminalizing), never a hang
  * or a thrown error propagating to the caller.
  */
-function findLiveProcessForJob(job, { worktreeDir, runCwd } = {}) {
+function findLiveProcessForJob(job, { worktreeDir, runCwd, platform = process.platform } = {}) {
+  if (platform === 'win32') return null; // no /proc — skip every read
   const slug = job?.slug;
   let entries;
   try {

package/src/main/lib/shippedPersonaSeeds.cjs

@@ -207,6 +207,16 @@ const SHIPPED_PERSONA_SEEDS = deepFreeze({
         tools: "Read, Grep, Glob, Bash",
       },
     },
+    {
+      commit: "<fill in>",
+      bodySha256: "ca159cd47ac4b618af842c6ccd59107fac4a34b0efcfa5dfe7d06875736156ed",
+      fm: {
+        description: "Validates a finished PLAN (the PRDs its validate PRD lists) once, after its last PRD lands — re-runs each PRD's gate, checks every acceptance criterion against the real tree, reviews the plan's combined diff, and reports one VERIFIED/REFUTED verdict per PRD via sentinel lines. Runs headless as a scheduled PRD (agentType: validator); never edits product code and never queues work.",
+        model: "sonnet",
+        title: "Engineering — Plan Validator",
+        tools: "Read, Grep, Glob, Bash",
+      },
+    },
   ],
   "demo-video-builder": [
     {

package/src/main/lib/timeoutShimScript.cjs

@@ -222,16 +222,28 @@ function main() {
   // spawned, without detaching further, dies too); fall back to the direct
   // pid only when the group signal itself fails (e.g. --foreground, where
   // the child shares OUR group rather than leading its own).
+  // Inlined (not require('./killTree.cjs')): this script is copied to ~ and
+  // runs standalone, so it cannot resolve app-relative modules. win32 has no
+  // process groups, so taskkill /T /F stands in for the group signal.
   function killGroup(sig) {
+    if (process.platform === 'win32') {
+      try {
+        require('node:child_process').spawn('taskkill', ['/PID', String(child.pid), '/T', '/F'], { stdio: 'ignore', windowsHide: true });
+      } catch {
+        try { process.kill(child.pid, sig); } catch { /* already gone */ }
+      }
+      return;
+    }
     try {
-      process.kill(-child.pid, sig);
+      const groupPid = -child.pid; // negative pid = whole POSIX process group
+      process.kill(groupPid, sig);
     } catch {
       try { process.kill(child.pid, sig); } catch { /* already gone */ }
     }
   }
 
   try {
-    child = spawn(command, commandArgs, { stdio: 'inherit', detached: !opts.foreground });
+    child = spawn(command, commandArgs, { stdio: 'inherit', detached: !opts.foreground, windowsHide: true });
   } catch (err) {
     finish(err && err.code === 'EACCES' ? 126 : 127);
     return;

package/src/main/lib/updateCheck.cjs

@@ -3,9 +3,10 @@
 /**
  * updateCheck.cjs — bounded, offline-safe, opt-out "is a newer build published?" probe.
  *
- * getUpdateStatus() → { current, latest, behind }. Never throws/rejects; any failure
- * (offline, DNS, non-200, bad JSON, timeout) → { current, latest: null, behind: false }.
- * The request is a bare GET (no headers/cookies/query/body) so it carries nothing that
+ * getUpdateStatus() → { current, latest, behind, channel, downloadUrl? } (installer builds compare
+ * against the latest GitHub Release; npx/dev builds against the npm registry). Never throws/rejects; any failure
+ * (offline, DNS, non-200, bad JSON, timeout) → { current, latest: null, behind: false, channel }.
+ * The request is a bare GET (only a static User-Agent; no cookies/query/body) so it carries nothing that
  * identifies the user or machine. Disabled by SM_UPDATE_CHECK=0 or E2E mode (SM_E2E=1).
  */
 
@@ -16,11 +17,14 @@ const path = require('node:path');
 const CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 const REQUEST_TIMEOUT_MS = 3000;
 const CACHE_FILE = 'update-check.json';
+const GITHUB_CACHE_FILE = 'update-check-github.json';
+const GITHUB_RELEASE_URL = 'https://api.github.com/repos/StanislavBG/claude-code-session-manager/releases/latest';
 
 /** Plain GET → parsed JSON. Rejects on non-200, bad JSON, or timeout. */
 function httpGetJson(url, timeoutMs) {
   return new Promise((resolve, reject) => {
-    const req = https.get(url, { timeout: timeoutMs }, (res) => {
+    // GitHub's API rejects requests without a User-Agent; it names the app only, not the user.
+    const req = https.get(url, { timeout: timeoutMs, headers: { 'User-Agent': 'claude-code-session-manager' } }, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
         reject(new Error(`HTTP ${res.statusCode}`));
@@ -58,15 +62,20 @@ function isBehind(current, latest) {
   return false;
 }
 
-function readCache(file, now) {
+function readCacheEntry(file, now) {
   try {
     const c = JSON.parse(fs.readFileSync(file, 'utf8'));
     if (c && typeof c.latest === 'string' && typeof c.checkedAt === 'number'
-      && now - c.checkedAt >= 0 && now - c.checkedAt < CACHE_TTL_MS) return c.latest;
+      && now - c.checkedAt >= 0 && now - c.checkedAt < CACHE_TTL_MS) return c;
   } catch { /* missing/corrupt cache = miss */ }
   return null;
 }
 
+function readCache(file, now) {
+  const c = readCacheEntry(file, now);
+  return c ? c.latest : null;
+}
+
 function defaultPackageName() {
   return require(path.join(__dirname, '..', '..', '..', 'package.json')).name;
 }
@@ -74,13 +83,34 @@ function defaultPackageName() {
 async function getUpdateStatus({ deps } = {}) {
   const d = deps || {};
   let current = '';
+  let channel = 'npm';
   try {
     const app = d.app || require('electron').app;
     current = app.getVersion();
+    const packaged = (d.isPackaged || require('./appRuntime.cjs').isPackagedApp)();
+    channel = packaged ? 'installer' : 'npm';
     const env = d.env || process.env;
-    if (env.SM_UPDATE_CHECK === '0' || env.SM_E2E === '1') return { current, latest: null, behind: false };
+    if (env.SM_UPDATE_CHECK === '0' || env.SM_E2E === '1') return { current, latest: null, behind: false, channel };
 
     const now = (d.now || Date.now)();
+    const write = d.writeJson || require('../config.cjs').writeJson;
+    if (packaged) {
+      const file = path.join(app.getPath('userData'), GITHUB_CACHE_FILE);
+      let entry = readCacheEntry(file, now);
+      if (entry == null) {
+        const rel = await (d.fetchJson || httpGetJson)(GITHUB_RELEASE_URL, REQUEST_TIMEOUT_MS);
+        const tag = rel && typeof rel.tag_name === 'string' ? rel.tag_name.replace(/^v/, '') : '';
+        if (!tag) return { current, latest: null, behind: false, channel };
+        const downloadUrl = typeof rel.html_url === 'string' ? rel.html_url : null;
+        entry = { checkedAt: now, latest: tag, downloadUrl };
+        try { await write(file, entry); } catch { /* cache is best-effort */ }
+      }
+      return {
+        current, latest: entry.latest, behind: isBehind(current, entry.latest), channel,
+        downloadUrl: typeof entry.downloadUrl === 'string' ? entry.downloadUrl : null,
+      };
+    }
+
     const file = path.join(app.getPath('userData'), CACHE_FILE);
     let latest = readCache(file, now);
     if (latest == null) {
@@ -88,14 +118,14 @@ async function getUpdateStatus({ deps } = {}) {
       const url = `https://registry.npmjs.org/-/package/${name}/dist-tags`;
       const tags = await (d.fetchJson || httpGetJson)(url, REQUEST_TIMEOUT_MS);
       latest = tags && typeof tags.latest === 'string' ? tags.latest : null;
-      if (latest == null) return { current, latest: null, behind: false };
+      if (latest == null) return { current, latest: null, behind: false, channel };
       try {
-        await (d.writeJson || require('../config.cjs').writeJson)(file, { checkedAt: now, latest });
+        await write(file, { checkedAt: now, latest });
       } catch { /* cache is best-effort */ }
     }
-    return { current, latest, behind: isBehind(current, latest) };
+    return { current, latest, behind: isBehind(current, latest), channel };
   } catch {
-    return { current, latest: null, behind: false };
+    return { current, latest: null, behind: false, channel };
   }
 }
 

package/src/main/lib/watchdogHelpers.cjs

@@ -9,6 +9,7 @@ const schedulerPaths = require('./schedulerPaths.cjs');
 const { isRestartingMarkerActive } = require('./upgradeDrain.cjs');
 const { pidAlive: pidAliveCore } = require('./pidAlive.cjs');
 const atomicFs = require('./atomicFs.cjs');
+const { isPackagedApp } = require('./appRuntime.cjs');
 
 
 
@@ -230,14 +231,32 @@ function logRelaunchLine(logPath, message) {
  * (short-lived) process doesn't block on the launched app and the app
  * survives the watchdog exiting.
  */
-function defaultSpawnRelaunch({ logPath = schedulerPaths.watchdogRelaunchLogPath() } = {}) {
-  const { spawn } = require('node:child_process');
+/**
+ * relaunchSpec(opts?) — what the watchdog spawns to bring the app back.
+ * Packaged installer builds have no npx: relaunch the app binary itself.
+ * @param {{ packaged?: boolean, execPath?: string }} [opts]
+ * @returns {{ command: string, args: string[], packaged: boolean }}
+ */
+function relaunchSpec(opts) {
+  if (isPackagedApp(opts)) {
+    return { command: (opts && opts.execPath) || process.execPath, args: [], packaged: true };
+  }
+  return { command: 'npx', args: ['claude-code-session-manager@latest'], packaged: false };
+}
+
+function defaultSpawnRelaunch({ logPath = schedulerPaths.watchdogRelaunchLogPath(), packaged, execPath, spawnFn } = {}) {
+  const spawn = spawnFn || require('node:child_process').spawn;
+  const spec = relaunchSpec({ packaged, execPath });
   fs.mkdirSync(path.dirname(logPath), { recursive: true });
   const fd = fs.openSync(logPath, 'a');
   try {
-    const child = spawn('npx', ['claude-code-session-manager@latest'], {
+    const env = { ...process.env };
+    // The watchdog may itself run as node via the app binary; the relaunched app must not.
+    if (spec.packaged) delete env.ELECTRON_RUN_AS_NODE;
+    const child = spawn(spec.command, spec.args, {
       detached: true,
       stdio: ['ignore', fd, fd],
+      env,
     });
     child.on('error', (e) => {
       logRelaunchLine(logPath, `spawn error: ${e?.message}`);
@@ -460,6 +479,7 @@ module.exports = {
   readRelaunchState,
   writeRelaunchState,
   defaultSpawnRelaunch,
+  relaunchSpec,
   maybeRelaunchApp,
   DEFAULT_MAX_AGE_MS,
   DEFAULT_DISPATCH_DEAD_MS,

package/src/main/lib/winSpawn.cjs

@@ -0,0 +1,67 @@
+/**
+ * winSpawn.cjs — make spawn() work for Windows .cmd/.bat shims (npx, npm) without
+ * shell:true. Node refuses to spawn those directly (EINVAL), so they are wrapped in
+ * an explicit `cmd.exe /d /s /c "<line>"` argv with every cmd metacharacter escaped.
+ * Non-win32 input passes through untouched.
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const DEFAULT_PATHEXT = '.COM;.EXE;.BAT;.CMD';
+const META = /([()\][%!^"`<>&|;, *?])/g;
+
+function envGet(env, name) {
+  if (env[name] !== undefined) return env[name];
+  const key = Object.keys(env).find((k) => k.toLowerCase() === name.toLowerCase());
+  return key ? env[key] : undefined;
+}
+
+function findOnPath(command, env, exists) {
+  const w = path.win32;
+  const exts = (envGet(env, 'PATHEXT') || DEFAULT_PATHEXT)
+    .split(';').filter(Boolean).map((e) => e.toLowerCase());
+  const hasDir = /[\\/]/.test(command);
+  const dirs = hasDir ? [''] : (envGet(env, 'PATH') || '').split(';').filter(Boolean);
+  const hasExt = exts.includes(w.extname(command).toLowerCase());
+  for (const dir of dirs) {
+    const base = dir ? w.join(dir, command) : command;
+    const candidates = hasExt ? [base] : [];
+    for (const e of exts) candidates.push(base + e);
+    // PATHEXT order is by extension; keep the casing the filesystem probe accepts.
+    for (const cand of candidates) {
+      if (exists(cand)) return cand;
+      const upper = cand.slice(0, cand.length - w.extname(cand).length) + w.extname(cand).toUpperCase();
+      if (upper !== cand && exists(upper)) return upper;
+    }
+  }
+  return null;
+}
+
+// Quote for CreateProcess argv parsing, then ^-escape every cmd metacharacter.
+function quoteArg(arg) {
+  let s = String(arg);
+  s = s.replace(/(\\*)"/g, '$1$1\\"').replace(/(\\*)$/, '$1$1');
+  s = `"${s}"`;
+  return s.replace(META, '^$1');
+}
+
+function resolveSpawn(command, args = [], { platform = process.platform, env = process.env, exists = fs.existsSync } = {}) {
+  if (platform !== 'win32') return { command, args };
+  const resolved = findOnPath(command, env, exists);
+  if (!resolved) return { command, args };
+  const ext = path.win32.extname(resolved).toLowerCase();
+  if (ext === '.cmd' || ext === '.bat') {
+    const line = [resolved, ...args].map(quoteArg).join(' ');
+    return {
+      command: envGet(env, 'ComSpec') || 'cmd.exe',
+      args: ['/d', '/s', '/c', `"${line}"`],
+      windowsVerbatimArguments: true,
+    };
+  }
+  return { command: resolved, args };
+}
+
+module.exports = { resolveSpawn };

package/src/main/otel.cjs

@@ -8,58 +8,36 @@
  * plan text, and agent prompts are excluded unless `includeContent` is on
  * (matches upstream OTEL_LOG_USER_PROMPTS opt-in).
  *
- * The OTEL SDK is required lazily — if any of the @opentelemetry/* packages
- * fail to load, the module is left in an inert state and `recordTranscriptEvent`
- * becomes a no-op. The app must keep working without telemetry.
- *
- * Threading: the BatchSpanProcessor batches/sends spans on its own timer; we
- * never block the transcript flush.
+ * Spans are POSTed as OTLP/HTTP JSON by lib/otlpTraceExporter.cjs (zero
+ * dependencies). recordSpan() only queues; the exporter batches/sends on its
+ * own unref()'d timer, so we never block the transcript flush. The app must
+ * keep working without telemetry: a failed export is surfaced, never thrown.
  */
 
 const otelSettings = require('./otelSettings.cjs');
+const { createOtlpTraceExporter } = require('./lib/otlpTraceExporter.cjs');
 
-let provider = null;
-let tracer = null;
+let exporter = null;
 let enabled = false;
 let includeContent = false;
 let lastError = null;
 let initialized = false;
 
 /**
- * Lazy-require all @opentelemetry/* packages. Returns null if any are missing.
- * We catch the per-require so a partial install doesn't half-init.
- */
-function loadDeps() {
-  try {
-    const api = require('@opentelemetry/api');
-    const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
-    const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
-    const { OTLPTraceExporter } = require('@opentelemetry/exporter-trace-otlp-http');
-    const { resourceFromAttributes } = require('@opentelemetry/resources');
-    const { ATTR_SERVICE_NAME } = require('@opentelemetry/semantic-conventions');
-    return { api, NodeTracerProvider, BatchSpanProcessor, OTLPTraceExporter, resourceFromAttributes, ATTR_SERVICE_NAME };
-  } catch (err) {
-    return { error: err };
-  }
-}
-
-/**
- * Tear down any existing provider. Best-effort — flushes pending spans on a
+ * Tear down any existing exporter. Best-effort — flushes pending spans on a
  * 2s ceiling so a wedged exporter doesn't block app shutdown / config reload.
  */
 async function shutdown() {
-  if (!provider) {
+  if (!exporter) {
     enabled = false;
-    tracer = null;
     return;
   }
-  const p = provider;
-  provider = null;
-  tracer = null;
+  const e = exporter;
+  exporter = null;
   enabled = false;
   try {
     await Promise.race([
-      p.shutdown(),
+      e.shutdown(),
       new Promise((resolve) => setTimeout(resolve, 2000)),
     ]);
   } catch (err) {
@@ -68,7 +46,7 @@ async function shutdown() {
 }
 
 /**
- * Configure the tracer provider. Tears down any prior provider first so a
+ * Configure the exporter. Tears down any prior exporter first so a
  * settings change reliably re-points at the new endpoint.
  *
  * Returns { ok, error?: string } — the renderer surfaces `error` in the UI.
@@ -77,31 +55,13 @@ async function init({ endpoint, headers, serviceName, includeContent: ic } = {})
   await shutdown();
   initialized = true;
 
-  const deps = loadDeps();
-  if (deps.error) {
-    lastError = `OTEL packages unavailable: ${deps.error.message}`;
-    return { ok: false, error: lastError };
-  }
-
-  const { NodeTracerProvider, BatchSpanProcessor, OTLPTraceExporter, resourceFromAttributes, ATTR_SERVICE_NAME } = deps;
-
   try {
-    const exporter = new OTLPTraceExporter({
+    exporter = createOtlpTraceExporter({
       url: String(endpoint || 'http://localhost:4318/v1/traces'),
       headers: typeof headers === 'object' && headers ? headers : {},
+      serviceName: String(serviceName || 'session-manager'),
+      scopeName: 'session-manager-transcripts',
     });
-    const tp = new NodeTracerProvider({
-      resource: resourceFromAttributes({
-        [ATTR_SERVICE_NAME]: String(serviceName || 'session-manager'),
-      }),
-      spanProcessors: [new BatchSpanProcessor(exporter)],
-    });
-    // Note: we deliberately do NOT call tp.register() — that installs a global
-    // tracer provider, which would intercept any other OTEL user in the
-    // process. We only want to emit our own spans, so we use the provider
-    // directly via getTracer().
-    provider = tp;
-    tracer = tp.getTracer('session-manager-transcripts');
     includeContent = !!ic;
     enabled = true;
     lastError = null;
@@ -205,11 +165,11 @@ function pruneAttrs(obj) {
 
 /**
  * Emit a 0-duration span for one classified transcript event.
- * Synchronous + non-blocking: the BatchSpanProcessor handles network I/O
+ * Synchronous + non-blocking: the exporter handles network I/O
  * on its own schedule.
  */
 function recordTranscriptEvent({ tabId, tabCwd, kind, data, ts }) {
-  if (!enabled || !tracer) return;
+  if (!enabled || !exporter) return;
   try {
     const startTime = typeof ts === 'number' ? ts : Date.now();
     const attrs = pruneAttrs({
@@ -218,11 +178,7 @@ function recordTranscriptEvent({ tabId, tabCwd, kind, data, ts }) {
       kind,
       ...attrsFor(kind, data),
     });
-    const span = tracer.startSpan(`transcript.${kind}`, {
-      startTime,
-      attributes: attrs,
-    });
-    span.end(startTime);
+    exporter.recordSpan({ name: `transcript.${kind}`, timeMs: startTime, attributes: attrs });
   } catch (err) {
     // A failure here must never break transcript ingestion. Log once-ish.
     if (!recordTranscriptEvent._warned) {