@tekyzinc/gsd-t 3.20.11 → 3.20.13

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [3.20.13] - 2026-05-05
+
+### Fixed — visualizer: surface in-session NDJSONs when `.index.json` is empty
+
+The dashboard's `/transcripts` endpoint only read `.gsd-t/transcripts/.index.json` to populate the left-rail spawn list. The M45 D2 conversation-capture hook writes `in-session-{sessionId}.ndjson` directly to `transcripts/` but does NOT update the index — the index is owned by the spawn lifecycle, not the in-session hook. Result: the visualizer's left rail showed "no spawns yet" even when the in-session conversation was actively being captured to disk. Discovered when the M43 D1 + M45 D2 hooks were installed (v3.20.12) and the conversation NDJSONs were appearing on disk but invisible in the UI.
+
+**Changes:**
+- `scripts/gsd-t-dashboard-server.js`: new `listInSessionTranscripts(projectDir)` function scans `transcripts/` for `in-session-*.ndjson` files and returns spawn-shaped entries with `spawnId: in-session-{sessionId}`. Filenames are validated through `isValidSpawnId` for path-traversal safety. `handleTranscriptsList` merges these with the index entries (index takes precedence on dup `spawnId`). The viewer's existing `in-session-` prefix detection then applies the `💬 conversation` badge.
+- `test/dashboard-server.test.js`: 5 new regression tests covering the empty-dir case, missing-dir case, find/filter behavior, mixed file types, and malformed-filename rejection.
+
+**Migration:** existing dashboards picking up the new code will surface in-session conversations automatically on next refresh of `/transcripts`. No state migration needed; the index is read-only here.
+
+**Suite:** 2047/2047 pass.
+
+**Side cleanup:** killed 144 + 20 orphan `gsd-t-dashboard-server.js` processes (164 total) accumulated from prior detached spawns whose parents had exited and been reparented to launchd. 3 stale pidfiles cleaned. Per-project `transcripts/` directories pre-created in 15 GSD-T projects so the M45 D2 hook can write without first-run delay.
+
+## [3.20.12] - 2026-05-05
+
+### Fixed — install: auto-configure M43 D1 + M45 D2 in-session hooks
+
+`gsd-t install` did not deploy or wire up the M43 D1 token-usage hook (`gsd-t-in-session-usage-hook.js`) or the M45 D2 conversation-capture hook (`gsd-t-conversation-capture.js`), even though the global CLAUDE.md "In-Session Conversation Capture" section documented these as mandatory. Result: the dashboard's `/transcripts` left rail never showed `💬 conversation` entries for in-session orchestrator dialog (this conversation right now); discovered when the live chat feed showed "no spawns yet" while the project's `.gsd-t/transcripts/` was missing entirely.
+
+**Changes:**
+- `bin/gsd-t.js`: new `installInSessionHooks()` + `configureInSessionHooks()` functions copy `scripts/hooks/gsd-t-conversation-capture.js` and `scripts/hooks/gsd-t-in-session-usage-hook.js` to `~/.claude/scripts/hooks/`, then register them in `~/.claude/settings.json` on the right events:
+  - `gsd-t-conversation-capture.js` → SessionStart, UserPromptSubmit, Stop (PostToolUse stays opt-in via the `GSD_T_CAPTURE_TOOL_USES=1` env flag)
+  - `gsd-t-in-session-usage-hook.js` → Stop
+- New install heading **In-Session Hooks (Conversation Capture + Token Usage)** runs in the install pipeline immediately after Auto-Route.
+- `test/filesystem.test.js`: bumped command-count assertions (54 → 55, utility 5 → 6) for the `cpua.md` command added in this session.
+
+**Migration:** existing installs pick up the wiring on next `gsd-t update-all` or `gsd-t install` run. The configure step is idempotent; re-running is safe. Suite: 2042/2042 pass.
+
+**Why this matters:** the conversation-capture hook is the only thing that lets you scroll back through your visualizer's `/transcripts` view and see chat with Claude in this session — without it, the dashboard's left rail is permanently empty for the in-session conversation. The token-usage hook records per-turn cost so the meter and economics dashboards have real data.
+
 ## [3.20.11] - 2026-05-05
 
 ### Fixed — install: ship `gsd-t-token-capture.cjs` to every project

package/bin/gsd-t.js

@@ -936,6 +936,106 @@ function configureAutoRouteHook(scriptPath) {
   }
 }
 
