@tekyzinc/gsd-t 3.18.13 → 3.18.17

package/commands/gsd-t-quick.md

@@ -184,24 +184,20 @@ Proceed.
 node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-quick --step 3 --step-label "Execute" 2>/dev/null || true
 ```
 
-### Optional — Parallel Dispatch (M44, lightweight · conditional-only)
+### Parallel Dispatch (MANDATORY — single instrument)
 
-**This block is a no-op for the typical quick invocation.** `gsd-t-quick` is designed for single-focus work; forcing parallel on every quick invocation would add gate overhead without benefit.
+Delegate to `gsd-t parallel --command` — do NOT re-implement probe-and-branch logic here (M44 D9 Step 3: "create 1 instrument that accomplishes this instead of implementing it in all the commands").
 
-**Trigger conditions (BOTH must hold)**:
-1. `.gsd-t/domains/` contains more than one pending task, AND
-2. All three gates (D4 depgraph + D5 file-disjointness + D6 economics) pass for the candidate batch.
-
-**If either condition fails** — and that includes the common case of a single-task quick invocation — skip this block entirely. The sequential single-subagent path in Step 0.1 remains unchanged.
-
-**If BOTH conditions hold** — dispatch the ready batch via `gsd-t parallel` (mode auto-detected from `GSD_T_UNATTENDED=1`; do not hardcode `--mode`):
+```bash
+node bin/gsd-t.js parallel --command gsd-t-quick && exit 0 || true
+# Exit 0  → fan-out happened; detached children handle the work.
+# Exit 2+ → sequential (N<2 or quick is single-task — the common case).
+#           Fall through to the single-subagent path in Step 0.1.
+```
 
-- Fallback is silent — any gate veto drops the affected tasks back to the sequential quick path.
-- D2 owns the spawn observability; the parallel path writes the same `.gsd-t/events/YYYY-MM-DD.jsonl` records and `.gsd-t/token-log.md` rows via `captureSpawn`. D3 adds no new spawn machinery.
-- `[unattended]` — D2 enforces the zero-compaction contract by splitting tasks when D6 estimates > 60% per-worker CW.
-- `[in-session]` — NEVER interrupts the user with a pause/resume prompt. If headroom is tight, D2 reduces the worker count (floor N=1). No opt-out flag exists (consistent with M43 D4: `--in-session` / `--headless` were never shipped).
+`runDispatch` inside `bin/gsd-t-parallel.cjs` owns the probe + D4/D5/D6 gate math + disjoint task-id partitioning + `autoSpawnHeadless()` fan-out. Mode auto-detects from `GSD_T_UNATTENDED=1`. No user prompt. Parallel-when-safe + headless-when-possible are both the default (per headless-default-contract v2.0.0).
 
-Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0.
+Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0; `.gsd-t/contracts/headless-default-contract.md` v2.0.0.
 
 ### Deviation Rules
 

package/commands/gsd-t-unattended-watch.md

@@ -207,7 +207,64 @@ out('DOMAIN_SUMMARY', domainSummary.join(' | '));
 
 If `PID_FILE_EXISTS=false`:
 
-The supervisor has finalized cleanly and removed its own PID file. Read the final `state.json` status and iter, then print the terminal report:
+The supervisor has finalized cleanly and removed its own PID file.
+
+### Step 3a: Reconciliation probe
+
+Before emitting a report, check whether the supervisor's final `status` agrees with the on-disk milestone evidence. A `status=failed` with a **fresh matching milestone archive** is the M45-class false-failed-marker pathology: the worker completed the milestone (including the archive rename under `.gsd-t/milestones/`) but a polarity-unsound exit-code matcher mapped the worker's clean exit to `1`, which the supervisor then finalized as `status=failed`.
+
+```bash
+node -e "
+const fs = require('fs');
+const path = require('path');
+const state = JSON.parse(fs.readFileSync('.gsd-t/.unattended/state.json', 'utf8'));
+const milestone = (state.milestone || '').toLowerCase();
+let reconciled = false;
+if (state.status === 'failed' && milestone) {
+  // Look for a fresh archive directory matching the milestone slug.
+  // Pattern: .gsd-t/milestones/{slug}-YYYY-MM-DD where slug contains the
+  // milestone identifier (e.g. 'M45' → 'm45-conversation-stream-observability-2026-04-23').
+  try {
+    const archives = fs.readdirSync('.gsd-t/milestones')
+      .filter(n => n.toLowerCase().includes(milestone));
+    if (archives.length > 0) {
+      // Check the most recent archive's mtime is within the supervisor's run window.
+      const recent = archives
+        .map(n => ({ n, mtime: fs.statSync(path.join('.gsd-t/milestones', n)).mtimeMs }))
+        .sort((a, b) => b.mtime - a.mtime)[0];
+      const runStart = Date.parse(state.startedAt || 0);
+      if (recent && recent.mtime >= runStart) {
+        reconciled = true;
+        console.log('RECONCILED=true');
+        console.log('RECONCILED_ARCHIVE=' + recent.n);
+      }
+    }
+  } catch (_) {}
+}
+if (!reconciled) console.log('RECONCILED=false');
+"
+```
+
+### Step 3b: Render reconciled or raw report
+
+If `RECONCILED=true` AND `STATUS=failed`, the archive is the authority — render the reconciled success report:
+
+```
+✅  Unattended supervisor finalized — milestone completed (auto-reconciled).
+
+   Session:       {SESSION}
+   Milestone:     {MILESTONE} — archived as {RECONCILED_ARCHIVE}
+   Supervisor flag: status=failed (not trusted — archive present)
+   Iterations:    {ITER} / {MAX_ITER}
+   Total elapsed: {Hh Mm — formatted from ELAPSED_MS}
+   Log:           {LOG_PATH}
+   State:         .gsd-t/.unattended/state.json
+
+   Note: the worker completed the milestone, but a polarity-unsound exit-code
+   matcher mapped clean exit → failed. Treat the archive as the source of truth.
+```
+
+Otherwise (no reconciliation — `STATUS` is genuinely terminal `done`, `failed` without archive, or `stopped`), render the raw final report:
 
 ```
 ✅  Unattended supervisor finalized cleanly.

