@tekyzinc/gsd-t 3.23.11 → 3.25.10

package/docs/workflow-diagram.md

@@ -0,0 +1,338 @@
+# GSD-T Workflow Diagram
+
+Visual reference for every GSD-T command and how they connect. Generated 2026-05-08, GSD-T v3.24.10.
+
+**Visual language** (consistent across all 6 diagrams):
+
+| Shape / Color | Role |
+|---|---|
+| 🟦 Blue rectangle | GSD-T command |
+| 🟪 Dashed purple rectangle | Auto-spawned subagent (qa, doc-ripple, debug-loop) |
+| 🟥 Red rectangle | Quality gate (Red Team, Design Verify) |
+| 🟧 Amber diamond | Decision point |
+| 🟫 Pink hexagon | Smart router (`/gsd`) |
+| ⬜ Oval | User input / output endpoint |
+| 🟨 Cylinder | File / artifact |
+| **Solid arrow** | Typical successor / auto-advance |
+| **Dashed arrow** | Optional or conditional path / spawn |
+
+The PNGs are rendered from D2 sources alongside each diagram. The Mermaid source is kept below each PNG as a fallback for environments that auto-render Mermaid (GitHub markdown).
+
+To regenerate after editing a `.d2` source:
+```sh
+cd docs/diagrams
+d2 --layout=elk --pad=40 NN-name.d2 NN-name.svg
+# Then convert to PNG via headless Chrome (D2's native PNG export needs Playwright)
+```
+
+---
+
+## 1. Top-Level Map — Entry Points → Lifecycle
+
+![Top-level map](diagrams/01-top-level-map-d2.png)
+
+```mermaid
+flowchart TD
+    USER([User input])
+
+    USER --> ROUTER{{"/gsd<br/>(smart router)"}}
+
+    ROUTER -->|"plain text<br/>(auto-route hook)"| ROUTER
+    ROUTER -->|continuation| RESUME["/gsd-t-resume"]
+    ROUTER -->|conversational| TALK["dialog-only<br/>no spawn"]
+    ROUTER -->|workflow| ENTRY{Entry kind?}
+
+    ENTRY -->|new greenfield| PROJ["/gsd-t-project"]
+    ENTRY -->|existing repo onboard| ISS["/gsd-t-init-scan-setup"]
+    ENTRY -->|new feature| FEAT["/gsd-t-feature"]
+    ENTRY -->|spec vs code| GAP["/gsd-t-gap-analysis"]
+    ENTRY -->|small task| QUICK["/gsd-t-quick"]
+    ENTRY -->|bug| DEBUG["/gsd-t-debug"]
+    ENTRY -->|design-to-code| DD["/gsd-t-design-decompose"]
+    ENTRY -->|backlog idea| BADD["/gsd-t-backlog-add"]
+    ENTRY -->|status check| STAT["/gsd-t-status"]
+
+    ISS --> INIT["/gsd-t-init"]
+    INIT --> SCAN["/gsd-t-scan"]
+    SCAN --> SETUP["/gsd-t-setup"]
+    SCAN -.->|techdebt found| PROMO["/gsd-t-promote-debt"]
+
+    PROJ --> MILE["/gsd-t-milestone"]
+    FEAT --> MILE
+    GAP -.->|gaps found| MILE
+    PROMO --> MILE
+    BADD --> BPROMO["/gsd-t-backlog-promote"]
+    BPROMO --> MILE
+    BPROMO -.->|small| QUICK
+    BPROMO -.->|bug| DEBUG
+
+    MILE --> WAVE_OR_MANUAL{Auto or manual?}
+    WAVE_OR_MANUAL -->|hands-off| WAVE["/gsd-t-wave<br/>(full cycle)"]
+    WAVE_OR_MANUAL -->|step-by-step| PART["/gsd-t-partition"]
+
+    DD --> DB["/gsd-t-design-build"]
+    DB --> DR["/gsd-t-design-review"]
+    DB -.-> DA["/gsd-t-design-audit"]
+
+    classDef entry fill:#e1f5ff,stroke:#0288d1
+    classDef milestone fill:#fff4e1,stroke:#f57c00
+    classDef router fill:#f3e5f5,stroke:#7b1fa2
+    class PROJ,ISS,FEAT,GAP,QUICK,DEBUG,DD,BADD,STAT entry
+    class MILE,WAVE,PART milestone
+    class ROUTER,ENTRY,WAVE_OR_MANUAL router
+```
+
+---
+
+## 2. Milestone Lifecycle — The Core Workflow
+
+This is the heart of GSD-T. Every milestone passes through these phases. `/gsd-t-wave` runs them all hands-off; manual mode advances one at a time.
+
+![Milestone lifecycle](diagrams/02-milestone-lifecycle-d2.png)
+
+```mermaid
+flowchart TD
+    MILE["/gsd-t-milestone<br/>define deliverable"]
+
+    MILE --> PART["/gsd-t-partition<br/>milestone → domains + contracts"]
+    PART -.->|complex| DISC["conversational mode<br/>(via /gsd)"]
+    DISC --> PLAN
+
+    PART --> PLAN["/gsd-t-plan<br/>atomic task lists per domain"]
+    PLAN -.->|risky| IMPACT["/gsd-t-impact<br/>downstream effect analysis"]
+    PLAN --> EXEC
+    IMPACT --> EXEC["/gsd-t-execute<br/>run tasks (solo or team)"]
+
+    EXEC -.->|after code| TS["/gsd-t-test-sync<br/>tests ↔ code"]
+    EXEC -.->|spawned| QA["/gsd-t-qa<br/>(subagent)"]
+    EXEC -.->|spawned| DR2["doc-ripple<br/>(subagent)"]
+    EXEC -.->|2 fails| DBGLOOP["headless --debug-loop"]
+
+    TS --> INTEG["/gsd-t-integrate<br/>wire domains together"]
+    INTEG --> VERIFY["/gsd-t-verify<br/>quality gates"]
+
+    VERIFY --> RT["Red Team<br/>adversarial QA"]
+    VERIFY --> DV["Design Verification<br/>(if design contract)"]
+
+    RT --> CM["/gsd-t-complete-milestone<br/>archive + git tag"]
+    DV --> CM
+
+    CM --> NEXT{More milestones?}
+    NEXT -->|yes| MILE
+    NEXT -->|no| DONE([Project complete])
+
+    classDef phase fill:#e8f5e9,stroke:#388e3c
+    classDef sub fill:#fff9c4,stroke:#f9a825
+    classDef gate fill:#ffebee,stroke:#c62828
+    class MILE,PART,PLAN,EXEC,TS,INTEG,VERIFY,CM phase
+    class QA,DR2,DBGLOOP,RT,DV,DISC sub
+    class IMPACT,NEXT gate
+```
+
+---
+
+## 3. Wave Mode — Hands-Off Full Cycle
+
+`/gsd-t-wave` chains every phase automatically. This is what runs in unattended mode.
+
+![Wave mode](diagrams/03-wave-mode-d2.png)
+
+```mermaid
+flowchart LR
+    START([wave triggered]) --> P1[partition]
+    P1 --> P2[plan]
+    P2 --> P3[impact]
+    P3 --> P4[execute]
+    P4 --> P5[test-sync]
+    P5 --> P6[integrate]
+    P6 --> P7[verify]
+    P7 --> P8[complete-milestone]
+    P8 --> END([milestone shipped])
+
+    P4 -.spawned.-> SUB1[qa]
+    P4 -.spawned.-> SUB2[doc-ripple]
+    P4 -.parallel.-> PAR[parallel<br/>task dispatch]
+    P7 -.gates.-> GATE1[Red Team]
+    P7 -.gates.-> GATE2[Design Verify]
+
+    classDef phase fill:#e8f5e9,stroke:#388e3c
+    classDef sub fill:#fff9c4,stroke:#f9a825
+    class P1,P2,P3,P4,P5,P6,P7,P8 phase
+    class SUB1,SUB2,PAR,GATE1,GATE2 sub
+```
+
+---
+
+## 4. Design-to-Code Pipeline
+
+Triggered when user provides a Figma URL, screenshots, or "build from this design".
+
+![Design-to-code pipeline](diagrams/04-design-to-code-d2.png)
+
+```mermaid
+flowchart TD
+    REQ([Design-to-code request])
+
+    REQ --> CHECK{Existing<br/>contracts?}
+    CHECK -->|"start over"| CLEAN[clean UI assets<br/>inline]
+    CHECK -->|none| DD
+    CHECK -->|present| DB
+
+    CLEAN --> DD["/gsd-t-design-decompose<br/>elements → widgets → pages"]
+
+    DD --> DDOUT[".gsd-t/contracts/design/<br/>elements/*.contract.md<br/>widgets/*.contract.md<br/>pages/*.contract.md<br/>INDEX.md"]
+
+    DDOUT --> DB["/gsd-t-design-build<br/>two-terminal review"]
+
+    DB --> T1[Term 1<br/>builder]
+    DB --> T2["/gsd-t-design-review<br/>Term 2 reviewer"]
+
+    T1 <-->|review loop| T2
+
+    T2 --> SHIP{All gates pass?}
+    SHIP -->|no| T1
+    SHIP -->|yes| DONE([UI shipped])
+
+    DONE -.optional.-> DA["/gsd-t-design-audit<br/>compare built vs Figma"]
+
+    classDef pipe fill:#e1f5ff,stroke:#0288d1
+    classDef art fill:#f3e5f5,stroke:#7b1fa2
+    class DD,DB,T1,T2,DA,CLEAN pipe
+    class DDOUT art
+```
+
+---
+
+## 5. Backlog Subsystem
+
+Lightweight idea capture that feeds into the main workflow.
+
+![Backlog subsystem](diagrams/05-backlog-d2.png)
+
+```mermaid
+flowchart LR
+    IDEA([User has idea]) --> BADD["/gsd-t-backlog-add"]
+    BADD --> BL[".gsd-t/backlog.md"]
+
+    BL --> VIEW["/gsd-t-backlog-list<br/>filtered view"]
+    BL --> EDIT["/gsd-t-backlog-edit"]
+    BL --> MOVE["/gsd-t-backlog-move<br/>reorder priority"]
+    BL --> RM["/gsd-t-backlog-remove"]
+    BL --> PROMO["/gsd-t-backlog-promote"]
+
+    PROMO --> ROUTE{Classify}
+    ROUTE -->|big| MILE["/gsd-t-milestone"]
+    ROUTE -->|small| QUICK["/gsd-t-quick"]
+    ROUTE -->|bug| DEBUG["/gsd-t-debug"]
+    ROUTE -->|feature| FEAT["/gsd-t-feature"]
+
+    SETTINGS["/gsd-t-backlog-settings"] -.configures.-> BADD
+
+    classDef backlog fill:#fff3e0,stroke:#ef6c00
+    class BADD,VIEW,EDIT,MOVE,RM,PROMO,SETTINGS backlog
+```
+
+---
+
+## 6. Automation, Observability & Utilities
+
+Commands that operate alongside the main workflow rather than within it.
+
+![Automation and utilities](diagrams/06-automation-utilities-d2.png)
+
+```mermaid
+flowchart TD
+    subgraph UNATTENDED [Unattended supervision]
+        UN["/gsd-t-unattended<br/>detached supervisor"]
+        UNW["/gsd-t-unattended-watch<br/>live status (270s reschedule)"]
+        UNS["/gsd-t-unattended-stop<br/>graceful halt"]
+        UN -.feeds.-> UNW
+        UNS -.signals.-> UN
+    end
+
+    subgraph OBS [Observability]
+        VIZ["/gsd-t-visualize<br/>SSE + React Flow"]
+        MET["/gsd-t-metrics<br/>ELO + signal dist"]
+        STAT["/gsd-t-status<br/>cross-domain progress"]
+        HEALTH["/gsd-t-health<br/>validate .gsd-t/"]
+    end
+
+    subgraph SESSION [Session control]
+        RES["/gsd-t-resume"]
+        PAUSE["/gsd-t-pause"]
+        LOG["/gsd-t-log<br/>sync Decision Log"]
+    end
+
+    subgraph MAINT [Maintenance]
+        VU["/gsd-t-version-update"]
+        VUA["/gsd-t-version-update-all"]
+        GC["/gsd-t-global-change"]
+        TM["/gsd-t-triage-and-merge"]
+        POP["/gsd-t-populate<br/>docs from code"]
+    end
+
+    subgraph HEAD [Headless / CI]
+        HEX["headless exec"]
+        HQ["headless query"]
+        HDL["headless --debug-loop"]
+        PAR["parallel<br/>task dispatch"]
+    end
+
+    classDef u fill:#e3f2fd,stroke:#1565c0
+    classDef o fill:#f1f8e9,stroke:#558b2f
+    classDef s fill:#fce4ec,stroke:#ad1457
+    classDef m fill:#ede7f6,stroke:#4527a0
+    classDef h fill:#fff8e1,stroke:#ff6f00
+    class UN,UNW,UNS u
+    class VIZ,MET,STAT,HEALTH o
+    class RES,PAUSE,LOG s
+    class VU,VUA,GC,TM,POP m
+    class HEX,HQ,HDL,PAR h
+```
+
+---
+
+## 7. Phase Successor Table
+
+| Completed phase | Auto-advances to | Also available |
+|-----------------|------------------|----------------|
+| `project` / `feature` | `milestone` | — |
+| `init` / `init-scan-setup` | `scan` / `milestone` | `setup` |
+| `scan` | `promote-debt` | `milestone` |
+| `gap-analysis` | `milestone` | `feature` |
+| `milestone` | `partition` | `wave` (full auto) |
+| `partition` | `plan` | conversational mode (if complex) |
+| `plan` | `execute` | `impact` (if risky) |
+| `impact` | `execute` | — |
+| `execute` | `test-sync` | spawns `qa`, `doc-ripple` |
+| `test-sync` | `verify` | `integrate` (multi-domain) |
+| `integrate` | `verify` | — |
+| `verify` | `complete-milestone` (auto) | spawns Red Team + Design Verify |
+| `complete-milestone` | `status` / next milestone | — |
+| `design-decompose` | `design-build` | `partition` (if domains needed) |
+| `design-build` | (review loop with `design-review`) | `design-audit` |
+
+Standalone commands (no successor): `quick`, `debug`, `status`, `help`, `resume`, `pause`, `log`, `health`, `metrics`, `visualize`, all `backlog-*`, `version-update*`, `global-change`, `triage-and-merge`, `populate`, `unattended*`.
+
+---
+
+## 8. Auto-Spawned Subagents
+
+These never need manual invocation — they fire as part of code-producing phases:
+
+| Subagent | Spawned by | Purpose |
+|----------|------------|---------|
+| `qa` | partition, plan, execute, verify, quick, debug, integrate, complete-milestone | Test generation + gap reporting |
+| `doc-ripple` | execute, integrate, quick, debug, wave | Update downstream docs |
+| Red Team | verify (after QA passes) | Adversarial bug-finding |
+| Design Verification | execute Step 5.25, verify (when design contract exists) | Browser-based pixel comparison |
+| `headless --debug-loop` | execute, test-sync, verify, debug, wave (after 2 failed fix attempts) | Compaction-proof fix loop |
+| `parallel` | execute, wave, integrate, quick, debug (when >1 task passes gates) | Task-level parallel dispatch |
+
+---
+
+## 9. Source
+
+- Canonical command list: `commands/` directory
+- Per-command details: `/gsd-t-help {command}` or [commands/gsd-t-help.md](../commands/gsd-t-help.md)
+- Command summaries section in help file is the source of truth — this diagram is derived from it.

