@tekyzinc/gsd-t 3.18.13 → 3.19.0

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) {

package/scripts/gsd-t-transcript.html

@@ -45,6 +45,27 @@
     .spawn-panel .empty { color: var(--fg-xdim); font-style: italic; padding: 4px 0; font-size: 11px; }
     .spawn-panel .wave-group { border-top: 1px dashed var(--border); padding-top: 4px; margin-top: 4px; }
     .spawn-panel .wave-group:first-child { border-top: none; padding-top: 0; margin-top: 0; }
+    /* M44 D9 — parallelism panel (additive; scoped to its own class). */
+    .parallelism-panel { margin-top: 14px; border: 1px solid var(--border); border-radius: 4px; padding: 10px 12px; background: var(--bg); transition: border-color 200ms ease; }
+    .parallelism-panel.color-green { border-color: #10b981; }
+    .parallelism-panel.color-yellow { border-color: #f59e0b; }
+    .parallelism-panel.color-red { border-color: #ef4444; }
+    .parallelism-panel.color-dimmed { border-color: #374151; opacity: 0.5; }
+    .parallelism-panel h3 { margin: 0 0 6px 0; font-size: 11px; text-transform: uppercase; color: var(--fg-xdim); letter-spacing: 0.08em; display: flex; justify-content: space-between; align-items: baseline; }
+    .parallelism-panel h3 .pp-dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: currentColor; margin-right: 6px; vertical-align: middle; }
+    .parallelism-panel .pp-dot.dot-green { color: #10b981; }
+    .parallelism-panel .pp-dot.dot-yellow { color: #f59e0b; }
+    .parallelism-panel .pp-dot.dot-red { color: #ef4444; }
+    .parallelism-panel .pp-dot.dot-dimmed { color: #374151; }
+    .parallelism-panel .pp-row { display: flex; justify-content: space-between; font-size: 11px; padding: 2px 0; font-family: var(--mono); }
+    .parallelism-panel .pp-row .pp-k { color: var(--fg-xdim); }
+    .parallelism-panel .pp-row .pp-v { color: var(--fg); }
+    .parallelism-panel .pp-gates { margin-top: 6px; padding-top: 6px; border-top: 1px dashed var(--border); font-size: 11px; font-family: var(--mono); color: var(--fg-dim); }
+    .parallelism-panel .pp-gates span { margin-right: 8px; }
+    .parallelism-panel .pp-actions { display: flex; gap: 6px; margin-top: 8px; }
+    .parallelism-panel .pp-actions button { flex: 1; padding: 4px 8px; font-size: 11px; background: var(--bg-raised); color: var(--fg); border: 1px solid var(--border); border-radius: 3px; cursor: pointer; font-family: var(--sans); }
+    .parallelism-panel .pp-actions button:hover { border-color: var(--accent); }
+    .parallelism-panel .pp-actions button.danger:hover { border-color: #ef4444; color: #ef4444; }
     .spawn-panel .wave-label { font-size: 10px; color: var(--fg-xdim); font-family: var(--mono); text-transform: uppercase; letter-spacing: 0.05em; margin: 4px 0 2px 0; }
     aside h3 { margin: 0 12px 8px 12px; font-size: 11px; text-transform: uppercase; color: var(--fg-xdim); letter-spacing: 0.08em; }
     aside .tree { font-size: 13px; }
@@ -76,6 +97,10 @@
     aside .tool-row .tool-tokens { color: var(--fg-dim); flex: 0 0 auto; }
     aside .tool-empty { color: var(--fg-xdim); font-size: 11px; font-style: italic; }
     aside .tool-error { color: var(--yellow); font-size: 11px; font-style: italic; }
+    /* M45 D2 — in-session conversation left-rail badge */
+    aside .node.in-session .name { color: var(--yellow); }
+    aside .node.in-session.active .name { color: var(--accent-warm, var(--yellow)); }
+    aside .node .label-in-session { color: var(--yellow); margin-right: 4px; }
     @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.5; } }
     /* 10s attention-pulse for a freshly-arrived spawn — fires once when
        auto-follow snaps focus to a new session, then self-removes. */
@@ -170,6 +195,20 @@
       <div class="sec-totals" id="active-totals">—</div>
       <div id="active-tasks"><div class="empty">no active spawn plan</div></div>
     </section>
+    <!-- M44 D9 — parallelism panel (additive). Reads /api/parallelism every 5s.
+         Color border reflects color_state (green/yellow/red/dimmed). -->
+    <div class="parallelism-panel color-dimmed" id="parallelism-panel">
+      <h3><span><span class="pp-dot dot-dimmed" id="pp-dot"></span>Parallelism</span><span id="pp-mode" style="font-size:10px;color:var(--fg-xdim);">idle</span></h3>
+      <div class="pp-row"><span class="pp-k">active workers</span><span class="pp-v" id="pp-active">—</span></div>
+      <div class="pp-row"><span class="pp-k">ready tasks</span><span class="pp-v" id="pp-ready">—</span></div>
+      <div class="pp-row"><span class="pp-k">parallelism factor</span><span class="pp-v" id="pp-factor">—</span></div>
+      <div class="pp-row"><span class="pp-k">oldest spawn</span><span class="pp-v" id="pp-oldest">—</span></div>
+      <div class="pp-gates" id="pp-gates"><span>dep: —</span><span>disj: —</span><span>eco: —</span></div>
+      <div class="pp-actions">
+        <button id="pp-report-btn" title="Download full parallelism post-mortem for the current wave">📄 Full Report</button>
+        <button id="pp-stop-btn" class="danger" title="Write .gsd-t/.unattended/stop sentinel to halt an active supervisor">Stop Supervisor</button>
+      </div>
+    </div>
   </aside>
   <button class="jump-to-live" id="jump-btn">↓ Jump to live</button>
 
@@ -483,14 +522,33 @@
           return;
         }
         const currentId = (location.hash || '#').slice(1) || spawnId;
+        // M45 D2: in-session conversation NDJSONs are distinguished by the
+        // `in-session-` spawn-id prefix. The viewer labels them with
+        // `💬 conversation` instead of the default `▶ spawn`. This is a
+        // front-end-only discriminator — no server-side type field is
+        // required; the filename prefix (== spawn-id) is the contract.
+        function isInSession(node) {
+          return typeof node.spawnId === 'string' && node.spawnId.indexOf('in-session-') === 0;
+        }
         function render(node, depth) {
           const el = document.createElement('div');
           el.className = 'node ' + statusClass(node);
+          if (isInSession(node)) el.classList.add('in-session');
           if (node.spawnId === currentId) el.classList.add('active');
           el.style.paddingLeft = (12 + depth * 14) + 'px';
           const dot = document.createElement('span'); dot.className = 'dot';
           const name = document.createElement('span'); name.className = 'name';
-          name.textContent = (node.command || 'spawn') + ' · ' + node.spawnId.slice(-8);
+          if (isInSession(node)) {
+            const badge = document.createElement('span');
+            badge.className = 'label-in-session';
+            badge.textContent = '💬 conversation';
+            name.appendChild(badge);
+            const tail = document.createElement('span');
+            tail.textContent = ' · ' + node.spawnId.slice(-8);
+            name.appendChild(tail);
+          } else {
+            name.textContent = (node.command || 'spawn') + ' · ' + node.spawnId.slice(-8);
+          }
           name.title = (node.description || node.spawnId) + '\n' + (node.startedAt || '');
           const kill = document.createElement('button');
           kill.className = 'kill';
@@ -919,6 +977,99 @@
       subscribePlanUpdates();
       // Light poll every 10s as a safety net if SSE is disconnected.
       setInterval(fetchInitialPlans, 10000);
+
+      // ── M44 D9 — Parallelism panel ─────────────────────────────────────────
+      // Polls /api/parallelism every 5s. Color border reflects color_state.
+      // Full Report button fetches /api/parallelism/report and downloads the
+      // markdown. Stop Supervisor POSTs /api/unattended-stop (writes sentinel).
+      (function wireParallelismPanel() {
+        const panel = document.getElementById('parallelism-panel');
+        if (!panel) return;
+        const dot = document.getElementById('pp-dot');
+        const modeEl = document.getElementById('pp-mode');
+        const activeEl = document.getElementById('pp-active');
+        const readyEl = document.getElementById('pp-ready');
+        const factorEl = document.getElementById('pp-factor');
+        const oldestEl = document.getElementById('pp-oldest');
+        const gatesEl = document.getElementById('pp-gates');
+        const reportBtn = document.getElementById('pp-report-btn');
+        const stopBtn = document.getElementById('pp-stop-btn');
+
+        function fmtAge(s) {
+          if (s == null || !isFinite(s)) return '—';
+          if (s < 60) return s + 's';
+          const m = Math.floor(s / 60), rs = s % 60;
+          if (m < 60) return m + 'm ' + rs + 's';
+          const h = Math.floor(m / 60), rm = m % 60;
+          return h + 'h ' + rm + 'm';
+        }
+
+        function applyColor(state) {
+          const colors = ['color-green', 'color-yellow', 'color-red', 'color-dimmed'];
+          const dots = ['dot-green', 'dot-yellow', 'dot-red', 'dot-dimmed'];
+          for (const c of colors) panel.classList.remove(c);
+          for (const d of dots) dot.classList.remove(d);
+          const cls = 'color-' + (state || 'dimmed');
+          const dcls = 'dot-' + (state || 'dimmed');
+          panel.classList.add(cls);
+          dot.classList.add(dcls);
+        }
+
+        function renderGates(g) {
+          if (!g) { gatesEl.textContent = 'gates: —'; return; }
+          const dep = g.dep_gate_veto || { count: 0 };
+          const dis = g.disjointness_fallback || { count: 0 };
+          const eco = g.economics_decision || { count: 0 };
+          function tally(c) { return c === 0 ? '✓ 0' : (c <= 3 ? '⚠ ' + c : '❌ ' + c); }
+          gatesEl.innerHTML = '<span>dep: ' + tally(dep.count) + '</span>' +
+                              '<span>disj: ' + tally(dis.count) + '</span>' +
+                              '<span>eco: ' + eco.count + '</span>';
+        }
+
+        async function poll() {
+          try {
+            const r = await fetch('/api/parallelism');
+            if (!r.ok) return;
+            const m = await r.json();
+            applyColor(m.color_state);
+            modeEl.textContent = m.parallelism_factor_mode || 'idle';
+            activeEl.textContent = String(m.activeWorkers);
+            readyEl.textContent = String(m.readyTasks);
+            factorEl.textContent = (typeof m.parallelism_factor === 'number' ? m.parallelism_factor.toFixed(1) : '—') + '×';
+            const oldest = (m.activeSpawnAges_s && m.activeSpawnAges_s.length) ? m.activeSpawnAges_s[0] : null;
+            oldestEl.textContent = fmtAge(oldest);
+            renderGates(m.gate_decisions);
+          } catch { /* keep last state on transient failure */ }
+        }
+
+        async function downloadReport() {
+          try {
+            const r = await fetch('/api/parallelism/report');
+            if (!r.ok) return;
+            const md = await r.text();
+            const blob = new Blob([md], { type: 'text/markdown' });
+            const url = URL.createObjectURL(blob);
+            const a = document.createElement('a');
+            a.href = url;
+            a.download = 'parallelism-report-' + new Date().toISOString().slice(0, 19).replace(/:/g, '-') + '.md';
+            document.body.appendChild(a); a.click(); document.body.removeChild(a);
+            setTimeout(() => URL.revokeObjectURL(url), 1000);
+          } catch { /* swallow */ }
+        }
+
+        async function stopSupervisor() {
+          if (!confirm('Write .gsd-t/.unattended/stop sentinel? Active supervisor will exit on next poll.')) return;
+          try {
+            const r = await fetch('/api/unattended-stop', { method: 'POST' });
+            if (r.ok) { stopBtn.textContent = 'Stop sent ✓'; setTimeout(() => { stopBtn.textContent = 'Stop Supervisor'; }, 3000); }
+          } catch { /* swallow */ }
+        }
+
+        if (reportBtn) reportBtn.addEventListener('click', downloadReport);
+        if (stopBtn) stopBtn.addEventListener('click', stopSupervisor);
+        poll();
+        setInterval(poll, 5000);
+      })();
     })();
   </script>
 </body>

package/scripts/gsd-t-update-check.js

@@ -14,6 +14,15 @@ const CACHE_FILE = path.join(CLAUDE_DIR, ".gsd-t-update-check");
 const CHANGELOG = "https://github.com/Tekyz-Inc/get-stuff-done-teams/blob/main/CHANGELOG.md";
 const SEMVER_RE = /^\d+\.\d+\.\d+(-[a-zA-Z0-9.]+)?$/;
 
+// Local-time date stamp prefix for the version banner: "Tue: Mar 26, 2026,  "
+// The trailing two spaces are intentional — separates the date from the [GSD-T*] tag.
+function dateStamp(now = new Date()) {
+  const day = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"][now.getDay()];
+  const mon = ["Jan", "Feb", "Mar", "Apr", "May", "Jun",
+               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"][now.getMonth()];
+  return `${day}: ${mon} ${now.getDate()}, ${now.getFullYear()},  `;
+}
+
 function isNewer(a, b) {
   const ap = a.split(".").map(Number);
   const bp = b.split(".").map(Number);
@@ -47,9 +56,9 @@ function doAutoUpdate(latest, installed) {
     const updated = fs.existsSync(VERSION_FILE)
       ? fs.readFileSync(VERSION_FILE, "utf8").trim()
       : latest;
-    console.log(`[GSD-T AUTO-UPDATE] v${installed} → v${updated}. Changelog: ${CHANGELOG}`);
+    console.log(`${dateStamp()}[GSD-T AUTO-UPDATE] v${installed} → v${updated}. Changelog: ${CHANGELOG}`);
   } catch {
-    console.log(`[GSD-T UPDATE] v${installed} — update available (v${installed} → v${latest}). Auto-update failed — run manually: /gsd-t-version-update-all. Changelog: ${CHANGELOG}`);
+    console.log(`${dateStamp()}[GSD-T UPDATE] v${installed} — update available (v${installed} → v${latest}). Auto-update failed — run manually: /gsd-t-version-update-all. Changelog: ${CHANGELOG}`);
   }
 }
 
@@ -86,7 +95,7 @@ function run() {
   if (cached && cached.latest && isNewer(cached.latest, installed)) {
     doAutoUpdate(cached.latest, installed);
   } else {
-    console.log(`[GSD-T] v${installed} — up to date. Changelog: ${CHANGELOG}`);
+    console.log(`${dateStamp()}[GSD-T] v${installed} — CURRENT. Changelog: ${CHANGELOG}`);
   }
 }
 
@@ -95,4 +104,4 @@ if (require.main === module) {
   try { run(); } catch { /* graceful failure — don't block session start */ }
 }
 
-module.exports = { isNewer, fetchLatestVersion, doAutoUpdate, run };
+module.exports = { isNewer, fetchLatestVersion, doAutoUpdate, run, dateStamp };