package/commands/gsd-t-visualize.md

@@ -55,49 +55,52 @@ If `.gsd-t/graph/index.json` exists, the dashboard can render entity-relationshi
 
 If `$ARGUMENTS` contains "stop", skip to **Step 5**. Otherwise continue to Step 3.
 
-## Step 3: Check if Server is Already Running
+## Step 3: Resolve Port + Check if Server is Already Running
+
+The dashboard server binds to a **per-project hashed port** in `[7433, 7532]` (see `projectScopedDefaultPort` in `gsd-t-dashboard-server.js`). Resolve it once and reuse:
 
-Run via Bash:
 ```bash
+PORT=$(node -e "console.log(require('$HOME/.claude/scripts/gsd-t-dashboard-server.js').resolvePort({ projectDir: process.cwd() }))")
 if [ -f .gsd-t/dashboard.pid ]; then
   PID=$(cat .gsd-t/dashboard.pid)
-  curl -sf http://localhost:7433/ping 2>/dev/null | grep -q '"ok"' && echo "SERVER_RUNNING=true" || echo "SERVER_RUNNING=false"
+  curl -sf http://localhost:$PORT/ping 2>/dev/null | grep -q '"ok"' && echo "SERVER_RUNNING=true" || echo "SERVER_RUNNING=false"
 else
   echo "SERVER_RUNNING=false"
 fi
 ```
 
-If output is `SERVER_RUNNING=true`, skip Step 3a and go directly to Step 4.
+If output is `SERVER_RUNNING=true`, skip Step 3a and go directly to Step 4. Carry `$PORT` forward to subsequent steps.
 
 ### Step 3a: Start Server if Not Running
 
-Run via Bash:
+Run via Bash (reuses `$PORT` from Step 3):
 ```bash
 node ~/.claude/scripts/gsd-t-dashboard-server.js --detach || true
 for i in 1 2 3 4 5; do
-  curl -sf http://localhost:7433/ping 2>/dev/null | grep -q '"ok"' && break
+  curl -sf http://localhost:$PORT/ping 2>/dev/null | grep -q '"ok"' && break
   sleep 1
 done
 ```
 
 ## Step 4: Open Browser
 
