claude-code-session-manager 0.35.2 → 0.35.4

package/src/main/runVerify.cjs

@@ -616,6 +616,18 @@ async function verifyRun({ runDir, prdPath, queueEntry, allJobs = [], committedD
       ? { ...(annotations.length ? { annotations } : {}), ...sentinelFields }
       : undefined;
 
+    // No pattern hits is not automatically "clean": a run that neither
+    // committed anything nor ever emitted the finish-protocol sentinel likely
+    // ended before doing real work (e.g. stopped on a clarifying question).
+    // Weaker evidence than a caught transcript error, but still not clean.
+    if (sentinel === null && !committedDuringRun) {
+      issues.push({
+        verdict: 'no_verdict_sentinel',
+        reason: 'run made no commit and emitted no SCHEDULER_VERDICT sentinel — likely ended before the finish protocol (e.g. stopped on a clarifying question)',
+        priority: 1,
+      });
+    }
+
     if (issues.length === 0) {
       const reason = annotations.length
         ? `no blocking issues (${annotations.length} annotation(s): ${annotations.map((a) => a.reason).join('; ')})`
@@ -623,7 +635,8 @@ async function verifyRun({ runDir, prdPath, queueEntry, allJobs = [], committedD
       return conclude('clean', reason, null, extras);
     }
 
-    // Pick highest-priority issue (transcript_errors > verify_unavailable).
+    // Pick highest-priority issue (transcript_errors > verify_unavailable ==
+    // no_verdict_sentinel; ties keep the loop's original order via stable sort).
     issues.sort((a, b) => b.priority - a.priority);
     const top = issues[0];
 

package/src/main/scheduler.cjs

@@ -1151,6 +1151,19 @@ function isPromotableOriginal(status) {
   return status === 'failed' || status === 'needs_review';
 }
 
+/**
+ * Pure helper: given a completed fix-plan slug (e.g. '451-fix-foo'), find the
+ * SPECIFIC promotable original job it heals. Matches on the full
+ * numeric-prefixed slug ('451-foo'), not just the base ('foo') — two
+ * needs_review jobs can share a base slug with different NN prefixes
+ * (e.g. '451-foo' and '453-foo'), and a fix plan must only heal the
+ * lineage whose NN it was authored against. Exported for tests.
+ */
+function healTargetForFix(fixSlug, jobs) {
+  const originalSlug = fixSlug.replace(/^(\d+)-fix-/, '$1-');
+  return jobs.find((x) => x.slug === originalSlug && isPromotableOriginal(x.status)) || null;
+}
+
 /**
  * Spawn an Opus investigation session for a failed job. The investigator's job
  * is to read the failure log + original PRD, identify the root cause, and write
@@ -1329,6 +1342,13 @@ DO NOT attempt the fix. ONLY write the file. When the file exists, exit immediat
         console.log(`[scheduler] investigation produced fix plan: ${fixSlug}`);
       } else {
         console.log(`[scheduler] investigation finished WITHOUT producing fix plan (slug=${failedJob.slug}, code=${exitCode})`);
+        // Record the no-plan outcome so selectAutoFixTargets can offer one
+        // bounded retry instead of permanently dead-ending behind the
+        // 1-attempt cap (autoFixAttempted stays true).
+        mutate((s) => {
+          const j = s.jobs.find((x) => x.slug === failedJob.slug);
+          if (j) j.autoFixOutcome = 'no-plan';
+        }).catch(() => {});
       }
       // Trigger a tick so the new fix plan is reconciled into the queue and fired.
       tickQueue().catch(() => {});
@@ -1525,17 +1545,16 @@ async function spawnJob(job, runId, runDir, defaultCwd) {
           // this, the queue stalls indefinitely behind a stale failure even
           // though the auto-recovery did its job.
           if (effectiveStatus === 'completed' && isFixPlanSlug(job.slug)) {
-            const originalSlug = job.slug.replace(/^(\d+)-fix-/, '$1-');
-            const orig = s.jobs.findIndex((x) => x.slug === originalSlug && isPromotableOriginal(x.status));
-            if (orig >= 0) {
-              const priorStatus = s.jobs[orig].status;
-              console.log(`[scheduler] auto-promote: ${originalSlug} (${priorStatus}) → completed because ${job.slug} succeeded`);
-              s.jobs[orig].status = 'completed';
-              s.jobs[orig].exitCode = 0;
-              s.jobs[orig].error = null;
-              s.jobs[orig].completedBy = job.slug;
+            const orig = healTargetForFix(job.slug, s.jobs);
+            if (orig) {
+              const priorStatus = orig.status;
+              console.log(`[scheduler] auto-promote: ${orig.slug} (${priorStatus}) → completed because ${job.slug} succeeded`);
+              orig.status = 'completed';
+              orig.exitCode = 0;
+              orig.error = null;
+              orig.completedBy = job.slug;
               if (priorStatus === 'needs_review') {
-                delete s.jobs[orig].verifierVerdict;
+                delete orig.verifierVerdict;
               }
             }
           }
@@ -1881,16 +1900,57 @@ function selectHistoryJobs(jobs, limit) {
 // heal a genuinely-unfinished job.
 const RESCANNABLE_VERDICTS = new Set(['transcript_errors', 'verify_unavailable']);
 
+/**
+ * Backfill a job's missing runId by scanning RUNS_DIR for a run directory
+ * whose contents reference this job's slug (a '<slug>.log' file inside it).
+ * A needs_review job can lose its runId (e.g. an old queue-schema gap) and
+ * become invisible to every auto-resolution path that requires job.runId
+ * truthy. O(number of run dirs) — a single readdir + per-dir existsSync
+ * check, no nested loop over user-scaled data. Dir names are ISO timestamps,
+ * so lexical-descending sort picks the newest match. Exported for tests.
+ */
+function resolveRunId(job, { runsDir = RUNS_DIR } = {}) {
+  if (!job || job.runId) return job?.runId || null;
+  if (!job.slug) return null;
+  let dirs;
+  try {
+    dirs = fs.readdirSync(runsDir);
+  } catch {
+    return null;
+  }
+  const matches = dirs.filter((d) => {
+    try {
+      return fs.existsSync(path.join(runsDir, d, `${job.slug}.log`));
+    } catch {
+      return false;
+    }
+  });
+  if (!matches.length) return null;
+  matches.sort().reverse();
+  return matches[0];
+}
+
+/**
+ * Pure predicate: a needs_review job with no runId and no backfillable run
+ * directory can never self-heal or get an auto-fix investigation — it must
+ * be surfaced for a human rather than silently dead-ended. Exported for
+ * tests.
+ */
+function isUnresolvableNeedsReview(job, { hasRunDir }) {
+  return !!job && job.status === 'needs_review' && !job.runId && !hasRunDir;
+}
+
 /**
  * Pure predicate: is this job eligible for the boot re-verify self-heal? Only
- * needs_review jobs with a run log AND a transcript-scan verdict. Crucially
- * EXCLUDES 'uncommitted_changes' (git commit-guard) — verifyRun can't see git,
- * so re-scanning it would falsely heal an unfinished job. Exported for tests.
+ * needs_review jobs with a run log (own or backfilled via resolveRunId) AND a
+ * transcript-scan verdict. Crucially EXCLUDES 'uncommitted_changes' (git
+ * commit-guard) — verifyRun can't see git, so re-scanning it would falsely
+ * heal an unfinished job. Exported for tests.
  */
 function isRescanCandidate(job) {
   return !!job
     && job.status === 'needs_review'
-    && !!job.runId
+    && !!(job.runId || resolveRunId(job))
     && RESCANNABLE_VERDICTS.has(job.verifierVerdict);
 }
 
@@ -1906,23 +1966,32 @@ function isRescanCandidate(job) {
  * @returns {Promise<{rescanned:number, healed:string[]}>}
  */
 /**
- * Pure helper — no I/O. Returns the subset of jobs eligible for automatic
- * fix-plan authoring after a reverify pass leaves them still in needs_review.
+ * Pure helper — no I/O by default (resolveJobRunId is injectable; production
+ * caller passes resolveRunId, which does touch disk). Returns the subset of
+ * jobs eligible for automatic fix-plan authoring after a reverify pass
+ * leaves them still in needs_review.
  *
  * Exclusion rules (all must pass):
  *   - status === 'needs_review'
- *   - truthy runId (need a run log to investigate)
- *   - autoFixAttempted !== true (1-attempt cap)
+ *   - a runId, own or backfilled via resolveJobRunId (need a run log to investigate)
  *   - not itself a fix-plan slug (avoids infinite recursion)
+ *   - autoFixAttempted cap: a job with no prior attempt is eligible; a job
+ *     whose prior attempt outcome was 'no-plan' gets ONE bounded retry
+ *     (autoFixRetries < 1); any other attempted job (or an exhausted
+ *     no-plan retry) is excluded
  *   - no fix sibling on disk (fixSlugExists) or already in the queue
  */
-function selectAutoFixTargets(jobs, { fixSlugExists }) {
+function selectAutoFixTargets(jobs, { fixSlugExists, resolveJobRunId = resolveRunId }) {
   const slugsInQueue = new Set(jobs.map((j) => j.slug));
   return jobs.filter((job) => {
     if (job.status !== 'needs_review') return false;
-    if (!job.runId) return false;
-    if (job.autoFixAttempted) return false;
+    const runId = job.runId || resolveJobRunId(job);
+    if (!runId) return false;
     if (isFixPlanSlug(job.slug)) return false;
+    if (job.autoFixAttempted) {
+      if (job.autoFixOutcome !== 'no-plan') return false;
+      if ((job.autoFixRetries ?? 0) >= 1) return false;
+    }
     const fixSlug = `${String(job.parallelGroup ?? 99).padStart(2, '0')}-fix-${job.slug.replace(/^\d+-/, '')}`;
     if (fixSlugExists(fixSlug)) return false;
     if (slugsInQueue.has(fixSlug)) return false;
@@ -1936,7 +2005,7 @@ async function reverifyNeedsReview() {
   const healed = [];
   const leftForReview = [];
   for (const job of candidates) {
-    const runDir = path.join(RUNS_DIR, job.runId);
+    const runDir = path.join(RUNS_DIR, job.runId || resolveRunId(job));
     const prdPath = path.join(PRDS_DIR, `${job.slug}.md`);
     // Derive committedDuringRun from the recorded run window. The live
     // commit-guard uses gitHead() (before/after HEAD diff); here the run is
@@ -1978,24 +2047,72 @@ async function reverifyNeedsReview() {
     console.log(`[scheduler] boot reverify: left for review: ${detail}`);
   }
 
+  // Surface needs_review jobs that can never self-heal or get an auto-fix
+  // investigation (no runId, no backfillable run dir) instead of leaving
+  // them silently stranded. Also surface no-plan auto-fix jobs whose one
+  // bounded retry is already exhausted. Both are annotated, never looped on.
+  const afterHealForAnnotate = await readQueue();
+  const unresolvable = afterHealForAnnotate.jobs.filter(
+    (j) => isUnresolvableNeedsReview(j, { hasRunDir: !!resolveRunId(j) }) && j.verifierVerdict !== 'no_run_artifacts',
+  );
+  const exhaustedNoPlan = afterHealForAnnotate.jobs.filter(
+    (j) => j.status === 'needs_review'
+      && j.autoFixAttempted && j.autoFixOutcome === 'no-plan' && (j.autoFixRetries ?? 0) >= 1
+      && j.verifierVerdict !== 'autofix_no_plan',
+  );
+  if (unresolvable.length || exhaustedNoPlan.length) {
+    const unresolvableSet = new Set(unresolvable.map((j) => j.slug));
+    const exhaustedSet = new Set(exhaustedNoPlan.map((j) => j.slug));
+    await mutate((s) => {
+      for (const j of s.jobs) {
+        if (unresolvableSet.has(j.slug)) {
+          j.verifierVerdict = 'no_run_artifacts';
+          j.error = 'no run artifacts — manual review';
+        } else if (exhaustedSet.has(j.slug)) {
+          j.verifierVerdict = 'autofix_no_plan';
+          j.error = 'auto-fix investigation produced no fix plan after retry — manual review';
+        }
+      }
+    });
+    if (unresolvable.length) {
+      console.log(`[scheduler] boot reverify: no run artifacts for ${unresolvable.map((j) => j.slug).join(', ')} — flagged for manual review`);
+    }
+    if (exhaustedNoPlan.length) {
+      console.log(`[scheduler] boot reverify: auto-fix retry exhausted for ${exhaustedNoPlan.map((j) => j.slug).join(', ')} — flagged for manual review`);
+    }
+    await broadcast();
+  }
+
   // Auto-fix: spawn a fix-plan investigation for each job still in
   // needs_review after the heal pass (kill-switch: SM_AUTOFIX_DISABLE=1).
+  // spawnInvestigation early-returns once investigationsInFlight reaches
+  // MAX_CONCURRENT_INVESTIGATIONS (queues the rest for retry), so this loop
+  // cannot fan out past the cap regardless of how many targets are selected.
   if (process.env.SM_AUTOFIX_DISABLE !== '1') {
     const afterHeal = await readQueue();
     const targets = selectAutoFixTargets(afterHeal.jobs, {
       fixSlugExists: (s) => fs.existsSync(path.join(PRDS_DIR, `${s}.md`)),
     });
     for (const job of targets) {
-      const runDir = path.join(RUNS_DIR, job.runId);
+      const runId = job.runId || resolveRunId(job);
+      const runDir = path.join(RUNS_DIR, runId);
+      const isNoPlanRetry = job.autoFixAttempted && job.autoFixOutcome === 'no-plan';
       // Persist the attempt BEFORE spawning — a crash mid-investigation still
       // counts it (mirrors orphanRetries). Safe even when the slot is busy: the
       // investigation is queued and drained as slots free, so it is genuinely
       // attempted rather than silently dropped.
       await mutate((s) => {
         const j = s.jobs.find((x) => x.slug === job.slug);
-        if (j) j.autoFixAttempted = true;
+        if (j) {
+          j.autoFixAttempted = true;
+          if (!j.runId && runId) j.runId = runId;
+          if (isNoPlanRetry) {
+            j.autoFixRetries = (j.autoFixRetries ?? 0) + 1;
+            delete j.autoFixOutcome;
+          }
+        }
       });
-      console.log(`[scheduler] auto-fix: needs_review ${job.slug} → authoring fix-plan (1/1)`);
+      console.log(`[scheduler] auto-fix: needs_review ${job.slug} → authoring fix-plan (${isNoPlanRetry ? 'retry' : '1/1'})`);
       spawnInvestigation(job, runDir).catch((e) => {
         console.error('[scheduler] auto-fix spawnInvestigation error', job.slug, e);
       });
@@ -2335,10 +2452,16 @@ async function init() {
     // Periodic self-heal: re-run the verifier over stale needs_review jobs so a
     // job whose work actually landed (committed in-window, no FAIL sentinel)
     // auto-clears WITHOUT waiting for the next app restart. Cheap-guarded — the
-    // log scan only runs when something is actually flagged.
-    const s = readQueueSync();
-    if (s.jobs.some((j) => j.status === 'needs_review')) {
-      reverifyNeedsReview().catch(() => {});
+    // log scan only runs when something is actually flagged. Kill-switch:
+    // SM_REVERIFY_PERIODIC_DISABLE=1 (boot reverify above stays always-on).
+    // reverifyNeedsReview's auto-fix loop is capped downstream by
+    // MAX_CONCURRENT_INVESTIGATIONS (spawnInvestigation queues/early-returns
+    // past it), so this interval firing cannot fan out investigations.
+    if (process.env.SM_REVERIFY_PERIODIC_DISABLE !== '1') {
+      const s = readQueueSync();
+      if (s.jobs.some((j) => j.status === 'needs_review')) {
+        reverifyNeedsReview().catch(() => {});
+      }
     }
   }, 10 * 60_000);
 
@@ -2479,7 +2602,12 @@ const remote = {
     });
     if (!found) return { ok: false, error: 'not found' };
     await broadcast();
-    return { ok: true };
+    return { ok: true, slug, status: 'pending' };
+  },
+
+  async listJobs() {
+    const state = await readQueue();
+    return state.jobs.map((j) => ({ slug: j.slug, title: j.title, status: j.status, cwd: j.cwd }));
   },
 
   async runNow() {
@@ -2505,4 +2633,4 @@ const remote = {
   },
 };
 
-module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets };
+module.exports = { registerScheduleHandlers, attachWindow, init, ROOT, PRDS_DIR, selectHistoryJobs, parsePorcelain, FINISH_PROTOCOL, remote, pickNextBatch, pickForProject, reapDeadRunningJobs, pollRecoveryClearSource, memoryLimitedBatchSize, availableForJobs, reverifyNeedsReview, isRescanCandidate, isPromotableOriginal, selectAutoFixTargets, resolveRunId, isUnresolvableNeedsReview, healTargetForFix };

package/src/main/sessionsStore.cjs

@@ -5,9 +5,9 @@
  * Storage: ~/.config/session-manager/tabs.json
  * Shape: { tabs: PersistedTab[], activeTabId: string | null, savedAt: number }
  *
- * Only serializable, durable fields are persisted: id, claudeSessionId, cwd,
- * label, presetId. Runtime-only fields (pid, status, startupCommand,
- * exitCode) are recomputed on boot.
+ * Only serializable, durable fields are persisted: id, claudeSessionId,
+ * chatSessionId, cwd, label, presetId. Runtime-only fields (pid, status,
+ * startupCommand, exitCode) are recomputed on boot.
  */
 
 const fs = require('node:fs');
@@ -59,6 +59,7 @@ async function markFreshRestart() {
   const freshTabs = tabs.map((t) => ({
     ...t,
     claudeSessionId: crypto.randomUUID(),
+    chatSessionId: crypto.randomUUID(),
   }));
   await save({ tabs: freshTabs, activeTabId, freshStart: true });
 }

package/src/preload/api.d.ts

@@ -15,6 +15,72 @@ export interface WriteErrorEvent {
   reason: string;
 }
 
+export interface BrowserNavState {
+  url: string;
+  title: string;
+  canGoBack: boolean;
+  canGoForward: boolean;
+  loading: boolean;
+  isSecure: boolean;
+}
+
+/** One captured recorder step (PRD 408 engine → PRD 409 panel). */
+export interface RecordStep {
+  n: number;
+  /** `select` is accepted by replay/export (PRD 410) for forward-compat;
+   * the live engine does not emit it yet. */
+  verb: 'navigate' | 'click' | 'type' | 'select' | 'wait-for';
+  target: string;
+  kind?: 'nav' | 'assert';
+  /** True for `type` steps — the actual typed value is never captured. */
+  masked?: boolean;
+  /** Engine-suggested `{{var}}` name for a `type` step (e.g. field name). */
+  variableSuggestion?: string;
+  /** Renderer-owned: set once the user checks "parameterize as {{var}}". */
+  variable?: string | null;
+  /** `select` steps only — the option value to choose on replay/export. */
+  value?: string;
+}
+
+/** Per-step replay outcome (PRD 410), streamed as `browser:replay-step:<viewId>`. */
+export interface ReplayStepResult {
+  n: number;
+  status: 'pass' | 'fail';
+  detail?: string;
+}
+
+/** find-in-page result (PRD 402), streamed as `browser:find-result:<viewId>`. */
+export interface FindResult {
+  requestId: number;
+  matches: number;
+  activeMatchOrdinal: number;
+}
+
+/** Element-picker event (PRD 403), streamed as `browser:picker-event:<viewId>`. */
+export interface PickerEvent {
+  type: 'hover' | 'pick' | 'unpick' | 'exit';
+  selector?: string;
+  label?: string;
+  tag?: string;
+  rect?: { x: number; y: number; width: number; height: number };
+  /** Present on a 'pick' event fired by an unmodified click — the selection was replaced, not accumulated. */
+  replace?: boolean;
+}
+
+/** One entry in `~/.claude/session-manager/browser/history.json` (PRD 402). */
+export interface BrowserHistoryEntry {
+  url: string;
+  title: string;
+  ts: number;
+}
+
+/** One entry in `~/.claude/session-manager/browser/bookmarks.json` (PRD 402). */
+export interface BrowserBookmark {
+  url: string;
+  title: string;
+  ts: number;
+}
+
 export interface ReadJsonResult {
   exists: boolean;
   raw: string;
@@ -82,6 +148,8 @@ export interface SubscribeResult {
 export interface PersistedTab {
   id: string;
   claudeSessionId: string;
+  /** Chat mode's own session id, decoupled from claudeSessionId. Optional for backwards-compat with tabs.json written before this field existed. */
+  chatSessionId?: string;
   cwd: string;
   label: string;
   presetId: string | null;
@@ -130,6 +198,21 @@ export type BillingFetchResult =
   | { kind: 'transient'; message: string; httpStatus: number | null }
   | { kind: 'config'; message: string };
 
+// ── MCP server live connection probe (`claude mcp list`)
+export interface McpServerStatus {
+  name: string;
+  target: string;
+  transport: 'stdio' | 'http' | 'sse' | 'ws' | 'unknown';
+  status: 'connected' | 'failed' | 'needs-auth' | 'pending' | 'unknown';
+}
+
+export interface McpStatusResult {
+  ok: boolean;
+  servers: McpServerStatus[];
+  error?: string;
+  checkedAt: number;
+}
+
 // ── Usage matrix (AgOps dashboard, main-side aggregator)
 export type UsageMatrixState = 'idle' | 'executing' | 'plan' | 'background';
 export type UsageMatrixIntensity = 'idle' | 'low' | 'medium' | 'critical';
@@ -435,12 +518,23 @@ export interface DayProjectRow {
   sessionCount: number;
   errorCount: number;
   estimatedCostUsd: number;
+  byModel: Record<string, {
+    inputTokens: number;
+    outputTokens: number;
+    cacheReadTokens: number;
+    cacheCreationTokens: number;
+    costUsd: number;
+    /** Set when the model id didn't match opus/sonnet/haiku and was priced at Sonnet rates as a fallback. */
+    estimated?: boolean;
+  }>;
 }
 
 export interface HistoryAggregateResult {
   rows: DayProjectRow[];
   partial: boolean;
   scannedMs: number;
+  /** Total $ saved across all rows from cache-read pricing vs. full input pricing. Global, not per-row. */
+  cacheSavingsUsd: number;
 }
 
 export interface SessionScanEntry {
@@ -899,6 +993,12 @@ export interface ChatRunErrorEvent {
   message: string;
 }
 
+export interface ChatRunNoticeEvent {
+  tabId: string;
+  sessionId: string;
+  message: string;
+}
+
 export interface SessionManagerAPI {
   app: {
     version: () => Promise<string>;
@@ -932,6 +1032,54 @@ export interface SessionManagerAPI {
     onExit: (tabId: string, handler: (info: PtyExit) => void) => () => void;
     onWriteError: (handler: (ev: WriteErrorEvent) => void) => () => void;
   };
+  browser: {
+    create: (payload: { viewId: string; partition: string }) => Promise<{ ok: boolean }>;
+    setBounds: (payload: { viewId: string; x: number; y: number; width: number; height: number }) => Promise<{ ok: boolean }>;
+    show: (viewId: string) => Promise<{ ok: boolean }>;
+    hide: (viewId: string) => Promise<{ ok: boolean }>;
+    destroy: (viewId: string) => Promise<{ ok: boolean }>;
+    navigate: (payload: { viewId: string; url: string }) => Promise<{ ok: boolean; error?: string }>;
+    back: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    forward: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    reload: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    stop: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    onNavState: (viewId: string, handler: (state: BrowserNavState) => void) => () => void;
+    recordStart: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    recordStop: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    onRecordStep: (viewId: string, handler: (step: RecordStep) => void) => () => void;
+    captureDom: (payload: { viewId: string; kind: 'text' | 'html' }) => Promise<
+      | { ok: true; url: string; title: string; text: string; truncated?: boolean }
+      | { ok: false; error: string }
+    >;
+    captureShot: (viewId: string) => Promise<
+      | { ok: true; url: string; title: string; dataUrl: string }
+      | { ok: false; error: string }
+    >;
+    saveBinary: (path: string, base64: string) => Promise<{ ok: boolean; error?: string }>;
+    replay: (payload: {
+      viewId: string;
+      steps: RecordStep[];
+      values?: Record<string, string>;
+      continueOnError?: boolean;
+    }) => Promise<{ ok: boolean; error?: string; stopped?: boolean; failedAt?: number }>;
+    onReplayStep: (viewId: string, handler: (step: ReplayStepResult) => void) => () => void;
+    setZoom: (payload: { viewId: string; factor: number }) => Promise<{ ok: boolean; error?: string; factor?: number }>;
+    find: (payload: { viewId: string; text: string; forward?: boolean }) => Promise<{ ok: boolean; error?: string }>;
+    stopFind: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    onFindResult: (viewId: string, handler: (result: FindResult) => void) => () => void;
+    pickerStart: (viewId: string) => Promise<{ ok: boolean; error?: string }>;
+    pickerStop: (viewId: string) => Promise<{ ok: boolean; error?: string; wasPicking?: boolean }>;
+    onPickerEvent: (viewId: string, handler: (ev: PickerEvent) => void) => () => void;
+    /** Selection-scoped capture pipeline (PRD 404): filter -> prune -> summarize -> chunk for 'agent', outerHTML for 'html', CDP AX-tree for 'a11y', fallback-chain for 'selector'. */
+    capture: (payload: {
+      viewId: string;
+      selectors: string[];
+      mode: 'agent' | 'html' | 'a11y' | 'selector';
+    }) => Promise<
+      | { ok: true; mode: string; text: string; meta: { chunks?: number; tokens?: number } }
+      | { ok: false; error: string }
+    >;
+  };
   transcripts: {
     subscribe: (payload: { tabId: string; cwd: string; sessionUuid: string }) => Promise<SubscribeResult>;
     /** Release the sub back to the LRU cache (view-switch). Does not destroy the watcher. */
@@ -949,6 +1097,9 @@ export interface SessionManagerAPI {
   billing: {
     fetch: () => Promise<BillingFetchResult>;
   };
+  mcp: {
+    status: () => Promise<McpStatusResult>;
+  };
   usageMatrix: {
     snapshot: () => Promise<UsageMatrixSnapshot>;
     onTick: (handler: (snap: UsageMatrixSnapshot) => void) => () => void;
@@ -1099,6 +1250,8 @@ export interface SessionManagerAPI {
       | { ok: true; path: string; bytes: number }
       | { ok: false; empty?: true; error?: string }
     >;
+    /** Write side — copies a Capture-panel screenshot data URL to the OS clipboard. */
+    copyImage: (dataUrl: string) => Promise<{ ok: boolean; error?: string }>;
   };
   memory: {
     /** List markdown memory entries for the given workspace (defaults to 'default'). */
@@ -1129,11 +1282,6 @@ export interface SessionManagerAPI {
     /** Delete one entry. Removes the file outright when last entry is removed. */
     delete: (agentId: string, entryId: string) => Promise<AgentMemoryMutationResult>;
   };
-  docEditor: {
-    pickFile: (payload?: { lastDir?: string }) => Promise<{ path: string | null; error?: string }>;
-    readFile: (path: string) => Promise<{ ok: boolean; text?: string; mtimeMs?: number; error?: string }>;
-    writeFile: (path: string, text: string) => Promise<{ ok: boolean; mtimeMs?: number; error?: string }>;
-  };
   git: {
     /** Full git status for `cwd`. Returns null when not a git repo, git is
      *  missing, or the call times out (5s ceiling). Cached per-cwd for 5s. */
@@ -1187,6 +1335,7 @@ export interface SessionManagerAPI {
     onNeedsInput: (handler: (e: ChatRunNeedsInputEvent) => void) => () => void;
     onComplete: (handler: (e: ChatRunCompleteEvent) => void) => () => void;
     onError: (handler: (e: ChatRunErrorEvent) => void) => () => void;
+    onNotice: (handler: (e: ChatRunNoticeEvent) => void) => () => void;
   };
   exchanges: {
     /** Durable per-exchange log entries for a project, newest-first (max 100 by default). */

package/src/preload/browserViewPreload.cjs

@@ -0,0 +1,67 @@
+/**
+ * Preload for embedded Browser-tab WebContentsViews (PRD 408 recorder
+ * engine). Exposes a minimal `window.__smRecorder.setRecording(bool)` toggle
+ * via contextBridge so the main process can arm/disarm step capture without
+ * ever giving page script node/ipcRenderer access. Typed values are never
+ * captured — only the target selector + a `masked` flag — per the tab's
+ * "sandboxed · no filesystem · no passwords" guardrail.
+ */
+const { contextBridge, ipcRenderer } = require('electron');
+
+// Secret handed to us via `additionalArguments` (never touches the DOM or a
+// script tag the embedded page could inspect) — required on every toggle so
+// the page itself can't call the exposeInMainWorld bridge to interfere with
+// a recording session it has no business controlling.
+const TOKEN_PREFIX = '--sm-record-token=';
+const expectedToken = (process.argv.find((a) => a.startsWith(TOKEN_PREFIX)) || '').slice(TOKEN_PREFIX.length) || null;
+
+let capturing = false;
+
+function selectorFor(el) {
+  if (!el || el.nodeType !== 1) return '';
+  if (el.id) return `#${el.id}`;
+  const testId = typeof el.getAttribute === 'function' ? el.getAttribute('data-testid') : null;
+  if (testId) return `[data-testid="${testId}"]`;
+  const tag = el.tagName.toLowerCase();
+  const cls = typeof el.className === 'string' ? el.className.trim().split(/\s+/)[0] : '';
+  return cls ? `${tag}.${cls}` : tag;
+}
+
+function variableSuggestionFor(el) {
+  const name = String(el.name || el.id || '').toLowerCase();
+  if (el.type === 'password' || /pass/.test(name)) return 'password';
+  if (/email/.test(name)) return 'email';
+  if (/user/.test(name)) return 'username';
+  return name || 'value';
+}
+
+document.addEventListener(
+  'click',
+  (e) => {
+    if (!capturing) return;
+    ipcRenderer.send('browser:record-event', { verb: 'click', target: selectorFor(e.target) });
+  },
+  true,
+);
+
+document.addEventListener(
+  'change',
+  (e) => {
+    if (!capturing) return;
+    const el = e.target;
+    if (!el || (el.tagName !== 'INPUT' && el.tagName !== 'TEXTAREA')) return;
+    ipcRenderer.send('browser:record-event', {
+      verb: 'type',
+      target: selectorFor(el),
+      variableSuggestion: variableSuggestionFor(el),
+    });
+  },
+  true,
+);
+
+contextBridge.exposeInMainWorld('__smRecorder', {
+  setRecording: (v, token) => {
+    if (!expectedToken || token !== expectedToken) return;
+    capturing = !!v;
+  },
+});