+// ─── In-Session Hooks (M43 D1 token usage + M45 D2 conversation capture) ────
+
+const HOOKS_DIR = path.join(SCRIPTS_DIR, "hooks");
+const PKG_HOOKS = path.join(PKG_SCRIPTS, "hooks");
+
+// Each entry: { script, events, async } — `events` is the array of hook event
+// names this script must be wired into. The `gsd-t-conversation-capture.js`
+// hook runs on SessionStart, UserPromptSubmit, and Stop (per the global
+// CLAUDE.md M45 D2 install block — PostToolUse stays opt-in via the
+// GSD_T_CAPTURE_TOOL_USES env flag, so we don't auto-register it).
+// `gsd-t-in-session-usage-hook.js` runs on Stop (per M43 D1 contract).
+const IN_SESSION_HOOKS = [
+  {
+    script: "gsd-t-conversation-capture.js",
+    events: ["SessionStart", "UserPromptSubmit", "Stop"],
+    async: true,
+  },
+  {
+    script: "gsd-t-in-session-usage-hook.js",
+    events: ["Stop"],
+    async: true,
+  },
+];
+
+function installInSessionHooks() {
+  ensureDir(SCRIPTS_DIR);
+  ensureDir(HOOKS_DIR);
+
+  if (!fs.existsSync(PKG_HOOKS)) {
+    info("No scripts/hooks/ in package — skipping in-session hooks");
+    return;
+  }
+
+  // Copy each script into ~/.claude/scripts/hooks/
+  for (const hook of IN_SESSION_HOOKS) {
+    const src = path.join(PKG_HOOKS, hook.script);
+    const dest = path.join(HOOKS_DIR, hook.script);
+    if (!fs.existsSync(src)) {
+      warn(`In-session hook source missing: ${hook.script} — skipping`);
+      continue;
+    }
+    const srcContent = fs.readFileSync(src, "utf8");
+    const destContent = fs.existsSync(dest) ? fs.readFileSync(dest, "utf8") : "";
+    if (normalizeEol(srcContent) !== normalizeEol(destContent)) {
+      copyFile(src, dest, `hooks/${hook.script}`);
+      try { fs.chmodSync(dest, 0o755); } catch {}
+    } else {
+      info(`In-session hook unchanged: ${hook.script}`);
+    }
+  }
+
+  configureInSessionHooks();
+}
+
+function configureInSessionHooks() {
+  const parsed = readSettingsJson();
+  if (parsed === null && fs.existsSync(SETTINGS_JSON)) {
+    warn("settings.json has invalid JSON — cannot configure in-session hooks");
+    return;
+  }
+  const settings = parsed || {};
+  if (!settings.hooks) settings.hooks = {};
+
+  let added = 0;
+  for (const hook of IN_SESSION_HOOKS) {
+    const scriptPath = path.join(HOOKS_DIR, hook.script);
+    const cmd = `node "${scriptPath.replace(/\\/g, "\\\\")}"`;
+
+    for (const event of hook.events) {
+      if (!settings.hooks[event]) settings.hooks[event] = [];
+      const already = settings.hooks[event].some((entry) =>
+        entry.hooks && entry.hooks.some((h) => h.command && h.command.includes(hook.script))
+      );
+      if (already) continue;
+      const hookEntry = { type: "command", command: cmd };
+      if (hook.async) hookEntry.async = true;
+      settings.hooks[event].push({
+        matcher: "",
+        hooks: [hookEntry],
+      });
+      added++;
+    }
+  }
+
+  if (added === 0) {
+    info("In-session hooks already configured");
+    return;
+  }
+  if (isSymlink(SETTINGS_JSON)) {
+    warn("Skipping settings.json write — target is a symlink");
+    return;
+  }
+  try {
+    fs.writeFileSync(SETTINGS_JSON, JSON.stringify(settings, null, 2));
+    success(`${added} in-session hook entr${added === 1 ? "y" : "ies"} configured in settings.json`);
+  } catch (e) {
+    warn(`Failed to write settings.json: ${e.message}`);
+  }
+}
+
 // ─── Figma MCP ──────────────────────────────────────────────────────────────
 
 const FIGMA_MCP_URL = "https://mcp.figma.com/mcp";