-Run via Bash:
+Run via Bash (reuses `$PORT` from Step 3):
 ```bash
-node -e "const {execFileSync}=require('child_process'); const url='http://localhost:7433'; try { if(process.platform==='win32'){execFileSync('cmd',['/c','start','',url],{stdio:'ignore'})}else{execFileSync(process.platform==='darwin'?'open':'xdg-open',[url],{stdio:'ignore'})} } catch(e) { console.error('Could not open browser:', e.message); }" || true
+URL="http://localhost:$PORT"
+node -e "const {execFileSync}=require('child_process'); const url=process.argv[1]; try { if(process.platform==='win32'){execFileSync('cmd',['/c','start','',url],{stdio:'ignore'})}else{execFileSync(process.platform==='darwin'?'open':'xdg-open',[url],{stdio:'ignore'})} } catch(e) { console.error('Could not open browser:', e.message); }" "$URL" || true
 ```
 
-Report to the user: "Dashboard is running at http://localhost:7433 — browser opened."
+Report to the user: "Dashboard is running at $URL — browser opened."
 
 ## Step 5: Stop Handler
 
-Run only when `$ARGUMENTS` contains "stop".
+Run only when `$ARGUMENTS` contains "stop". Resolves the same hashed port used at start:
 
-Run via Bash:
 ```bash
+PORT=$(node -e "console.log(require('$HOME/.claude/scripts/gsd-t-dashboard-server.js').resolvePort({ projectDir: process.cwd() }))")
 if [ -f .gsd-t/dashboard.pid ]; then
   PID=$(cat .gsd-t/dashboard.pid)
-  curl -sf http://localhost:7433/stop 2>/dev/null || kill $PID 2>/dev/null || true
+  curl -sf http://localhost:$PORT/stop 2>/dev/null || kill $PID 2>/dev/null || true
   rm -f .gsd-t/dashboard.pid
   echo "Dashboard server stopped"
 else

package/commands/gsd-t-wave.md

@@ -211,18 +211,9 @@ Spawn agent → `commands/gsd-t-impact.md`
 Spawn agent → `commands/gsd-t-execute.md`
 - This is the heaviest phase. The execute agent uses **task-level dispatch** (fresh-dispatch-contract.md): one Task subagent per task within each domain, each receiving only scope.md + relevant contracts + single task + graph context + up to 5 prior summaries. The execute agent handles domain task-dispatching and QA internally.
 
-##### Optional — Parallel Dispatch (M44)
+##### Parallel Dispatch (M44 D9, single instrument)
 
-The spawned execute agent will itself decide whether to dispatch parallel workers via `gsd-t parallel` (see `commands/gsd-t-execute.md` Step 3 → "Optional — Parallel Dispatch (M44)"). The wave orchestrator does not need to configure this — it is automatic:
-
-- If `.gsd-t/domains/` contains more than one pending task passing D4/D5/D6 gates, the execute agent dispatches via `gsd-t parallel` instead of sequentially.
-- Mode is auto-detected from `GSD_T_UNATTENDED=1` — the wave orchestrator inherits this env from its own spawn. Do not hardcode `--mode`.
-- Fallback is silent: any gate veto, unprovable disjointness, or single-task scope drops back to the sequential execute path without a user prompt.
-- D2 owns the spawn observability; the parallel path writes the same `.gsd-t/events/YYYY-MM-DD.jsonl` records and `.gsd-t/token-log.md` rows as the sequential path via `captureSpawn`. D3 adds no new spawn machinery.
-- `[unattended]` — D2 enforces the zero-compaction contract by splitting tasks when D6 estimates per-worker CW > 60%.
-- `[in-session]` — NEVER interrupts the user with pause/resume. If headroom is tight, D2 reduces the worker count (floor N=1) and emits `parallelism_reduced`.
-
-No wave-orchestrator-level flag exists to opt out; the parallel-vs-sequential decision is owned by the execute agent and the D2 gating math. Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0.
+The spawned execute agent delegates the parallel-vs-sequential decision to the single instrument `gsd-t parallel --command gsd-t-execute` (see `commands/gsd-t-execute.md` → "Parallel Dispatch"). The wave orchestrator does not need to configure this — it is automatic, deterministic, and inherited via `GSD_T_UNATTENDED` env. Contract: `.gsd-t/contracts/wave-join-contract.md` v1.2.0 §Single Instrument.
 
 - **Adaptive replanning**: After each domain completes, the execute agent runs a replan check (per `adaptive-replan-contract.md`). If a completed domain's task summaries reveal new constraints (e.g., deprecated API, wrong column name, incompatible library), the execute agent checks remaining domains' `tasks.md` files for invalidated assumptions and revises them on disk before dispatching the next domain. Maximum 2 replan cycles per execute run — if exceeded, execution pauses for user input. All replan decisions are logged to the Decision Log in `progress.md`. The wave phase summary includes any replan actions taken.
 - **Team/parallel mode**: If the plan defines parallel domains (same wave), the execute agent dispatches each domain teammate with `isolation: "worktree"` (per worktree-isolation-contract.md). Each domain works in an isolated git worktree. After all domains complete, the execute agent runs the Sequential Merge Protocol: merge domain A → test → merge domain B → test. Per-domain rollback if tests fail. Worktrees are cleaned up after all merges complete.

package/docs/architecture.md

@@ -978,6 +978,72 @@ means in-flight.
 `test/m44-d8-dashboard-spawn-plans-endpoint.test.js`,
 `test/m44-d8-transcript-renderer-panel.test.js` — 36 tests total.
 
+## Parallelism Panel (M44 D9, v3.19.0+)
+
+Pure-observer readout answering two questions:
+
+> *Is the orchestrator actually fanning out, or serializing despite parallelism being available?*
+
+> *When this wave finishes, did it hit the parallelism factor D6 estimated?*
+
+Zero added LLM token cost — every number is derived from files the other
+M44 domains already write: D8 spawn-plan files, D4/D5/D6 event rows, and
+D7 `cw_id` columns in `.gsd-t/token-log.md`.
+
+**Module**: `bin/parallelism-report.cjs` —
+`computeParallelismMetrics({projectDir, wave?, now?})` returns the shape
+defined in `.gsd-t/contracts/parallelism-report-contract.md` v1.0.0.
+`buildFullReport(...)` returns a post-mortem markdown string with Summary,
+Per-spawn timeline, Per-gate decisions, Per-worker Gantt, Token cost, and
+Notes sections.
+
+**Data flow**:
+
+```
+  .gsd-t/spawns/*.json  ─┐                     (D8 writer)
+  .gsd-t/events/*.jsonl ─┼─▶  bin/parallelism-report.cjs
+  .gsd-t/domains/*/tasks.md ┤       │
+  .gsd-t/token-log.md   ─┘       (pure I/O — never writes, never spawns)
+                                    │
+                                    ▼
+                    scripts/gsd-t-dashboard-server.js
+                    (5s in-memory cache per wave param)
+                      ├── GET /api/parallelism           → JSON metrics
+                      ├── GET /api/parallelism/report    → markdown
+                      └── POST /api/unattended-stop      → writes sentinel
+                                    │
+                                    ▼
+                    scripts/gsd-t-transcript.html
+                    `<aside class="spawn-panel"> .parallelism-panel`
+                    polls /api/parallelism every 5s
+```
+
+**Color thresholds** (worst-of across five per-signal colors, from contract §color_state):
+
+| Signal | Green | Yellow | Red |
+|--------|-------|--------|-----|
+| activeWorkers / readyTasks | ≥80% | 50–80% | <50% AND >10 min since last spawn |
+| Gate veto rate (D4) | <10% | 10–30% | >30% |
+| parallelism_factor vs. D6 estimate | ≥80% | 50–80% | <50% |
+| Spawn age (any active worker) | <30 min | 30–45 min | >45 min |
+| Time since last `spawn_started` (when ready>0) | <5 min | 5–10 min | >10 min |
+
+Special: `color_state === "dimmed"` when no spawn-plan files exist (idle
+project) — never red.
+
+**Silent-fail invariant**: malformed spawn-plan JSON, corrupt JSONL event
+lines, missing `.gsd-t/domains/`, missing `.gsd-t/token-log.md` — every
+case logs a note to `metrics.notes` / Full Report `## Notes` and continues
+with partial data. Observer must never throw when watching a live system.
+
+**Contract**: `.gsd-t/contracts/parallelism-report-contract.md` v1.0.0.
+
+**Tests**: `test/m44-d9-parallelism.test.js` — 16 tests covering metric
+shape, parallelism_factor math (live 1-worker, 4-worker, mixed-duration,
+post-wave), color-state thresholds, silent-fail on malformed inputs, Full
+Report markdown sections, and `/api/parallelism*` endpoint shape + 5s
+cache behaviour.
+
 ## Planned Architecture Changes (M23-M24)
 
 **M23: Headless Mode**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.18.13",
