@tekyzinc/gsd-t 3.16.12 → 3.18.11

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

@@ -222,6 +222,78 @@ function tailTranscriptFile(filePath, callback) {
   return () => fs.unwatchFile(filePath, processNewData);
 }
 
+// ── M43 D6 — per-spawn tool-cost + usage routes ────────────────────────────
+
+/**
+ * Load per-turn usage rows for a given spawn-id from
+ * `.gsd-t/metrics/token-usage.jsonl`.
+ *
+ * Rows emitted by M41/M43 include either `spawn_id` OR `session_id`. We match
+ * against both so the route works both for headless spawns (which tag rows
+ * with `spawn_id` at emit time) and in-session D1 captures (which tag with
+ * the session's `session_id`).
+ *
+ * @param {string} projectDir
+ * @param {string} spawnId
+ * @returns {Array<object>}
+ */
+function readSpawnUsageRows(projectDir, spawnId) {
+  const fp = path.join(projectDir, ".gsd-t", "metrics", "token-usage.jsonl");
+  if (!fs.existsSync(fp)) return [];
+  const lines = safeReadJsonl(fp);
+  return lines.filter((row) => {
+    if (!row || typeof row !== "object") return false;
+    return row.spawn_id === spawnId || row.session_id === spawnId;
+  });
+}
+
+function handleTranscriptUsage(req, res, spawnId, projectDir) {
+  if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
+  const rows = readSpawnUsageRows(projectDir, spawnId);
+  res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+  res.end(JSON.stringify({ spawn_id: spawnId, rows, generated_at: new Date().toISOString() }));
+}
+
+/**
+ * Proxy to D2's `aggregateByTool`. D2 is co-deployed in Wave 2 — if the
+ * library isn't on disk yet, we return HTTP 503 with a machine-readable
+ * body so the viewer panel can display "Tool attribution not yet available"
+ * without breaking.
+ */
+function handleTranscriptToolCost(req, res, spawnId, projectDir) {
+  if (!isValidSpawnId(spawnId)) { res.writeHead(400); res.end("Invalid spawn id"); return; }
+  let attribution;
+  try {
+    // TODO(D6→D2): remove the try/catch once D2 lands. Keep the call shape.
+    // eslint-disable-next-line global-require
+    attribution = require("../bin/gsd-t-tool-attribution.cjs");
+  } catch (_) {
+    res.writeHead(503, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+    res.end(JSON.stringify({ error: "tool-attribution library not yet available" }));
+    return;
+  }
+  const rows = readSpawnUsageRows(projectDir, spawnId);
+  let tools = [];
+  try {
+    if (typeof attribution.aggregateByTool !== "function") {
+      res.writeHead(503, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+      res.end(JSON.stringify({ error: "aggregateByTool not exported by tool-attribution library" }));
+      return;
+    }
+    tools = attribution.aggregateByTool(rows) || [];
+  } catch (err) {
+    res.writeHead(500, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+    res.end(JSON.stringify({ error: String(err && err.message ? err.message : err) }));
+    return;
+  }
+  res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+  res.end(JSON.stringify({
+    spawn_id: spawnId,
+    tools,
+    generated_at: new Date().toISOString(),
+  }));
+}
+
 // ── M42 D3 — kill per-spawn ────────────────────────────────────────────────
 
 function writeTranscriptsIndex(projectDir, idx) {
@@ -380,6 +452,94 @@ function handleTranscriptStream(req, res, spawnId, projectDir) {
   req.on("close", () => { clearInterval(timer); if (unwatchFile) unwatchFile(); });
 }
 
+// ── M44 D8 — spawn-plan endpoint + SSE channel ─────────────────────────────
+//
+// Additive; does not change existing endpoints or SSE streams. Reads plan
+// files atomically written by `bin/spawn-plan-writer.cjs` under
+// `.gsd-t/spawns/{spawnId}.json`. A plan is "active" when `endedAt === null`.
+// Contract: .gsd-t/contracts/spawn-plan-contract.md v1.0.0
+
+const SPAWNS_SUBDIR = path.join(".gsd-t", "spawns");
+
+function spawnsDir(projectDir) {
+  return path.join(projectDir, SPAWNS_SUBDIR);
+}
+
+function readSpawnPlanFile(fp) {
+  try {
+    const raw = fs.readFileSync(fp, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object") return null;
+    return parsed;
+  } catch { return null; }
+}
+
+function listAllSpawnPlans(projectDir) {
+  const dir = spawnsDir(projectDir);
+  if (!fs.existsSync(dir)) return [];
+  let files;
+  try { files = fs.readdirSync(dir).filter((f) => f.endsWith(".json")); } catch { return []; }
+  const out = [];
+  for (const f of files) {
+    const plan = readSpawnPlanFile(path.join(dir, f));
+    if (plan) out.push(plan);
+  }
+  return out;
+}
+
+function listActiveSpawnPlans(projectDir) {
+  return listAllSpawnPlans(projectDir).filter((p) => p && p.endedAt == null);
+}
+
+function handleSpawnPlans(req, res, projectDir) {
+  const plans = listActiveSpawnPlans(projectDir).sort((a, b) => {
+    const ta = Date.parse(a.startedAt) || 0;
+    const tb = Date.parse(b.startedAt) || 0;
+    return tb - ta;
+  });
+  res.writeHead(200, { "Content-Type": "application/json", "Access-Control-Allow-Origin": "*" });
+  res.end(JSON.stringify({ plans, generated_at: new Date().toISOString() }));
+}
+
+function handleSpawnPlanUpdates(req, res, projectDir) {
+  res.writeHead(200, SSE_HEADERS);
+  // Initial snapshot: every current active plan.
+  const initial = listActiveSpawnPlans(projectDir);
+  for (const plan of initial) {
+    try { res.write("data: " + JSON.stringify({ spawnId: plan.spawnId, plan }) + "\n\n"); } catch { /* gone */ }
+  }
+
+  const dir = spawnsDir(projectDir);
+  let dirWatcher = null;
+  const emittedCache = new Map(); // spawnId → last-mtime-ms, dedup rapid rename events
+
+  function pushChange(spawnId) {
+    if (!spawnId) return;
+    const fp = path.join(dir, spawnId + ".json");
+    let mtime = 0;
+    try { mtime = fs.statSync(fp).mtimeMs || 0; } catch { /* missing */ }
+    // Dedup rapid-fire rename events — only emit when mtime advances.
+    if (emittedCache.get(spawnId) === mtime && mtime > 0) return;
+    emittedCache.set(spawnId, mtime);
+    const plan = readSpawnPlanFile(fp);
+    if (!plan) return;
+    try { res.write("data: " + JSON.stringify({ spawnId, plan }) + "\n\n"); } catch { /* gone */ }
+  }
+
+  try {
+    if (fs.existsSync(dir)) {
+      dirWatcher = fs.watch(dir, (eventType, filename) => {
+        if (!filename || !filename.endsWith(".json")) return;
+        const spawnId = filename.slice(0, -5);
+        pushChange(spawnId);
+      });
+    }
+  } catch { /* dir may not exist yet; skip watch */ }
+
+  const timer = setInterval(() => { try { res.write(": keepalive\n\n"); } catch { clearInterval(timer); } }, KEEPALIVE_MS);
+  req.on("close", () => { clearInterval(timer); if (dirWatcher) { try { dirWatcher.close(); } catch { /* ok */ } } });
+}
+
 function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath) {
   const projDir = projectDir || path.resolve(eventsDir, "..", "..");
   const tHtmlPath = transcriptHtmlPath || path.join(path.dirname(htmlPath), "gsd-t-transcript.html");
@@ -391,9 +551,18 @@ function startServer(port, eventsDir, htmlPath, projectDir, transcriptHtmlPath)
     if (url === "/ping") return handlePing(req, res, port);
     if (url === "/stop") return handleStop(req, res, server);
     if (url === "/transcripts") return handleTranscriptsList(req, res, projDir);
+    // 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);
     // 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);
+    // M43 D6 — /transcript/:spawnId/tool-cost — D2 attribution proxy
+    const toolCostMatch = url.match(/^\/transcript\/([^/]+)\/tool-cost$/);
+    if (toolCostMatch) return handleTranscriptToolCost(req, res, decodeURIComponent(toolCostMatch[1]), projDir);
+    // M43 D6 — /transcript/:spawnId/usage — per-turn rows for this spawn
+    const usageMatch = url.match(/^\/transcript\/([^/]+)\/usage$/);
+    if (usageMatch) return handleTranscriptUsage(req, res, decodeURIComponent(usageMatch[1]), projDir);
     // /transcript/:spawnId/stream — SSE tail of per-spawn ndjson
     const streamMatch = url.match(/^\/transcript\/([^/]+)\/stream$/);
     if (streamMatch) return handleTranscriptStream(req, res, decodeURIComponent(streamMatch[1]), projDir);
@@ -421,10 +590,20 @@ module.exports = {
   handleTranscriptStream,
   handleTranscriptPage,
   handleTranscriptKill,
+  handleTranscriptToolCost,
+  handleTranscriptUsage,
+  readSpawnUsageRows,
   transcriptsDir,
   DEFAULT_PORT,
   projectScopedDefaultPort,
   resolvePort,
+  // M44 D8 — spawn-plan visibility
+  listAllSpawnPlans,
+  listActiveSpawnPlans,
+  handleSpawnPlans,
+  handleSpawnPlanUpdates,
+  readSpawnPlanFile,
+  spawnsDir,
 };
 
 if (require.main === module) {

package/scripts/gsd-t-heartbeat.js

@@ -19,7 +19,7 @@ const SAFE_SID = /^[a-zA-Z0-9_-]+$/; // Allowlist for session_id — blocks path
 const MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days — auto-cleanup threshold
 
 // ─── Exports (for testing) ───────────────────────────────────────────────────
-module.exports = { scrubSecrets, scrubUrl, buildEvent, summarize, shortPath, buildEventStreamEntry, appendToEventsFile };
+module.exports = { scrubSecrets, scrubUrl, buildEvent, summarize, shortPath, buildEventStreamEntry, appendToEventsFile, resolveTurnIdFromTranscript };
 
 // ─── Main (stdin processing) ─────────────────────────────────────────────────
 if (require.main === module) {
@@ -222,13 +222,61 @@ function buildEventStreamEntry(hook) {
       reasoning: null, outcome: null };
   }
   if (n === "PostToolUse") {
+    // M43 D2-fix: resolve turn_id (parent assistant message id) from the
+    // transcript via the tool_use_id lookup so downstream tool attribution
+    // can join on (session_id, turn_id) directly instead of the lossy
+    // timestamp-window heuristic. Fast (~0ms) in practice — the matching
+    // tool_use is always near the end of the transcript.
+    const tuid = hook.tool_use_id || null;
+    const turn_id = resolveTurnIdFromTranscript(hook.transcript_path, tuid);
     return { ...base, event_type: "tool_call",
       agent_id: hook.agent_id || hook.session_id || null, parent_agent_id: null,
-      reasoning: hook.tool_name || null, outcome: null };
+      reasoning: hook.tool_name || null, outcome: null,
+      turn_id: turn_id, tool_use_id: tuid };
   }
   return null;
 }
 
+// ─── Turn-id resolution ──────────────────────────────────────────────────────
+
+/**
+ * Given a transcript path and a tool_use_id, scan the transcript backward to
+ * find the assistant turn (message) that produced this tool_use, and return
+ * its message.id (the canonical turn_id used by per-turn token capture).
+ *
+ * Returns `null` on any failure — never throws. Hooks must not break on a
+ * missing/unreadable transcript.
+ *
+ * Performance note: real-world transcripts are a few MB and the matching
+ * tool_use is always the most recent one the LLM just emitted, so scanning
+ * from the tail finds the match in the first handful of lines (~0ms).
+ */
+function resolveTurnIdFromTranscript(transcriptPath, toolUseId) {
+  if (!transcriptPath || !toolUseId) return null;
+  try {
+    if (!fs.existsSync(transcriptPath)) return null;
+    const text = fs.readFileSync(transcriptPath, "utf8");
+    const lines = text.split("\n");
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i];
+      if (!line) continue;
+      // Cheap string prefilter — skip lines that can't possibly contain the id.
+      if (line.indexOf(toolUseId) === -1) continue;
+      try {
+        const j = JSON.parse(line);
+        if (j && j.type === "assistant" && j.message && Array.isArray(j.message.content)) {
+          for (const c of j.message.content) {
+            if (c && c.type === "tool_use" && c.id === toolUseId) {
+              return j.message.id || null;
+            }
+          }
+        }
+      } catch { /* malformed line — skip */ }
+    }
+  } catch { /* transcript unreadable — bail */ }
+  return null;
+}
+
 function appendToEventsFile(gsdtDir, entry) {
   try {
     const date = new Date().toISOString().slice(0, 10);

package/scripts/gsd-t-post-commit-spawn-plan.sh

@@ -0,0 +1,86 @@
+#!/usr/bin/env bash
+# GSD-T Post-Commit Spawn-Plan Hook (M44 D8 T2)
+#
+# Greps the latest commit message for every `[M\d+-D\d+-T\d+]` task id and
+# flips the matching task in every ACTIVE spawn plan under `.gsd-t/spawns/`
+# to `done` (with commit SHA + token attribution from `.gsd-t/token-log.md`).
+#
+# Contract: .gsd-t/contracts/spawn-plan-contract.md v1.0.0
+#
+# HARD RULE: silent-fail. This hook must NEVER break the user's commit.
+# Every error path logs to stderr and exits 0.
+
+set +e  # never bail on error — silent-fail is mandatory
+
+# Resolve project root (the dir git operates from).
+PROJECT_DIR="$(git rev-parse --show-toplevel 2>/dev/null)"
+if [ -z "$PROJECT_DIR" ] || [ ! -d "$PROJECT_DIR/.gsd-t/spawns" ]; then
+  exit 0
+fi
+
+UPDATER="$PROJECT_DIR/bin/spawn-plan-status-updater.cjs"
+if [ ! -f "$UPDATER" ]; then
+  exit 0
+fi
+
+# Require node; log once and continue if absent.
+if ! command -v node >/dev/null 2>&1; then
+  echo "[spawn-plan-hook] node not found — skipping" 1>&2
+  exit 0
+fi
+
+COMMIT_SHA="$(git rev-parse --short HEAD 2>/dev/null)"
+COMMIT_MSG="$(git log -1 --format=%B 2>/dev/null)"
+if [ -z "$COMMIT_SHA" ] || [ -z "$COMMIT_MSG" ]; then
+  exit 0
+fi
+
+# Extract all [M\d+-D\d+-T\d+] ids (unique, preserved order).
+TASK_IDS="$(printf '%s' "$COMMIT_MSG" | grep -oE '\[M[0-9]+-D[0-9]+-T[0-9]+\]' | sed 's/[][]//g' | awk '!seen[$0]++')"
+if [ -z "$TASK_IDS" ]; then
+  exit 0
+fi
+
+# Delegate patching to node. One invocation handles every active plan ×
+# every task id. Pipes the task-id list via stdin; silent-fails on any
+# error so the commit is never broken.
+printf '%s\n' "$TASK_IDS" | node -e '
+"use strict";
+try {
+  const path = require("path");
+  const fs = require("fs");
+  const projectDir = process.argv[1];
+  const commit = process.argv[2];
+  let raw = "";
+  process.stdin.setEncoding("utf8");
+  process.stdin.on("data", (c) => { raw += c; });
+  process.stdin.on("end", () => {
+    try {
+      const taskIds = raw.split("\n").map((s) => s.trim()).filter(Boolean);
+      if (!taskIds.length) process.exit(0);
+      const updater = require(path.join(projectDir, "bin", "spawn-plan-status-updater.cjs"));
+      const activePaths = updater.listActivePlans(projectDir);
+      if (!activePaths.length) process.exit(0);
+      for (const fp of activePaths) {
+        let plan;
+        try { plan = JSON.parse(fs.readFileSync(fp, "utf8")); } catch (_) { continue; }
+        const spawnId = plan && plan.spawnId;
+        const spawnStartedAt = plan && plan.startedAt;
+        if (!spawnId) continue;
+        const planTaskIds = new Set((plan.tasks || []).map((t) => t && t.id).filter(Boolean));
+        for (const taskId of taskIds) {
+          if (!planTaskIds.has(taskId)) continue;
+          const tokens = updater.sumTokensForTask({ projectDir, taskId, spawnStartedAt });
+          updater.markTaskDone({ spawnId, taskId, commit, tokens, projectDir });
+        }
+      }
+    } catch (err) {
+      try { process.stderr.write("[spawn-plan-hook] " + String(err && err.message || err) + "\n"); } catch (_) { /* silent */ }
+    }
+  });
+} catch (err) {
+  try { process.stderr.write("[spawn-plan-hook] " + String(err && err.message || err) + "\n"); } catch (_) { /* silent */ }
+}
+' "$PROJECT_DIR" "$COMMIT_SHA" 2>/dev/null
+
+exit 0