@tekyzinc/gsd-t 2.31.18 → 2.33.12

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

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+/**
+ * GSD-T Dashboard Server — Zero-dep SSE server for .gsd-t/events/*.jsonl
+ * Serves gsd-t-dashboard.html and streams events to browser clients.
+ */
+const http = require("http");
+const fs = require("fs");
+const path = require("path");
+const { spawn } = require("child_process");
+
+const DEFAULT_PORT = 7433;
+const MAX_EVENTS = 500;
+const KEEPALIVE_MS = 15000;
+const SSE_HEADERS = { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", "Connection": "keep-alive", "Access-Control-Allow-Origin": "*" };
+
+function parseEventLine(line) {
+  if (!line || !line.trim()) return null;
+  try { return JSON.parse(line.trim()); } catch { return null; }
+}
+
+function findEventsDir(projectDir) {
+  return path.join(projectDir || process.cwd(), ".gsd-t", "events");
+}
+
+function safeReadJsonl(filePath) {
+  try { if (fs.lstatSync(filePath).isSymbolicLink()) return []; } catch { /* safe */ }
+  try { return fs.readFileSync(filePath, "utf8").split("\n").map(parseEventLine).filter(Boolean); } catch { return []; }
+}
+
+function readExistingEvents(eventsDir, maxEvents) {
+  const limit = maxEvents || MAX_EVENTS;
+  if (!eventsDir) return [];
+  try { fs.accessSync(eventsDir); } catch { return []; }
+  let files;
+  try { files = fs.readdirSync(eventsDir).filter((f) => f.endsWith(".jsonl")).sort().reverse(); } catch { return []; }
+  const results = [];
+  for (const f of files) {
+    if (results.length >= limit) break;
+    safeReadJsonl(path.join(eventsDir, f)).forEach((e) => { if (results.length < limit) results.push(e); });
+  }
+  return results;
+}
+
+function tailEventsFile(filePath, callback) {
+  let offset = 0;
+  try { offset = fs.statSync(filePath).size; } catch { /* new file */ }
+  function processNewData() {
+    try { if (fs.lstatSync(filePath).isSymbolicLink()) return; } catch { return; }
+    let stat;
+    try { stat = fs.statSync(filePath); } catch { return; }
+    if (stat.size <= offset) return;
+    const fd = fs.openSync(filePath, "r");
+    let chunk;
+    try {
+      const buf = Buffer.alloc(stat.size - offset);
+      fs.readSync(fd, buf, 0, buf.length, offset);
+      chunk = buf.toString("utf8");
+      offset = stat.size;
+    } finally { fs.closeSync(fd); }
+    chunk.split("\n").forEach((line) => { const obj = parseEventLine(line); if (obj) callback(obj); });
+  }
+  fs.watchFile(filePath, { interval: 500, persistent: true }, processNewData);
+  return () => fs.unwatchFile(filePath, processNewData);
+}
+
+function handleRoot(req, res, htmlPath) {
+  fs.readFile(htmlPath, (err, data) => {
+    if (err) { res.writeHead(404); res.end("Not found"); return; }
+    res.writeHead(200, { "Content-Type": "text/html" });
+    res.end(data);
+  });
+}
+
+function handlePing(req, res, port) {
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ status: "ok", port }));
+}
+
+function handleStop(req, res, server) {
+  res.writeHead(200, { "Content-Type": "application/json" });
+  res.end(JSON.stringify({ status: "stopping" }));
+  setImmediate(() => server.close());
+}
+
+function getNewestJsonl(eventsDir) {
+  try { const files = fs.readdirSync(eventsDir).filter((f) => f.endsWith(".jsonl")).sort(); return files.length ? path.join(eventsDir, files[files.length - 1]) : null; } catch { return null; }
+}
+
+function handleEvents(req, res, eventsDir) {
+  res.writeHead(200, SSE_HEADERS);
+  readExistingEvents(eventsDir, MAX_EVENTS).forEach((e) => { try { res.write("data: " + JSON.stringify(e) + "\n\n"); } catch { /* gone */ } });
+  const watched = getNewestJsonl(eventsDir);
+  const unwatch = watched ? tailEventsFile(watched, (obj) => { try { res.write("data: " + JSON.stringify(obj) + "\n\n"); } catch { /* gone */ } }) : null;
+  const timer = setInterval(() => { try { res.write(": keepalive\n\n"); } catch { clearInterval(timer); } }, KEEPALIVE_MS);
+  req.on("close", () => { clearInterval(timer); if (unwatch) unwatch(); });
+}
+
+function startServer(port, eventsDir, htmlPath) {
+  const server = http.createServer((req, res) => {
+    const url = req.url.split("?")[0];
+    if (url === "/" || url === "") return handleRoot(req, res, htmlPath);
+    if (url === "/events") return handleEvents(req, res, eventsDir);
+    if (url === "/ping") return handlePing(req, res, port);
+    if (url === "/stop") return handleStop(req, res, server);
+    res.writeHead(404); res.end("Not found");
+  });
+  server.listen(port);
+  return { server, url: `http://localhost:${port}` };
+}
+
+module.exports = { startServer, tailEventsFile, readExistingEvents, parseEventLine, findEventsDir };
+
+if (require.main === module) {
+  const argv = process.argv.slice(2);
+  const getArg = (flag) => { const i = argv.indexOf(flag); return i >= 0 ? argv[i + 1] : null; };
+  const hasFlag = (f) => argv.includes(f);
+  const port = parseInt(getArg("--port") || DEFAULT_PORT, 10);
+  const projectDir = process.env.GSD_T_PROJECT_DIR || process.cwd();
+  const eventsDir = getArg("--events") || findEventsDir(projectDir);
+  const pidFile = path.join(projectDir, ".gsd-t", "dashboard.pid");
+  const htmlPath = path.join(__dirname, "gsd-t-dashboard.html");
+
+  if (hasFlag("--stop")) {
+    try { const pid = parseInt(fs.readFileSync(pidFile, "utf8").trim(), 10); process.kill(pid); fs.unlinkSync(pidFile); }
+    catch (e) { process.stderr.write("No running server: " + e.message + "\n"); }
+    process.exit(0);
+  }
+  if (hasFlag("--detach")) {
+    const child = spawn(process.execPath, [__filename, ...argv.filter((a) => a !== "--detach")], { detached: true, stdio: "ignore" });
+    child.unref();
+    try { fs.mkdirSync(path.dirname(pidFile), { recursive: true }); } catch { /* exists */ }
+    fs.writeFileSync(pidFile, String(child.pid));
+    process.exit(0);
+  }
+  const { server, url } = startServer(port, eventsDir, htmlPath);
+  process.stdout.write("GSD-T Dashboard: " + url + "\n");
+  function cleanup() { try { fs.unlinkSync(pidFile); } catch { /* ok */ } server.close(() => process.exit(0)); }
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+}

