@tekyzinc/gsd-t 3.21.10 → 3.21.12

package/CHANGELOG.md

@@ -2,6 +2,51 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [3.21.12] - 2026-05-06
+
+### Fixed — dashboard orphan accumulation (M49 lazy autostart + idle-TTL + doctor-prune)
+
+88 dead `gsd-t-dashboard-server.js` processes accumulated under v3.21.11 (164 under v3.20.13). Root cause: `bin/headless-auto-spawn.cjs::autoSpawnHeadless()` called `ensureDashboardRunning()` on every spawn, fork-detaching a fresh dashboard for every gsd-t-execute / gsd-t-debug / gsd-t-wave invocation across any project across any session. 99% of those autostarted dashboards are never opened by the user (the live-transcript URL banner is just-in-case observability), so they accumulated on the project-scoped port range 7433–7532 until the user manually killed them.
+
+**Changes:**
+- `bin/headless-auto-spawn.cjs::autoSpawnHeadless()`: removed the `ensureDashboardRunning()` call. Spawns no longer autostart dashboards. New synchronous `_probeDashboardLazy(projectDir)` reads `.gsd-t/.dashboard.pid` and verifies the pid is alive via `process.kill(pid, 0)` (cheap; runs on every spawn). Banner is now conditional:
+  - Dashboard running: `▶ Live transcript: http://127.0.0.1:{port}/transcript/{spawn-id}` (existing M43 D6-T3 shape).
+  - No dashboard: `▶ Transcript file: {logPath}\n  (to view live: gsd-t-visualize)` — points at the on-disk log + tells the user how to open the dashboard if they want it.
+- `scripts/gsd-t-dashboard-server.js`: idle-TTL self-shutdown. Default 4 hours, configurable via env `GSD_T_DASHBOARD_IDLE_TTL_MS` or `--idle-ttl-ms` flag. "Idle" means zero HTTP requests AND zero active SSE connections for the full TTL window. setInterval check every 60s; on shutdown, removes `.gsd-t/.dashboard.pid` so the lazy probe sees a clean state. SSE-active dashboards never exit — `_wrapSseHandler` increments/decrements an active-connection counter on req/res `close` events.
+- `bin/gsd-t.js doctor`: new `Dashboard Orphans` check + `--prune` flag. Scans for live `gsd-t-dashboard-server.js` processes via `ps -eo pid,command`; cross-references each pid against pidfiles in cwd, `GSD_T_PROJECT_DIR`, and the registered-projects list. Reports orphans (process running, pidfile missing or mismatched). With `--prune`, sends SIGTERM to each orphan. Recovery for any orphans that piled up under earlier versions.
+- `commands/gsd-t-visualize.md` (unchanged): the explicit user opt-in path still calls `ensureDashboardRunning()` via `--detach` — the dashboard starts when (and only when) the user runs `/gsd-t-visualize`.
+
+**Tests:**
+- `test/m49-lazy-dashboard.test.js` (9): probe correctness across 5 pidfile states (missing / dead / live / garbage / empty), probe speed (< 50ms for 100 calls), `autoSpawnHeadless` does NOT invoke `ensureDashboardRunning` (require-cache stub), URL banner shape when running, file-path banner shape when not running.
+- `test/m49-dashboard-idle-ttl.test.js` (7): `tracker.bump` resets `lastActivity`, SSE connect/disconnect counter, TTL fires when window elapses with no SSE, TTL does NOT fire while `activeSseConnections > 0`, recent `bump` prevents fire, `_wrapSseHandler` tracks idempotently on close, `startServer` accepts `idleTtlMs` opt without crashing.
+- `test/m49-doctor-orphan-check.test.js` (4): no-process baseline, fake-dashboard process detected as orphan, `--prune` actually kills the orphan PID, tracked dashboard (pidfile lists pid) is NOT an orphan.
+- `test/m43-url-banner.test.js`: updated for M49 — file-path banner expected by default; URL banner exercised with a pre-written pidfile pointing at the test runner's pid (proxy for "live").
+
+**Migration:** existing autostarted dashboards stay running until they hit the 4h idle-TTL or are pruned via `gsd-t doctor --prune`. New spawns no longer add to the count. Re-running `/gsd-t-visualize` continues to work as before.
+
+**Suite:** 2103/2105 (2 pre-existing env-sensitive flakes preserved per M47/M48 baseline). +20 new M49 tests, 0 regressions.
+
+## [3.21.11] - 2026-05-06
+
+### Fixed — viewer: 4 rendering regressions surfaced post-M47
+
+The M47 viewer redesign shipped four user-visible rendering bugs that only became apparent when a project's in-session conversation was actually being viewed against a non-GSD-T project. Discovered when the dashboard for `Move-Zoom-Recordings-to-GDrive` showed three captured `in-session-*.ndjson` files but rendered them with a hardcoded "GSD-T Transcript" header, identical timestamps on every frame, raw `JSON.stringify` dumps in place of chat turns, and the same content in both top and bottom panes.
+
+**Changes:**
+- `scripts/gsd-t-dashboard-server.js`: `<title>` and `.title` div now carry a `__PROJECT_NAME__` placeholder substituted server-side via `path.basename(path.resolve(projectDir))` in both `handleTranscriptsList` and `handleTranscriptPage`. New `_escapeHtml()` helper escapes `<` / `&` / `"` in basenames; the substitution uses the function form of `replace` to defuse `$&` / `$1` / `$$` backreference patterns in basenames (Red Team BUG-1).
+- `scripts/gsd-t-transcript.html`:
+  - `frameTs(frame, fallback)` parses each frame's ISO `ts` field and only falls back to the SSE-handler-captured `arrivedAt` when absent or invalid. `connect()` and `connectMain()` now thread `renderAt = frameTs(frame, arrivedAt)` to `renderFrame`. Initial-replay batches no longer collapse 200 distinct timestamps into one.
+  - 4 new render helpers (`renderUserTurn` / `renderAssistantTurn` / `renderSessionStart` / `renderToolUseLine`) plus dispatch arms in `renderFrameInner` BEFORE the `JSON.stringify` fallback. New CSS for `.frame.assistant-turn` (green border-left), `.frame.session-start` (small inline badge), `.frame.tool-call-line`, `.frame.truncated-tag`. `user_turn` reuses `.frame.user` bubble styling. Truncated content gets a "(truncated)" tag.
+  - 5 separate guards keep `in-session-*` ids out of the bottom pane: `renderRailEntry` click handler returns early on `isInSession`; initial bottom-pane resolution scrubs `in-session-*` from `SS_KEY_SELECTED` sessionStorage before `connect()`; `hashchange` handler returns early; `maybeAutoFollow` filters in-session spawns out; legacy `renderTree` click handler in the live-bucket fallback path also gets the guard (Red Team BUG-2).
+- `test/m48-viewer-rendering-fixes.test.js`: 23 new regression tests — 5 Bug-1, 5 Bug-2 (incl. functional `frameTs` eval-extract probe), 7 Bug-3, 5 Bug-4, 1 functional probe (Red Team test-quality concern). Includes explicit `$&` and `$1` regression tests for the BUG-1 fix.
+- `test/m44-transcript-timestamp.test.js`: updated for the `renderAt` / `arrivedAt` rename — semantics preserved (`arrivedAt` is now the fallback layer beneath parsed `frame.ts`).
+
+**Migration:** existing dashboards pick up the new code on next refresh after `gsd-t update-all` propagates the package; the per-project transcript page reflects the project's directory basename automatically. No state migration.
+
+**Suite:** 2083/2083 pass — both pre-existing M47-baseline flakes resolved on the release run.
+
+**Red Team adversarial QA (opus):** initial sweep found 1 MEDIUM (`$&`-corruption in basename → fixed via function-form replace) + 1 LOW (legacy `renderTree` click handler → fixed via `isInSession` guard) + 1 test-quality recommendation (addressed via functional `frameTs` probe). Re-verification: GRUDGING PASS — no new bugs introduced.
+
 ## [3.20.13] - 2026-05-05
 
 ### Fixed — visualizer: surface in-session NDJSONs when `.index.json` is empty

