claude-code-session-manager 0.4.0 → 0.5.0

package/src/main/scheduler.cjs

@@ -54,10 +54,17 @@ const QUEUE_PATH = path.join(ROOT, 'queue.json');
 const DEFAULT_PROJECT_CWD = path.join(os.homedir(), 'Projects', 'session-manager');
 
 const DEFAULT_CONFIG = {
+  // Legacy on/off retained for backwards compat; v0.5+ uses firePolicy.
   enabled: false,
   offsetMinutes: 15,
   concurrencyCap: 5,
   defaultCwd: DEFAULT_PROJECT_CWD,
+  // 'when-available' = poll usage and fire whenever utilization < threshold.
+  // 'on-reset'        = fire offsetMinutes after the next 5h reset (legacy).
+  // 'manual'          = only fire on explicit Run-now click.
+  firePolicy: 'when-available',
+  // For 'when-available'. Fire only when five_hour utilization < this percent.
+  utilizationThreshold: 90,
   schemaVersion: 1,
 };
 
@@ -83,9 +90,10 @@ function readQueue() {
       jobs: Array.isArray(data.jobs) ? data.jobs : [],
       scheduledFor: data.scheduledFor ?? null,
       lastRunAt: data.lastRunAt ?? null,
+      paused: data.paused ?? null,
     };
   } catch {
-    return { config: { ...DEFAULT_CONFIG }, jobs: [], scheduledFor: null, lastRunAt: null };
+    return { config: { ...DEFAULT_CONFIG }, jobs: [], scheduledFor: null, lastRunAt: null, paused: null };
   }
 }
 
