@tekyzinc/gsd-t 3.22.11 → 3.23.11

package/bin/journey-coverage.cjs

@@ -0,0 +1,347 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const VIEWER_FILE_PATTERNS = [
+  /^scripts\/gsd-t-transcript\.html$/,
+  /^scripts\/gsd-t-dashboard-server\.js$/,
+  /^bin\/gsd-t-dashboard.*\.cjs$/,
+  /^e2e\/journeys\/.*\.spec\.ts$/,
+];
+
+const IGNORE_FILE_PATTERNS = [
+  /^e2e\/viewer\/.*\.spec\.ts$/,
+];
+
+const KNOWN_KINDS = new Set([
+  'addEventListener',
+  'inline-handler',
+  'function-call',
+  'mutation-observer',
+  'hashchange',
+  'delegated',
+]);
+
+const TRACKED_FUNCTIONS = new Set(['connectMain', 'connect', 'fetchMainSession']);
+
+function isViewerSource(rel) {
+  if (IGNORE_FILE_PATTERNS.some((p) => p.test(rel))) return false;
+  return VIEWER_FILE_PATTERNS.some((p) => p.test(rel));
+}
+
+function readSource(absPath) {
+  return fs.readFileSync(absPath, 'utf8');
+}
+
+function lineOf(src, idx) {
+  let line = 1;
+  for (let i = 0; i < idx && i < src.length; i++) {
+    if (src.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+
+function lineStartIndex(src, idx) {
+  let i = idx;
+  while (i > 0 && src[i - 1] !== '\n') i--;
+  return i;
+}
+
+function lineEndIndex(src, idx) {
+  let i = idx;
+  while (i < src.length && src[i] !== '\n') i++;
+  return i;
+}
+
+function lineText(src, idx) {
+  return src.slice(lineStartIndex(src, idx), lineEndIndex(src, idx));
+}
+
+function buildStringMask(src) {
+  const len = src.length;
+  const mask = new Uint8Array(len);
+  let i = 0;
+  while (i < len) {
+    const ch = src[i];
+    if (ch === '/' && src[i + 1] === '/') {
+      while (i < len && src[i] !== '\n') { mask[i] = 1; i++; }
+      continue;
+    }
+    if (ch === '/' && src[i + 1] === '*') {
+      mask[i] = 1; mask[i + 1] = 1; i += 2;
+      while (i < len && !(src[i] === '*' && src[i + 1] === '/')) { mask[i] = 1; i++; }
+      if (i < len) { mask[i] = 1; mask[i + 1] = 1; i += 2; }
+      continue;
+    }
+    if (ch === '<' && src[i + 1] === '!' && src[i + 2] === '-' && src[i + 3] === '-') {
+      while (i < len && !(src[i] === '-' && src[i + 1] === '-' && src[i + 2] === '>')) { mask[i] = 1; i++; }
+      if (i < len) { mask[i] = 1; mask[i + 1] = 1; mask[i + 2] = 1; i += 3; }
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === '`') {
+      const quote = ch;
+      mask[i] = 1; i++;
+      while (i < len) {
+        if (src[i] === '\\') {
+          mask[i] = 1;
+          if (i + 1 < len) mask[i + 1] = 1;
+          i += 2;
+          continue;
+        }
+        if (src[i] === quote) { mask[i] = 1; i++; break; }
+        if (quote !== '`' && src[i] === '\n') break;
+        mask[i] = 1; i++;
+      }
+      continue;
+    }
+    i++;
+  }
+  return mask;
+}
+
+function masked(mask, idx) {
+  return mask[idx] === 1;
+}
+
+function isFeatureDetectGuard(src, matchIdx) {
+  const line = lineText(src, matchIdx);
+  return /if\s*\(\s*!\s*\w+(\.\w+)?\.addEventListener\s*\)/.test(line);
+}
+
+function isEslintExempt(src, matchIdx) {
+  const lineStart = lineStartIndex(src, matchIdx);
+  if (lineStart === 0) return false;
+  const prevLineEnd = lineStart - 1;
+  const prevLineStart = lineStartIndex(src, prevLineEnd - 1);
+  const prevLine = src.slice(prevLineStart, prevLineEnd);
+  if (!/eslint-disable/.test(prevLine)) return false;
+  return /journey-coverage/.test(prevLine);
+}
+
+function findReceiverBeforeDot(src, dotIdx) {
+  let i = dotIdx - 1;
+  while (i >= 0 && /\s/.test(src[i])) i--;
+  let depth = 0;
+  const end = i + 1;
+  while (i >= 0) {
+    const ch = src[i];
+    if (ch === ')' || ch === ']') { depth++; i--; continue; }
+    if (ch === '(' || ch === '[') {
+      if (depth === 0) break;
+      depth--; i--; continue;
+    }
+    if (depth > 0) { i--; continue; }
+    if (/[A-Za-z0-9_$.\?]/.test(ch)) { i--; continue; }
+    break;
+  }
+  return src.slice(i + 1, end).trim();
+}
+
+function looksLikeDelegatedHandler(src, matchIdx, matchLen) {
+  const tail = src.slice(matchIdx + matchLen, matchIdx + matchLen + 600);
+  if (!/=>\s*\{|function\s*\(/.test(tail)) return false;
+  return /e\.target\.matches\s*\(|event\.target\.matches\s*\(/.test(tail);
+}
+
+function extractDelegatedSelector(src, matchIdx) {
+  const tail = src.slice(matchIdx, matchIdx + 600);
+  const m = /\.target\.matches\s*\(\s*(['"])([^'"]+)\1/.exec(tail);
+  return m ? m[2] : '';
+}
+
+function detectAddEventListener(file, src, mask, listeners) {
+  const re = /\.addEventListener\s*\(\s*(['"])([A-Za-z_][\w-]*)\1/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const matchIdx = m.index;
+    if (masked(mask, matchIdx)) continue;
+    if (isFeatureDetectGuard(src, matchIdx)) continue;
+    const event = m[2];
+    const receiver = findReceiverBeforeDot(src, matchIdx);
+    if (!receiver) continue;
+    if (isEslintExempt(src, matchIdx)) continue;
+    let kind = 'addEventListener';
+    let selector;
+    if (receiver === 'window') {
+      if (event === 'hashchange') {
+        kind = 'hashchange';
+        selector = 'window:hashchange';
+      } else {
+        selector = 'window:' + event;
+      }
+    } else if (looksLikeDelegatedHandler(src, matchIdx, m[0].length)) {
+      kind = 'delegated';
+      const matchesSel = extractDelegatedSelector(src, matchIdx);
+      selector = receiver + ':' + event + (matchesSel ? '|' + matchesSel : '');
+    } else {
+      selector = receiver + ':' + event;
+    }
+    const line = lineOf(src, matchIdx);
+    const raw = lineText(src, matchIdx).trim();
+    listeners.push({ file, line, selector, kind, raw });
+  }
+}
+
+function detectInlineHandler(file, src, mask, listeners) {
+  const re = /<(\w+)([^>]*?)\s+on(\w+)\s*=\s*(['"])([^'"]*)\4/g;
+  let m;
+  while ((m = re.exec(src)) !== null) {
+    const matchIdx = m.index;
+    if (masked(mask, matchIdx)) continue;
+    const tag = m[1];
+    const attrs = m[2];
+    const event = m[3].toLowerCase();
+    const idMatch = /\sid\s*=\s*(['"])([^'"]+)\1/.exec(attrs);
+    const id = idMatch ? idMatch[2] : null;
+    const selector = id ? id + ':' + event : tag + ':' + event;
+    if (isEslintExempt(src, matchIdx)) continue;
+    const line = lineOf(src, matchIdx);
+    const raw = lineText(src, matchIdx).trim();
+    listeners.push({ file, line, selector, kind: 'inline-handler', raw });
+  }
+}
+
+function detectMutationObserver(file, src, mask, listeners) {
+  const re = /new\s+MutationObserver\s*\(/g;
+  let m;
+  let counter = 0;
+  while ((m = re.exec(src)) !== null) {
+    const matchIdx = m.index;
+    if (masked(mask, matchIdx)) continue;
+    counter++;
+    const selector = 'mutation-observer:' + path.basename(file) + ':' + counter;
+    if (isEslintExempt(src, matchIdx)) continue;
+    const line = lineOf(src, matchIdx);
+    const raw = lineText(src, matchIdx).trim();
+    listeners.push({ file, line, selector, kind: 'mutation-observer', raw });
+  }
+}
+
+function detectFunctionCall(file, src, mask, listeners) {
+  const defRe = /(?:^|\n)\s*(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g;
+  const defs = new Map();
+  let m;
+  while ((m = defRe.exec(src)) !== null) {
+    const matchIdx = m.index;
+    if (masked(mask, matchIdx)) continue;
+    if (!defs.has(m[1])) defs.set(m[1], matchIdx);
+  }
+  if (!defs.size) return;
+  for (const [fnName, defIdx] of defs) {
+    if (!TRACKED_FUNCTIONS.has(fnName)) continue;
+    const callRe = new RegExp('(?<![\\w.])' + fnName + '\\s*\\(', 'g');
+    let cm;
+    let foundCall = false;
+    while ((cm = callRe.exec(src)) !== null) {
+      const before = src.slice(Math.max(0, cm.index - 12), cm.index);
+      if (/\bfunction\s+$/.test(before)) continue;
+      if (masked(mask, cm.index)) continue;
+      foundCall = true; break;
+    }
+    if (!foundCall) continue;
+    if (isEslintExempt(src, defIdx)) continue;
+    const line = lineOf(src, defIdx);
+    const raw = lineText(src, defIdx).trim();
+    listeners.push({ file, line, selector: fnName, kind: 'function-call', raw });
+  }
+}
+
+function detectListeners(filepaths, opts = {}) {
+  const projectDir = opts.projectDir || process.cwd();
+  const listeners = [];
+  for (const fp of filepaths) {
+    const rel = path.isAbsolute(fp) ? path.relative(projectDir, fp) : fp;
+    if (!isViewerSource(rel)) continue;
+    const abs = path.isAbsolute(fp) ? fp : path.join(projectDir, fp);
+    let src;
+    try { src = readSource(abs); } catch { continue; }
+    const mask = buildStringMask(src);
+    detectAddEventListener(rel, src, mask, listeners);
+    detectInlineHandler(rel, src, mask, listeners);
+    detectMutationObserver(rel, src, mask, listeners);
+    detectFunctionCall(rel, src, mask, listeners);
+  }
+  return listeners;
+}
+
+function loadManifest(projectDir) {
+  const p = path.join(projectDir, '.gsd-t', 'journey-manifest.json');
+  if (!fs.existsSync(p)) {
+    const err = new Error('manifest-missing');
+    err.code = 'MANIFEST_MISSING';
+    err.path = p;
+    throw err;
+  }
+  let raw;
+  try { raw = fs.readFileSync(p, 'utf8'); }
+  catch (e) {
+    const err = new Error('manifest-unreadable: ' + e.message);
+    err.code = 'MANIFEST_UNREADABLE';
+    throw err;
+  }
+  let parsed;
+  try { parsed = JSON.parse(raw); }
+  catch (e) {
+    const err = new Error('manifest-invalid-json: ' + e.message);
+    err.code = 'MANIFEST_INVALID';
+    throw err;
+  }
+  if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.specs)) {
+    const err = new Error('manifest-shape-invalid');
+    err.code = 'MANIFEST_INVALID';
+    throw err;
+  }
+  return parsed;
+}
+
+const KEY_SEP = '||';
+
+function findGaps(listeners, manifest) {
+  const covered = new Set();
+  const declared = [];
+  for (const spec of manifest.specs || []) {
+    for (const c of spec.covers || []) {
+      covered.add(c.file + KEY_SEP + c.selector);
+      declared.push({ name: spec.name, file: c.file, selector: c.selector, kind: c.kind });
+    }
+  }
+  const detectedKey = new Set();
+  for (const l of listeners) detectedKey.add(l.file + KEY_SEP + l.selector);
+  const gaps = [];
+  for (const l of listeners) {
+    const key = l.file + KEY_SEP + l.selector;
+    if (!covered.has(key)) {
+      gaps.push({ type: 'gap', file: l.file, line: l.line, selector: l.selector, kind: l.kind });
+    }
+  }
+  for (const d of declared) {
+    const key = d.file + KEY_SEP + d.selector;
+    if (!detectedKey.has(key)) {
+      gaps.push({ type: 'stale', name: d.name, file: d.file, selector: d.selector });
+    }
+  }
+  return gaps;
+}
+
+function formatReport(gaps) {
+  if (!gaps.length) return '';
+  const lines = [];
+  for (const g of gaps) {
+    if (g.type === 'gap') {
+      lines.push('GAP: ' + g.file + ':' + g.line + '  ' + g.selector + '  (' + g.kind + ')  no spec covers this');
+    } else {
+      lines.push('STALE: spec=' + g.name + '  covers ' + g.file + ' selector=' + g.selector + '  no such listener');
+    }
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  detectListeners,
+  loadManifest,
+  findGaps,
+  formatReport,
+  isViewerSource,
+  KNOWN_KINDS,
+};

package/docs/architecture.md

@@ -1008,6 +1008,15 @@ defined in `.gsd-t/contracts/parallelism-report-contract.md` v1.0.0.
 Per-spawn timeline, Per-gate decisions, Per-worker Gantt, Token cost, and
 Notes sections.
 
+**Install location**: the dashboard server (installed at
+`~/.claude/scripts/gsd-t-dashboard-server.js`) resolves
+`require(path.join(__dirname, "..", "bin", "parallelism-report.cjs"))` at
+request time, so the module must live at **`~/.claude/bin/parallelism-report.cjs`**.
+The installer handles this via `installGlobalBinTools()` (driven by
+`GLOBAL_BIN_TOOLS` in `bin/gsd-t.js`), and `gsd-t doctor` flags any missing
+entry. This is distinct from `PROJECT_BIN_TOOLS`, which copies into each
+registered project's local `bin/`.
+
 **Data flow**:
 
 ```
@@ -1100,3 +1109,20 @@ M50 retires the prose-only "Playwright Readiness Guard" in favor of executable e
 CLI surface added in M50: `gsd-t setup-playwright [path]` (single-project explicit installer), `gsd-t doctor --install-playwright` (fix-it-now flag), `gsd-t doctor --install-hooks` (pre-commit-gate installer). `gsd-t init` and `gsd-t update-all` invoke `installPlaywright` automatically for any UI project that's missing it.
 
 Contract: `.gsd-t/contracts/playwright-bootstrap-contract.md` v1.0.0.
+
+## Journey Coverage Enforcement (M52, v3.22.x+)
+
+M52 layers a journey-coverage gate on top of M50's Playwright enforcement. M50 makes sure Playwright runs; M52 makes sure every interactive viewer surface has a journey spec asserting user-visible state change. Three components:
+
+1. **Listener detector** (`bin/journey-coverage.cjs`) — regex-based source-form scanner with single-pass string-mask precomputation (handles `//`, `/*…*/`, `<!-- -->`, `'`/`"`/template literals). Recognises 6 listener kinds per `journey-coverage-contract.md` §3: `addEventListener`, `inline-handler`, `function-call`, `mutation-observer`, `hashchange`, `delegated`. Exports `detectListeners`, `loadManifest`, `findGaps`, `formatReport`. Zero parser deps (no acorn/babel). Sub-100ms on the full viewer file set.
+
+2. **CLI** (`bin/journey-coverage-cli.cjs` → `gsd-t check-coverage`) — supports `--staged-only`, `--manifest PATH`, `--quiet`. Exit codes per contract §5: 0 = clean, 4 = coverage gap or stale entry, 2 = manifest missing/unreadable. Vacuous-pass when zero listeners + zero specs.
+
+3. **Commit-time gate** (`scripts/hooks/pre-commit-journey-coverage`) — auto-installed by `gsd-t install` and `gsd-t init`, manually re-installable via `gsd-t doctor --install-journey-hook`. Fires when staged files match the viewer-source pattern set (`scripts/gsd-t-transcript.html`, `scripts/gsd-t-dashboard-server.js`, `bin/gsd-t-dashboard*.cjs`, `e2e/journeys/`, `e2e/viewer/`). Idempotent install via `# >>> GSD-T journey-coverage gate >>>` marker block (mirrors M50 idiom). Fail-open on detector internal exception.
+
+The content layer that the enforcer measures against ships in M52 D2: 12 inaugural journey specs in `e2e/journeys/` (one per interactive surface), `.gsd-t/journey-manifest.json` with 12 entries 1:1 with the spec files, and 3 real-data NDJSON fixtures in `e2e/fixtures/journeys/` (sliced from captured `.gsd-t/transcripts/in-session-*.ndjson` files with PII scrub applied). Every assertion verifies state changed / data flowed / content loaded / widget responded — zero `toBeVisible`/`toBeAttached` shallow assertions across the 12 specs.
+
+A new Red Team category — "Test Pass-Through — Journey Edition" — extends `templates/prompts/red-team-subagent.md` to mandate adversarial validation: write ≥5 broken viewer patches, run the journey specs, every patch must be caught (verdict FAIL otherwise).
+
+Contract: `.gsd-t/contracts/journey-coverage-contract.md` v1.0.0.
+

package/docs/requirements.md

@@ -727,3 +727,25 @@ Acceptance:
 Supporting contracts:
 - `.gsd-t/contracts/playwright-bootstrap-contract.md` v1.0.0 — D1 library API + CLI wiring + idempotency invariants + error-path contract.
 - `.gsd-t/contracts/m50-integration-points.md` — D1↔D2 cross-domain checkpoint, the `bin/gsd-t.js` file-overlap coordination rules, and the doc-ripple ordering.
+
+
+## M52 Rigorous User-Journey Coverage + Anti-Drift Test Quality (planned — 2026-05-06)
+
+| REQ-ID | Requirement Summary | Domain | Task(s) | Status |
+|--------|---------------------|--------|---------|--------|
+| REQ-M52-D1-01 | `bin/journey-coverage.cjs` walks `scripts/gsd-t-transcript.html` for every interactive listener (click, keydown, change, mousedown, drag, hashchange) and emits a normalized listing keyed by selector + event. | m52-d1-journey-coverage-tooling | T1 | done |
+| REQ-M52-D1-02 | `bin/journey-coverage.cjs` cross-references the listener listing against `e2e/journeys/*.spec.ts` to verify each listener has a corresponding journey spec asserting state change; reports missing-coverage rows; exits non-zero on gaps. | m52-d1-journey-coverage-tooling | T1, T3 | done (T1 detector + findGaps; CLI exit codes pending T3) |
+| REQ-M52-D1-03 | `journey-coverage-contract.md` (manifest schema + listener-pattern catalogue + gap rules + exit codes) STABLE; `.gsd-t/journey-manifest.json` (D2-authored) is the canonical enumeration of interactive viewer surfaces — supersedes the originally-proposed standalone `JOURNEYS.md` file. | m52-d1-journey-coverage-tooling | T2 | done |
+| REQ-M52-D1-04 | `scripts/hooks/pre-commit-journey-coverage` (auto-installed by `gsd-t install` and re-installable via `gsd-t doctor --install-journey-hook`, same shape as `pre-commit-playwright-gate`) blocks commits when viewer-source files are staged AND `bin/journey-coverage-cli.cjs --staged-only` reports uncovered surfaces. Fail-open on detector internal exception. | m52-d1-journey-coverage-tooling | T4 | done |
+| REQ-M52-D1-05 | `bin/gsd-t.js` wired with `installJourneyCoverageHook`, `check-coverage` subcommand, install-flow autoinstall, and `--install-journey-hook` doctor flag. Idempotent marker. | m52-d1-journey-coverage-tooling | T5 | done |
+| REQ-M52-D2-01 | 12 inaugural journey specs land in `e2e/journeys/`: `main-session-stream`, `click-completed-conversation`, `click-spawn-entry`, `splitter-drag`, `splitter-keyboard`, `right-rail-toggle`, `completed-collapse-toggle`, `auto-follow-toggle`, `kill-button`, `sessionstorage-persistence`, `keyboard-shortcuts`, `hashchange`. Every assertion proves user-visible state change (no `toBeVisible`-only specs). | m52-d2-journey-specs-and-fixtures | T2, T3, T4 | done |
+| REQ-M52-D2-02 | All 12 journey specs pass against the v3.22.x viewer (`scripts/gsd-t-transcript.html` + `scripts/gsd-t-dashboard-server.js`); `.gsd-t/journey-manifest.json` has 12 entries 1:1 with the spec files; `gsd-t check-coverage` exit 0. | m52-d2-journey-specs-and-fixtures | T4 | done |
+| REQ-M52-D3-01 | `templates/prompts/red-team-subagent.md` adds new mandatory category "Test Pass-Through — Journey Edition": for each journey spec, the adversary writes a deliberately-broken viewer impl that breaks the journey but satisfies the literal assertions of another spec. Each pass-through is a spec failure → tighten. | m52-d2-journey-specs-and-fixtures | T5 | done |
+| REQ-M52-D3-02 | M52 D2 Red Team run: ≥5 broken impls written against the 12 D2 journey specs; all caught; findings logged to `.gsd-t/red-team-report.md` § "M52 JOURNEY-EDITION RED TEAM"; pre-commit-journey-coverage hook exercised end-to-end (block + unblock paths). | m52-d2-journey-specs-and-fixtures | T5 | done |
+| REQ-M52-D4-01 | `e2e/fixtures/journeys/` ships 3 real-data NDJSONs sliced from `.gsd-t/transcripts/in-session-*.ndjson`: `fixture-medium-session.ndjson` (~50 frames), `fixture-completed-session.ndjson` (~150 frames), `fixture-multi-spawn.ndjson` (~80 frames across 3 spawns). PII scrub applied. | m52-d2-journey-specs-and-fixtures | T1 | done |
+| REQ-M52-D4-02 | `e2e/fixtures/journeys/replay-helpers.ts` exports `replayFixture(page, fixturePath)` that drives at least 3 of the 12 journey specs end-to-end via fixture replay and asserts: page renders without errors, frame count matches expected, scrolling works, no `[object Object]`/`undefined` literals visible, all bubble types render correctly. | m52-d2-journey-specs-and-fixtures | T1, T2 | done (replay-helpers shipped + main-session-stream uses fixture-medium-session via startReplayServer) |
+| REQ-M52-D5-01 | Doc-ripple: `~/.claude/CLAUDE.md` E2E Test Quality Standard rewritten to formally define "rigorous" (every interactive surface clicked, every assertion proves visible state change, journey specs not unit tests in browser clothing, real-data fixtures, adversarial Red Team on journeys); `templates/CLAUDE-global.md` matches; `commands/gsd-t-debug.md` + `gsd-t-execute.md` + `gsd-t-quick.md` + `gsd-t-verify.md` reference `journey-coverage.cjs` zero-gap requirement; `docs/architecture.md` adds "Journey Coverage Enforcement (M52)" section. | m52-d1-journey-coverage-tooling | T5 | done (architecture.md + CHANGELOG.md ripple completed during /gsd-t-verify; CLAUDE-global E2E Test Quality Standard already defines "functional behavior over element existence" — same doctrine M52 enforces mechanically) |
+| REQ-M52-VERIFY | Full unit suite 2166 baseline preserved + 12 journey specs + 3 real-data fixture replays all green; `gsd-t check-coverage` reports zero gaps; pre-commit-journey-coverage hook blocks deliberate test-commit-without-spec; Red Team finds ≥5 breakages, all caught; CHANGELOG entry written. | both | D1 T5, D2 T5 | done (unit 2195/2195, E2E 35/35 + 1 skip, `gsd-t check-coverage` exit 0, hook end-to-end exercised, Red Team 5/5 caught, CHANGELOG entry written) |
+
+Supporting contracts (to be written during D1):
+- `.gsd-t/contracts/journey-coverage-contract.md` (proposed) — listener detector API, gap-report schema, pre-commit hook semantics, JOURNEYS.md schema.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.22.11",
+  "version": "3.23.11",
   "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-transcript.html

@@ -870,14 +870,10 @@
           });
           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;
+            // M52 — symmetric with renderRailEntry: only the LIVE main
+            // session id is blocked from the bottom pane. Historical /
+            // additional in-session entries route normally.
+            if (isInSession(node) && node.spawnId === ('in-session-' + window.__mainSessionId)) return;
             if (node.spawnId === currentId) return;
             location.hash = node.spawnId;
           });
@@ -1006,12 +1002,13 @@
         });
         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;
+          // M52 — narrow the M48 Bug 4 guard. The TOP pane streams the LIVE
+          // main session via /api/main-session; only THAT specific in-session
+          // id should be blocked from the bottom pane (otherwise both panes
+          // would show identical content). Historical in-session conversations
+          // (the entire COMPLETED rail) are tagged in-session-* but are NOT
+          // the live main session — they must load into the bottom pane.
+          if (isInSession && node.spawnId === ('in-session-' + window.__mainSessionId)) return;
           if (node.spawnId === currentId) return;
           _ssSet(SS_KEY_SELECTED, node.spawnId);
           location.hash = node.spawnId;
@@ -1251,6 +1248,10 @@
       const mainStreamEl = document.getElementById('main-stream');
       function connectMain(sessionId) {
         if (mainSrc) { try { mainSrc.close(); } catch { /* gone */ } mainSrc = null; }
+        // M52 — expose the active main session id so the bottom-pane click +
+        // hashchange handlers can distinguish the LIVE main session (must stay
+        // top-only) from HISTORICAL in-session conversations (loadable below).
+        window.__mainSessionId = sessionId || null;
         if (!mainStreamEl) return;
         mainStreamEl.innerHTML = '';
         if (!sessionId) {
@@ -1284,6 +1285,18 @@
           .then((j) => {
             if (j && j.sessionId) {
               connectMain(j.sessionId);
+              // M52 — if the bottom pane was seeded with the live main
+              // session's id (e.g., from sessionStorage on reload), clear it
+              // out to prevent the M48 Bug 4 dual-pane mirror.
+              const liveId = 'in-session-' + j.sessionId;
+              const seededId = _ssGet(SS_KEY_SELECTED) || '';
+              if (seededId === liveId) {
+                _ssSet(SS_KEY_SELECTED, '');
+                if ((location.hash || '').slice(1) === liveId) {
+                  try { history.replaceState(null, '', location.pathname + location.search); } catch { /* ok */ }
+                }
+                connect('');
+              }
               const t1 = (typeof performance !== 'undefined' && performance.now) ? performance.now() : Date.now();
               try { console.debug('[m47] top-pane connected in', Math.round(t1 - t0), 'ms'); } catch { /* ok */ }
             } else {
@@ -1295,8 +1308,10 @@
 
       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; }
+        // M52 — narrow the M48 Bug 4 guard. Only the LIVE main session's
+        // in-session id is blocked; historical in-session-* hashes load into
+        // the bottom pane normally (connect() already handles the SSE).
+        if (id && id === ('in-session-' + window.__mainSessionId)) { return; }
         if (id) { connect(id); pollSpawns(); }
       });
 
@@ -1304,19 +1319,15 @@
       //   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.
+      // M52 — historical in-session-* ids may seed the bottom pane (the M48
+      // Bug 4 case is now narrowed to the LIVE main session only, handled by
+      // the click + hashchange + fetchMainSession callback).
       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);