package/scripts/gsd-t-dashboard.html

@@ -0,0 +1,199 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<title>GSD-T Agent Dashboard</title>
+<script src="https://unpkg.com/react@17/umd/react.production.min.js"></script>
+<script src="https://unpkg.com/react-dom@17/umd/react-dom.production.min.js"></script>
+<script src="https://unpkg.com/dagre@0.8.5/dist/dagre.min.js"></script>
+<script src="https://unpkg.com/reactflow@11.11.4/dist/umd/index.js"></script>
+<link rel="stylesheet" href="https://unpkg.com/reactflow@11.11.4/dist/style.css">
+<style>
+:root{--bg:#0d1117;--surface:#161b22;--border:#30363d;--text:#e6edf3;--muted:#7d8590;
+  --green:#3fb950;--green-bg:#1a3a1e;--red:#f85149;--red-bg:#3a1a1a;
+  --yellow:#d29922;--yellow-bg:#3a2c10;--blue:#388bfd;--blue-bg:#1f3a5f;
+  --font:'SF Mono','Fira Code',monospace;}
+*{box-sizing:border-box;margin:0;padding:0;}
+body{background:var(--bg);color:var(--text);font-family:var(--font);font-size:12px;
+  height:100vh;display:flex;flex-direction:column;overflow:hidden;}
+.hdr{display:flex;align-items:center;gap:12px;padding:0 16px;background:var(--surface);
+  border-bottom:1px solid var(--border);height:40px;flex-shrink:0;}
+.logo{color:var(--blue);font-weight:bold;font-size:13px;}
+.status{display:flex;align-items:center;gap:5px;padding:2px 8px;border-radius:10px;
+  font-size:10px;border:1px solid;}
+.status.live{background:var(--green-bg);border-color:var(--green);color:var(--green);}
+.status.wait{background:var(--yellow-bg);border-color:var(--yellow);color:var(--yellow);}
+.dot{width:6px;height:6px;border-radius:50%;background:currentColor;
+  animation:pdot 1.5s ease-in-out infinite;}
+@keyframes pdot{0%,100%{opacity:1}50%{opacity:.3}}
+.hright{margin-left:auto;color:var(--muted);font-size:11px;}
+.main{display:flex;flex:1;overflow:hidden;}
+.garea{flex:1;position:relative;background:var(--bg);}
+.rfwrap{width:100%;height:100%;}
+.react-flow__background{background:var(--bg);}
+.react-flow__node{font-family:var(--font);font-size:11px;}
+.agent-node{background:var(--surface);border:1px solid var(--border);border-radius:6px;
+  padding:8px 12px;min-width:120px;text-align:center;}
+.agent-node.success{border-color:var(--green);background:var(--green-bg);}
+.agent-node.failure{border-color:var(--red);background:var(--red-bg);}
+.agent-node.learning,.agent-node.deferred{border-color:var(--yellow);background:var(--yellow-bg);}
+.agent-node.session{border-color:var(--blue);background:var(--blue-bg);}
+.node-id{color:var(--text);font-weight:500;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;max-width:140px;}
+.node-cnt{color:var(--muted);font-size:9px;margin-top:2px;}
+.sidebar{width:300px;background:var(--surface);border-left:1px solid var(--border);
+  display:flex;flex-direction:column;overflow:hidden;}
+.sb-hdr{padding:10px 12px;border-bottom:1px solid var(--border);color:var(--muted);
+  font-size:10px;text-transform:uppercase;letter-spacing:.8px;flex-shrink:0;}
+.feed{flex:1;overflow-y:auto;padding:8px;}
+.feed::-webkit-scrollbar{width:4px;}
+.feed::-webkit-scrollbar-thumb{background:var(--border);border-radius:2px;}
+.ev{border-radius:4px;padding:6px 8px;margin-bottom:5px;border-left:3px solid var(--border);
+  background:#1c2128;}
+.ev.success{border-left-color:var(--green);}
+.ev.failure{border-left-color:var(--red);}
+.ev.learning,.ev.deferred{border-left-color:var(--yellow);}
+.ev-type{font-weight:500;color:var(--text);font-size:11px;}
+.ev-cmd{color:var(--blue);font-size:10px;margin-top:1px;}
+.ev-ts{color:var(--muted);font-size:9px;margin-top:2px;}
+.badge{display:inline-block;font-size:9px;padding:1px 5px;border-radius:3px;font-weight:bold;margin-left:4px;}
+.badge.success{background:var(--green-bg);color:var(--green);}
+.badge.failure{background:var(--red-bg);color:var(--red);}
+.badge.learning,.badge.deferred{background:var(--yellow-bg);color:var(--yellow);}
+.noevents{color:var(--muted);font-size:11px;padding:12px;text-align:center;}
+</style>
+</head>
+<body>
+<div class="hdr">
+  <span class="logo">GSD-T Agent Dashboard</span>
+  <div id="status" class="status wait"><span class="dot"></span><span id="status-txt">Connecting...</span></div>
+  <div class="hright"><span id="ev-count">0 events</span></div>
+</div>
+<div class="main">
+  <div class="garea"><div id="rf-root" class="rfwrap"></div></div>
+  <div class="sidebar">
+    <div class="sb-hdr">Live Event Feed</div>
+    <div id="feed" class="feed"><div class="noevents">Waiting for events...</div></div>
+  </div>
+</div>
+<script>
+const {useState,useEffect,useCallback,useRef}=React;
+const {ReactFlow,useNodesState,useEdgesState,Background,Controls,MarkerType}=window.ReactFlow||{};
+const dagre=window.dagre;
+const params=new URLSearchParams(location.search);
+const PORT=params.get('port')||'7433';
+const MAX_EVENTS=200;
+const GRAPH_W=160,GRAPH_H=60;
+
+function outcomeClass(o){return o==='success'?'success':o==='failure'?'failure':o==='learning'||o==='deferred'?o:'';}
+
+function layoutGraph(nodes,edges){
+  const g=new dagre.graphlib.Graph();
+  g.setGraph({rankdir:'TB',ranksep:60,nodesep:40});
+  g.setDefaultEdgeLabel(()=>({}));
+  nodes.forEach(n=>g.setNode(n.id,{width:GRAPH_W,height:GRAPH_H}));
+  edges.forEach(e=>g.setEdge(e.source,e.target));
+  dagre.layout(g);
+  return nodes.map(n=>{const p=g.node(n.id);return{...n,position:{x:p.x-GRAPH_W/2,y:p.y-GRAPH_H/2}};});
+}
+
+function AgentNode({data}){
+  return React.createElement('div',{className:`agent-node ${data.outcome} ${data.nodeType||''}`},
+    React.createElement('div',{className:'node-id',title:data.label},data.label),
+    React.createElement('div',{className:'node-cnt'},`${data.count} event${data.count!==1?'s':''}`));
+}
+
+const nodeTypes={agentNode:AgentNode};
+
+function Dashboard(){
+  const [nodes,setNodes,onNodesChange]=useNodesState([]);
+  const [edges,setEdges,onEdgesChange]=useEdgesState([]);
+  const [events,setEvents]=useState([]);
+  const agentMap=useRef({});
+
+  const processEvent=useCallback((ev)=>{
+    setEvents(prev=>{
+      const next=[ev,...prev];
+      return next.length>MAX_EVENTS?next.slice(0,MAX_EVENTS):next;
+    });
+    if(!ev.agent_id)return;
+    const id=ev.agent_id;
+    const prev=agentMap.current[id]||{count:0,outcome:null,parent:null,nodeType:null,firstTs:null};
+    const nodeType=prev.nodeType||(ev.event_type==='session_start'?'session':ev.event_type==='subagent_spawn'?(ev.reasoning||'task'):null);
+    agentMap.current[id]={
+      count:prev.count+1,
+      outcome:ev.outcome||prev.outcome,
+      parent:ev.parent_agent_id||prev.parent||null,
+      nodeType,
+      firstTs:prev.firstTs||ev.ts||null
+    };
+    const newNodes=Object.entries(agentMap.current).map(([aid,d])=>{
+      const isSession=d.nodeType==='session';
+      const dateStr=d.firstTs?new Date(d.firstTs).toLocaleDateString('en',{month:'short',day:'numeric'}):'';
+      const lbl=isSession?`Session · ${dateStr?dateStr+' ':''}${aid.slice(0,7)}`:(d.nodeType||aid.slice(0,8)+'..'+aid.slice(-4));
+      return{id:aid,type:'agentNode',data:{label:lbl,count:d.count,outcome:d.outcome||'',nodeType:d.nodeType||''},position:{x:0,y:0}};
+    });
+    const newEdges=Object.entries(agentMap.current)
+      .filter(([,d])=>d.parent&&d.parent!=='')
+      .map(([aid,d])=>({id:`${d.parent}-${aid}`,source:d.parent,target:aid,
+        markerEnd:{type:MarkerType.ArrowClosed},style:{stroke:'#30363d'}}));
+    const laid=layoutGraph(newNodes,newEdges);
+    setNodes(laid);
+    setEdges(newEdges);
+  },[]);
+
+  useEffect(()=>{
+    let es;
+    function connect(){
+      es=new EventSource(`http://localhost:${PORT}/events`);
+      es.onopen=()=>{
+        document.getElementById('status').className='status live';
+        document.getElementById('status-txt').textContent='Live';
+      };
+      es.onmessage=(e)=>{
+        if(e.data&&e.data.trim()&&!e.data.startsWith(':')){
+          try{processEvent(JSON.parse(e.data));}catch(err){}
+        }
+      };
+      es.onerror=()=>{
+        document.getElementById('status').className='status wait';
+        document.getElementById('status-txt').textContent='Reconnecting...';
+        es.close();
+        setTimeout(connect,3000);
+      };
+    }
+    connect();
+    return()=>{if(es)es.close();};
+  },[processEvent]);
+
+  useEffect(()=>{
+    document.getElementById('ev-count').textContent=`${events.length} event${events.length!==1?'s':''}`;
+    const feed=document.getElementById('feed');
+    if(!events.length){feed.innerHTML='<div class="noevents">Waiting for events...</div>';return;}
+    feed.innerHTML=events.slice(0,50).map(ev=>{
+      const oc=outcomeClass(ev.outcome);
+      const ts=ev.ts?new Date(ev.ts).toLocaleTimeString():'';
+      const cmd=ev.command||ev.phase||'';
+      return`<div class="ev${oc?' '+oc:''}">
+        <div class="ev-type">${ev.event_type||'event'}${oc?`<span class="badge ${oc}">${ev.outcome}</span>`:''}</div>
+        ${cmd?`<div class="ev-cmd">${cmd}</div>`:''}
+        ${ev.reasoning?`<div class="ev-ts" style="color:var(--muted)">${ev.reasoning.slice(0,60)}</div>`:''}
+        <div class="ev-ts">${ts}</div>
+      </div>`;
+    }).join('');
+  },[events]);
+
+  if(!ReactFlow)return React.createElement('div',{style:{color:'#f85149',padding:'20px'}},'ReactFlow failed to load. Check CDN.');
+  return React.createElement(ReactFlow,{
+    nodes,edges,onNodesChange,onEdgesChange,nodeTypes,fitView:true,
+    style:{background:'var(--bg)'},
+    defaultEdgeOptions:{type:'smoothstep',animated:false}
+  },
+    React.createElement(Background,{color:'#30363d',gap:24,size:1}),
+    React.createElement(Controls,{style:{background:'var(--surface)',border:'1px solid var(--border)'}})
+  );
+}
+
+ReactDOM.render(React.createElement(Dashboard),document.getElementById('rf-root'));
+</script>
+</body>
+</html>

package/scripts/gsd-t-event-writer.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+/**
+ * GSD-T Event Writer — Structured JSONL Event Appender
+ *
+ * Writes structured events to .gsd-t/events/YYYY-MM-DD.jsonl (UTC date rotation).
+ * CLI for use from hooks and command files.
+ *
+ * Usage:
+ *   node gsd-t-event-writer.js --type phase_transition --command gsd-t-wave \
+ *     --phase execute --reasoning "Execute complete" --outcome success \
+ *     --agent-id "$SESSION" --parent-id null --trace-id "$TRACE"
+ *
+ * Exit codes: 0 = success, 1 = validation error, 2 = filesystem error
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// ─── Schema ──────────────────────────────────────────────────────────────────
+
+const VALID_EVENT_TYPES = new Set([
+  "command_invoked",
+  "phase_transition",
+  "subagent_spawn",
+  "subagent_complete",
+  "tool_call",
+  "experience_retrieval",
+  "outcome_tagged",
+  "distillation",
+]);
+
+const VALID_OUTCOMES = new Set(["success", "failure", "learning", "deferred", null]);
+
+// ─── Exports (for testing) ────────────────────────────────────────────────────
+module.exports = { validateEvent, resolveEventsFile, appendEvent };
+
+// ─── CLI Entry ───────────────────────────────────────────────────────────────
+if (require.main === module) {
+  const args = parseArgs(process.argv.slice(2));
+  const event = buildEvent(args);
+  const validationError = validateEvent(event);
+  if (validationError) {
+    process.stderr.write(validationError + "\n");
+    process.exit(1);
+  }
+  const projectDir = process.env.GSD_T_PROJECT_DIR || process.cwd();
+  const eventsFile = resolveEventsFile(projectDir);
+  const exitCode = appendEvent(eventsFile, event);
+  process.exit(exitCode);
+}
+
+// ─── Arg Parsing ─────────────────────────────────────────────────────────────
+
+function parseArgs(argv) {
+  const map = {};
+  for (let i = 0; i < argv.length - 1; i++) {
+    if (argv[i].startsWith("--")) {
+      map[argv[i].slice(2)] = argv[i + 1];
+      i++;
+    }
+  }
+  return map;
+}
+
+function nullify(val) {
+  return val === undefined || val === "null" ? null : val;
+}
+
+function buildEvent(args) {
+  return {
+    ts: new Date().toISOString(),
+    event_type: nullify(args["type"]),
+    command: nullify(args["command"]),
+    phase: nullify(args["phase"]),
+    agent_id: nullify(args["agent-id"]),
+    parent_agent_id: nullify(args["parent-id"]),
+    trace_id: nullify(args["trace-id"]),
+    reasoning: nullify(args["reasoning"]),
+    outcome: nullify(args["outcome"]),
+  };
+}
+
+// ─── Validation ──────────────────────────────────────────────────────────────
+
+function validateEvent(event) {
+  if (!event || typeof event !== "object") return "Event must be an object";
+  if (!event.event_type) return "Missing required field: --type";
+  if (!VALID_EVENT_TYPES.has(event.event_type)) {
+    return `Invalid event_type: "${event.event_type}". Must be one of: ${[...VALID_EVENT_TYPES].join(", ")}`;
+  }
+  if (!VALID_OUTCOMES.has(event.outcome)) {
+    return `Invalid outcome: "${event.outcome}". Must be one of: success, failure, learning, deferred, null`;
+  }
+  return null;
+}
+
+// ─── File Resolution ──────────────────────────────────────────────────────────
+
+function resolveEventsFile(projectDir) {
+  const date = new Date().toISOString().slice(0, 10); // YYYY-MM-DD UTC
+  return path.join(projectDir, ".gsd-t", "events", `${date}.jsonl`);
+}
+
+// ─── Append ───────────────────────────────────────────────────────────────────
+
+function appendEvent(filePath, event) {
+  try {
+    const eventsDir = path.dirname(filePath);
+    if (!fs.existsSync(eventsDir)) {
+      fs.mkdirSync(eventsDir, { recursive: true });
+    }
+    // Symlink check — prevent writing to redirected files
+    try {
+      if (fs.lstatSync(filePath).isSymbolicLink()) return 2;
+    } catch {
+      // File doesn't exist yet — safe to create
+    }
+    fs.appendFileSync(filePath, JSON.stringify(event) + "\n");
+    return 0;
+  } catch {
+    return 2;
+  }
+}

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 };
+module.exports = { scrubSecrets, scrubUrl, buildEvent, summarize, shortPath, buildEventStreamEntry, appendToEventsFile };
 
 // ─── Main (stdin processing) ─────────────────────────────────────────────────
 if (require.main === module) {
@@ -65,6 +65,10 @@ process.stdin.on("end", () => {
       try { if (fs.lstatSync(file).isSymbolicLink()) return; } catch { /* file doesn't exist yet — safe */ }
       fs.appendFileSync(file, JSON.stringify(event) + "\n");
     }
