npm - @tekyzinc/gsd-t - Versions diffs - 3.13.16 → 3.16.11 - Mend

@tekyzinc/gsd-t 3.13.16 → 3.16.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (54) hide show

package/CHANGELOG.md +44 -0
package/README.md +1 -0
package/bin/gsd-t-benchmark-orchestrator.js +437 -0
package/bin/gsd-t-capture-lint.cjs +276 -0
package/bin/gsd-t-completion-check.cjs +106 -0
package/bin/gsd-t-orchestrator-config.cjs +64 -0
package/bin/gsd-t-orchestrator-queue.cjs +180 -0
package/bin/gsd-t-orchestrator-recover.cjs +231 -0
package/bin/gsd-t-orchestrator-worker.cjs +219 -0
package/bin/gsd-t-orchestrator.js +534 -0
package/bin/gsd-t-stream-feed-client.cjs +151 -0
package/bin/gsd-t-task-brief-compactor.cjs +89 -0
package/bin/gsd-t-task-brief-template.cjs +96 -0
package/bin/gsd-t-task-brief.js +249 -0
package/bin/gsd-t-token-backfill.cjs +366 -0
package/bin/gsd-t-token-capture.cjs +306 -0
package/bin/gsd-t-token-dashboard.cjs +318 -0
package/bin/gsd-t-token-regenerate-log.cjs +129 -0
package/bin/gsd-t-transcript-tee.cjs +246 -0
package/bin/gsd-t-unattended-heartbeat.cjs +188 -0
package/bin/gsd-t-unattended-platform.cjs +191 -27
package/bin/gsd-t-unattended-safety.cjs +8 -1
package/bin/gsd-t-unattended.cjs +192 -31
package/bin/gsd-t.js +329 -2
package/bin/supervisor-pid-fingerprint.cjs +126 -0
package/commands/gsd-t-debug.md +63 -51
package/commands/gsd-t-design-decompose.md +2 -7
package/commands/gsd-t-doc-ripple.md +20 -11
package/commands/gsd-t-execute.md +82 -50
package/commands/gsd-t-integrate.md +43 -16
package/commands/gsd-t-plan.md +20 -7
package/commands/gsd-t-prd.md +19 -12
package/commands/gsd-t-quick.md +64 -29
package/commands/gsd-t-resume.md +51 -4
package/commands/gsd-t-unattended.md +19 -20
package/commands/gsd-t-verify.md +48 -32
package/commands/gsd-t-visualize.md +19 -17
package/commands/gsd-t-wave.md +29 -27
package/docs/architecture.md +16 -0
package/docs/m40-benchmark-report.md +35 -0
package/docs/requirements.md +20 -0
package/package.json +1 -1
package/scripts/gsd-t-dashboard-server.js +291 -4
package/scripts/gsd-t-dashboard.html +31 -1
package/scripts/gsd-t-design-review-server.js +3 -1
package/scripts/gsd-t-stream-feed-server.js +428 -0
package/scripts/gsd-t-stream-feed.html +1168 -0
package/scripts/gsd-t-token-aggregator.js +373 -0
package/scripts/gsd-t-transcript.html +422 -0
package/scripts/hooks/gsd-t-in-session-probe.js +62 -0
package/scripts/hooks/pre-commit-capture-lint +26 -0
package/templates/CLAUDE-global.md +69 -0
package/scripts/gsd-t-agent-dashboard-server.js +0 -424
package/scripts/gsd-t-agent-dashboard.html +0 -1043

package/scripts/gsd-t-transcript.html ADDED Viewed