@@ -213,12 +221,14 @@ function reconcile(state) {
 // ---------- next-reset detection ----------
 
 let cachedNextReset = { at: null, fetchedAt: 0 };
+let cachedUtilization = null; // five_hour utilization %, 0–100, or null if unknown
 
 async function refreshNextReset() {
   try {
     const r = await billing.fetchUsage();
     const at = r?.usage?.five_hour?.resets_at ?? null;
     cachedNextReset = { at, fetchedAt: Date.now() };
+    cachedUtilization = r?.usage?.five_hour?.utilization ?? cachedUtilization;
     return at;
   } catch {
     return cachedNextReset.at;
@@ -233,7 +243,10 @@ function getNextResetCached() {
 
 let mainWindow = null;
 let fireTimer = null;
+let resumeTimer = null;
+let pollTimer = null;
 let isExecuting = false;
+let cancelToken = { cancelled: false };
 let claudeBinPathCached = null;
 
 function attachWindow(w) { mainWindow = w; }
@@ -249,6 +262,8 @@ function broadcast() {
     scheduledFor: state.scheduledFor,
     lastRunAt: state.lastRunAt,
     nextReset: getNextResetCached(),
+    paused: state.paused,
+    utilization: cachedUtilization,
   });
 }
 
@@ -260,7 +275,10 @@ function clearFireTimer() {
 }
 
 function computeFireAt(state, nextResetIso) {
-  if (!state.config.enabled) return null;
+  // Only the legacy 'on-reset' policy uses scheduled fire times. Other
+  // policies fire either immediately on demand ('manual') or via the
+  // when-available poll loop.
+  if (state.config.firePolicy !== 'on-reset') return null;
   if (!nextResetIso) return null;
   const reset = new Date(nextResetIso).getTime();
   if (Number.isNaN(reset)) return null;
@@ -292,6 +310,67 @@ async function rescheduleTimer() {
   console.log(`[scheduler] next fire in ${Math.round(delay / 1000)}s @ ${state.scheduledFor}`);
 }
 
+// ---------- pause / resume ----------
+
+function setPaused(reason, resumeAtIso) {
+  const s = readQueue();
+  if (s.paused && s.paused.reason === reason) {
+    // already paused for this reason; just refresh resumeAt if newer
+    if (resumeAtIso) s.paused.resumeAt = resumeAtIso;
+  } else {
+    s.paused = { reason, since: new Date().toISOString(), resumeAt: resumeAtIso || null };
+  }
+  writeQueue(s);
+  broadcast();
+  cancelToken.cancelled = true;
+  if (resumeTimer) { clearTimeout(resumeTimer); resumeTimer = null; }
+  if (resumeAtIso) {
+    // Resume 30s after the reset to give the auth/billing endpoint time to flip.
+    const delay = Math.max(30_000, new Date(resumeAtIso).getTime() - Date.now() + 30_000);
+    if (delay <= 0x7fffffff) {
+      resumeTimer = setTimeout(() => {
+        clearPause('resume-timer');
+        runDueJobs().catch(() => {});
+      }, delay);
+      console.log(`[scheduler] paused (${reason}); auto-resume in ${Math.round(delay/1000)}s`);
+    } else {
+      console.warn(`[scheduler] paused (${reason}); resumeAt too far in future for setTimeout (${delay}ms)`);
+    }
+  }
+}
+
+function clearPause(source) {
+  if (resumeTimer) { clearTimeout(resumeTimer); resumeTimer = null; }
+  const s = readQueue();
+  if (s.paused) {
+    console.log(`[scheduler] clearPause (${source || 'manual'})`);
+    s.paused = null;
+    writeQueue(s);
+    broadcast();
+  }
+}
+
+/** Scan the tail of a job's log for the canonical rate-limit signal. We look
+ *  at the last 16 KB — final result event always lands at the end. */
+function detectRateLimitInLog(logPath) {
+  try {
+    const stat = fs.statSync(logPath);
+    const start = Math.max(0, stat.size - 16384);
+    const len = stat.size - start;
+    if (len <= 0) return false;
+    const fd = fs.openSync(logPath, 'r');
+    const buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, start);
+    fs.closeSync(fd);
+    const text = buf.toString('utf8');
+    return /"rateLimitType":"five_hour"/.test(text)
+      || /"api_error_status":429/.test(text)
+      || /You'?ve hit your limit/.test(text);
+  } catch {
+    return false;
+  }
+}
+
 // ---------- claude binary ----------
 
 function resolveClaudeBin() {
@@ -366,8 +445,9 @@ async function executeJob(job, runDir, defaultCwd) {
       const durationMs = Date.now() - startedAt;
       fs.writeSync(fd, `\n[scheduler] exit code=${code} duration=${Math.round(durationMs / 1000)}s\n`);
       fs.closeSync(fd);
-      atomicWriteJson(metaPath, { slug: job.slug, cwd, exitCode: code, startedAt, finishedAt: Date.now(), durationMs });
-      resolve({ exitCode: code, durationMs });
+      const rateLimited = code !== 0 && detectRateLimitInLog(logPath);
+      atomicWriteJson(metaPath, { slug: job.slug, cwd, exitCode: code, rateLimited, startedAt, finishedAt: Date.now(), durationMs });
+      resolve({ exitCode: code, durationMs, rateLimited });
     });
   });
 }