+
+    // Event stream enrichment — additive only, does not affect heartbeat writes above
+    const streamEntry = buildEventStreamEntry(hook);
+    if (streamEntry) appendToEventsFile(gsdtDir, streamEntry);
   } catch (e) {
     // Silent failure — never interfere with Claude Code
   }
@@ -178,3 +182,52 @@ function shortPath(p) {
   }
   return p.replace(/\\/g, "/");
 }
+
+// ─── Event Stream Enrichment ──────────────────────────────────────────────────
+
+function buildEventStreamEntry(hook) {
+  const ts = new Date().toISOString();
+  const base = { ts, command: null, phase: null, trace_id: null };
+  const n = hook.hook_event_name;
+  if (n === "SessionStart") {
+    return { ...base, event_type: "session_start",
+      agent_id: hook.session_id || null, parent_agent_id: null,
+      reasoning: hook.model || null, outcome: null };
+  }
+  if (n === "SessionEnd") {
+    return { ...base, event_type: "session_end",
+      agent_id: hook.session_id || null, parent_agent_id: null,
+      reasoning: hook.reason || null, outcome: null };
+  }
+  if (n === "SubagentStart") {
+    return { ...base, event_type: "subagent_spawn",
+      agent_id: hook.agent_id || null,
+      parent_agent_id: hook.parent_agent_id || hook.session_id || null,
+      reasoning: hook.agent_type || null, outcome: null };
+  }
+  if (n === "SubagentStop") {
+    return { ...base, event_type: "subagent_complete",
+      agent_id: hook.agent_id || null,
+      parent_agent_id: hook.parent_agent_id || hook.session_id || null,
+      reasoning: null, outcome: null };
+  }
+  if (n === "PostToolUse") {
+    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 };
+  }
+  return null;
+}
+
+function appendToEventsFile(gsdtDir, entry) {
+  try {
+    const date = new Date().toISOString().slice(0, 10);
+    const eventsDir = path.join(gsdtDir, "events");
+    if (!fs.existsSync(eventsDir)) fs.mkdirSync(eventsDir, { recursive: true });
+    const filePath = path.join(eventsDir, `${date}.jsonl`);
+    try { if (fs.lstatSync(filePath).isSymbolicLink()) return; } catch { /* safe */ }
+    fs.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+  } catch {
+    // Silent failure — never interfere with Claude Code
+  }
+}

package/templates/CLAUDE-global.md

@@ -56,6 +56,8 @@ PROJECT or FEATURE or SCAN
 | `/user:gsd-t-status` | Cross-domain progress view |
 | `/user:gsd-t-debug` | Systematic debugging |
 | `/user:gsd-t-quick` | Fast task, respects contracts |
+| `/user:gsd-t-reflect` | Generate retrospective from event stream, propose memory updates |
+| `/user:gsd-t-visualize` | Launch browser dashboard |
 | `/user:gsd-t-health` | Validate .gsd-t/ structure, optionally repair |
 | `/user:gsd-t-pause` | Save exact position for reliable resume |
 | `/user:gsd-t-populate` | Auto-populate docs from existing codebase |