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

@tekyzinc/gsd-t 3.15.10 → 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 (17) hide show

package/bin/gsd-t-orchestrator-worker.cjs +35 -3
package/bin/gsd-t-token-capture.cjs +24 -3
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 +15 -1
package/bin/supervisor-pid-fingerprint.cjs +126 -0
package/commands/gsd-t-resume.md +18 -4
package/docs/architecture.md +16 -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-transcript.html +422 -0
package/scripts/hooks/gsd-t-in-session-probe.js +62 -0

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
+  }
+}