@@ -375,12 +455,16 @@ async function executeJob(job, runDir, defaultCwd) {
 async function runDueJobs() {
   if (isExecuting) return;
   isExecuting = true;
+  cancelToken = { cancelled: false };
   try {
     const state = readQueue();
+    if (state.paused) {
+      console.log('[scheduler] runDueJobs skipped: paused');
+      return;
+    }
     reconcile(state);
     const pending = state.jobs.filter((j) => j.status === 'pending');
     if (pending.length === 0) {
-      isExecuting = false;
       return;
     }
     const { runId, dir: runDir } = pickRunDir();
@@ -400,6 +484,7 @@ async function runDueJobs() {
     broadcast();
 
     for (const gk of groupKeys) {
+      if (cancelToken.cancelled) break;
       const groupJobs = groups.get(gk);
       // Within a group: cap concurrency and run waves until all done.
       const cap = Math.max(1, Math.min(state.config.concurrencyCap, groupJobs.length));
@@ -416,14 +501,31 @@ async function runDueJobs() {
           writeQueue(s);
           broadcast();
         }
-        const promise = executeJob(job, runDir, state.config.defaultCwd).then((res) => {
+        const promise = executeJob(job, runDir, state.config.defaultCwd).then(async (res) => {
+          // Rate-limit OR pause-already-set means we treat this job as
+          // unfinished — bounce it back to 'pending' so the next run
+          // (after token reset) picks it up.
+          if (res.rateLimited) {
+            const resetIso = await refreshNextReset();
+            setPaused('rate_limit', resetIso);
+          }
           const sn = readQueue();
           const i2 = sn.jobs.findIndex((x) => x.slug === job.slug);
           if (i2 >= 0) {
-            sn.jobs[i2].status = res.exitCode === 0 ? 'completed' : 'failed';
-            sn.jobs[i2].finishedAt = new Date().toISOString();
-            sn.jobs[i2].exitCode = res.exitCode;
-            sn.jobs[i2].error = res.error || null;
+            const treatAsPending = res.rateLimited || (sn.paused && sn.paused.reason === 'rate_limit');
+            if (treatAsPending) {
+              sn.jobs[i2].status = 'pending';
+              sn.jobs[i2].runId = null;
+              sn.jobs[i2].startedAt = null;
+              sn.jobs[i2].finishedAt = null;
+              sn.jobs[i2].exitCode = null;
+              sn.jobs[i2].error = res.rateLimited ? 'paused: rate limit' : 'paused: queue halted';
+            } else {
+              sn.jobs[i2].status = res.exitCode === 0 ? 'completed' : 'failed';
+              sn.jobs[i2].finishedAt = new Date().toISOString();
+              sn.jobs[i2].exitCode = res.exitCode;
+              sn.jobs[i2].error = res.error || null;
+            }
             writeQueue(sn);
             broadcast();
           }
@@ -433,24 +535,64 @@ async function runDueJobs() {
       };
 
       // Prime up to cap
-      while (queue.length && inFlight.size < cap) launch(queue.shift());
-      // Drain
+      while (queue.length && inFlight.size < cap && !cancelToken.cancelled) launch(queue.shift());
+      // Drain. If cancelled mid-group, stop launching new jobs but let
+      // already-launched ones settle (they're rate-limited too — short).
       while (inFlight.size > 0) {
         await Promise.race(inFlight);
+        if (cancelToken.cancelled) {
+          await Promise.allSettled([...inFlight]);
+          break;
+        }
         while (queue.length && inFlight.size < cap) launch(queue.shift());
       }
     }
   } finally {
     isExecuting = false;
-    // After a run, disable auto-fire so the user has to opt-in for the next reset.
+    // No longer auto-disable after a run. The firePolicy now governs whether
+    // the next batch fires automatically. Just clear the one-shot scheduledFor.
     const s = readQueue();
-    s.config.enabled = false;
     s.scheduledFor = null;
     writeQueue(s);
     broadcast();
   }
 }
 
+// ---------- when-available poll loop ----------
+
+async function pollWhenAvailable() {
+  try {
+    const state = readQueue();
+    if (state.config.firePolicy !== 'when-available') return;
+    if (state.paused) return;
+    if (isExecuting) return;
+    const pending = state.jobs.filter((j) => j.status === 'pending');
+    if (pending.length === 0) return;
+
+    // Refresh utilization. If the call fails, don't fire blindly — wait
+    // for the next tick.
+    let util;
+    try {
+      const r = await billing.fetchUsage();
+      util = r?.usage?.five_hour?.utilization ?? null;
+      cachedUtilization = util;
+      cachedNextReset = { at: r?.usage?.five_hour?.resets_at ?? cachedNextReset.at, fetchedAt: Date.now() };
+    } catch {
+      return;
+    }
+    if (util === null || util === undefined) return;
+    if (util >= state.config.utilizationThreshold) {
+      // Tokens too high — broadcast so the UI shows current util but don't fire.
+      broadcast();
+      return;
+    }
+    console.log(`[scheduler] when-available: util=${util}%, ${pending.length} pending — firing`);
+    runDueJobs().catch((e) => console.error('[scheduler] runDueJobs error', e));
+  } catch (e) {
+    console.error('[scheduler] poll error', e);
+  }
+}
+
 // ---------- IPC ----------
 
 function registerScheduleHandlers() {
@@ -466,6 +608,8 @@ function registerScheduleHandlers() {
       scheduledFor: state.scheduledFor,
       lastRunAt: state.lastRunAt,
       nextReset: getNextResetCached(),
+      paused: state.paused,
+      utilization: cachedUtilization,
       paths: { root: ROOT, prds: PRDS_DIR, runs: RUNS_DIR, queue: QUEUE_PATH },
     };
   });
@@ -500,10 +644,17 @@ function registerScheduleHandlers() {
   });
 
   ipcMain.handle('schedule:run-now', async () => {
+    // Manual run-now overrides any auto-pause. Clear it first.
+    clearPause('run-now');
     runDueJobs().catch((e) => console.error('[scheduler] runDueJobs error', e));
     return { ok: true };
   });
 
+  ipcMain.handle('schedule:resume', async () => {
+    clearPause('manual');
+    return { ok: true };
+  });
+
   ipcMain.handle('schedule:refresh-reset', async () => {
     const at = await refreshNextReset();
     await rescheduleTimer();
@@ -539,11 +690,28 @@ function registerScheduleHandlers() {
 async function init() {
   ensureDirs();
   // Ensure queue.json exists with defaults so the renderer can read it.
-  if (!fs.existsSync(QUEUE_PATH)) writeQueue({ config: { ...DEFAULT_CONFIG }, jobs: [], scheduledFor: null, lastRunAt: null });
+  if (!fs.existsSync(QUEUE_PATH)) writeQueue({ config: { ...DEFAULT_CONFIG }, jobs: [], scheduledFor: null, lastRunAt: null, paused: null });
+
+  // If we boot up while paused with a resumeAt in the past, clear it. This
+  // happens when the app was closed across the reset window.
+  const boot = readQueue();
+  if (boot.paused && boot.paused.resumeAt && new Date(boot.paused.resumeAt).getTime() <= Date.now()) {
+    clearPause('boot-elapsed');
+  } else if (boot.paused && boot.paused.resumeAt) {
+    // Re-arm the resume timer (lost across restart).
+    setPaused(boot.paused.reason, boot.paused.resumeAt);
+  }
+
   await rescheduleTimer();
   // Refresh next-reset every 10 minutes — billing window can shift if usage
   // resets early or the auth token rotates.
   setInterval(() => { rescheduleTimer().catch(() => {}); }, 10 * 60_000);
+  // when-available poll loop. Tick every 2 minutes; the function itself is
+  // a no-op when policy != 'when-available' or queue is empty/paused.
+  if (pollTimer) clearInterval(pollTimer);
+  pollTimer = setInterval(() => { pollWhenAvailable().catch(() => {}); }, 2 * 60_000);
+  // First tick fires after a short delay so billing is warmed up.
+  setTimeout(() => { pollWhenAvailable().catch(() => {}); }, 15_000);
 }
 
 module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR };

package/src/main/transcripts.cjs

@@ -23,6 +23,7 @@ const fsp = require('node:fs/promises');
 const path = require('node:path');
 const os = require('node:os');
 const chokidar = require('chokidar');
+const otel = require('./otel.cjs');
 
 let window = null;
 
@@ -132,6 +133,15 @@ async function flush(sub, { emit = true } = {}) {
     if (emit && window && !window.isDestroyed()) {
       window.webContents.send(`transcript:event:${sub.tabId}`, ev);
     }
+    // Mirror to OTEL — no-op when disabled. We emit on the initial drain too
+    // so backfilled transcripts show up in the trace store.
+    otel.recordTranscriptEvent({
+      tabId: sub.tabId,
+      tabCwd: sub.cwd,
+      kind: ev.kind,
+      data: ev.data,
+      ts: Date.now(),
+    });
   }
 }
 

package/src/main/watchers.cjs

@@ -0,0 +1,154 @@
+/**
+ * watchers.cjs — per-tab background shell watchers.
+ *
+ * Each watcher spawns a shell command, splits stdout into lines, and forwards
+ * them to the renderer via `watcher:line`. Stderr is folded into the same
+ * stream so users see compile errors / curl progress without a second channel.
+ * Lifetime is process-bound: killed on `before-quit` and on explicit remove.
+ * No persistence across restarts (deliberately ephemeral — the user re-adds).
+ */
+
+const { ipcMain } = require('electron');
+const { spawn } = require('node:child_process');
+const readline = require('node:readline');
+const crypto = require('node:crypto');
+
+class WatcherManager {
+  constructor() {
+    // watcherId -> { tabId, label, command, cwd, child, startedAt, lineCount }
+    this.watchers = new Map();
+    this.window = null;
+  }
+
+  attachWindow(window) {
+    this.window = window;
+  }
+
+  add({ tabId, label, command, cwd }) {
+    const watcherId = crypto.randomUUID();
+    const trimmedLabel = (label && label.trim()) || command.slice(0, 40);
+    const child = spawn(command, [], {
+      cwd: cwd || process.cwd(),
+      shell: true,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: process.env,
+    });
+
+    const entry = {
+      watcherId,
+      tabId,
+      label: trimmedLabel,
+      command,
+      cwd: cwd || process.cwd(),
+      child,
+      startedAt: Date.now(),
+      lineCount: 0,
+      pid: child.pid ?? null,
+    };
+    this.watchers.set(watcherId, entry);
+
+    const emitLine = (line) => {
+      entry.lineCount++;
+      if (this.window && !this.window.isDestroyed()) {
+        this.window.webContents.send('watcher:line', {
+          tabId,
+          watcherId,
+          line,
+          ts: Date.now(),
+        });
+      }
+    };
+
+    const stdoutRl = readline.createInterface({ input: child.stdout });
+    stdoutRl.on('line', emitLine);
+    const stderrRl = readline.createInterface({ input: child.stderr });
+    stderrRl.on('line', emitLine);
+
+    child.on('error', (err) => {
+      emitLine(`[watcher error] ${err?.message ?? String(err)}`);
+    });
+
+    child.on('close', (code, signal) => {
+      stdoutRl.close();
+      stderrRl.close();
+      // Only emit close if still registered (remove() suppresses by deleting first).
+      if (this.watchers.has(watcherId)) {
+        emitLine(`[exited code=${code ?? 'null'}${signal ? ` signal=${signal}` : ''}]`);
+        this.watchers.delete(watcherId);
+        if (this.window && !this.window.isDestroyed()) {
+          this.window.webContents.send('watcher:closed', { tabId, watcherId });
+        }
+      }
+    });
+
+    return {
+      watcherId,
+      tabId,
+      label: trimmedLabel,
+      command,
+      cwd: entry.cwd,
+      pid: entry.pid,
+      startedAt: entry.startedAt,
+    };
+  }
+
+  list({ tabId }) {
+    const out = [];
+    for (const w of this.watchers.values()) {
+      if (w.tabId !== tabId) continue;
+      out.push({
+        watcherId: w.watcherId,
+        tabId: w.tabId,
+        label: w.label,
+        command: w.command,
+        cwd: w.cwd,
+        pid: w.pid,
+        startedAt: w.startedAt,
+        lineCount: w.lineCount,
+      });
+    }
+    return out;
+  }
+
+  remove({ watcherId }) {
+    const w = this.watchers.get(watcherId);
+    if (!w) return { ok: false };
+    // Delete first so the close handler treats this as a quiet shutdown.
+    this.watchers.delete(watcherId);
+    try { w.child.kill('SIGTERM'); } catch { /* already dead */ }
+    // Ensure the child can't survive a stuck SIGTERM.
+    setTimeout(() => {
+      try { if (w.child.exitCode === null && w.child.signalCode === null) w.child.kill('SIGKILL'); } catch { /* */ }
+    }, 2000).unref?.();
+    if (this.window && !this.window.isDestroyed()) {
+      this.window.webContents.send('watcher:closed', { tabId: w.tabId, watcherId });
+    }
+    return { ok: true };
+  }
+
+  killAll() {
+    for (const watcherId of [...this.watchers.keys()]) {
+      this.remove({ watcherId });
+    }
+  }
+}
+
+const manager = new WatcherManager();
+
+function registerWatcherHandlers() {
+  const { z } = require('zod');
+  const addSchema = z.object({
+    tabId: z.string().min(1).max(128),
+    label: z.string().max(256).optional().default(''),
+    command: z.string().min(1).max(8192),
+    cwd: z.string().max(4096).optional().nullable(),
+  });
+  const listSchema = z.object({ tabId: z.string().min(1).max(128) });
+  const removeSchema = z.object({ watcherId: z.string().min(1).max(128) });
+
+  ipcMain.handle('watchers:add', (_e, payload) => manager.add(addSchema.parse(payload)));
+  ipcMain.handle('watchers:list', (_e, payload) => manager.list(listSchema.parse(payload)));
+  ipcMain.handle('watchers:remove', (_e, payload) => manager.remove(removeSchema.parse(payload)));
+}
+
+module.exports = { manager, registerWatcherHandlers };

package/src/preload/api.d.ts

@@ -179,11 +179,61 @@ export interface VoiceSetTurnDetectorResult {
   state: VoiceTurnDetectorState;
 }
 
+export interface TestFireHookArgs {
+  command: string;
+  env?: Record<string, string>;
+  payload: string;
+  timeoutMs?: number;
+}
+
+export interface TestFireHookResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  durationMs: number;
+}
+
+export interface OtelConfig {
+  enabled: boolean;
+  endpoint: string;
+  /** Newline-separated "Key: Value" pairs. */
+  headers: string;
+  serviceName: string;
+  /** Mirrors upstream OTEL_LOG_USER_PROMPTS — opt-in PII. */
+  includeContent: boolean;
+  schemaVersion: 1;
+}
+
+export interface OtelStatus {
+  enabled: boolean;
+  initialized: boolean;
+  error: string | null;
+  includeContent: boolean;
+}
+
+export interface OtelSetConfigResult {
+  ok: boolean;
+  error: string | null;
+  config: OtelConfig;
+  status: OtelStatus;
+}
+
+export type ScheduleFirePolicy = 'manual' | 'on-reset' | 'when-available';
+
 export interface ScheduleConfig {
+  /** Legacy on/off — kept for backwards compat with v0.4 queue.json. New
+   *  installs derive enablement from firePolicy ('manual' === disabled). */
   enabled: boolean;
+  /** Minutes to wait after the 5h reset before firing pending jobs.
+   *  Used by 'on-reset'. Ignored by 'when-available' and 'manual'. */
   offsetMinutes: number;
   concurrencyCap: number;
   defaultCwd: string;
+  /** Auto-fire policy. Default 'when-available'. */
+  firePolicy: ScheduleFirePolicy;
+  /** When firePolicy='when-available', fire only if five_hour utilization is
+   *  strictly below this percent. 0–100. Default 90. */
+  utilizationThreshold: number;
   schemaVersion: 1;
 }
 
@@ -211,16 +261,64 @@ export interface SchedulePaths {
   queue: string;
 }
 
+export type SchedulePauseReason = 'rate_limit';
+
+export interface SchedulePauseInfo {
+  reason: SchedulePauseReason;
+  /** When the pause was first set (ISO). */
+  since: string;
+  /** ISO timestamp at which auto-resume will fire (typically next 5h reset).
+   *  null means "indefinite — wait for manual Run now". */
+  resumeAt: string | null;
+}
+
 export interface ScheduleStateSnapshot {
   config: ScheduleConfig;
   jobs: ScheduleJob[];
   scheduledFor: string | null;
   lastRunAt: string | null;
   nextReset: string | null;
+  /** Set when scheduler self-paused (rate-limit detected). null when running normally. */
+  paused: SchedulePauseInfo | null;
+  /** Latest five_hour utilization percent (0–100) cached from billing.fetchUsage. null if unknown. */
+  utilization: number | null;
   /** Returned only by the initial state() call, not the broadcast event. */
   paths?: SchedulePaths;
 }
 
+export interface WatcherInfo {
+  watcherId: string;
+  tabId: string;
+  label: string;
+  command: string;
+  cwd: string;
+  pid: number | null;
+  startedAt: number;
+  lineCount: number;
+}
+
+export interface WatcherAddResult {
+  watcherId: string;
+  tabId: string;
+  label: string;
+  command: string;
+  cwd: string;
+  pid: number | null;
+  startedAt: number;
+}
+
+export interface WatcherLineEvent {
+  tabId: string;
+  watcherId: string;
+  line: string;
+  ts: number;
+}
+
+export interface WatcherClosedEvent {
+  tabId: string;
+  watcherId: string;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -228,7 +326,9 @@ export interface SessionManagerAPI {
     cwd: () => Promise<string>;
     engageRulesPath: () => Promise<string | null>;
     pickDirectory: () => Promise<string | null>;
+    gitBranch: (cwd: string) => Promise<string | null>;
     rebootApp: () => void;
+    testFireHook: (args: TestFireHookArgs) => Promise<TestFireHookResult>;
     /** F7 — true under SM_E2E=1; renderer uses this to suppress wizard auto-trigger. */
     isE2E: () => Promise<boolean>;
     onNewSession: (handler: () => void) => () => void;
@@ -291,11 +391,25 @@ export interface SessionManagerAPI {
     /** F8 — persist turn-detector settings. */
     setTurnDetector: (state: VoiceTurnDetectorState) => Promise<VoiceSetTurnDetectorResult>;
   };
+  watchers: {
+    add: (payload: { tabId: string; label?: string; command: string; cwd?: string | null }) => Promise<WatcherAddResult>;
+    list: (tabId: string) => Promise<WatcherInfo[]>;
+    remove: (watcherId: string) => Promise<{ ok: boolean }>;
+    onLine: (handler: (ev: WatcherLineEvent) => void) => () => void;
+    onClosed: (handler: (ev: WatcherClosedEvent) => void) => () => void;
+  };
+  otel: {
+    getConfig: () => Promise<OtelConfig>;
+    setConfig: (cfg: OtelConfig) => Promise<OtelSetConfigResult>;
+    status: () => Promise<OtelStatus>;
+    configPath: () => Promise<string>;
+  };
   schedule: {
     state: () => Promise<ScheduleStateSnapshot>;
     setConfig: (partial: Partial<ScheduleConfig>) => Promise<{ ok: boolean; config: ScheduleConfig }>;
     resetJob: (slug: string) => Promise<{ ok: boolean; error?: string }>;
     runNow: () => Promise<{ ok: boolean }>;
+    resume: () => Promise<{ ok: boolean }>;
     refreshReset: () => Promise<{ ok: boolean; nextReset: string | null }>;
     openFolder: () => Promise<{ ok: boolean }>;
     readPrd: (slug: string) => Promise<{ ok: boolean; text?: string; error?: string }>;