package/package.json

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

@@ -699,6 +699,184 @@ function handleParallelismReport(req, res, projectDir) {
   res.end(md);
 }
 
+// M54 D1 T3 — Live Activity endpoints (additive, read-only)
+// Contract: .gsd-t/contracts/live-activity-contract.md v1.0.0
+// Three endpoints: GET /api/live-activity (5s cache),
+//   GET /api/live-activity/<id>/tail (per-id 5s cache, path-traversal guard),
+//   GET /api/live-activity/<id>/stream (SSE, uncached, 15s heartbeat).
+
+const LIVE_ACTIVITY_CACHE_MS = 5000;
+const _liveActivityCache = { list: { at: 0, body: null }, tail: new Map() };
+
+function _loadLiveActivityReporter() {
+  try {
+    return require(path.join(__dirname, "..", "bin", "live-activity-report.cjs"));
+  } catch (err) {
+    return { _loadError: err && err.message || String(err) };
+  }
+}
+
+function isValidActivityId(id) {
+  if (typeof id !== "string") return false;
+  if (id.length === 0 || id.length > 256) return false;
+  if (id.indexOf("..") !== -1) return false;
+  if (id.indexOf("/") !== -1) return false;
+  if (id.indexOf("\\") !== -1) return false;
+  if (id.indexOf("\0") !== -1) return false;
+  return true;
+}
+
+function handleLiveActivity(req, res, projectDir) {
+  const now = Date.now();
+  const cache = _liveActivityCache.list;
+  if (cache.body && (now - cache.at) < LIVE_ACTIVITY_CACHE_MS) {
+    res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*", "Cache-Control": "no-store", "X-Cache": "hit" });
+    res.end(cache.body);
+    return;
+  }
+  const reporter = _loadLiveActivityReporter();
+  if (reporter._loadError) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "live-activity-report module unavailable", detail: reporter._loadError }));
+    return;
+  }
+  let result;
+  try {
+    result = reporter.computeLiveActivities({ projectDir });
+  } catch (err) {
+    // Contract regression — computeLiveActivities must never throw
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "computeLiveActivities threw", detail: err && err.message || String(err) }));
+    return;
+  }
+  const body = JSON.stringify(result);
+  cache.at = now;
+  cache.body = body;
+  res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*", "Cache-Control": "no-store", "X-Cache": "miss" });
+  res.end(body);
+}
+
+function handleLiveActivityTail(req, res, projectDir, id) {
+  if (!isValidActivityId(id)) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "invalid_id" }));
+    return;
+  }
+  const cacheKey = projectDir + "\0" + id;
+  const now = Date.now();
+  const cached = _liveActivityCache.tail.get(cacheKey);
+  if (cached && (now - cached.at) < LIVE_ACTIVITY_CACHE_MS) {
+    res.writeHead(cached.statusCode, cached.headers);
+    res.end(cached.body);
+    return;
+  }
+
+  // Find the activity to determine kind and tail path
+  const reporter = _loadLiveActivityReporter();
+  if (reporter._loadError) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "live-activity-report module unavailable" }));
+    return;
+  }
+  let result;
+  try {
+    result = reporter.computeLiveActivities({ projectDir });
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "computeLiveActivities threw", detail: err && err.message || String(err) }));
+    return;
+  }
+
+  const activity = result.activities.find((a) => a.id === id);
+  if (!activity) {
+    const notFound = { statusCode: 404, headers: { "Content-Type": "application/json", "Cache-Control": "no-store" }, body: JSON.stringify({ error: "not_found" }) };
+    _liveActivityCache.tail.set(cacheKey, Object.assign({ at: now }, notFound));
+    res.writeHead(404, notFound.headers);
+    res.end(notFound.body);
+    return;
+  }
+
+  // Read tail content by kind
+  let tailContent = "";
+  const kind = activity.kind;
+  if (kind === "bash" || kind === "spawn") {
+    // Last ~64 KB of process stdout — use _readFileTail pattern
+    // For bash: the log file path is not directly known without process inspection.
+    // Return a JSON snapshot of the activity as a fallback.
+    tailContent = JSON.stringify(activity, null, 2);
+  } else if (kind === "monitor") {
+    tailContent = JSON.stringify(activity, null, 2);
+  } else if (kind === "tool") {
+    tailContent = JSON.stringify(activity, null, 2);
+  } else {
+    tailContent = JSON.stringify(activity, null, 2);
+  }
+
+  const hit = { statusCode: 200, headers: { "Content-Type": "text/plain; charset=utf-8", "Cache-Control": "no-store", "Access-Control-Allow-Origin": "*" }, body: tailContent };
+  _liveActivityCache.tail.set(cacheKey, Object.assign({ at: now }, hit));
+  res.writeHead(200, hit.headers);
+  res.end(hit.body);
+}
+
+function handleLiveActivityStream(req, res, projectDir, id) {
+  if (!isValidActivityId(id)) {
+    res.writeHead(400, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "invalid_id" }));
+    return;
+  }
+  res.writeHead(200, Object.assign({}, SSE_HEADERS, { "Access-Control-Allow-Origin": "*", "Cache-Control": "no-store" }));
+
+  // Send an initial data frame
+  res.write("data: " + JSON.stringify({ id, status: "stream_opened" }) + "\n\n");
+
+  // Heartbeat every 15s
+  const heartbeat = setInterval(() => {
+    if (!res.writableEnded) {
+      res.write(": heartbeat\n\n");
+    }
+  }, KEEPALIVE_MS);
+
+  // Poll for activity presence; close stream when activity disappears
+  const reporter = _loadLiveActivityReporter();
+  const poll = setInterval(() => {
+    if (res.writableEnded) {
+      clearInterval(poll);
+      clearInterval(heartbeat);
+      return;
+    }
+    if (reporter._loadError) {
+      clearInterval(poll);
+      clearInterval(heartbeat);
+      res.write("data: " + JSON.stringify({ id, status: "reporter_unavailable" }) + "\n\n");
+      res.end();
+      return;
+    }
+    let result;
+    try {
+      result = reporter.computeLiveActivities({ projectDir });
+    } catch (_) {
+      return; // silent — will retry next tick
+    }
+    const still = result.activities.find((a) => a.id === id);
+    if (!still) {
+      clearInterval(poll);
+      clearInterval(heartbeat);
+      if (!res.writableEnded) {
+        res.write("data: " + JSON.stringify({ id, status: "activity_ended" }) + "\n\n");
+        res.end();
+      }
+      return;
+    }
+    // Emit a status frame
+    res.write("data: " + JSON.stringify({ id, durationMs: still.durationMs, alive: still.alive }) + "\n\n");
+  }, 1000);
+
+  req.on("close", () => {
+    clearInterval(poll);
+    clearInterval(heartbeat);
+  });
+}
+
 // 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
@@ -887,6 +1065,12 @@ function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath,
     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);
+    // M54 D1 T3 — live-activity endpoints (additive, read-only)
+    if (url === "/api/live-activity") return handleLiveActivity(req, res, projDir);
+    const laTailMatch = url.match(/^\/api\/live-activity\/([^/]+)\/tail$/);
+    if (laTailMatch) return handleLiveActivityTail(req, res, projDir, decodeURIComponent(laTailMatch[1]));
+    const laStreamMatch = url.match(/^\/api\/live-activity\/([^/]+)\/stream$/);
+    if (laStreamMatch) return handleLiveActivityStream(req, res, projDir, decodeURIComponent(laStreamMatch[1]));
     // 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);
@@ -959,6 +1143,12 @@ module.exports = {
   handleParallelism,
   handleParallelismReport,
   handleUnattendedStop,
+  // M54 D1 T3 — live-activity observability
+  handleLiveActivity,
+  handleLiveActivityTail,
+  handleLiveActivityStream,
+  isValidActivityId,
+  _liveActivityCache,
   // M49 — idle-TTL exports for tests
   _activityTracker,
   _wrapSseHandler,