@@ -1321,6 +1421,9 @@ async function doInstall(opts = {}) {
   heading("Auto-Route (UserPromptSubmit)");
   installAutoRoute();
 
+  heading("In-Session Hooks (Conversation Capture + Token Usage)");
+  installInSessionHooks();
+
   heading("Figma MCP (Design-to-Code)");
   configureFigmaMcp();
 

package/commands/cpua.md

@@ -0,0 +1,155 @@
+# CPUA — Commit, Publish, Update All
+
+You are running the GSD-T release flow: commit pending in-tree changes, bump the version, publish to npm, tag the release, push to origin, and propagate to all registered projects.
+
+This is a **scoped release command** — only run in the GSD-T source repo (`/Users/david/projects/GSD-T` or whichever directory hosts `package.json` with `"name": "@tekyzinc/gsd-t"`). If invoked elsewhere, abort with a clear error.
+
+## Step 0: Verify scope
+
+```bash
+node -e "
+const pkg = require('./package.json');
+if (pkg.name !== '@tekyzinc/gsd-t') {
+  console.error('ERROR: /cpua must be run from the GSD-T source repo. Current dir is not @tekyzinc/gsd-t.');
+  process.exit(1);
+}
+console.log('Scope OK — releasing', pkg.name, 'v' + pkg.version);
+"
+```
+
+If this exits non-zero, stop and tell the user.
+
+## Step 1: Pre-flight checks
+
+Before staging anything:
+
+1. **Run the test suite.** A failing suite blocks the release. Show the result count.
+   ```bash
+   npm test 2>&1 | tail -10
+   ```
+2. **Show the pending changes** so the user can scan what's about to be committed:
+   ```bash
+   git status -s
+   git diff --stat
+   ```
+3. **Decide the version bump** based on the nature of changes (semver per `~/.claude/CLAUDE.md` § Versioning):
+   - **Patch** (`x.y.10` → `x.y.11`) — bug fix, doc fix, minor improvement
+   - **Minor** (`x.y.zz` → `x.(y+1).10`) — new feature, new capability, behavior addition
+   - **Major** (`x.y.zz` → `(x+1).0.10`) — breaking change, major rework
+   - Patch numbers always ≥ 10 (per the patch-2-digit convention).
+   
+   If the bump is ambiguous (e.g., the changes mix bug fix + new feature), ask the user which they want; default to the higher bump if the user doesn't answer immediately.
+
+4. **Stop if any of these are true:**
+   - Test suite has failures
+   - Working tree is clean (nothing to commit — tell user "nothing to release")
+   - Current branch is not `main` (warn user; ask before proceeding)
+   - There are unstaged changes outside the GSD-T scope (e.g., `.gsd-t/.unattended/run.log`, `.gsd-t/headless-*.log`, `.gsd-t/events/*.jsonl`) — these are runtime noise and should NOT be committed. Stage explicitly by file, never `git add -A`.
+
+## Step 2: Stage, version-bump, and update CHANGELOG + progress.md
+
+1. **Stage only relevant files explicitly** — `git add path1 path2 ...`. Never `git add -A` or `git add .` (would scoop up runtime logs).
+2. **Bump `package.json`** version to the new value.
+3. **Add a CHANGELOG entry** at the top, immediately under the header. Use this format:
+   ```markdown
+   ## [NEW_VERSION] - YYYY-MM-DD
+   
+   ### {Added|Fixed|Changed|Removed} — {one-line summary}
+   
+   {2-4 sentences explaining what + why. Bullet the file-level changes.}
+   
+   - `path/to/file`: {what changed}
+   - `path/to/test`: {regression test added if applicable}
+   
+   {migration note if any}
+   ```
+   Use the live system clock for the date — pull from `[GSD-T NOW]` or `node -e "console.log(new Date().toISOString().slice(0,10))"`. Never use `currentDate`.
+4. **Append a Decision Log entry** to `.gsd-t/progress.md` under `## Decision Log`. Format:
+   ```
+   - YYYY-MM-DD HH:MM: [tag] {summary} (vNEW_VERSION) — {what changed and why}.
+   ```
+   Tag is one of: `[fix]`, `[feature]`, `[refactor]`, `[docs]`, `[chore]`, `[release]`.
+5. **Update `.gsd-t/progress.md` header** — bump the `## Date:` to today and `## Version:` to NEW_VERSION.
+6. **Stage** the CHANGELOG and progress.md changes too.
+
+## Step 3: Commit
+
+```bash
+git commit -m "$(cat <<'EOF'
+{type}({scope}): {short summary} (v{NEW_VERSION})
+
+{2-3 sentences explaining the change and motivation.}
+
+- {file}: {change}
+- {file}: {change}
+
+Suite: N/N pass.
+
+Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
+EOF
+)"
+```
+
+`{type}` is `fix` | `feat` | `chore` | `docs` | `refactor` per the convention seen in `git log --oneline`. `{scope}` is a short module/area identifier (e.g., `install`, `banner`, `parallel`).
+
+## Step 4: Tag and push
+
+```bash
+git tag v{NEW_VERSION}
+git push origin main --tags
+```
+
+If push fails (auth, network, conflict), surface the error and stop — do NOT publish a version that's not in origin.
+
+## Step 5: Publish to npm
+
+```bash
+npm publish --access public 2>&1 | tail -10
+```
+
+Verify the output shows `+ @tekyzinc/gsd-t@{NEW_VERSION}`. If publish fails:
+- Auth issue → tell user to `npm login` and retry
+- Version already published → version bump was wrong; redo Step 2 with a higher version
+- Network → retry once, then surface the error
+
+## Step 6: Update global install + propagate to projects
+
+```bash
+npm install -g @tekyzinc/gsd-t@{NEW_VERSION}
+gsd-t update-all 2>&1 | tail -30
+```
+
+Use `npm install -g @tekyzinc/gsd-t@{NEW_VERSION}` (NOT `npm update -g`) — npm rejects update for some legacy version strings (e.g., `3.19.00` is invalid semver because of the leading-zero patch). Pinning to the exact version sidesteps this.
+
+## Step 7: Report
+
+Print a concise summary:
+
+```
+✅ CPUA complete — v{OLD} → v{NEW}
+
+  Commit:    {short_sha} {commit message subject}
+  Tag:       v{NEW}
+  Pushed:    origin/main + tags
+  npm:       @tekyzinc/gsd-t@{NEW} published
+  Global:    {old global version} → v{NEW}
+  Projects:  N updated, M already current
+
+Test suite: N/N pass — zero regressions.
+```
+
+If anything failed, surface the specific step + error and tell the user what to do next.
+
+## Behavior
+
+- **Always interactive on the version bump decision** — unless the user pre-specified the bump in `$ARGUMENTS` (e.g., `/cpua patch` or `/cpua minor`).
+- **Never `git add -A`** — explicitly stage by file. Runtime logs and event streams stay out.
+- **Never amend commits** — if anything goes wrong post-commit, create a new commit. (Per global CLAUDE.md.)
+- **Never skip Step 1 pre-flight** — a broken release worse than a delayed one.
+- **Always use the live system clock** for CHANGELOG and progress.md dates — `[GSD-T NOW]` or `node -e "..."`.
+
+$ARGUMENTS
+
+## Auto-Clear
+
+All work is committed and propagated. Execute `/clear` to free the context window for the next command.

package/package.json

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

@@ -176,9 +176,47 @@ function isValidSpawnId(id) {
   return typeof id === "string" && /^[a-zA-Z0-9._-]+$/.test(id) && id.length <= 200;
 }
 
+// M45 D2 follow-up: filesystem-walk fallback for in-session conversation NDJSONs.
+// The conversation-capture hook writes `in-session-{sessionId}.ndjson` directly
+// to `transcripts/`, but does NOT update `.index.json` (the index is owned by
+// the spawn lifecycle, not by the in-session hook). Without this scan, the
+// dashboard's left rail never shows in-session conversations even though the
+// NDJSONs are on disk. Synthesizes a spawn-shaped entry per in-session file
+// using filesystem timestamps; the viewer's `in-session-` prefix detection
+// then labels it as `💬 conversation`.
+function listInSessionTranscripts(projectDir) {
+  const dir = transcriptsDir(projectDir);
+  let files;
+  try { files = fs.readdirSync(dir); } catch { return []; }
+  const out = [];
+  for (const f of files) {
+    if (!f.startsWith("in-session-") || !f.endsWith(".ndjson")) continue;
+    const spawnId = f.slice(0, -".ndjson".length); // "in-session-{sessionId}"
+    if (!isValidSpawnId(spawnId)) continue;
+    let stat;
+    try { stat = fs.statSync(path.join(dir, f)); } catch { continue; }
+    out.push({
+      spawnId,
+      command: "in-session conversation",
+      startedAt: stat.birthtime ? stat.birthtime.toISOString() : stat.mtime.toISOString(),
+      lastUpdatedAt: stat.mtime.toISOString(),
+      status: "active", // best-effort; the viewer doesn't currently use this field
+      kind: "in-session",
+    });
+  }
+  return out;
+}
+
 function handleTranscriptsList(req, res, projectDir, transcriptHtmlPath) {
   const idx = readTranscriptsIndex(projectDir);
-  const sorted = idx.spawns
+
+  // Merge index entries with in-session NDJSONs from the filesystem.
+  // De-dupe by spawnId — index entries take precedence (richer metadata).
+  const known = new Set(idx.spawns.map((s) => s.spawnId));
+  const inSession = listInSessionTranscripts(projectDir).filter((s) => !known.has(s.spawnId));
+  const merged = idx.spawns.concat(inSession);
+
+  const sorted = merged
     .slice()
     .sort((a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0));
 
@@ -723,6 +761,7 @@ module.exports = {
   writeTranscriptsIndex,
   readIndexEntry,
   isValidSpawnId,
+  listInSessionTranscripts,
   handleTranscriptsList,
   handleTranscriptStream,
   handleTranscriptPage,