+  "version": "3.18.17",
   "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-compact-detector.js

@@ -131,7 +131,20 @@ function writeRow(payload) {
 /**
  * Find the most-recently-modified .ndjson in <cwd>/.gsd-t/transcripts/.
  * Returns the absolute path, or null if none exists or the directory is absent.
+ *
+ * Target-selection rules (M45 D2):
+ * 1. Default: prefer the most-recently-modified SPAWN NDJSON (any file whose
+ *    basename does NOT start with `in-session-`).
+ * 2. Fallback: if no spawn NDJSON has been modified within the last
+ *    IN_SESSION_FALLBACK_MS (30s) AND a fresh `in-session-*.ndjson` exists,
+ *    target that file instead. Log the decision to stderr so regressions
+ *    are obvious during debugging.
+ * 3. Last resort: if only in-session NDJSONs exist, pick the newest one
+ *    (covers the edge case where a user triggers /compact during a pure
+ *    conversation session with no spawns in flight).
  */
+const IN_SESSION_FALLBACK_MS = 30 * 1000; // 30 seconds
+
 function findActiveTranscript(cwd) {
   const transcriptsDir = path.join(cwd, ".gsd-t", "transcripts");
   let entries;
@@ -143,21 +156,51 @@ function findActiveTranscript(cwd) {
   const ndjsons = entries.filter((e) => e.endsWith(".ndjson"));
   if (!ndjsons.length) return null;
 
-  let newest = null;
-  let newestMtime = -1;
+  let newestSpawn = null;
+  let newestSpawnMtime = -1;
+  let newestInSession = null;
+  let newestInSessionMtime = -1;
   for (const name of ndjsons) {
     const full = path.join(transcriptsDir, name);
+    let mtimeMs;
     try {
-      const stat = fs.statSync(full);
-      if (stat.mtimeMs > newestMtime) {
-        newestMtime = stat.mtimeMs;
-        newest = full;
+      mtimeMs = fs.statSync(full).mtimeMs;
+    } catch {
+      continue;
+    }
+    const isInSession = name.indexOf("in-session-") === 0;
+    if (isInSession) {
+      if (mtimeMs > newestInSessionMtime) {
+        newestInSessionMtime = mtimeMs;
+        newestInSession = full;
+      }
+    } else {
+      if (mtimeMs > newestSpawnMtime) {
+        newestSpawnMtime = mtimeMs;
+        newestSpawn = full;
       }
+    }
+  }
+
+  const now = Date.now();
+  const spawnFresh = newestSpawn != null && (now - newestSpawnMtime) < IN_SESSION_FALLBACK_MS;
+
+  if (spawnFresh) return newestSpawn;
+
+  if (newestInSession != null) {
+    try {
+      process.stderr.write(
+        "compact-detector: targeting " + path.basename(newestInSession) + " (fallback)\n"
+      );
     } catch {
-      // skip unreadable entries
+      // silent — stderr write must never break the hook
     }
+    return newestInSession;
   }
-  return newest;
+
+  // No fresh spawn, no in-session — fall back to the newest spawn (even if stale)
+  // so v1.0.0 behavior is preserved for legacy projects with no in-session file.
+  return newestSpawn;
 }
 
 /**

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

@@ -176,102 +176,37 @@ function isValidSpawnId(id) {
   return typeof id === "string" && /^[a-zA-Z0-9._-]+$/.test(id) && id.length <= 200;
 }
 
-function handleTranscriptsList(req, res, projectDir) {
+function handleTranscriptsList(req, res, projectDir, transcriptHtmlPath) {
   const idx = readTranscriptsIndex(projectDir);
   const sorted = idx.spawns
     .slice()
     .sort((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0));
 
   // Content negotiation: browser navigations send Accept: text/html, fetch()
-  // defaults to */*. We serve HTML only when the client explicitly asks for it,
-  // so the existing dashboard fetch (which expects JSON) stays unaffected.
+  // defaults to */*. For text/html we serve the viewer (same HTML as
+  // /transcript/:id) with an empty spawn-id placeholder — the viewer's left
+  // rail populates from /api/spawns-index and the main pane defers until the
+  // user clicks a spawn. Programmatic clients (fetch's default */* or explicit
+  // application/json) continue to get the JSON shape the dashboard JS already
+  // consumes.
   const accept = String(req.headers["accept"] || "");
-  if (accept.includes("text/html")) {
-    res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
-    res.end(renderTranscriptsHtml(sorted));
+  if (accept.includes("text/html") && transcriptHtmlPath) {
+    fs.readFile(transcriptHtmlPath, (err, data) => {
+      if (err) { res.writeHead(404); res.end("Transcript UI not found"); return; }
+      // Substitute the __SPAWN_ID__ placeholder with an empty string; the
+      // 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, "");
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end(html);
+    });
     return;
   }
   res.writeHead(200, { "Content-Type": "application/json" });
   res.end(JSON.stringify({ spawns: sorted }));
 }
 
-function renderTranscriptsHtml(spawns) {
-  const escape = (s) => String(s == null ? "" : s)
-    .replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-  const fmtDuration = (a, b) => {
-    const start = Date.parse(a); const end = Date.parse(b || "") || Date.now();
-    if (!Number.isFinite(start)) return "—";
-    const ms = Math.max(0, end - start);
-    const s = Math.floor(ms / 1000); const m = Math.floor(s / 60); const r = s % 60;
-    return m > 0 ? `${m}m ${r}s` : `${r}s`;
-  };
-  const fmtTime = (s) => { const d = new Date(s); return Number.isFinite(d.getTime()) ? d.toLocaleString() : "—"; };
-  const liveStatuses = new Set(["initializing", "running"]);
-  const isLive = (s) => liveStatuses.has(s);
-
-  const rows = spawns.map((s) => {
-    const live = isLive(s.status);
-    const statusBadge = `<span class="status status-${escape(s.status || 'unknown')}">${escape(s.status || 'unknown')}</span>`;
-    return `<tr class="${live ? 'row-live' : ''}">
-      <td><a href="/transcript/${encodeURIComponent(s.spawnId)}">${escape(s.spawnId)}</a></td>
-      <td>${escape(s.command || '—')}</td>
-      <td>${escape(s.description || '—')}</td>
-      <td>${statusBadge}</td>
-      <td>${escape(fmtTime(s.startedAt))}</td>
-      <td>${escape(fmtDuration(s.startedAt, s.endedAt))}</td>
-    </tr>`;
-  }).join("");
-
-  const empty = `<div class="empty">
-    <h2>No spawn transcripts yet</h2>
-    <p>Transcripts appear here as soon as the first agent spawns. Run any GSD-T command (for example <code>/gsd-t-quick</code>) to generate one.</p>
-    <p><a href="/">← Back to dashboard</a></p>
-  </div>`;
-
-  const table = spawns.length ? `<table>
-    <thead><tr><th>Spawn ID</th><th>Command</th><th>Description</th><th>Status</th><th>Started</th><th>Duration</th></tr></thead>
-    <tbody>${rows}</tbody>
-  </table>` : empty;
-
-  return `<!DOCTYPE html>
-<html lang="en"><head><meta charset="UTF-8"><title>GSD-T Transcripts</title>
-<style>
-:root{--bg:#0d1117;--surface:#161b22;--border:#30363d;--text:#e6edf3;--muted:#7d8590;
-  --green:#3fb950;--green-bg:#1a3a1e;--blue:#388bfd;--blue-bg:#1f3a5f;--yellow:#d29922;--red:#f85149;
-  --font:'SF Mono','Fira Code',Menlo,monospace;}
-*{box-sizing:border-box;margin:0;padding:0}
-body{background:var(--bg);color:var(--text);font-family:var(--font);font-size:13px;padding:20px;line-height:1.5}
-.hdr{display:flex;align-items:center;gap:12px;margin-bottom:18px;padding-bottom:12px;border-bottom:1px solid var(--border)}
-.logo{color:var(--blue);font-weight:bold;font-size:14px}
-.hright{margin-left:auto;color:var(--muted);font-size:11px}
-a{color:var(--blue);text-decoration:none}a:hover{text-decoration:underline}
-table{width:100%;border-collapse:collapse;background:var(--surface);border:1px solid var(--border);border-radius:6px;overflow:hidden}
-th,td{padding:8px 12px;text-align:left;border-bottom:1px solid var(--border);font-size:12px}
-th{background:#1c2128;color:var(--muted);text-transform:uppercase;font-size:10px;letter-spacing:0.5px}
-tbody tr:last-child td{border-bottom:none}
-tbody tr:hover{background:#1c2128}
-tr.row-live{background:var(--green-bg)}
-.status{display:inline-block;padding:2px 8px;border-radius:10px;font-size:10px;text-transform:uppercase;letter-spacing:0.5px;border:1px solid}
-.status-running,.status-initializing{background:var(--green-bg);color:var(--green);border-color:var(--green)}
-.status-done{background:var(--blue-bg);color:var(--blue);border-color:var(--blue)}
-.status-stopped{background:#2a2a2a;color:var(--muted);border-color:var(--border)}
-.status-failed,.status-crashed{background:#3a1a1a;color:var(--red);border-color:var(--red)}
-.status-unknown{color:var(--muted);border-color:var(--border)}
-.empty{text-align:center;padding:60px 20px;color:var(--muted);background:var(--surface);border:1px solid var(--border);border-radius:6px}
-.empty h2{color:var(--text);margin-bottom:12px;font-size:16px}
-.empty p{margin-bottom:8px}
-.empty code{background:#1c2128;padding:2px 6px;border-radius:3px;color:var(--green)}
-</style></head><body>
-<div class="hdr">
-  <span class="logo">GSD-T Transcripts</span>
-  <a href="/" style="font-size:11px">← Dashboard</a>
-  <span class="hright">${spawns.length} spawn${spawns.length === 1 ? '' : 's'}</span>
-</div>
-${table}
-</body></html>`;
-}
-
 function handleTranscriptPage(req, res, spawnId, transcriptHtmlPath) {
   if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
   fs.readFile(transcriptHtmlPath, (err, data) => {
@@ -578,6 +513,116 @@ function listActiveSpawnPlans(projectDir) {
   return listAllSpawnPlans(projectDir).filter((p) => p && p.endedAt == null);
 }
 
+// ── M44 D9 — Parallelism observability ──────────────────────────────────────
+// Additive endpoints powered by bin/parallelism-report.cjs (v1.0.0 contract).
+// Pure read-only observer; never writes, never spawns. 5-second per-response
+// cache so rapid panel polls don't hammer the filesystem.
+
+const PARALLELISM_CACHE_MS = 5000;
+const _parallelismCache = { metrics: { at: 0, body: null, wave: null }, report: new Map() };
+
+function _loadParallelismReporter() {
+  try {
+    // Resolve at call-time so tests that don't install the module don't break
+    // unrelated endpoints. Require is cached by Node after first success.
+    return require(path.join(__dirname, "..", "bin", "parallelism-report.cjs"));
+  } catch (err) {
+    return { _loadError: err && err.message || String(err) };
+  }
+}
+
+function handleParallelism(req, res, projectDir) {
+  const urlObj = req.url ? req.url.split("?") : ["", ""];
+  const qs = urlObj[1] || "";
+  const params = new URLSearchParams(qs);
+  const wave = params.get("wave") || null;
+  const now = Date.now();
+  const cache = _parallelismCache.metrics;
+  if (cache.body && cache.wave === wave && (now - cache.at) < PARALLELISM_CACHE_MS) {
+    res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*", "X-Cache": "hit" });
+    res.end(cache.body);
+    return;
+  }
+  const reporter = _loadParallelismReporter();
+  if (reporter._loadError) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "parallelism-report module unavailable", detail: reporter._loadError }));
+    return;
+  }
+  let metrics;
+  try {
+    metrics = reporter.computeParallelismMetrics({ projectDir, wave: wave || undefined });
+  } catch (err) {
+    // Contract says silent-fail; a thrown error here means contract regression.
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "computeParallelismMetrics threw", detail: err && err.message || String(err) }));
+    return;
+  }
+  const body = JSON.stringify(metrics);
+  cache.at = now;
+  cache.wave = wave;
+  cache.body = body;
+  res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*", "X-Cache": "miss" });
+  res.end(body);
+}
+
+function handleParallelismReport(req, res, projectDir) {
+  const urlObj = req.url ? req.url.split("?") : ["", ""];
+  const qs = urlObj[1] || "";
+  const params = new URLSearchParams(qs);
+  const wave = params.get("wave") || null;
+  const cacheKey = wave || "__all__";
+  const now = Date.now();
+  const cached = _parallelismCache.report.get(cacheKey);
+  if (cached && (now - cached.at) < PARALLELISM_CACHE_MS) {
+    res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Access-Control-Allow-Origin": "*", "X-Cache": "hit" });
+    res.end(cached.body);
+    return;
+  }
+  const reporter = _loadParallelismReporter();
+  if (reporter._loadError) {
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end("parallelism-report module unavailable: " + reporter._loadError);
+    return;
+  }
+  let md;
+  try {
+    md = reporter.buildFullReport({ projectDir, wave: wave || undefined });
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "text/plain" });
+    res.end("buildFullReport threw: " + (err && err.message || String(err)));
+    return;
+  }
+  _parallelismCache.report.set(cacheKey, { at: now, body: md });
+  res.writeHead(200, { "Content-Type": "text/markdown; charset=utf-8", "Access-Control-Allow-Origin": "*", "X-Cache": "miss" });
+  res.end(md);
+}
+
+// POST /api/unattended-stop — proxies to the existing stop-sentinel flow so
+// the transcript panel's "Stop Supervisor" button reuses the canonical
+// kill path. Writes `.gsd-t/.unattended/stop` sentinel; supervisor polls
+// it and self-exits. Contract reminder: D9 does NOT implement its own
+// stop logic, does NOT PID-kill.
+function handleUnattendedStop(req, res, projectDir) {
+  if (req.method !== "POST") {
+    res.writeHead(405, { "Content-Type": "application/json", "Allow": "POST" });
+    res.end(JSON.stringify({ error: "method not allowed" }));
+    return;
+  }
+  const stopDir = path.join(projectDir, ".gsd-t", ".unattended");
+  const stopFile = path.join(stopDir, "stop");
+  try {
+    fs.mkdirSync(stopDir, { recursive: true });
+    fs.writeFileSync(stopFile, new Date().toISOString() + "\n");
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "failed to write stop sentinel", detail: err && err.message || String(err) }));
+    return;
+  }
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ ok: true, sentinel: stopFile }));
+}
+
 function handleSpawnPlans(req, res, projectDir) {
   const plans = listActiveSpawnPlans(projectDir).sort((a, b) => {
     const ta = Date.parse(a.startedAt) || 0;
@@ -637,10 +682,15 @@ function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath)
     if (url === "/metrics") return handleMetrics(req, res, projDir);
     if (url === "/ping") return handlePing(req, res, port);
     if (url === "/stop") return handleStop(req, res, server);
-    if (url === "/transcripts") return handleTranscriptsList(req, res, projDir);
+    if (url === "/transcripts") return handleTranscriptsList(req, res, projDir, tHtmlPath);
     // 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);
+    // 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);
+    // M44 D9 — stop-supervisor proxy (POST only; reuses existing sentinel flow)
+    if (url === "/api/unattended-stop") return handleUnattendedStop(req, res, projDir);
     // POST /transcript/:spawnId/kill — SIGTERM the recorded workerPid
     const killMatch = url.match(/^\/transcript\/([^/]+)\/kill$/);
     if (killMatch && req.method === "POST") return handleTranscriptKill(req, res, decodeURIComponent(killMatch[1]), projDir);
@@ -674,7 +724,6 @@ module.exports = {
   readIndexEntry,
   isValidSpawnId,
   handleTranscriptsList,
-  renderTranscriptsHtml,
   handleTranscriptStream,
   handleTranscriptPage,
   handleTranscriptKill,
@@ -692,6 +741,10 @@ module.exports = {
   handleSpawnPlanUpdates,
   readSpawnPlanFile,
   spawnsDir,
+  // M44 D9 — parallelism observability
+  handleParallelism,
+  handleParallelismReport,
+  handleUnattendedStop,
 };
 
 if (require.main === module) {