@@ -0,0 +1,422 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>GSD-T Transcript</title>
+  <style>
+    :root {
+      --bg: #0d1117;
+      --bg-raised: #161b22;
+      --bg-soft: #1f2937;
+      --fg: #c9d1d9;
+      --fg-dim: #8b949e;
+      --fg-xdim: #6e7681;
+      --accent: #58a6ff;
+      --accent-warm: #f0883e;
+      --border: #30363d;
+      --green: #3fb950;
+      --yellow: #d29922;
+      --red: #f85149;
+      --mono: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace;
+      --sans: -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+    }
+    * { box-sizing: border-box; }
+    body { margin: 0; background: var(--bg); color: var(--fg); font-family: var(--sans); font-size: 14px; line-height: 1.55; display: grid; grid-template-columns: 280px 1fr; grid-template-rows: auto 1fr; min-height: 100vh; }
+    body > header { grid-column: 1 / -1; }
+    body > aside { grid-column: 1; grid-row: 2; background: var(--bg-raised); border-right: 1px solid var(--border); padding: 12px 0; overflow-y: auto; max-height: calc(100vh - 50px); position: sticky; top: 49px; align-self: start; }
+    body > main { grid-column: 2; grid-row: 2; }
+    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; }
+    aside .node { display: flex; align-items: center; padding: 5px 12px; cursor: pointer; gap: 6px; }
+    aside .node:hover { background: var(--bg-soft); }
+    aside .node.active { background: var(--bg-soft); border-left: 2px solid var(--accent); }
+    aside .node .dot { flex: 0 0 8px; width: 8px; height: 8px; border-radius: 50%; background: var(--fg-xdim); }
+    aside .node.running .dot { background: var(--green); animation: pulse 2s ease-in-out infinite; }
+    aside .node.stopped .dot { background: var(--yellow); }
+    aside .node.failed .dot { background: var(--red); }
+    aside .node .name { flex: 1; font-family: var(--mono); font-size: 11px; color: var(--fg-dim); white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+    aside .node.active .name { color: var(--fg); }
+    aside .node .kill { flex: 0 0 auto; background: transparent; border: 1px solid var(--border); color: var(--fg-xdim); border-radius: 3px; padding: 1px 6px; font-size: 10px; cursor: pointer; font-family: var(--mono); }
+    aside .node.running .kill { color: var(--red); border-color: var(--red); }
+    aside .node .kill:hover:not([disabled]) { background: var(--red); color: #fff; }
+    aside .node .kill[disabled] { opacity: 0.3; cursor: not-allowed; }
+    aside .empty { padding: 12px; color: var(--fg-xdim); font-size: 12px; font-style: italic; }
+    @keyframes pulse { 0%, 100% { opacity: 1; } 50% { opacity: 0.5; } }
+    header { position: sticky; top: 0; z-index: 10; background: var(--bg-raised); border-bottom: 1px solid var(--border); padding: 10px 16px; display: flex; align-items: center; gap: 12px; }
+    header .title { font-weight: 600; }
+    header .spawn-id { font-family: var(--mono); color: var(--fg-dim); font-size: 12px; }
+    header .status { margin-left: auto; font-size: 12px; color: var(--fg-dim); }
+    header .status .dot { display: inline-block; width: 8px; height: 8px; border-radius: 50%; background: var(--yellow); margin-right: 6px; vertical-align: middle; }
+    header .status.connected .dot { background: var(--green); }
+    header .status.ended .dot { background: var(--fg-xdim); }
+    header .status.error .dot { background: var(--red); }
+    main { padding: 16px; padding-bottom: 120px; max-width: 960px; margin: 0 auto; width: 100%; }
+    .frame { margin: 8px 0; }
+    .frame.system { color: var(--fg-xdim); font-style: italic; font-size: 12px; padding: 2px 0; }
+    .frame.user { border-left: 3px solid var(--accent); padding: 6px 12px; background: var(--bg-raised); border-radius: 0 4px 4px 0; }
+    .frame.user .prefix { color: var(--accent); font-weight: 600; margin-right: 6px; }
+    .frame.assistant-text { font-family: var(--mono); white-space: pre-wrap; word-break: break-word; }
+    .frame.thinking { color: var(--fg-xdim); font-style: italic; font-size: 13px; padding: 4px 8px; border-left: 2px dashed var(--border); margin: 6px 0; }
+    .frame.thinking summary { cursor: pointer; color: var(--fg-dim); }
+    .frame.tool-use { margin: 8px 0; border: 1px solid var(--border); border-radius: 4px; background: var(--bg-raised); }
+    .frame.tool-use summary { padding: 8px 12px; cursor: pointer; color: var(--accent-warm); font-family: var(--mono); font-size: 13px; list-style: none; }
+    .frame.tool-use summary::before { content: "⎿ "; color: var(--fg-dim); }
+    .frame.tool-use[open] summary { border-bottom: 1px solid var(--border); }
+    .frame.tool-use pre { margin: 0; padding: 10px 12px; font-family: var(--mono); font-size: 12px; color: var(--fg); white-space: pre-wrap; word-break: break-word; overflow-x: auto; }
+    .frame.tool-result { margin: 4px 0 8px 24px; padding: 8px 12px; border-left: 2px solid var(--border); background: var(--bg-soft); border-radius: 0 4px 4px 0; }
+    .frame.tool-result pre { margin: 0; font-family: var(--mono); font-size: 12px; color: var(--fg-dim); white-space: pre-wrap; word-break: break-word; max-height: 240px; overflow: hidden; }
+    .frame.tool-result.expanded pre { max-height: none; }
+    .frame.tool-result .show-more { display: block; margin-top: 6px; color: var(--accent); cursor: pointer; font-size: 11px; font-family: var(--mono); }
+    .frame.raw { color: var(--fg-xdim); font-family: var(--mono); font-size: 11px; white-space: pre-wrap; padding: 2px 0; }
+    .frame.boundary { margin: 12px 0; padding: 8px 12px; background: var(--bg-soft); border-left: 3px solid var(--accent-warm); border-radius: 0 4px 4px 0; font-size: 13px; }
+    .frame.boundary.done { border-left-color: var(--green); }
+    .frame.boundary.failed { border-left-color: var(--red); }
+    .frame.boundary .label { color: var(--accent-warm); font-weight: 600; font-family: var(--mono); font-size: 12px; margin-right: 8px; }
+    .frame.boundary.done .label { color: var(--green); }
+    .frame.boundary.failed .label { color: var(--red); }
+    .frame.boundary .meta { color: var(--fg-dim); font-family: var(--mono); font-size: 12px; }
+    .jump-to-live { position: fixed; bottom: 24px; right: 24px; background: var(--accent); color: #fff; border: none; padding: 10px 16px; border-radius: 20px; cursor: pointer; font-size: 13px; font-family: var(--sans); font-weight: 600; box-shadow: 0 4px 12px rgba(0,0,0,0.4); display: none; z-index: 20; }
+    .jump-to-live.visible { display: block; }
+    .jump-to-live:hover { background: #79c0ff; }
+  </style>
+</head>
+<body data-spawn-id="__SPAWN_ID__">
+  <header>
+    <div class="title">GSD-T Transcript</div>
+    <div class="spawn-id" id="hdr-spawn-id"></div>
+    <div class="status" id="hdr-status"><span class="dot"></span><span class="label">connecting…</span></div>
+  </header>
+  <aside>
+    <h3>Spawns</h3>
+    <div class="tree" id="tree"></div>
+  </aside>
+  <main id="stream"></main>
+  <button class="jump-to-live" id="jump-btn">↓ Jump to live</button>
+  <script>
+    (function () {
+      'use strict';
+      const spawnId = document.body.getAttribute('data-spawn-id');
+      document.getElementById('hdr-spawn-id').textContent = spawnId;
+      const stream = document.getElementById('stream');
+      const statusEl = document.getElementById('hdr-status');
+      const statusLabel = statusEl.querySelector('.label');
+      const jumpBtn = document.getElementById('jump-btn');
+      // Pair tool_result → tool_use by tool_use_id so the renderer can place
+      // the result next to the call even when they come as separate frames.
+      const toolUseById = new Map();
+      let autoScroll = true;
+      function setStatus(cls, text) {
+        statusEl.className = 'status ' + cls;
+        statusLabel.textContent = text;
+      }
+      function atBottom() {
+        return window.innerHeight + window.scrollY >= document.body.offsetHeight - 40;
+      }
+      window.addEventListener('scroll', () => {
+        if (atBottom()) { autoScroll = true; jumpBtn.classList.remove('visible'); }
+        else { autoScroll = false; jumpBtn.classList.add('visible'); }
+      });
+      jumpBtn.addEventListener('click', () => {
+        autoScroll = true;
+        window.scrollTo({ top: document.body.scrollHeight, behavior: 'smooth' });
+        jumpBtn.classList.remove('visible');
+      });
+      function appendFrame(el) {
+        stream.appendChild(el);
+        if (autoScroll) {
+          requestAnimationFrame(() => window.scrollTo(0, document.body.scrollHeight));
+        }
+      }
+      function renderSystem(frame) {
+        const div = document.createElement('div');
+        div.className = 'frame system';
+        const sid = frame.session_id ? ' session=' + frame.session_id.slice(0, 8) : '';
+        const model = frame.model ? ' model=' + frame.model : '';
+        const subtype = frame.subtype ? ' ' + frame.subtype : '';
+        div.textContent = 'system' + subtype + sid + model;
+        appendFrame(div);
+      }
+      function renderUserMessage(content) {
+        const div = document.createElement('div');
+        div.className = 'frame user';
+        const p = document.createElement('span');
+        p.className = 'prefix';
+        p.textContent = '>';
+        div.appendChild(p);
+        const span = document.createElement('span');
+        span.textContent = typeof content === 'string' ? content : JSON.stringify(content);
+        div.appendChild(span);
+        appendFrame(div);
+      }
+      function renderAssistantText(text) {
+        const div = document.createElement('div');
+        div.className = 'frame assistant-text';
+        div.textContent = text;
+        appendFrame(div);
+      }
+      function renderThinking(text) {
+        const d = document.createElement('details');
+        d.className = 'frame thinking';
+        const s = document.createElement('summary');
+        s.textContent = '✻ Thinking (' + text.length + ' chars)';
+        d.appendChild(s);
+        const pre = document.createElement('div');
+        pre.textContent = text;
+        d.appendChild(pre);
+        appendFrame(d);
+      }
+      function toolUsePreview(input) {
+        if (!input || typeof input !== 'object') return '';
+        // Surface the most useful single arg: file_path, command, pattern, path, description
+        const keys = ['file_path', 'command', 'pattern', 'path', 'description', 'prompt'];
+        for (const k of keys) {
+          if (typeof input[k] === 'string') {
+            const v = input[k];
+            return k + '="' + (v.length > 80 ? v.slice(0, 77) + '…' : v) + '"';
+          }
+        }
+        const first = Object.keys(input)[0];
+        if (first) return first + '=…';
+        return '';
+      }
+      function renderToolUse(block) {
+        const d = document.createElement('details');
+        d.className = 'frame tool-use';
+        const s = document.createElement('summary');
+        s.textContent = block.name + '(' + toolUsePreview(block.input) + ')';
+        d.appendChild(s);
+        const pre = document.createElement('pre');
+        try { pre.textContent = JSON.stringify(block.input, null, 2); }
+        catch { pre.textContent = String(block.input); }
+        d.appendChild(pre);
+        toolUseById.set(block.id, { name: block.name, el: d });
+        appendFrame(d);
+      }
+      function renderToolResult(block) {
+        const div = document.createElement('div');
+        div.className = 'frame tool-result';
+        const pre = document.createElement('pre');
+        let text;
+        if (typeof block.content === 'string') text = block.content;
+        else if (Array.isArray(block.content)) {
+          text = block.content.map(c => typeof c === 'string' ? c : (c.text || JSON.stringify(c))).join('\n');
+        } else text = JSON.stringify(block.content || '');
+        pre.textContent = text;
+        div.appendChild(pre);
+        if (text.length > 800) {
+          const more = document.createElement('span');
+          more.className = 'show-more';
+          more.textContent = 'show more';
+          more.addEventListener('click', () => {
+            div.classList.toggle('expanded');
+            more.textContent = div.classList.contains('expanded') ? 'show less' : 'show more';
+          });
+          div.appendChild(more);
+        }
+        appendFrame(div);
+      }
+      function renderBoundary(frame) {
+        const div = document.createElement('div');
+        div.className = 'frame boundary ' + (frame.state || '');
+        const label = document.createElement('span');
+        label.className = 'label';
+        label.textContent = '▸ task ' + (frame.state || '?');
+        div.appendChild(label);
+        const meta = document.createElement('span');
+        meta.className = 'meta';
+        const bits = [];
+        if (frame.taskId) bits.push('id=' + frame.taskId);
+        if (frame.domain) bits.push('domain=' + frame.domain);
+        if (frame.wave != null) bits.push('wave=' + frame.wave);
+        if (frame.exitCode != null) bits.push('exit=' + frame.exitCode);
+        if (frame.durationMs != null) bits.push('duration=' + Math.round(frame.durationMs/1000) + 's');
+        meta.textContent = bits.join('  ');
+        div.appendChild(meta);
+        appendFrame(div);
+      }
+      function renderRaw(line) {
+        const div = document.createElement('div');
+        div.className = 'frame raw';
+        div.textContent = line;
+        appendFrame(div);
+      }
+      function renderFrame(frame) {
+        if (!frame || typeof frame !== 'object') return;
+        const type = frame.type;
+        if (type === 'system') { renderSystem(frame); return; }
+        if (type === 'task-boundary') { renderBoundary(frame); return; }
+        if (type === 'raw') { renderRaw(frame.line || ''); return; }
+        if (type === 'assistant' && frame.message && Array.isArray(frame.message.content)) {
+          for (const b of frame.message.content) {
+            if (b.type === 'text') renderAssistantText(b.text || '');
+            else if (b.type === 'thinking') renderThinking(b.thinking || b.text || '');
+            else if (b.type === 'tool_use') renderToolUse(b);
+            else renderRaw(JSON.stringify(b));
+          }
+          return;
+        }
+        if (type === 'user' && frame.message && Array.isArray(frame.message.content)) {
+          for (const b of frame.message.content) {
+            if (b.type === 'tool_result') renderToolResult(b);
+            else if (b.type === 'text') renderUserMessage(b.text || '');
+            else renderRaw(JSON.stringify(b));
+          }
+          return;
+        }
+        if (type === 'user' && typeof frame.message === 'string') {
+          renderUserMessage(frame.message);
+          return;
+        }
+        if (type === 'result') {
+          const d = document.createElement('div');
+          d.className = 'frame system';
+          d.textContent = 'result subtype=' + (frame.subtype || '?') + ' duration=' + (frame.duration_ms || 0) + 'ms';
+          appendFrame(d);
+          return;
+        }
+        renderRaw(JSON.stringify(frame));
+      }
+      // ── Sidebar ─────────────────────────────────────────────────────────
+      //
+      // Poll /transcripts every 3s, build a parent-indented tree, render.
+      // Exposed as window.__gsdtBuildTree for unit-testable tree-build logic.
+      function buildTree(spawns) {
+        // Map spawnId → node, then link children to parents. Orphans float
+        // to the root level.
+        const byId = new Map();
+        const roots = [];
+        for (const s of spawns) byId.set(s.spawnId, { ...s, children: [] });
+        for (const node of byId.values()) {
+          if (node.parentId && byId.has(node.parentId)) {
+            byId.get(node.parentId).children.push(node);
+          } else {
+            roots.push(node);
+          }
+        }
+        // Sort each level newest-first
+        const ts = (a, b) => (Date.parse(b.startedAt) || 0) - (Date.parse(a.startedAt) || 0);
+        roots.sort(ts);
+        for (const n of byId.values()) n.children.sort(ts);
+        return roots;
+      }
+      window.__gsdtBuildTree = buildTree;
+      function statusClass(s) {
+        if (s.status === 'running') return 'running';
+        if (s.status === 'failed') return 'failed';
+        if (s.status === 'stopped') return 'stopped';
+        return '';
+      }
+      function renderTree(roots) {
+        const tree = document.getElementById('tree');
+        tree.innerHTML = '';
+        if (!roots.length) {
+          const e = document.createElement('div');
+          e.className = 'empty';
+          e.textContent = 'No spawns yet.';
+          tree.appendChild(e);
+          return;
+        }
+        const currentId = (location.hash || '#').slice(1) || spawnId;
+        function render(node, depth) {
+          const el = document.createElement('div');
+          el.className = 'node ' + statusClass(node);
+          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);
+          name.title = (node.description || node.spawnId) + '\n' + (node.startedAt || '');
+          const kill = document.createElement('button');
+          kill.className = 'kill';
+          kill.textContent = 'kill';
+          kill.disabled = node.status !== 'running' || !node.workerPid;
+          kill.addEventListener('click', (ev) => {
+            ev.stopPropagation();
+            if (!confirm('SIGTERM spawn ' + node.spawnId + ' (pid ' + node.workerPid + ')?')) return;
+            fetch('/transcript/' + encodeURIComponent(node.spawnId) + '/kill', { method: 'POST' })
+              .then((r) => r.json())
+              .then((j) => { kill.textContent = j.status || 'killed'; })
+              .catch(() => { kill.textContent = 'err'; });
+          });
+          el.appendChild(dot); el.appendChild(name); el.appendChild(kill);
+          el.addEventListener('click', () => {
+            if (node.spawnId === currentId) return;
+            location.hash = node.spawnId;
+          });
+          document.getElementById('tree').appendChild(el);
+          for (const c of node.children) render(c, depth + 1);
+        }
+        for (const r of roots) render(r, 0);
+      }
+      let pollTimer = null;
+      function pollSpawns() {
+        fetch('/transcripts')
+          .then((r) => r.json())
+          .then((j) => renderTree(buildTree(j.spawns || [])))
+          .catch(() => { /* keep last render */ });
+      }
+      // ── SSE connection (reconnectable on hash change) ───────────────────
+      let src = null;
+      function connect(id) {
+        if (src) { try { src.close(); } catch { /* gone */ } src = null; }
+        stream.innerHTML = '';
+        toolUseById.clear();
+        autoScroll = true;
+        jumpBtn.classList.remove('visible');
+        document.getElementById('hdr-spawn-id').textContent = id;
+        setStatus('', 'connecting…');
+        src = new EventSource('/transcript/' + encodeURIComponent(id) + '/stream');
+        src.onopen = () => setStatus('connected', 'live');
+        src.onerror = () => setStatus('error', 'disconnected');
+        src.onmessage = (ev) => {
+          if (!ev.data) return;
+          try { renderFrame(JSON.parse(ev.data)); }
+          catch { renderRaw(ev.data); }
+        };
+      }
+      window.addEventListener('hashchange', () => {
+        const id = (location.hash || '').slice(1);
+        if (id) { connect(id); pollSpawns(); }
+      });
+      const initialId = (location.hash || '').slice(1) || spawnId;
+      if (!location.hash && spawnId) location.hash = spawnId;
+      connect(initialId);
+      pollSpawns();
+      pollTimer = setInterval(pollSpawns, 3000);
+    })();
+  </script>
+</body>
+</html>

package/scripts/hooks/gsd-t-in-session-probe.js ADDED Viewed

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * M43 D1-T1 Probe — In-Session Usage Capture Branch Selection
+ *
+ * Captures the RAW Claude Code hook payload for Stop / SessionEnd / PostToolUse
+ * into .gsd-t/.hook-probe/{event}-{ts}.json so D1-T1 can decide:
+ *   Branch A (hook-based) — if payload carries a `usage` object.
+ *   Branch B (transcript tee) — otherwise.
+ *
+ * Behavior:
+ * - Zero-dep. Silent failure on any error (never interferes with Claude Code).
+ * - Writes at most 10 files per event type (rotating) to avoid growth.
+ * - Only active when .gsd-t/.hook-probe/ exists in the cwd; creating/deleting
+ *   that directory is the on/off switch.
+ */
+const fs = require("fs");
+const path = require("path");
+const MAX_STDIN = 1024 * 1024;
+const MAX_PER_EVENT = 10;
+let input = "";
+let aborted = false;
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (d) => {
+  input += d;
+  if (input.length > MAX_STDIN) { aborted = true; process.stdin.destroy(); }
+});
+process.stdin.on("end", () => {
+  if (aborted) return;
+  try {
+    const hook = JSON.parse(input);
+    const cwd = hook.cwd || process.cwd();
+    if (!path.isAbsolute(cwd)) return;
+    const probeDir = path.join(cwd, ".gsd-t", ".hook-probe");
+    if (!fs.existsSync(probeDir)) return; // disabled unless dir exists
+    const event = hook.hook_event_name || "unknown";
+    const ts = new Date().toISOString().replace(/[:.]/g, "-");
+    const sid = (hook.session_id || "nosid").slice(0, 12);
+    const file = path.join(probeDir, `${event}-${ts}-${sid}.json`);
+    const resolved = path.resolve(file);
+    if (!resolved.startsWith(path.resolve(probeDir) + path.sep)) return;
+    fs.writeFileSync(file, JSON.stringify(hook, null, 2) + "\n");
+    rotate(probeDir, event);
+  } catch {
+    // silent
+  }
+});
+function rotate(dir, event) {
+  try {
+    const files = fs.readdirSync(dir)
+      .filter((f) => f.startsWith(event + "-") && f.endsWith(".json"))
+      .map((f) => ({ f, t: fs.statSync(path.join(dir, f)).mtimeMs }))
+      .sort((a, b) => b.t - a.t);
+    for (const { f } of files.slice(MAX_PER_EVENT)) {
+      try { fs.unlinkSync(path.join(dir, f)); } catch { /* noop */ }
+    }
+  } catch {
+    // silent
+  }
+}

package/scripts/hooks/pre-commit-capture-lint ADDED Viewed

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# GSD-T capture lint (M41 D5)
+# Rejects commits that introduce bare Task(…) / claude -p / spawn('claude', …)
+# calls bypassing bin/gsd-t-token-capture.cjs.
+#
+# Install (opt-in):  gsd-t init --install-hooks
+# Remove:            rm .git/hooks/pre-commit  (or delete this block if merged
+#                    into an existing hook)
+set -e
+if command -v gsd-t >/dev/null 2>&1; then
+  GSD_T_BIN=gsd-t
+elif [ -x "./bin/gsd-t.js" ]; then
+  GSD_T_BIN="node ./bin/gsd-t.js"
+else
+  echo "[capture-lint] gsd-t CLI not found — skipping lint" >&2
+  exit 0
+fi
+if ! $GSD_T_BIN capture-lint --staged; then
+  echo ""
+  echo "Token capture lint failed — see paths above."
+  echo "Wrap spawns with captureSpawn({…, spawnFn}) or add GSD-T-CAPTURE-LINT: skip" >&2
+  exit 1
+fi

package/templates/CLAUDE-global.md CHANGED Viewed

@@ -253,6 +253,75 @@ This gives the user real-time visibility into which model is handling each opera
 **Context Meter (M34/M38, v3.12.10+)** — The real context-window measurement feeding the headless-default spawn decision. A PostToolUse hook (`scripts/gsd-t-context-meter.js`) runs after every tool call, uses local token estimation to write the current input-token count into `.gsd-t/.context-meter-state.json`. `getSessionStatus()` reads that state file (fresh window = 5 minutes) with a historical heuristic fallback when the file is missing or stale. Command files consume the signal via a small bash shim (`CTX_PCT=$(node -e "…tb.getSessionStatus('.').pct")`). **Single-band model** (context-meter-contract v1.3.0): there's one threshold (default 85%) and one action — hand off to a detached headless spawn. No three-band routing, no silent downgrades, no MANDATORY STOP prose. The meter exists to inform spawn-time routing, not to pause work in-flight.
+## Observability Logging (MANDATORY)
+Every command that spawns a Task subagent, invokes `claude -p`, or calls `spawn('claude', ...)` MUST route the spawn through `bin/gsd-t-token-capture.cjs` so the real token-usage envelope is parsed and recorded. This is the M41 canonical pattern — the pre-M41 bash block that wrote `| N/A |` is retired.
+### Pattern A — wrap a spawn callable with `captureSpawn`
+Preferred for new spawn sites. The wrapper owns the before/after timing, model banner, envelope parse, row write, and JSONL record.
+```
+node -e "
+const { captureSpawn } = require('./bin/gsd-t-token-capture.cjs');
+(async () => {
+  await captureSpawn({
+    command: 'gsd-t-execute',
+    step: 'Step 4',
+    model: 'sonnet',
+    description: 'domain: auth-service',
+    projectDir: '.',
+    domain: 'auth-service',
+    task: 'T-3',
+    spawnFn: async () => { /* actual Task(...) or spawn('claude', ...) call */ },
+  });
+})();
+"
+```
+### Pattern B — record after the result envelope is already in hand
+For command files where the Task subagent already ran and the caller has the result object. Identical row format, no timing wrap.
+```
+node -e "
+const { recordSpawnRow } = require('./bin/gsd-t-token-capture.cjs');
+recordSpawnRow({
+  projectDir: '.',
+  command: 'gsd-t-verify',
+  step: 'Step 4',
+  model: 'haiku',
+  startedAt: '2026-04-21 10:00',
+  endedAt:   '2026-04-21 10:02',
+  usage: result.usage, // may be undefined — wrapper handles with '—'
+  domain: '-', task: '-',
+  ctxPct: 42,
+  notes: 'test audit + contract review',
+});
+"
+```
+### Canonical `.gsd-t/token-log.md` header
+```
+| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Tokens | Notes | Domain | Task | Ctx% |
+```
+The wrapper detects old headers (no `Tokens` column) and upgrades in place, preserving existing rows. The **Tokens** cell renders as `in=N out=N cr=N cc=N $X.XX` when usage is present, or `—` when absent. Never `0`. Never `N/A`. A zero is a measurement; a dash is an acknowledged gap.
+For QA/validation subagents, append findings to `.gsd-t/qa-issues.md`:
+```
+| Date | Command | Step | Model | Duration(s) | Severity | Finding |
+```
+## Token Capture Rule (MANDATORY)
+Every `Task(...)` subagent spawn, every `claude -p` child process, and every `spawn('claude', ...)` call MUST flow through `bin/gsd-t-token-capture.cjs`. Either wrap with `captureSpawn({..., spawnFn})` or record explicitly with `recordSpawnRow({...})` after the call returns.
+No command file ships a bare `Task(...)` or `claude -p` line outside of a wrapper call. `gsd-t capture-lint` (D5) enforces this mechanically; violations fail the opt-in pre-commit hook.
+Rationale: the pre-M41 convention silently wrote `N/A` tokens because no caller parsed the `usage` envelope. The wrapper is the single place that parses it. Bypassing the wrapper re-introduces blind spots.
 ## Headless-by-Default Spawn (M38, v3.12.10+)
 Long-running work (execute, wave, integrate, debug repair loops) spawns detached by default. Interactive session shows a banner, event-stream path, then exits — no mid-session `/compact` wall. `--watch` keeps a ScheduleWakeup-driven status block in the caller; events stream JSONL to `.gsd-t/events/YYYY-MM-DD.jsonl`. Router mode (`/gsd`) answers exploratory requests inline without a command spawn — see `commands/gsd.md` Step 2.5.