claude-code-session-manager 0.104.2 → 0.106.0

package/src/main/lib/procIdentity.cjs

@@ -97,12 +97,47 @@ function identityFromPs(pid) {
   return { pid, startTicks, cmdline, complete: startTicks !== null && cmdline !== null };
 }
 
-/** identity(pid) → {pid, startTicks, cmdline, complete}. Never throws. */
-function identity(pid) {
+/** PowerShell serialises DateTime as "\/Date(ms)\/" (5.1) or ISO-8601 (7+). */
+function parseWinStartTime(v) {
+  if (typeof v === 'string') {
+    const m = /^\/Date\((-?\d+)\)\/$/.exec(v.trim());
+    if (m) return Number(m[1]);
+    const ms = Date.parse(v);
+    return Number.isFinite(ms) ? ms : null;
+  }
+  if (v && typeof v === 'object' && typeof v.value === 'string') return parseWinStartTime(v.value);
+  return null;
+}
+
+function identityFromPowerShell(pid, execFile) {
+  const unknown = { pid, startTicks: null, cmdline: null, complete: false };
+  let out;
+  try {
+    out = execFile(
+      'powershell.exe',
+      ['-NoProfile', '-Command', `Get-Process -Id ${pid} | Select-Object StartTime,ProcessName | ConvertTo-Json`],
+      { encoding: 'utf8', windowsHide: true, timeout: 5000 },
+    );
+    const parsed = JSON.parse(String(out));
+    const startTicks = parseWinStartTime(parsed && parsed.StartTime);
+    const name = parsed && typeof parsed.ProcessName === 'string' ? parsed.ProcessName.trim() : '';
+    const cmdline = name || null;
+    return { pid, startTicks, cmdline, complete: startTicks !== null && cmdline !== null };
+  } catch {
+    return unknown; // missing process, timeout, or unparseable output
+  }
+}
+
+/**
+ * identity(pid, opts?) → {pid, startTicks, cmdline, complete}. Never throws.
+ * opts.platform / opts.execFile (sync, execFileSync-shaped) are injectable for tests.
+ */
+function identity(pid, { platform = process.platform, execFile = execFileSync } = {}) {
   if (!Number.isInteger(pid) || pid <= 0) {
     return { pid, startTicks: null, cmdline: null, complete: false };
   }
   try {
+    if (platform === 'win32') return identityFromPowerShell(pid, execFile);
     return hasProc() ? identityFromProc(pid) : identityFromPs(pid);
   } catch {
     return { pid, startTicks: null, cmdline: null, complete: false };

package/src/main/lib/projectFolder.cjs

@@ -0,0 +1,89 @@
+'use strict';
+
+/**
+ * projectFolder.cjs — create a new, empty project folder from a parent
+ * directory + a user-typed name. Electron's `createDirectory` picker property
+ * is macOS-only, so the app creates the folder itself.
+ *
+ * Never throws for validation / exists / io failures; returns a result object.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const MAX_NAME_LENGTH = 100;
+// NUL + C0 controls + DEL.
+// eslint-disable-next-line no-control-regex
+const CONTROL_RE = /[\u0000-\u001f\u007f]/;
+
+/**
+ * @param {unknown} name
+ * @returns {{ ok: true, name: string } | { ok: false, error: string }}
+ */
+function validateProjectName(name) {
+  if (typeof name !== 'string') return { ok: false, error: 'Project name must be text.' };
+  const trimmed = name.trim();
+  if (!trimmed) return { ok: false, error: 'Project name cannot be empty.' };
+  if (trimmed.length > MAX_NAME_LENGTH) {
+    return { ok: false, error: `Project name must be ${MAX_NAME_LENGTH} characters or fewer.` };
+  }
+  if (trimmed === '.' || trimmed === '..') {
+    return { ok: false, error: 'Project name cannot be "." or "..".' };
+  }
+  if (trimmed.startsWith('-')) return { ok: false, error: 'Project name cannot start with "-".' };
+  if (trimmed.includes('/') || trimmed.includes('\\')) {
+    return { ok: false, error: 'Project name cannot contain "/" or "\\".' };
+  }
+  if (CONTROL_RE.test(trimmed)) {
+    return { ok: false, error: 'Project name cannot contain control characters.' };
+  }
+  return { ok: true, name: trimmed };
+}
+
+/**
+ * @param {{ parentDir: string, name: string }} input
+ * @returns {Promise<
+ *   | { ok: true, path: string }
+ *   | { ok: false, code: 'invalid-name' | 'invalid-parent' | 'io', error: string }
+ *   | { ok: false, code: 'exists', path: string, error: string }
+ * >}
+ */
+async function createProjectFolder({ parentDir, name } = /** @type {any} */ ({})) {
+  const v = validateProjectName(name);
+  if (!v.ok) return { ok: false, code: 'invalid-name', error: v.error };
+
+  if (typeof parentDir !== 'string' || !path.isAbsolute(parentDir)) {
+    return { ok: false, code: 'invalid-parent', error: 'Parent folder must be an absolute path.' };
+  }
+  try {
+    const st = await fs.promises.stat(parentDir);
+    if (!st.isDirectory()) {
+      return { ok: false, code: 'invalid-parent', error: `${parentDir} is not a folder.` };
+    }
+  } catch {
+    return { ok: false, code: 'invalid-parent', error: `Parent folder ${parentDir} does not exist.` };
+  }
+
+  const target = path.join(parentDir, v.name);
+  if (path.dirname(target) !== path.resolve(parentDir)) {
+    return { ok: false, code: 'invalid-name', error: 'Project name must be a single folder name.' };
+  }
+
+  try {
+    await fs.promises.mkdir(target); // non-recursive on purpose
+    return { ok: true, path: target };
+  } catch (err) {
+    const e = /** @type {NodeJS.ErrnoException} */ (err);
+    if (e && e.code === 'EEXIST') {
+      return {
+        ok: false,
+        code: 'exists',
+        path: target,
+        error: `A folder named "${v.name}" already exists in ${parentDir}`,
+      };
+    }
+    return { ok: false, code: 'io', error: (e && e.message) || String(err) };
+  }
+}
+
+module.exports = { createProjectFolder, validateProjectName };

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/lib/winUserData.cjs

@@ -0,0 +1,22 @@
+// Chromium resolves 'userData' via Windows known folders; with a stripped profile
+// (no AppData) app.getPath('userData') throws "Failed to get 'userData' path" and the
+// process dies 0x80000003. Fall back to an explicit %APPDATA%-based path.
+const path = require('node:path');
+
+function ensureWinUserDataPath({ app, env, platform, fs, os, log = () => {} }) {
+  if (platform !== 'win32') return false;
+  try {
+    app.getPath('userData');
+    return false;
+  } catch (err) {
+    const appData = (env && env.APPDATA) || path.win32.join(os.homedir(), 'AppData', 'Roaming');
+    const userData = path.win32.join(appData, 'Session Manager');
+    fs.mkdirSync(userData, { recursive: true });
+    app.setPath('appData', appData);
+    app.setPath('userData', userData);
+    log(`[win-userdata] getPath('userData') failed (${err && err.message}); using ${userData}`);
+    return true;
+  }
+}
+
+module.exports = { ensureWinUserDataPath };

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) {