package/bin/gsd-t.js

@@ -2758,7 +2758,145 @@ async function checkDoctorContextMeter(projectDir) {
   return issues;
 }
 
-async function doDoctor() {
+// M49 — Detect dashboard server processes whose pidfile is missing or
+// mismatched ("orphans"). The lazy-dashboard + idle-TTL changes prevent new
+// orphans from accumulating, but recovery is still needed for any that piled
+// up under earlier versions. With `--prune`, kills the orphan PIDs.
+//
+// "Orphan" = a `gsd-t-dashboard-server.js` process whose pidfile (at
+// `{projectDir}/.gsd-t/.dashboard.pid` resolved from the process's cwd / the
+// `GSD_T_PROJECT_DIR` env / the registered-projects list) doesn't list the pid.
+//
+// Detection is best-effort across platforms — `ps` shape varies. We use:
+//   - macOS / Linux:  `ps -eo pid,command` (no `=`-stripped header)
+//   - Windows:        unsupported here (logged as N/A)
+//
+// Returns an issue count (0 if clean, 1 if orphans found and not pruned).
+function checkDoctorDashboardOrphans(opts) {
+  const prune = !!(opts && opts.prune);
+  let issues = 0;
+  heading("Dashboard Orphans");
+
+  if (process.platform === "win32") {
+    info("Skipping (Windows process inventory not yet supported)");
+    return 0;
+  }
+
+  let psOut;
+  try {
+    psOut = execFileSync("ps", ["-eo", "pid,command"], {
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+  } catch {
+    warn("Could not run `ps -eo pid,command` — orphan detection skipped");
+    return 0;
+  }
+
+  const dashPids = [];
+  for (const line of psOut.split("\n")) {
+    const t = line.trim();
+    if (!t) continue;
+    if (!t.includes("gsd-t-dashboard-server.js")) continue;
+    if (t.includes("ps -eo")) continue; // never list ourselves
+    if (t.includes("grep")) continue;
+    const m = t.match(/^(\d+)\s+(.+)$/);
+    if (!m) continue;
+    const pid = parseInt(m[1], 10);
+    if (!Number.isFinite(pid) || pid <= 0) continue;
+    // Red Team — only treat as a dashboard process if the first argv token is
+    // a `node`-flavored binary AND the second token ends with the script
+    // filename. Filters out e.g. `cat gsd-t-dashboard-server.js`,
+    // `vim gsd-t-dashboard-server.js`, etc. that happen to mention the path.
+    const argv = m[2].trim().split(/\s+/);
+    if (argv.length < 2) continue;
+    const exe = argv[0];
+    const script = argv[1] || "";
+    const exeIsNode = /(^|\/)node([0-9.]+)?$/.test(exe);
+    const scriptMatches = script.endsWith("gsd-t-dashboard-server.js");
+    if (!exeIsNode || !scriptMatches) continue;
+    dashPids.push({ pid, cmd: m[2] });
+  }
+
+  if (dashPids.length === 0) {
+    success("No dashboard processes running");
+    return 0;
+  }
+
+  // Collect candidate pidfiles. We probe (a) cwd + GSD_T_PROJECT_DIR for the
+  // current shell, (b) each registered project. Each contributes one
+  // {projectDir → pidfile pid} mapping. An orphan is a live dashboard pid
+  // that doesn't match any pidfile we found.
+  const projects = new Set();
+  projects.add(process.cwd());
+  if (process.env.GSD_T_PROJECT_DIR) projects.add(process.env.GSD_T_PROJECT_DIR);
+  try {
+    for (const p of getRegisteredProjects()) projects.add(p);
+  } catch { /* registry may not exist */ }
+
+  const knownPids = new Set();
+  for (const proj of projects) {
+    const pidFile = path.join(proj, ".gsd-t", ".dashboard.pid");
+    try {
+      const raw = fs.readFileSync(pidFile, "utf8").trim();
+      const pid = parseInt(raw, 10);
+      if (Number.isFinite(pid) && pid > 0) knownPids.add(pid);
+    } catch { /* missing or unreadable */ }
+    // Also accept the older M38 pidfile (no leading dot).
+    const legacyPidFile = path.join(proj, ".gsd-t", "dashboard.pid");
+    try {
+      const raw = fs.readFileSync(legacyPidFile, "utf8").trim();
+      const pid = parseInt(raw, 10);
+      if (Number.isFinite(pid) && pid > 0) knownPids.add(pid);
+    } catch { /* missing */ }
+  }
+
+  const orphans = dashPids.filter((d) => !knownPids.has(d.pid));
+
+  log(`  Detected ${dashPids.length} dashboard process${dashPids.length === 1 ? "" : "es"} ` +
+      `(${knownPids.size} tracked via pidfile, ${orphans.length} orphan${orphans.length === 1 ? "" : "s"})`);
+
+  if (orphans.length === 0) {
+    success("No orphans");
+    return 0;
+  }
+
+  for (const o of orphans) {
+    log(`  ${YELLOW}orphan${RESET} pid=${o.pid}`);
+  }
+
+  if (prune) {
+    let killed = 0;
+    let failed = 0;
+    for (const o of orphans) {
+      try {
+        process.kill(o.pid, "SIGTERM");
+        killed++;
+      } catch (err) {
+        if (err && err.code === "ESRCH") {
+          // Already gone — count as success.
+          killed++;
+        } else {
+          failed++;
+        }
+      }
+    }
+    if (failed === 0) {
+      success(`Pruned ${killed} orphan${killed === 1 ? "" : "s"}`);
+    } else {
+      warn(`Pruned ${killed}, failed ${failed}`);
+      issues++;
+    }
+  } else {
+    info("Run `gsd-t doctor --prune` to kill orphans");
+    issues++;
+  }
+
+  return issues;
+}
+
+async function doDoctor(opts) {
   heading("GSD-T Doctor");
   log("");
   let issues = 0;
@@ -2767,6 +2905,7 @@ async function doDoctor() {
   issues += checkDoctorProject();
   issues += checkDoctorCgc();
   issues += await checkDoctorContextMeter(process.cwd());
+  issues += checkDoctorDashboardOrphans(opts);
   log("");
   if (issues === 0) {
     log(`${GREEN}${BOLD}  All checks passed!${RESET}`);
@@ -3881,7 +4020,7 @@ function showHelp() {
   log(`  ${CYAN}register${RESET}       Register current directory as a GSD-T project`);
   log(`  ${CYAN}status${RESET}         Show installation status + check for updates`);
   log(`  ${CYAN}uninstall${RESET}      Remove GSD-T commands (keeps project files)`);
-  log(`  ${CYAN}doctor${RESET}         Diagnose common issues`);
+  log(`  ${CYAN}doctor${RESET}         Diagnose common issues (use --prune to kill dashboard orphans)`);
   log(`  ${CYAN}changelog${RESET}      Open changelog in the browser`);
   log(`  ${CYAN}graph${RESET}          Code graph operations (index, status, query)`);
   log(`  ${CYAN}headless${RESET}       Non-interactive execution via claude -p + fast state queries`);
@@ -3946,6 +4085,8 @@ module.exports = {
   checkDoctorClaudeMd,
   checkDoctorSettings,
   checkDoctorEncoding,
+  checkDoctorDashboardOrphans,
+  doDoctor,
   mergeGsdtSection,
   migrateToMarkers,
   appendGsdtToClaudeMd,
@@ -4034,9 +4175,14 @@ if (require.main === module) {
     case "uninstall":
       doUninstall();
       break;
-    case "doctor":
-      doDoctor().catch((e) => { error(e.message || String(e)); process.exit(1); });
+    case "doctor": {
+      const doctorOpts = { prune: false };
+      for (let i = 1; i < args.length; i++) {
+        if (args[i] === "--prune") doctorOpts.prune = true;
+      }
+      doDoctor(doctorOpts).catch((e) => { error(e.message || String(e)); process.exit(1); });
       break;
+    }
     case "changelog":
       doChangelog();
       break;

package/bin/headless-auto-spawn.cjs

@@ -55,6 +55,8 @@ module.exports = {
   // it now unconditionally returns true. See headless-default-contract
   // v2.0.0 §Invariants.
   shouldSpawnHeadless: () => true,
+  // M49 — exported for tests. Synchronous probe; never throws.
+  _probeDashboardLazy,
 };
 
 // M43 D4 — one-shot deprecation banner when a caller still passes `watch`
@@ -126,16 +128,18 @@ function autoSpawnHeadless(opts) {
   ensureDir(path.join(projectDir, LOG_DIR_REL));
   ensureDir(path.join(projectDir, SESSIONS_DIR_REL));
 
-  // M43 D6-T4 — Ensure dashboard is running (idempotent; no-op if already up).
-  // Must happen BEFORE the URL banner print (D6-T3) so the link is live.
-  // Never throws — autostart is best-effort.
-  let autostartInfo = null;
-  try {
-    const { ensureDashboardRunning } = require("../scripts/gsd-t-dashboard-autostart.cjs");
-    autostartInfo = ensureDashboardRunning({ projectDir });
-  } catch (_) {
-    /* best-effort; fall through without banner port info */
-  }
+  // M49 — Lazy dashboard. Spawns no longer autostart the dashboard. Each
+  // spawn would otherwise fork-detach a fresh `gsd-t-dashboard-server.js`
+  // (M43 D6-T4); 99% of those banners are never opened so they accumulated
+  // to 88+ orphans on the project-scoped port range. The dashboard now only
+  // starts when the user explicitly invokes `/gsd-t-visualize`. The banner
+  // below remains, but becomes conditional on whether a dashboard is already
+  // listening on the project's scoped port.
+  //
+  // Probe is sync + cheap: read `.gsd-t/.dashboard.pid` and `process.kill(pid, 0)`.
+  // Falls back to "no dashboard" on any error — never throws.
+  // See .gsd-t/contracts/headless-default-contract.md v2.0.0 §M49 (lazy banner).
+  const dashboardInfo = _probeDashboardLazy(projectDir);
 
   // M46 follow-up — Date + version banner. Printed before the transcript URL
   // so multi-day-old read-backs are immediately dated. Best-effort.
@@ -155,17 +159,27 @@ function autoSpawnHeadless(opts) {
     /* best-effort — never crash the spawn on banner failure */
   }
 
-  // M43 D6-T3 — Live transcript URL banner. Printed for every spawn so the
-  // viewer at :PORT is "the" primary watching surface. Never throws.
-  // Text is coordinated with D4 — exact line shape is part of
-  // dashboard-server-contract.md §Banner Format.
+  // M49 — Conditional transcript banner. If a dashboard is already running
+  // on the project's scoped port, point at the live URL (M43 D6-T3 shape).
+  // Otherwise, point at the on-disk log path and hint at /gsd-t-visualize so
+  // the user knows how to open the viewer if they want it. The viewer URL
+  // is no longer printed for spawns where no listener exists — that is what
+  // caused users to assume one was running and accumulated orphans on retry.
+  //
+  // Text is coordinated with D4 — banner format spec in
+  // .gsd-t/contracts/dashboard-server-contract.md v1.3.0 §Banner Format
+  // and headless-default-contract.md v2.0.0 §M49.
   try {
-    let port = autostartInfo && autostartInfo.port;
-    if (!port) {
-      const { projectScopedDefaultPort } = require("../scripts/gsd-t-dashboard-server.js");
-      port = projectScopedDefaultPort(projectDir);
+    if (dashboardInfo.running && dashboardInfo.port) {
+      process.stdout.write(
+        `▶ Live transcript: http://127.0.0.1:${dashboardInfo.port}/transcript/${id}\n`,
+      );
+    } else {
+      const relLog = path.relative(projectDir, logPath);
+      process.stdout.write(
+        `▶ Transcript file: ${relLog}\n  (to view live: gsd-t-visualize)\n`,
+      );
     }
-    process.stdout.write(`▶ Live transcript: http://127.0.0.1:${port}/transcript/${id}\n`);
   } catch (_) {
     /* best-effort — never crash the spawn on banner failure */
   }
@@ -515,6 +529,57 @@ function appendTokenLog(projectDir, entry) {
 
 // ── Helpers ──────────────────────────────────────────────────────────────────
 
+/**
+ * M49 — Cheap synchronous probe: is a dashboard listening on this project's
+ * scoped port? Strategy: read `.gsd-t/.dashboard.pid`; if the pid is alive
+ * (`process.kill(pid, 0)` doesn't throw), assume the dashboard is up and
+ * resolve the port via `projectScopedDefaultPort(projectDir)`. No child
+ * process forking — this runs on every spawn and must be cheap.
+ *
+ * Returns `{ running: boolean, port: number|null, pid: number|null }`. Never
+ * throws. A return of `{ running: false }` is the safe fallback that drives
+ * the file-path-only banner.
+ *
+ * @param {string} projectDir
+ * @returns {{ running: boolean, port: number|null, pid: number|null }}
+ */
+function _probeDashboardLazy(projectDir) {
+  const out = { running: false, port: null, pid: null };
+  try {
+    const pidFile = path.join(projectDir, ".gsd-t", ".dashboard.pid");
+    if (!fs.existsSync(pidFile)) return out;
+    const raw = fs.readFileSync(pidFile, "utf8").trim();
+    const pid = parseInt(raw, 10);
+    if (!pid || Number.isNaN(pid) || pid <= 0) return out;
+    // process.kill(pid, 0) — signal 0 only checks for existence/permission.
+    // Throws ESRCH if no such process; EPERM if process exists but owned by
+    // someone else. EPERM still implies "alive", so treat both ESRCH-only as
+    // dead.
+    try {
+      process.kill(pid, 0);
+    } catch (err) {
+      if (err && err.code === "EPERM") {
+        // Alive but not owned by us — still a live listener; treat as running.
+      } else {
+        return out; // ESRCH or unknown — treat as dead.
+      }
+    }
+    out.pid = pid;
+    out.running = true;
+    try {
+      const { projectScopedDefaultPort } = require("../scripts/gsd-t-dashboard-server.js");
+      out.port = projectScopedDefaultPort(projectDir);
+    } catch (_) {
+      // Without the port we can't render the URL — fall back to file banner.
+      out.running = false;
+      out.port = null;
+    }
+  } catch (_) {
+    /* probe is best-effort */
+  }
+  return out;
+}
+
 function ensureDir(d) {
   if (!fs.existsSync(d)) fs.mkdirSync(d, { recursive: true });
 }

package/docs/architecture.md

@@ -73,8 +73,8 @@ The framework has no runtime — it is consumed entirely by Claude Code's slash
 ### Transcript Viewer as Primary Surface (M43 D6 — complete v3.16.13)
 - **Dashboard server additions** (`scripts/gsd-t-dashboard-server.js`): two new HTTP routes for the per-spawn viewer. `GET /transcript/:id/usage` → `{spawn_id, rows, truncated}` filtered from `.gsd-t/metrics/token-usage.jsonl` by `row.spawn_id === id` OR (no `spawn_id` column + `row.session_id === id` — the session-id branch covers M43 D1 Branch B in-session rows). `GET /transcript/:id/tool-cost` → proxies to `bin/gsd-t-tool-attribution.cjs::aggregateByTool` (M43 D2); returns 503 `{error: "tool-attribution library not yet available"}` when D2 isn't on disk so D6 could ship before D2 in Wave 2 without crashing callers.
 - **Transcript viewer panel** (`scripts/gsd-t-transcript.html`): collapsible "Tool Cost" sidebar panel that fetches `/transcript/:id/tool-cost` on viewer load and debounces a 2s refresh on each SSE `turn_complete` / `result` frame. Renders top-N tools sorted by attributed tokens with name, call count, tokens, and USD cost. Live badge green while SSE is open, muted otherwise. 503 → friendly "tool attribution not yet wired" row. `window.__gsdtRenderToolCostPanel` exposed for DOM tests.
-- **URL banner** (`bin/headless-auto-spawn.cjs`): every detached spawn prints `▶ Live transcript: http://127.0.0.1:{port}/transcript/{spawn-id}` on stdout. Port sourced from `ensureDashboardRunning().port` with `projectScopedDefaultPort(projectDir)` fallback. Best-effort — banner failure never crashes the spawn.
-- **Dashboard autostart** (`scripts/gsd-t-dashboard-autostart.cjs`, ~160 lines, zero deps): `ensureDashboardRunning({projectDir, port?})` probes the port synchronously via a short-lived subprocess (`_isPortBusySync` issues `net.createServer().listen(port)` host-less — matches the server's IPv6-wildcard bind on macOS dual-stack; specifying `127.0.0.1` would falsely report free). If free, fork-detaches the server with `spawn(…, {detached:true, stdio:'ignore'})` + `child.unref()` + writes `.gsd-t/.dashboard.pid` (hyphen → dot distinguishes this lifecycle from M38's `.gsd-t/dashboard.pid`). Idempotent on repeated invocation. Called at the top of `autoSpawnHeadless` so the banner printed immediately after resolves to a live listener.
+- **URL banner** (`bin/headless-auto-spawn.cjs`, M49 — lazy): every detached spawn prints either `▶ Live transcript: http://127.0.0.1:{port}/transcript/{spawn-id}` (when a dashboard is already listening, detected via `_probeDashboardLazy()` reading `.gsd-t/.dashboard.pid` + `process.kill(pid, 0)`) OR `▶ Transcript file: {logPath}\n  (to view live: gsd-t-visualize)` (when no dashboard is up). Pre-M49 the spawn unconditionally autostarted a dashboard via `ensureDashboardRunning()` and printed the URL — that accumulated 88+ orphan dashboard processes because 99% of those URLs are never opened. M49 removed the autostart from the spawn path; the dashboard now only starts when the user explicitly invokes `/gsd-t-visualize`. Best-effort — banner failure never crashes the spawn.
+- **Dashboard autostart** (`scripts/gsd-t-dashboard-autostart.cjs`, ~160 lines, zero deps): `ensureDashboardRunning({projectDir, port?})` probes the port synchronously via a short-lived subprocess (`_isPortBusySync` issues `net.createServer().listen(port)` host-less — matches the server's IPv6-wildcard bind on macOS dual-stack; specifying `127.0.0.1` would falsely report free). If free, fork-detaches the server with `spawn(…, {detached:true, stdio:'ignore'})` + `child.unref()` + writes `.gsd-t/.dashboard.pid` (hyphen → dot distinguishes this lifecycle from M38's `.gsd-t/dashboard.pid`). Idempotent on repeated invocation. **M49 — only called by `/gsd-t-visualize` now**, never by the spawn path; combined with the dashboard's idle-TTL self-shutdown (4-hour default, configurable via `GSD_T_DASHBOARD_IDLE_TTL_MS` or `--idle-ttl-ms`) this caps the long-tail orphan accumulation.
 - **Contract**: `.gsd-t/contracts/dashboard-server-contract.md` v1.2.0 — new §HTTP Endpoints entries, §Banner Format, §Autostart sections. (Bumped to v1.3.0 in M47 — see Focused Visualizer Redesign below.)
 - **Tests**: `test/m43-dashboard-tool-cost-route.test.js` (9), `test/m43-transcript-panel.test.js` (12), `test/m43-dashboard-autostart.test.js` (6), `test/m43-url-banner.test.js` (3).
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.21.10",
+  "version": "3.21.12",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/scripts/gsd-t-dashboard-server.js

@@ -273,7 +273,14 @@ function handleTranscriptsList(req, res, projectDir, transcriptHtmlPath) {
       // viewer's initialId logic falls through to location.hash (also empty)
       // and connect('') is a no-op beyond a 404 SSE attempt — harmless, since
       // the left rail polls /api/spawns-index independently.
-      const html = data.toString("utf8").replace(/__SPAWN_ID__/g, "");
+      const projectName = path.basename(path.resolve(projectDir || "."));
+      // Function-form replacement: a string replacement would interpret
+      // `$&`, `$1`, `$$`, etc. in the project basename as backreferences,
+      // re-injecting the placeholder or fragments of it (Red Team BUG-1).
+      const escapedName = _escapeHtml(projectName);
+      const html = data.toString("utf8")
+        .replace(/__SPAWN_ID__/g, () => "")
+        .replace(/__PROJECT_NAME__/g, () => escapedName);
       res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
       res.end(html);
     });
@@ -283,18 +290,36 @@ function handleTranscriptsList(req, res, projectDir, transcriptHtmlPath) {
   res.end(JSON.stringify({ spawns: sorted }));
 }
 
-function handleTranscriptPage(req, res, spawnId, transcriptHtmlPath) {
+function handleTranscriptPage(req, res, spawnId, transcriptHtmlPath, projectDir) {
   if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
   fs.readFile(transcriptHtmlPath, (err, data) => {
     if (err) { res.writeHead(404); res.end("Transcript UI not found"); return; }
     // Inject the spawn-id as a data attribute on <body> by string replacement;
     // the HTML ships with a placeholder `data-spawn-id="__SPAWN_ID__"`.
-    const html = data.toString("utf8").replace(/__SPAWN_ID__/g, spawnId);
+    const projectName = path.basename(path.resolve(projectDir || "."));
+    // Function-form replacement: see comment in handleTranscriptsList. Even
+    // though isValidSpawnId guards spawnId against `$`, defence in depth.
+    const escapedName = _escapeHtml(projectName);
+    const html = data.toString("utf8")
+      .replace(/__SPAWN_ID__/g, () => spawnId)
+      .replace(/__PROJECT_NAME__/g, () => escapedName);
     res.writeHead(200, { "Content-Type": "text/html" });
     res.end(html);
   });
 }
 
+// HTML-escape just enough to make a directory basename safe in <title> and
+// <div class="title">. Project basenames effectively never contain quotes or
+// angle brackets, but we still escape to keep the surface tight.
+function _escapeHtml(s) {
+  return String(s == null ? "" : s)
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
 function tailTranscriptFile(filePath, callback) {
   let offset = 0;
   let buf = "";
@@ -748,13 +773,106 @@ function handleSpawnPlanUpdates(req, res, projectDir) {
   req.on("close", () => { clearInterval(timer); if (dirWatcher) { try { dirWatcher.close(); } catch { /* ok */ } } });
 }
 
-function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath) {
+// ── M49 — Idle-TTL self-shutdown ────────────────────────────────────────────
+//
+// A dashboard with zero HTTP requests AND zero active SSE connections for the
+// full TTL window self-exits cleanly. Safety net for any dashboard that
+// somehow gets started and then walks away — even if a future bug lets one
+// be auto-started, it dies on its own. Configurable via env
+// `GSD_T_DASHBOARD_IDLE_TTL_MS` or `--idle-ttl-ms` flag.
+//
+// "Idle" means: zero HTTP requests AND zero active SSE connections for the
+// full TTL window. `lastActivity` is bumped on every HTTP request handler
+// entry and on SSE connect/disconnect. SSE-active dashboards never exit.
+//
+// On shutdown, removes `.gsd-t/.dashboard.pid` so the lazy probe (M49 in
+// `bin/headless-auto-spawn.cjs`) sees a clean state.
+
+const DEFAULT_IDLE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
+const IDLE_CHECK_INTERVAL_MS = 60 * 1000;        // 60s
+
+function _activityTracker() {
+  let lastActivity = Date.now();
+  let activeSseConnections = 0;
+  return {
+    bump() { lastActivity = Date.now(); },
+    sseConnect() { activeSseConnections++; lastActivity = Date.now(); },
+    sseDisconnect() {
+      if (activeSseConnections > 0) activeSseConnections--;
+      lastActivity = Date.now();
+    },
+    snapshot() { return { lastActivity, activeSseConnections }; },
+  };
+}
+
+/**
+ * Wrap an SSE handler so it bumps the connect/disconnect counters.
+ */
+function _wrapSseHandler(handler, tracker) {
+  return function (req, res, ...rest) {
+    tracker.sseConnect();
+    let closed = false;
+    const onClose = () => {
+      if (closed) return;
+      closed = true;
+      tracker.sseDisconnect();
+    };
+    req.on("close", onClose);
+    res.on("close", onClose);
+    res.on("finish", onClose);
+    return handler(req, res, ...rest);
+  };
+}
+
+/**
+ * @param {object} opts { ttlMs, intervalMs, projectDir, server }
+ * @returns timer handle (so callers can clearInterval in tests).
+ */
+function _startIdleTtlTimer({ ttlMs, intervalMs, projectDir, server, tracker, onShutdown }) {
+  const interval = setInterval(() => {
+    const { lastActivity, activeSseConnections } = tracker.snapshot();
+    const idle = Date.now() - lastActivity;
+    if (activeSseConnections === 0 && idle >= ttlMs) {
+      clearInterval(interval);
+      try {
+        // Remove pid file so the lazy probe in headless-auto-spawn sees clean state.
+        if (projectDir) {
+          const pidFile = path.join(projectDir, ".gsd-t", ".dashboard.pid");
+          try { fs.unlinkSync(pidFile); } catch { /* may not exist */ }
+        }
+      } catch { /* best-effort */ }
+      try { if (typeof onShutdown === "function") onShutdown(); } catch { /* best-effort */ }
+      try {
+        if (server) server.close(() => process.exit(0));
+        else process.exit(0);
+      } catch { process.exit(0); }
+    }
+  }, intervalMs);
+  if (typeof interval.unref === "function") interval.unref();
+  return interval;
+}
+
+function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath, opts) {
   const projDir = projectDir || path.resolve(eventsDir, "..", "..");
   const tHtmlPath = transcriptHtmlPath || path.join(path.dirname(htmlPath), "gsd-t-transcript.html");
+  const tracker = _activityTracker();
+  const ttlMs = (opts && Number.isFinite(opts.idleTtlMs))
+    ? opts.idleTtlMs
+    : (Number.parseInt(process.env.GSD_T_DASHBOARD_IDLE_TTL_MS || "", 10) || DEFAULT_IDLE_TTL_MS);
+  const intervalMs = (opts && Number.isFinite(opts.idleCheckIntervalMs))
+    ? opts.idleCheckIntervalMs
+    : IDLE_CHECK_INTERVAL_MS;
+
+  // Wrap the three SSE handlers with the connect/disconnect tracker.
+  const handleEventsSse = _wrapSseHandler(handleEvents, tracker);
+  const handleTranscriptStreamSse = _wrapSseHandler(handleTranscriptStream, tracker);
+  const handleSpawnPlanUpdatesSse = _wrapSseHandler(handleSpawnPlanUpdates, tracker);
+
   const server = http.createServer((req, res) => {
+    tracker.bump(); // bump on every HTTP request handler entry
     const url = req.url.split("?")[0];
     if (url === "/" || url === "") return handleRoot(req, res, htmlPath);
-    if (url === "/events") return handleEvents(req, res, eventsDir);
+    if (url === "/events") return handleEventsSse(req, res, eventsDir);
     if (url === "/metrics") return handleMetrics(req, res, projDir);
     if (url === "/ping") return handlePing(req, res, port);
     if (url === "/stop") return handleStop(req, res, server);
@@ -763,7 +881,7 @@ function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath)
     if (url === "/api/main-session") return handleMainSession(req, res, projDir);
     // M44 D8 — spawn plans: GET list + SSE change stream
     if (url === "/api/spawn-plans") return handleSpawnPlans(req, res, projDir);
-    if (url === "/api/spawn-plans/stream") return handleSpawnPlanUpdates(req, res, projDir);
+    if (url === "/api/spawn-plans/stream") return handleSpawnPlanUpdatesSse(req, res, projDir);
     // M44 D9 — parallelism observability (additive, read-only)
     if (url === "/api/parallelism") return handleParallelism(req, res, projDir);
     if (url === "/api/parallelism/report") return handleParallelismReport(req, res, projDir);
@@ -780,14 +898,30 @@ function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath)
     if (usageMatch) return handleTranscriptUsage(req, res, decodeURIComponent(usageMatch[1]), projDir);
     // /transcript/:spawnId/stream — SSE tail of per-spawn ndjson
     const streamMatch = url.match(/^\/transcript\/([^/]+)\/stream$/);
-    if (streamMatch) return handleTranscriptStream(req, res, decodeURIComponent(streamMatch[1]), projDir);
+    if (streamMatch) return handleTranscriptStreamSse(req, res, decodeURIComponent(streamMatch[1]), projDir);
     // /transcript/:spawnId — HTML viewer page
     const pageMatch = url.match(/^\/transcript\/([^/]+)$/);
-    if (pageMatch) return handleTranscriptPage(req, res, decodeURIComponent(pageMatch[1]), tHtmlPath);
+    if (pageMatch) return handleTranscriptPage(req, res, decodeURIComponent(pageMatch[1]), tHtmlPath, projDir);
     res.writeHead(404); res.end("Not found");
   });
   server.listen(port);
-  return { server, url: `http://localhost:${port}` };
+
+  // M49 — install idle-TTL self-shutdown timer. Skipped only when caller
+  // explicitly passes `idleTtlMs: 0` (used by tests that don't want the
+  // server to self-exit mid-test).
+  let idleTimer = null;
+  if (ttlMs > 0) {
+    idleTimer = _startIdleTtlTimer({
+      ttlMs,
+      intervalMs,
+      projectDir: projDir,
+      server,
+      tracker,
+      onShutdown: opts && opts.onShutdown,
+    });
+  }
+
+  return { server, url: `http://localhost:${port}`, tracker, idleTimer };
 }
 
 module.exports = {
@@ -825,6 +959,11 @@ module.exports = {
   handleParallelism,
   handleParallelismReport,
   handleUnattendedStop,
+  // M49 — idle-TTL exports for tests
+  _activityTracker,
+  _wrapSseHandler,
+  _startIdleTtlTimer,
+  DEFAULT_IDLE_TTL_MS,
 };
 
 if (require.main === module) {
@@ -850,9 +989,25 @@ if (require.main === module) {
     fs.writeFileSync(pidFile, String(child.pid));
     process.exit(0);
   }
-  const { server, url } = startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath);
+  // M49 — idle-TTL flag/env override. Falls through to startServer's default
+  // (env var GSD_T_DASHBOARD_IDLE_TTL_MS or 4h).
+  const ttlArg = getArg("--idle-ttl-ms");
+  const startOpts = {};
+  if (ttlArg != null && ttlArg !== "") {
+    const n = Number.parseInt(ttlArg, 10);
+    if (Number.isFinite(n)) startOpts.idleTtlMs = n;
+  }
+
+  const { server, url } = startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath, startOpts);
   process.stdout.write("GSD-T Dashboard: " + url + "\n");
-  function cleanup() { try { fs.unlinkSync(pidFile); } catch { /* ok */ } server.close(() => process.exit(0)); }
+  function cleanup() {
+    try { fs.unlinkSync(pidFile); } catch { /* ok */ }
+    // M49 — also remove the lazy-probe pidfile so headless-auto-spawn sees clean state.
+    try {
+      fs.unlinkSync(path.join(projectDir, ".gsd-t", ".dashboard.pid"));
+    } catch { /* ok */ }
+    server.close(() => process.exit(0));
+  }
   process.on("SIGTERM", cleanup);
   process.on("SIGINT", cleanup);
 }

package/scripts/gsd-t-transcript.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="UTF-8">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>GSD-T Transcript</title>
+  <title>__PROJECT_NAME__</title>
   <style>
     :root {
       --bg: #0d1117;
@@ -183,6 +183,17 @@
     .frame.boundary.done .label { color: var(--green); }
     .frame.boundary.failed .label { color: var(--red); }
     .frame.boundary .meta { color: var(--fg-dim); font-family: var(--mono); font-size: 12px; }
+    /* M48 — chat-bubble frame types emitted by the in-session conversation
+       capture hook. user_turn reuses .frame.user styling; assistant_turn
+       gets a softer right-aligned-feel bubble; session_start is a tiny badge. */
+    .frame.assistant-turn { border-left: 3px solid var(--green); padding: 6px 12px; background: var(--bg-raised); border-radius: 0 4px 4px 0; }
+    .frame.assistant-turn .prefix { color: var(--green); font-weight: 600; margin-right: 6px; font-family: var(--mono); }
+    .frame.assistant-turn .body { white-space: pre-wrap; word-break: break-word; }
+    .frame.user-turn .body { white-space: pre-wrap; word-break: break-word; }
+    .frame.session-start { display: inline-flex; align-items: center; gap: 6px; margin: 8px 0; padding: 3px 10px; background: rgba(88,166,255,0.10); border: 1px solid var(--border); border-radius: 12px; font-family: var(--mono); font-size: 11px; color: var(--fg-dim); }
+    .frame.session-start .badge { color: var(--accent); font-weight: 600; }
+    .frame.tool-call-line { font-family: var(--mono); font-size: 12px; color: var(--accent-warm); padding: 2px 0; }
+    .frame.truncated-tag { color: var(--fg-xdim); font-style: italic; font-size: 11px; margin-left: 6px; }
 
     .jump-to-live { position: fixed; bottom: 24px; right: 24px; background: var(--accent); color: #fff; border: none; padding: 10px 16px; border-radius: 20px; cursor: pointer; font-size: 13px; font-family: var(--sans); font-weight: 600; box-shadow: 0 4px 12px rgba(0,0,0,0.4); display: none; z-index: 20; }
     .jump-to-live.visible { display: block; }
@@ -202,7 +213,7 @@
 </head>
 <body data-spawn-id="__SPAWN_ID__">
   <header>
-    <div class="title">GSD-T Transcript</div>
+    <div class="title">__PROJECT_NAME__</div>
     <div class="spawn-id" id="hdr-spawn-id"></div>
     <label class="auto-follow" title="When ON, snap focus to the most recent live spawn as soon as it appears."><input type="checkbox" id="auto-follow" checked> auto-follow latest</label>
     <div class="status" id="hdr-status"><span class="dot"></span><span class="label">connecting…</span></div>
@@ -440,17 +451,26 @@
       }
       window.__gsdtFmtTs = fmtTs;
 
-      // Per-frame arrival timestamp. The renderer captures Date.now() once
-      // per SSE message and threads it through; everything else falls back
-      // to "now" so manually-rendered frames stay visible too. Spotting a
-      // stuck stream is then trivial — adjacent frames will show identical
-      // or far-apart timestamps in the left-margin pill.
+      // Per-frame timestamp. We prefer the producer-side `frame.ts`
+      // (ISO string written by the conversation-capture hook) when it
+      // parses cleanly, and only fall back to SSE arrival time when no
+      // `ts` field is present. Without this, an initial-load replay of
+      // N frames all arrives within one millisecond and every row shows
+      // the same HH:MM:SS — useless for spotting stuck or stale streams.
       //
       // M47 D1: appendFrame writes to a module-scope `renderTarget`. The
       // renderFrame entry point swaps it per-call so the same code paths
       // render into either the top pane (#main-stream — main-conversation
       // SSE) or the bottom pane (#stream inside #spawn-stream — selected
       // spawn SSE).
+      function frameTs(frame, fallback) {
+        if (frame && typeof frame.ts === 'string') {
+          const d = new Date(frame.ts);
+          if (!isNaN(d.getTime())) return d;
+        }
+        return fallback instanceof Date ? fallback : new Date();
+      }
+      window.__gsdtFrameTs = frameTs;
       let renderTarget = stream;
       function appendFrame(el, arrivedAt) {
         const ts = document.createElement('span');
@@ -604,6 +624,74 @@
         appendFrame(div, arrivedAt);
       }
 
+      // M48 — chat-bubble renderers for the in-session conversation NDJSON.
+      // The conversation-capture hook emits frames of type
+      // `user_turn`, `assistant_turn`, `session_start`, and `tool_use`.
+      // Without explicit handling these fall through to renderRaw and the
+      // user sees a JSON.stringify dump per row.
+      function _appendTruncatedTag(div, frame) {
+        if (!frame || !frame.truncated) return;
+        const tag = document.createElement('span');
+        tag.className = 'truncated-tag';
+        tag.textContent = '(truncated)';
+        div.appendChild(tag);
+      }
+      function renderUserTurn(frame, arrivedAt) {
+        const div = document.createElement('div');
+        div.className = 'frame user user-turn';
+        const p = document.createElement('span');
+        p.className = 'prefix';
+        p.textContent = '>';
+        div.appendChild(p);
+        const body = document.createElement('span');
+        body.className = 'body';
+        body.textContent = (frame && typeof frame.content === 'string') ? frame.content : '';
+        div.appendChild(body);
+        _appendTruncatedTag(div, frame);
+        appendFrame(div, arrivedAt);
+      }
+      function renderAssistantTurn(frame, arrivedAt) {
+        const div = document.createElement('div');
+        div.className = 'frame assistant-turn';
+        const p = document.createElement('span');
+        p.className = 'prefix';
+        p.textContent = '⏺';
+        div.appendChild(p);
+        const body = document.createElement('span');
+        body.className = 'body';
+        body.textContent = (frame && typeof frame.content === 'string') ? frame.content : '';
+        div.appendChild(body);
+        _appendTruncatedTag(div, frame);
+        appendFrame(div, arrivedAt);
+      }
+      function renderSessionStart(frame, arrivedAt) {
+        const div = document.createElement('div');
+        div.className = 'frame session-start';
+        const badge = document.createElement('span');
+        badge.className = 'badge';
+        badge.textContent = '◆ session';
+        div.appendChild(badge);
+        if (frame && typeof frame.session_id === 'string') {
+          const sid = document.createElement('span');
+          sid.textContent = frame.session_id.slice(0, 8);
+          div.appendChild(sid);
+        }
+        appendFrame(div, arrivedAt);
+      }
+      function renderToolUseLine(frame, arrivedAt) {
+        const div = document.createElement('div');
+        div.className = 'frame tool-call-line';
+        const span = document.createElement('span');
+        const name = (frame && typeof frame.name === 'string') ? frame.name : 'tool';
+        span.textContent = '⎿ ' + name + '()';
+        div.appendChild(span);
+        appendFrame(div, arrivedAt);
+      }
+      window.__gsdtRenderUserTurn       = renderUserTurn;
+      window.__gsdtRenderAssistantTurn  = renderAssistantTurn;
+      window.__gsdtRenderSessionStart   = renderSessionStart;
+      window.__gsdtRenderToolUseLine    = renderToolUseLine;
+
       function renderCompactMarker(frame, arrivedAt) {
         const div = document.createElement('div');
         div.className = 'frame compact-marker';
@@ -646,12 +734,23 @@
       }
       function renderFrameInner(frame, arrivedAt) {
         if (!frame || typeof frame !== 'object') return;
-        const ts = arrivedAt instanceof Date ? arrivedAt : new Date();
+        // Defense in depth: if a caller passes a non-Date `arrivedAt`, still
+        // try to derive a real timestamp from frame.ts before falling back
+        // to "now". Without this guard, every renderFrame() call from a
+        // non-SSE path (e.g. tests, manual dispatch) collapses to one Date.
+        const ts = (arrivedAt instanceof Date && !isNaN(arrivedAt.getTime()))
+          ? arrivedAt
+          : frameTs(frame, new Date());
         const type = frame.type;
         if (type === 'compact_marker') { renderCompactMarker(frame, ts); return; }
         if (type === 'system') { renderSystem(frame, ts); return; }
         if (type === 'task-boundary') { renderBoundary(frame, ts); return; }
         if (type === 'raw') { renderRaw(frame.line || '', ts); return; }
+        // M48 — in-session conversation-capture frame types.
+        if (type === 'session_start')   { renderSessionStart(frame, ts); return; }
+        if (type === 'user_turn')       { renderUserTurn(frame, ts); return; }
+        if (type === 'assistant_turn')  { renderAssistantTurn(frame, ts); return; }
+        if (type === 'tool_use')        { renderToolUseLine(frame, ts); return; }
         if (type === 'assistant' && frame.message && Array.isArray(frame.message.content)) {
           for (const b of frame.message.content) {
             if (b.type === 'text') renderAssistantText(b.text || '', ts);
@@ -771,6 +870,14 @@
           });
           el.appendChild(dot); el.appendChild(name); el.appendChild(kill);
           el.addEventListener('click', () => {
+            // M48 — symmetric with renderRailEntry: in-session entries
+            // belong to the TOP pane only. Without this guard the legacy
+            // renderTree path (called for the `live` bucket when ≥2
+            // in-session NDJSONs exist) would mutate location.hash to an
+            // in-session-* value, polluting the URL and the rail's active
+            // highlight even though the hashchange handler now blocks
+            // bottom-pane SSE pinning.
+            if (isInSession(node)) return;
             if (node.spawnId === currentId) return;
             location.hash = node.spawnId;
           });
@@ -822,9 +929,14 @@
       function maybeAutoFollow(spawns) {
         if (!autoFollowEl.checked) return;
         const currentId = (location.hash || '').slice(1) || spawnId;
+        // M48 — auto-follow drives the BOTTOM pane (selected-spawn). The
+        // top pane is owned by /api/main-session and shows in-session-*
+        // entries automatically. Excluding them here prevents the auto-
+        // follow loop from also pinning them into the bottom pane.
         // Most recent running spawn by startedAt (descending).
         const running = spawns
           .filter((s) => s.status === 'running')
+          .filter((s) => !(typeof s.spawnId === 'string' && s.spawnId.indexOf('in-session-') === 0))
           .sort((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0));
         if (!running.length) return;
         const latest = running[0];
@@ -894,6 +1006,12 @@
         });
         el.appendChild(dot); el.appendChild(name); el.appendChild(kill);
         el.addEventListener('click', () => {
+          // M48 — in-session conversation entries belong in the TOP pane only.
+          // The top pane is wired to /api/main-session and streams the
+          // current orchestrator session. Routing them through location.hash
+          // would also load them into the bottom pane (the SELECTED-SPAWN
+          // pane), making both panes show identical content.
+          if (isInSession) return;
           if (node.spawnId === currentId) return;
           _ssSet(SS_KEY_SELECTED, node.spawnId);
           location.hash = node.spawnId;
@@ -1102,14 +1220,15 @@
         src.onerror = () => { setStatus('error', 'disconnected'); setToolCostLive(false); };
         src.onmessage = (ev) => {
           if (!ev.data) return;
-          // Capture arrival time once per SSE message — every render call for
-          // this frame stamps the same wall-clock value, so the user can spot
-          // a stuck stream by adjacent identical/far-apart timestamps.
+          // Arrival time is the FALLBACK; we prefer the producer-side
+          // frame.ts so a 200-frame initial replay shows actual event
+          // times (spread out over minutes), not the same millisecond.
           const arrivedAt = new Date();
           try {
             const frame = JSON.parse(ev.data);
+            const renderAt = frameTs(frame, arrivedAt);
             // Bottom pane = default renderTarget = #stream.
-            renderFrame(frame, arrivedAt);
+            renderFrame(frame, renderAt);
             // M43 D6 — refresh tool-cost on turn-complete frames (debounced).
             // Various producers emit different turn-complete markers; accept
             // any of them.
@@ -1146,7 +1265,8 @@
             const arrivedAt = new Date();
             try {
               const frame = JSON.parse(ev.data);
-              renderFrame(frame, arrivedAt, mainStreamEl);
+              const renderAt = frameTs(frame, arrivedAt);
+              renderFrame(frame, renderAt, mainStreamEl);
             } catch {
               const prev = renderTarget; renderTarget = mainStreamEl;
               try { renderRaw(ev.data, arrivedAt); } finally { renderTarget = prev; }
@@ -1175,6 +1295,8 @@
 
       window.addEventListener('hashchange', () => {
         const id = (location.hash || '').slice(1);
+        // M48 — keep in-session-* ids out of the bottom pane (top pane only).
+        if (id && id.indexOf('in-session-') === 0) { return; }
         if (id) { connect(id); pollSpawns(); }
       });
 
@@ -1182,12 +1304,19 @@
       //   1. data-spawn-id non-empty → connect that (bookmark flow)
       //   2. else sessionStorage.selectedSpawnId → connect that
       //   3. else show empty state
+      // M48 — never seed the bottom pane with an in-session-* id; the top
+      // pane already owns the main session, and showing it in both panes
+      // is one of the regressions Bug 4 fixes.
       let initialBottomId = '';
       if (spawnId) {
         initialBottomId = spawnId;
       } else {
         initialBottomId = _ssGet(SS_KEY_SELECTED) || '';
       }
+      if (typeof initialBottomId === 'string' && initialBottomId.indexOf('in-session-') === 0) {
+        initialBottomId = '';
+        _ssSet(SS_KEY_SELECTED, '');
+      }
       if (initialBottomId && !location.hash) location.hash = initialBottomId;
       connect(initialBottomId);