claude-code-session-manager 0.120.0 → 0.122.0

package/src/main/seedDevPlugin.cjs

@@ -29,21 +29,21 @@
 const fs = require('node:fs');
 const path = require('node:path');
 const os = require('node:os');
-const { install, update } = require('./pluginInstall.cjs');
+const { install, update, bundledMarketplaceDir } = require('./pluginInstall.cjs');
 
 const PLUGIN_SLUG = 'session-manager-dev';
 const MARKETPLACE = { add: 'bundled', name: 'session-manager' };
 const ENABLED_KEY = `${PLUGIN_SLUG}@${MARKETPLACE.name}`;
 const MAX_ATTEMPTS = 3; // give a transient first-boot failure a few chances
 
-function markerPath() {
-  return path.join(os.homedir(), '.claude', 'session-manager', '.dev-plugin-seeded');
+function markerPath(home = os.homedir()) {
+  return path.join(home, '.claude', 'session-manager', '.dev-plugin-seeded');
 }
 
 /** Read the marker → { done:boolean, attempts:number }. Absent = fresh. */
-function readMarker() {
+function readMarker(home) {
   try {
-    const raw = fs.readFileSync(markerPath(), 'utf8').trim();
+    const raw = fs.readFileSync(markerPath(home), 'utf8').trim();
     const m = JSON.parse(raw);
     return { done: !!m.done, attempts: Number(m.attempts) || 0 };
   } catch {
@@ -51,9 +51,9 @@ function readMarker() {
   }
 }
 
-function alreadyEnabled() {
+function alreadyEnabled(home = os.homedir()) {
   try {
-    const raw = fs.readFileSync(path.join(os.homedir(), '.claude', 'settings.json'), 'utf8');
+    const raw = fs.readFileSync(path.join(home, '.claude', 'settings.json'), 'utf8');
     const enabled = JSON.parse(raw)?.enabledPlugins;
     return !!(enabled && enabled[ENABLED_KEY]);
   } catch {
@@ -61,9 +61,9 @@ function alreadyEnabled() {
   }
 }
 
-function writeMarker(state) {
+function writeMarker(state, home) {
   try {
-    const p = markerPath();
+    const p = markerPath(home);
     fs.mkdirSync(path.dirname(p), { recursive: true });
     fs.writeFileSync(p, JSON.stringify({ ...state, ts: new Date().toISOString() }) + '\n');
   } catch (err) {
@@ -87,6 +87,24 @@ function readJson(p) {
   try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
 }
 
+/**
+ * Pure check: is the registered 'session-manager' marketplace source missing on disk or
+ * different from `expectedDir`? Not registered at all → false (a deliberate uninstall stays).
+ * (Own reader: delegationReadiness's readDevMarketplacePath is not exported.)
+ */
+function marketplaceIsStale({ homeDir = os.homedir(), expectedDir = bundledMarketplaceDir() } = {}) {
+  const m = readJson(path.join(homeDir, '.claude', 'plugins', 'known_marketplaces.json'))?.[MARKETPLACE.name];
+  const p = m?.source?.path ?? m?.installLocation;
+  if (typeof p !== 'string' || !p) return false;
+  if (path.resolve(p) !== path.resolve(expectedDir)) return true;
+  return !fs.existsSync(p);
+}
+
+/** True only when settings.json explicitly sets the plugin to false. */
+function deliberatelyDisabled(home) {
+  return readJson(path.join(home, '.claude', 'settings.json'))?.enabledPlugins?.[ENABLED_KEY] === false;
+}
+
 function bundledVersion() {
   const m = readJson(path.join(__dirname, '..', '..', 'plugins', PLUGIN_SLUG, '.claude-plugin', 'plugin.json'));
   return typeof m?.version === 'string' ? m.version : null;
@@ -131,23 +149,32 @@ async function upgradeIfStale({
   }
 }
 
-async function seedDevPlugin({ logger = console, writeLog = () => {} } = {}) {
+async function seedDevPlugin({
+  logger = console,
+  writeLog = () => {},
+  home = os.homedir(),
+  expectedDir = bundledMarketplaceDir(),
+  runInstall = install,
+  runUpdate = update,
+} = {}) {
   if (process.env.SM_SEED_DEV_PLUGIN_DISABLE === '1') return;
-  await upgradeIfStale({ logger, writeLog });
-  const marker = readMarker();
-  if (marker.done) return;                       // succeeded before — leave it alone.
-  if (marker.attempts >= MAX_ATTEMPTS) return;   // gave up — manual install only.
+  await upgradeIfStale({ logger, writeLog, home, runUpdate });
+  const marker = readMarker(home);
+  // Repair: the registered marketplace dir vanished or points at an older package dir.
+  const repair = marker.done && !deliberatelyDisabled(home) && marketplaceIsStale({ homeDir: home, expectedDir });
+  if (marker.done && !repair) return;            // succeeded before — leave it alone.
+  if (!marker.done && marker.attempts >= MAX_ATTEMPTS) return;   // gave up — manual install only.
 
   try {
-    if (alreadyEnabled()) {
-      writeMarker({ done: true, attempts: marker.attempts });
+    if (!repair && alreadyEnabled(home)) {
+      writeMarker({ done: true, attempts: marker.attempts }, home);
       return;
     }
-    logger.log?.('[seedDevPlugin] installing bundled session-manager-dev plugin…');
-    const r = await install({ slug: PLUGIN_SLUG, marketplace: MARKETPLACE });
+    logger.log?.(`[seedDevPlugin] ${repair ? 're-registering' : 'installing'} bundled session-manager-dev plugin…`);
+    const r = await runInstall({ slug: PLUGIN_SLUG, marketplace: MARKETPLACE });
     if (r.ok) {
       logger.log?.('[seedDevPlugin] installed session-manager-dev@session-manager');
-      writeMarker({ done: true, attempts: marker.attempts });
+      writeMarker({ done: true, attempts: marker.attempts }, home);
     } else {
       // Failure: bump the attempt counter so the next boot can retry (bounded).
       logger.warn?.(`[seedDevPlugin] install failed (exit ${r.exitCode})${r.error ? ` — ${r.error}` : ''}; attempt ${marker.attempts + 1}/${MAX_ATTEMPTS}`);
@@ -157,7 +184,7 @@ async function seedDevPlugin({ logger = console, writeLog = () => {} } = {}) {
         message: 'install failed',
         meta: { exitCode: r.exitCode, error: r.error, attempt: marker.attempts + 1, maxAttempts: MAX_ATTEMPTS },
       });
-      writeMarker({ done: false, attempts: marker.attempts + 1 });
+      writeMarker({ done: false, attempts: marker.attempts + 1 }, home);
     }
   } catch (err) {
     logger.warn?.('[seedDevPlugin] error:', err?.message ?? err);
@@ -167,8 +194,8 @@ async function seedDevPlugin({ logger = console, writeLog = () => {} } = {}) {
       message: 'seed error',
       meta: { error: err?.message ?? String(err), attempt: marker.attempts + 1, maxAttempts: MAX_ATTEMPTS },
     });
-    writeMarker({ done: false, attempts: marker.attempts + 1 });
+    writeMarker({ done: false, attempts: marker.attempts + 1 }, home);
   }
 }
 
-module.exports = { seedDevPlugin, upgradeIfStale, compareSemver, markerPath, MAX_ATTEMPTS };
+module.exports = { seedDevPlugin, upgradeIfStale, marketplaceIsStale, compareSemver, markerPath, MAX_ATTEMPTS };

package/src/main/seedStatus.cjs

@@ -22,14 +22,15 @@ const SEEDERS = {
   'agent-personas': seedAgentPersonas,
 };
 
-/** One seeder's marker → 'done' | 'pending' | 'exhausted'. */
+/** One seeder's marker → 'done' | 'pending' | 'failed' | 'exhausted'. */
 function statusFromMarker(mod) {
   try {
     const raw = fs.readFileSync(mod.markerPath(), 'utf8').trim();
     const m = JSON.parse(raw);
     if (m && m.done) return 'done';
     const attempts = Number(m && m.attempts) || 0;
-    return attempts >= mod.MAX_ATTEMPTS ? 'exhausted' : 'pending';
+    if (attempts >= mod.MAX_ATTEMPTS) return 'exhausted';
+    return attempts > 0 ? 'failed' : 'pending';
   } catch {
     return 'pending'; // absent or unparseable — never surfaced as an error.
   }

package/src/main/supervisor.cjs

@@ -254,6 +254,7 @@ async function runProbe(claudeBin, prompt) {
         '--max-budget-usd', '0.50',
         '--dangerously-skip-permissions',
         ...headlessPermissionArgs(),
+        '--strict-mcp-config',
         '--allowedTools', 'Bash',
       ], { env: withProcRole(process.env, 'aux'), stdio: ['ignore', 'pipe', 'pipe'], ...(target.argv0 ? { argv0: target.argv0 } : {}) });
     } catch (e) {

package/src/main/templates/PRD_AUTHORING.md

@@ -1,10 +1,10 @@
-<!-- PRD_AUTHORING.md v7 -->
+<!-- PRD_AUTHORING.md v9 -->
 # PRD Authoring Guide — Scheduler Safety Rules
 
 Rule: every PRD you queue follows the rules below.
 Why: two real stuck jobs (fizzpop poll-hang, etch-engine post-AC overrun) cost hours of wall-clock time and real money.
 
-Before queueing, run the §15 checklist at the bottom. It is last on purpose — check it last.
+Before queueing, run the §14 checklist at the bottom. It is last on purpose — check it last.
 
 ---
 
@@ -69,7 +69,7 @@ if (!found) {
 Rule: every PRD needs these fields.
 1. `title` — one line, plain English.
 2. `cwd` — the Epic's project root, as an absolute path or `~/…`. The API always sets it to the Epic's project, whatever you pass. To work in another project, open an Epic in that project. The folder must exist when you queue.
-3. `estimateMinutes` — a realistic integer. Most PRDs take 5–10 minutes (§8) — don't inflate it.
+3. `estimateMinutes` — optional; omit it. A run without one gets the 45-minute kill-budget floor. Pass one only if the run legitimately needs longer. Most PRDs take 5–10 minutes (§8).
 
 `parallelGroup` is deprecated and ignored. `dependsOn: [<slug>, ...]` is the only ordering primitive.
 
@@ -125,7 +125,7 @@ A short Epic-context digest is prepended automatically for orientation only —
 
 The executor can't ask you anything: no `ScheduleWakeup`, Cron, Monitor, `AskUserQuestion`, plan mode, or worktree tools; background tasks are off (a `timeout` command is always on PATH — the app installs a shim on macOS). It must never stop to ask a question — it makes the safest reasonable call and reports it, so write the PRD so that call is obvious.
 
-Worktree reach: every PRD runs in an isolated git worktree holding tracked files plus `.venv`/`venv` (and `node_modules` for non-pnpm projects) symlinked from the main checkout; pnpm projects (pnpm-lock.yaml) get a worktree-local `node_modules` installed offline from the store. Why: a pnpm install through the symlink purged the main checkout's node_modules (Bilko-Game-Academy 2026-10-18). A step that needs gitignored runtime state (databases, `downloads/`, browser profiles, logs) or a live side effect must address the main checkout by absolute path (e.g. `$HOME/Projects/<repo>/...`), be artifact-only (a deliverable artifact + `artifactPaths`, no tracked edits), and `dependsOn` the PRD that lands its tracked edits. Host crontab installs stay human-only (see §15).
+Worktree reach: every PRD runs in an isolated git worktree holding tracked files plus `.venv`/`venv` (and `node_modules` for non-pnpm projects) symlinked from the main checkout; pnpm projects (pnpm-lock.yaml) get a worktree-local `node_modules` installed offline from the store. Why: a pnpm install through the symlink purged the main checkout's node_modules (Bilko-Game-Academy 2026-10-18). A step that needs gitignored runtime state (databases, `downloads/`, browser profiles, logs) or a live side effect must address the main checkout by absolute path (e.g. `$HOME/Projects/<repo>/...`), be artifact-only (a deliverable artifact + `artifactPaths`, no tracked edits), and `dependsOn` the PRD that lands its tracked edits. Host crontab installs stay human-only (see §14).
 Why: burrow PRD 1516 halted because its relative `.venv` python against `downloads/fb-tracker.db`, `scripts/install-cron.sh` and `pipeline-cron.sh --now` resolved inside the worktree (no runtime state; install-cron would bake a temporary worktree path into crontab), while sibling 1494 succeeded the same day using an absolute main-checkout path and artifact-only output. `scheduler_create_prd` warns on relative gitignored paths.
 
 ---
@@ -155,7 +155,7 @@ Note: a `rateLimited` exit-1 is the scheduler's own benign auto-pause (it resume
 ## §10 Negative-assertion checks must exit 0 on the clean case
 
 Rule: a check that asserts something is ABSENT must exit 0 when it's absent. Write it as `if <detector>; then echo HALT...; exit 1; fi` — never leave the no-match path carrying the non-zero exit.
-Why: `grep` exits 1 when it finds nothing. PRD `62-x-trader-doctrine` cleaned up correctly, but its sanity `grep` for a banned phrase found nothing, exited 1, and a perfect run was flagged `needs_review` by the verifier's `transcript_errors` check.
+Why: `grep` exits 1 when it finds nothing. PRD `62-x-trader-doctrine` cleaned up correctly, but its sanity `grep` for a banned phrase found nothing, exited 1, and the gate command itself failed on a clean tree.
 
 ```bash
 if grep -rniE "banned phrase" path/; then
@@ -168,10 +168,10 @@ Applies to `grep`, `rg`, `diff` (exits 1 on any difference), and any custom dete
 
 ---
 
-## §11 End green, and trust the verdict line
+## §11 End green
 
-Rule: order the run so the acceptance/test gate is the LAST command. Run any intentionally-failing step (a TDD red test, an expected-nonzero probe) EARLY, and capture its output (`2>&1 | tail` inside a conditional) so a bare `Traceback`/`is_error` never lands in the final part of the transcript.
-Why: the post-run verifier scans the transcript and downgrades to `needs_review` on error markers — it can't tell an intentional failure from a real one.
+Rule: order the run so the acceptance/test gate is the LAST command. Run any intentionally-failing step (a TDD red test, an expected-nonzero probe) EARLY, and capture its output (`2>&1 | tail`).
+Why: the last command's result is the run's real outcome; a red step left at the end hides whether the work is green.
 
 ```bash
 # RIGHT — red demo first and captured, green gate last
@@ -180,38 +180,24 @@ timeout 120 python -m pytest tests/test_repro.py::test_bug 2>&1 | tail -3 || tru
 timeout 300 pytest -q   # LAST thing the run does
 ```
 
-The scheduler appends a finish protocol after your PRD's own steps — you never write it: review, then the `# Gate` commands (§6), then commit only the exact paths you created or changed for this PRD, then the verdict line — `SCHEDULER_VERDICT: PASS` once the gate is green and the commit landed, else `SCHEDULER_VERDICT: FAIL <one-line reason>`. The verifier trusts a truthful `PASS` plus a landed commit over stray transcript markers. Never print `PASS` on a red gate.
+The scheduler appends a finish protocol after your PRD's own steps — you never write it: review, then the `# Gate` commands (§6), then commit only the exact paths you created or changed for this PRD, then the verdict line — `SCHEDULER_VERDICT: PASS` once the gate is green and the commit landed, else `SCHEDULER_VERDICT: FAIL <one-line reason>`. Never print `PASS` on a red gate.
 
 ---
 
-## §12 Don't strand mid-run probe errors; annotate expected timeouts
-
-Rule: a throwaway probe that errors (a bad quote, a wrong kwarg) must be re-run corrected right after, or annotated `# expected/handled: <why>` on the next line — never left stranded. Prefer a temp `.py` file over a fragile inline `python -c` one-liner.
-
-Rule: an *expected* `timeout` cap (a long ingest/scan you expect to hit it) is success-with-note, not a bare `Exit code 124` — branch on it explicitly:
-```bash
-timeout 120 python -m project.ingest --all || { rc=$?
-  [ $rc -eq 124 ] && echo "hit time cap — partial, rows persist; OK" \
-                  || { echo "HALT: ingest failed rc=$rc"; exit 1; }; }
-```
-Why: both a stranded probe traceback and a bare `Exit code 124` read as failure to the verifier even when the committed work is correct and green (PRDs 77, 80 — 2026-06-13).
-
----
-
-## §13 Queueing PRDs from external automation
+## §12 Queueing PRDs from external automation
 
 Decision: is the session-manager app running on this machine right now?
-- Yes → call the `scheduler_create_prd` MCP tool, with the usual fields (`title`, `cwd`, `estimateMinutes`, `sourcePromptId`, `goal`, `acceptanceCriteria`, `implementationNotes`) plus `gate` and `files` (§6).
+- Yes → call the `scheduler_create_prd` MCP tool, with the usual fields (`title`, `cwd`, `sourcePromptId`, `goal`, `acceptanceCriteria`, `implementationNotes`) plus `gate` and `files` (§6).
 - No → stop. Ask the human to start the app, then call the tool again. Never write the PRD file by hand: the scheduler quarantines a file the API did not write, and it never runs.
 
 It only works while the app is running — closing it removes the admin port/token, and the call fails with `session-manager app is not running (admin API unreachable)`.
 
 ---
 
-## §14 A parked job may resolve itself now
+## §13 A parked job may resolve itself now
 
-Rule: if a job parks `needs_review` with verdict `transcript_errors`, `no_verdict_sentinel`, or `abandoned_background_task`, do nothing first. The scheduler re-runs the gate on its own and completes the job once the gate is green, the commit is on HEAD, and the tracked tree is clean.
-Why: those three verdicts mean the transcript looked noisy, not that the work was wrong.
+Rule: if a job parks `needs_review` with verdict `no_verdict_sentinel` or `abandoned_background_task`, do nothing first. The scheduler re-runs the gate on its own and completes the job once the gate is green, the commit is on HEAD, and the tracked tree is clean.
+Why: those verdicts mean the run ended without a clean verdict line, not that the work was wrong.
 
 Rule: a park caused by a DIFFERENT actor already finishing the same objective (a sibling PRD, a human) does not self-heal this way. Why: the job has no landed commit of its own. Confirm in the tree that the work is really done, then call `scheduler_archive_prd` with the slug. Archiving marks the job completed and frees the PRDs that depend on it. Never hand-edit `queue.json`: the scheduler and the watchdog both write it. Archiving clears a stale label; it does not fix a real bug.
 
@@ -219,7 +205,7 @@ Known gap: `pass_no_commit` ("already correct, nothing to commit") isn't yet in
 
 ---
 
-## §15 Pre-queue checklist (the litany)
+## §14 Pre-queue checklist (the litany)
 
 Before queueing a new PRD, verify each of these:
 
@@ -228,7 +214,7 @@ Before queueing a new PRD, verify each of these:
 - [ ] **§2 No bonus work:** the AC list is the only source of work.
 - [ ] **§3 Verify, don't poll:** every deploy/migration step is followed by a test command that exits 1 on failure; the AC test command ran green once before you declare done.
 - [ ] **§4 Bounded generators:** any search/seed loop has an explicit max and surfaces failure on exhaustion.
-- [ ] **§5 Frontmatter:** `title`, `cwd` (exists on this machine), `estimateMinutes` present; `dependsOn` used for ordering, not `parallelGroup`.
+- [ ] **§5 Frontmatter:** `title`, `cwd` (exists on this machine); `estimateMinutes` omitted (optional); `dependsOn` used for ordering, not `parallelGroup`.
 - [ ] **§6 Gate and files:** `gate` follows every rule in §6 (or is `["none"]` alone); `files` is 1–50 repo-relative paths, no overlap with a concurrent PRD.
 - [ ] **§7 Self-contained:** no reference to "the conversation" or outside context; paths/identifiers inline; clean UTF-8, no NUL bytes (`grep -qP '\x00' file && echo BAD`).
 - [ ] **§7 Worktree reach:** no relative path to a gitignored file; live-run steps use absolute main-checkout paths in an artifact-only PRD. Why: the job worktree has no gitignored runtime state, so relative paths fail or bake a temporary path into host config (burrow 1516).
@@ -236,6 +222,5 @@ Before queueing a new PRD, verify each of these:
 - [ ] **§9 Failure surfacing:** errors exit 1 with a diagnostic line; no silent `|| true`.
 - [ ] **§10 Negative assertions:** every "should find nothing" check is inverted to exit 0 on the clean case.
 - [ ] **§11 End green:** the gate runs last; any intentional failure runs early and is captured.
-- [ ] **§12 No stranded probes:** a probe error is corrected or annotated; an expected `timeout` cap branches on exit 124.
 - [ ] **Gate baseline:** every gate command ran green once at HEAD in the main checkout; a red suite is scoped to the PRD's own test files and the PRD notes say why. Why: a gate already red on base parks as `sentinel_fail`.
 - [ ] **No human-only gates:** no gate or criterion needs a human or the passage of time (cron install, live post wait, live payment, dashboard action); those end `SCHEDULER_VERDICT: NEEDS_HUMAN <question>`. Why: no executor can pass them.

package/src/main/webRemote.cjs

@@ -29,7 +29,6 @@ const logs = require('./logs.cjs');
 const { sendIfAlive } = require('./lib/sendToRenderer.cjs');
 const { claudeHome } = require('./lib/scheduler/schedulerPaths.cjs');
 const { schemas } = require('./ipcSchemas.cjs');
-const { summarize: _sharedSummarize } = require('./lib/summarize.cjs');
 const { makeState, confirmSas: confirmSasLogic } = require('./lib/e2eStateMachine.cjs');
 const { createClientSessions, LEGACY_CLIENT_KEY } = require('./lib/feedback-remote/remoteClientSessions.cjs');
 
@@ -497,12 +496,11 @@ async function handleTokenRevoked(deviceId) {
   sendIfAlive(_window, 'webRemote:token-revoked', { deviceId });
 }
 
-// ─── v2 mobile: session live state + summary push ────────────────────────────
+// ─── v2 mobile: session live state push ────────────────────────────
 //
 // For each subscribed tab the agent tails its transcript JSONL (reusing the
 // canonical classifyLine + transcriptPath from transcripts.cjs — single source of
 // truth), derives a coarse state, and pushes event:session:state on change.
-// The last completed assistant turn drives the Haiku summary (see maybeSummarize).
 
 const SESSION_POLL_MS = 1500;
 const SESSION_INIT_TAIL_BYTES = 512 * 1024; // bound the initial read
@@ -524,7 +522,7 @@ function pushEventTo(client, type, payload) {
   }
 }
 
-/** Authenticated clients subscribed to a tab's session state/summary. */
+/** Authenticated clients subscribed to a tab's session state. */
 function subscribersOf(tabId) {
   return _clients.authenticated().filter((c) => c.subscriptions.has(tabId));
 }
@@ -551,15 +549,6 @@ function teardownAllClients() {
   return n;
 }
 
-/** Extract concatenated text from an assistant transcript line, or '' if none. */
-function extractAssistantText(raw) {
-  const msg = raw?.message || raw;
-  const content = msg?.content;
-  if (typeof content === 'string') return content;
-  if (!Array.isArray(content)) return '';
-  return content.filter((b) => b?.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n').trim();
-}
-
 /** Map a classified transcript event to a coarse session state. */
 function deriveState(ev, raw) {
   // API/usage errors surface as a flagged message line.
@@ -613,6 +602,19 @@ async function tailLines(filePath, fromOffset) {
 }
 
 async function pollSessionWatcher(w) {
+  // The transcript may not exist yet (new session) or may live under another
+  // project/worktree encoding: re-resolve while the watched file is missing.
+  if (!fs.existsSync(w.filePath)) {
+    try {
+      const next = require('./transcripts.cjs').transcriptPath(w.cwd, w.sessionId);
+      if (next && next !== w.filePath) {
+        validatePath(next);
+        w.filePath = next;
+        w.offset = null;
+        w.inode = undefined;
+      }
+    } catch { /* keep the old path */ }
+  }
   let res;
   try {
     res = await tailLines(w.filePath, w.offset);
@@ -627,8 +629,6 @@ async function pollSessionWatcher(w) {
   w.inode = res.inode;
 
   let nextState = null;
-  let newAssistantText = null;
-  let newMsgId = null;
   for (const line of res.lines) {
     let obj;
     try { obj = JSON.parse(line); } catch { continue; }
@@ -636,10 +636,6 @@ async function pollSessionWatcher(w) {
     for (const ev of events) {
       const s = deriveState(ev, obj);
       if (s) nextState = s;
-      if (ev.kind === 'assistant') {
-        const text = extractAssistantText(obj);
-        if (text) { newAssistantText = text; newMsgId = obj.uuid || obj.message?.id || `${w.tabId}:${res.size}`; }
-      }
     }
   }
 
@@ -650,33 +646,20 @@ async function pollSessionWatcher(w) {
       pushEventTo(c, 'event:session:state', { tabId: w.tabId, state: w.state, since: Date.now() });
     }
   }
-  if (newAssistantText && newMsgId !== w.lastMsgId) {
-    w.lastAssistantText = newAssistantText;
-    w.lastMsgId = newMsgId;
-  }
-  // Summarize only a COMPLETED turn (state idle) — not assistant text mid-turn that
-  // is followed by a tool call. Cache by msgId so re-subscribe doesn't re-bill.
-  if (w.state === 'idle' && w.lastAssistantText && w.lastMsgId !== w.summarizedMsgId) {
-    w.summarizedMsgId = w.lastMsgId;
-    maybeSummarize(w).catch(() => {});
-  }
 }
 
-function startSessionWatch(tabId, cwd) {
+function startSessionWatch(tabId, cwd, sessionId = tabId) {
   if (_sessionWatchers.has(tabId)) return;
-  const filePath = require('./transcripts.cjs').transcriptPath(cwd, tabId);
+  const filePath = require('./transcripts.cjs').transcriptPath(cwd, sessionId);
   // Defense in depth: the schema restricts tabId charset, but re-validate the
   // FINAL joined path against the home-dir boundary (validatePath resolves
   // symlinks + rejects escapes) before any fs read. Throws → dispatch drops it.
   validatePath(filePath);
   const w = {
-    tabId, cwd, filePath,
+    tabId, cwd, sessionId, filePath,
     offset: null,       // null → first poll reads a bounded tail then tracks EOF
     inode: undefined,
     state: 'idle',
-    lastAssistantText: null,
-    lastMsgId: null,
-    summarizedMsgId: null,
     timer: null,
   };
   _sessionWatchers.set(tabId, w);
@@ -732,44 +715,6 @@ function buildRemoteSessionList(tabs, readIndex) {
   return out;
 }
 
-// ─── SM-V2-03: mobile summary via Claude Haiku 4.5 ───────────────────────────
-// Summarization logic lives in lib/summarize.cjs (shared with exchanges.cjs).
-
-const SUMMARY_MIN_CHARS = 280; // below this, push raw — not worth an API call
-
-/**
- * Produce a mobile summary of the watcher's last completed assistant turn and push it.
- * Short turns are pushed raw (no API call). If no API key is configured, degrades to
- * the raw message so core remote control is never blocked. Cost: Haiku in+out per
- * completed turn per subscribed tab (~$1/$5 per 1M tokens).
- */
-async function maybeSummarize(w) {
-  // Guard: summaries (session transcript content) go only to SAS-confirmed subscribers.
-  if (subscribersOf(w.tabId).length === 0) return;
-  const text = w.lastAssistantText;
-  if (!text) return;
-  const ofMessageId = w.lastMsgId;
-
-  if (text.length < SUMMARY_MIN_CHARS) {
-    for (const c of subscribersOf(w.tabId)) {
-      pushEventTo(c, 'event:session:summary', { tabId: w.tabId, summary: text, ofMessageId, model: 'raw', ts: Date.now() });
-    }
-    return;
-  }
-
-  const { summary, model, degraded } = await _sharedSummarize(text);
-  if (degraded) {
-    logs.writeLine({ scope: 'webRemote', level: 'warn', message: `summary degraded: ${degraded}`, meta: {} });
-  }
-  for (const c of subscribersOf(w.tabId)) {
-    pushEventTo(c, 'event:session:summary', {
-      tabId: w.tabId, summary, ofMessageId, model,
-      ...(degraded ? { degraded } : {}),
-      ts: Date.now(),
-    });
-  }
-}
-
 /**
  * Shared finish-up for any path that transitions a client's e2e state into 'authenticated'
  * (manual SAS confirmation or pinned-key auto-trust): log, broadcast the new
@@ -1010,7 +955,7 @@ async function dispatchEnvelope(envelope, device, client) {
   let result;
   try {
     result = await dispatchCommand(type, payload ?? {}, client);
-    await auditLog(ts, type, device.deviceId, id, 'ok', client);
+    await auditLog(ts, type, device.deviceId, id, auditResultFor(result), client);
   } catch (e) {
     const code = e?.name === 'ZodError' ? 'schema_invalid' : 'dispatch_error';
     await auditLog(ts, type, device.deviceId, id, `error:${code}`, client);
@@ -1020,6 +965,14 @@ async function dispatchEnvelope(envelope, device, client) {
   respond(id, result, undefined, client);
 }
 
+/** Audit result string for a handler result: structured refusals log as refused[:reason]. */
+function auditResultFor(result) {
+  if (result && result.ok === false && typeof result.disposition === 'string') {
+    return typeof result.reason === 'string' && result.reason ? `refused:${result.reason}` : 'refused';
+  }
+  return 'ok';
+}
+
 function respond(msgId, payload, typeOverride, client) {
   if (!_ws || _ws.readyState !== WebSocket.OPEN) return;
   const responseType = typeOverride || (msgId ? `resp:${msgId}` : undefined);
@@ -1102,26 +1055,34 @@ function getDispatchMap() {
       const parsed = schemas.remoteSessionTranscript.parse(payload);
       const { readActiveIndex } = require('./lib/epic/epicMint.cjs');
       const { resolveEpicTranscriptPath } = require('./lib/epic/epicTranscriptPath.cjs');
-      const { readRecentChatMessages } = require('./lib/remoteTranscriptTail.cjs');
+      const { readRecentChatMessages, buildRemoteConversation } = require('./lib/remoteTranscriptTail.cjs');
+      const { listExchanges } = require('./exchanges.cjs');
       const data = await sessionsStore.load();
       const tab = (data?.tabs ?? []).find((t) => t && t.cwd === parsed.cwd);
       if (!tab) throw new Error('cwd is not an open project');
       validatePath(parsed.cwd);
+      const limit = parsed.limit ?? 10;
+      const before = parsed.before ?? 0;
       let filePath = null;
-      if (parsed.sessionKey === (tab.id ?? tab.sessionId)) {
-        filePath = require('./transcripts.cjs').transcriptPath(parsed.cwd, parsed.sessionKey);
+      let sessionId = null;
+      if (parsed.sessionKey === tab.id || parsed.sessionKey === tab.sessionId) {
+        sessionId = tab.sessionId || parsed.sessionKey;
+        filePath = require('./transcripts.cjs').transcriptPath(parsed.cwd, sessionId);
       } else {
         const sessions = readActiveIndex(parsed.cwd)?.sessions ?? {};
         const epic = Object.values(sessions).find(
           (e) => e && (e.id === parsed.sessionKey || e.claudeSessionId === parsed.sessionKey),
         );
         if (epic && epic.claudeSessionId) {
-          filePath = resolveEpicTranscriptPath({ cwd: parsed.cwd, claudeSessionId: epic.claudeSessionId }).path;
+          sessionId = epic.claudeSessionId;
+          filePath = resolveEpicTranscriptPath({ cwd: parsed.cwd, claudeSessionId: sessionId }).path;
         }
       }
-      if (!filePath) return { messages: [] };
+      if (!filePath || !sessionId) return { messages: [], hasMore: false, nextBefore: null };
       validatePath(filePath);
-      return { messages: await readRecentChatMessages(filePath, { limit: parsed.limit }) };
+      const exchanges = await listExchanges({ cwd: parsed.cwd, sessionId, limit: limit + 1, offset: before });
+      const tail = before === 0 ? await readRecentChatMessages(filePath, { limit: 30 }) : [];
+      return buildRemoteConversation({ exchanges, tail, limit, before });
     },
 
     'cmd:session:prds': async (payload) => {
@@ -1209,12 +1170,15 @@ function getDispatchMap() {
     'cmd:app:info': async () =>
       ({ version: app.getVersion(), platform: process.platform }),
 
-    // v2 mobile: start/stop pushing live state + summary for a session.
+    // v2 mobile: start/stop pushing live state for a session.
     'cmd:session:subscribe': async (payload, reqClient) => {
       const client = reqClient || _clients.getOrCreate(LEGACY_CLIENT_KEY);
       const parsed = schemas.sessionSubscribe.parse(payload);
       validatePath(parsed.cwd); // home-dir boundary before any fs access
-      startSessionWatch(parsed.tabId, parsed.cwd);
+      // The phone's Main row passes the tab `id`, but the transcript is keyed by the tab's `sessionId`.
+      const { tabs } = await require('./sessionsStore.cjs').load();
+      const tab = (Array.isArray(tabs) ? tabs : []).find((t) => t && t.id === parsed.tabId && t.cwd === parsed.cwd);
+      startSessionWatch(parsed.tabId, parsed.cwd, tab?.sessionId || parsed.tabId);
       client.subscriptions.add(parsed.tabId);
       return { ok: true };
     },
@@ -1236,23 +1200,28 @@ function getDispatchMap() {
       const data = await sessionsStore.load();
       const tabs = data?.tabs ?? [];
       // Resolve the target in main: an open tab, or an ACTIVE Epic (by id or
-      // claudeSessionId) of an open project. Anything else fails loudly.
+      // claudeSessionId) of an open project. Anything else is a structured refusal.
+      const outcome = (r) => ({
+        ok: r.disposition !== 'refused',
+        disposition: r.disposition,
+        ...(r.reason ? { reason: r.reason } : {}),
+      });
       if (tabs.some((t) => t.sessionId === parsed.tabId || t.id === parsed.tabId)) {
-        chatRunner.enqueueExternalPrompt(parsed.tabId, parsed.prompt);
-        return { ok: true };
+        return outcome(await chatRunner.enqueueExternalPrompt(parsed.tabId, parsed.prompt));
       }
       for (const tab of tabs) {
         const sessions = Object.values(readActiveIndex(tab.cwd)?.sessions ?? {});
         const epic = sessions.find((e) => e && (e.id === parsed.tabId || e.claudeSessionId === parsed.tabId));
         if (!epic) continue;
-        if (epic.status !== 'active' || !epic.claudeSessionId) throw new Error('target is not an active session');
-        chatRunner.enqueueExternalPrompt(epic.id, parsed.prompt, {
+        if (epic.status !== 'active' || !epic.claudeSessionId) {
+          return { ok: false, disposition: 'refused', reason: epic.status === 'proposed' ? 'proposed' : 'not-active' };
+        }
+        return outcome(await chatRunner.enqueueExternalPrompt(epic.id, parsed.prompt, {
           sessionId: epic.claudeSessionId,
           cwd: epic.cwd || tab.cwd,
-        });
-        return { ok: true };
+        }));
       }
-      throw new Error('unknown chat target');
+      return { ok: false, disposition: 'refused', reason: 'unknown-target' };
     },
 
     'cmd:session:options': async () => {
@@ -1266,6 +1235,7 @@ function getDispatchMap() {
         agents: personas.map((a) => ({ name: a.name, description: a.description })),
         tags: EpicTagSchema.options,
         macros: await macroLibrary.listMacros(),
+        macroInputs: true,
       };
     },
 
@@ -1278,7 +1248,23 @@ function getDispatchMap() {
       if (!tabs.some((t) => t.cwd === parsed.cwd)) throw new Error('cwd is not an open project');
       const personas = await agentLibrary.listPersonas();
       if (!personas.some((a) => a.name === parsed.agentName)) throw new Error('unknown agent');
-      chatRunner.requestExternalNewSession(parsed);
+      let prompt = parsed.prompt;
+      if (parsed.macroId) {
+        const macroLibrary = require('./lib/persona-macro/macroLibrary.cjs');
+        const macros = await macroLibrary.listMacros();
+        const macro = macros.find((m) => m.id === parsed.macroId);
+        if (!macro || !macroLibrary.macroVisibleIn(macro, parsed.cwd)) throw new Error('unknown macro');
+        const result = macroLibrary.renderMacroPrompt(parsed.prompt, macro.inputs, parsed.inputs ?? {});
+        if (!result.ok) throw new Error(result.error);
+        prompt = result.prompt;
+      }
+      chatRunner.requestExternalNewSession({
+        cwd: parsed.cwd,
+        agentName: parsed.agentName,
+        tag: parsed.tag,
+        title: parsed.title,
+        prompt,
+      });
       return { ok: true };
     },
   };
@@ -1551,6 +1537,11 @@ module.exports = {
   },
   __test: {
     getDispatchMap,
+    auditResultFor,
+    startSessionWatch,
+    pollSessionWatcher,
+    getSessionWatcher: (tabId) => _sessionWatchers.get(tabId),
+    stopAllSessionWatches,
     buildRemoteSessionList,
     setWs: (ws) => { _ws = ws; },
     connect,