@tekyzinc/gsd-t 3.15.10 → 3.16.12

package/bin/gsd-t-orchestrator-worker.cjs

@@ -3,6 +3,7 @@
 const { spawn } = require('child_process');
 const path = require('path');
 const { assertCompletion } = require('./gsd-t-completion-check.cjs');
+const transcriptTee = require('./gsd-t-transcript-tee.cjs');
 
 const DEFAULT_CLAUDE_BIN = 'claude';
 
@@ -71,19 +72,44 @@ function runWorker(opts) {
   const bin = pickClaudeBin(env);
   const args = buildArgs(task);
 
+  // M42 D1 — allocate a spawn-id and open the transcript registry entry
+  const parentSpawnId = (opts && opts.parentSpawnId) || env.GSD_T_SPAWN_ID || null;
+  const spawnId = (opts && opts.spawnId) || transcriptTee.allocateSpawnId({ parentId: parentSpawnId });
+  let transcriptOpened = false;
+  try {
+    transcriptTee.openTranscript({
+      spawnId,
+      projectDir: config.projectDir,
+      meta: {
+        parentId: parentSpawnId,
+        command: 'orchestrator-worker',
+        description: `task=${task.id} domain=${task.domain || '-'} wave=${task.wave == null ? '-' : task.wave}`,
+        model: (task && task.model) || 'sonnet',
+      },
+    });
+    transcriptOpened = true;
+  } catch (_) { /* tee is best-effort */ }
+
   emitBoundary(onFrame, task, 'start');
 
   return new Promise((resolve) => {
     const child = spawnImpl(bin, args, {
       cwd: config.projectDir,
-      env: { ...env, GSD_T_PROJECT_DIR: config.projectDir },
+      env: { ...env, GSD_T_PROJECT_DIR: config.projectDir, GSD_T_SPAWN_ID: spawnId },
       stdio: ['pipe', 'pipe', 'pipe']
     });
 
     const workerPid = child && typeof child.pid === 'number' ? child.pid : null;
     emitBoundary(onFrame, task, 'pid', { workerPid });
+    if (transcriptOpened && workerPid != null) {
+      try {
+        const idx = transcriptTee._readIndex(config.projectDir);
+        const i = idx.spawns.findIndex((s) => s.spawnId === spawnId);
+        if (i >= 0) { idx.spawns[i].workerPid = workerPid; transcriptTee._writeIndex(config.projectDir, idx); }
+      } catch (_) {}
+    }
     if (typeof opts.onSpawn === 'function') {
-      try { opts.onSpawn({ child, pid: workerPid }); } catch (_) {}
+      try { opts.onSpawn({ child, pid: workerPid, spawnId }); } catch (_) {}
     }
 
     let stdoutBuf = '';
@@ -92,6 +118,9 @@ function runWorker(opts) {
     let killTimer = null;
 
     const handleLine = (line) => {
+      if (transcriptOpened) {
+        try { transcriptTee.appendFrame({ spawnId, projectDir: config.projectDir, frame: line }); } catch (_) {}
+      }
       try {
         const frame = JSON.parse(line);
         if (typeof onFrame === 'function') onFrame(frame);
@@ -171,7 +200,10 @@ function runWorker(opts) {
       }
 
       emitBoundary(onFrame, task, result.ok ? 'done' : 'failed', { exitCode, durationMs, workerPid });
-      resolve({ result, exitCode, durationMs, timedOut, stderr: stderrBuf, workerPid });
+      if (transcriptOpened) {
+        try { transcriptTee.closeTranscript({ spawnId, projectDir: config.projectDir, status: result.ok ? 'done' : 'failed' }); } catch (_) {}
+      }
+      resolve({ result, exitCode, durationMs, timedOut, stderr: stderrBuf, workerPid, spawnId });
     });
 
     child.stdin.on('error', () => { /* ignore — covered by child exit */ });

package/bin/gsd-t-token-capture.cjs

@@ -20,7 +20,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 
 const NEW_HEADER = '| Datetime-start | Datetime-end | Command | Step | Model | Duration(s) | Tokens | Notes | Domain | Task | Ctx% |';
 const NEW_SEP    = '|---|---|---|---|---|---|---|---|---|---|---|';
@@ -94,10 +94,10 @@ function _appendJsonlRecord(jsonlPath, record) {
   fs.appendFileSync(jsonlPath, JSON.stringify(record) + '\n');
 }
 
-function _buildJsonlRecord({ command, step, model, startedAt, endedAt, durationSec, usage, domain, task, notes, ctxPct, milestone, source }) {
+function _buildJsonlRecord({ command, step, model, startedAt, endedAt, durationSec, usage, domain, task, notes, ctxPct, milestone, source, sessionId, turnId, sessionType, toolAttribution, compactionPressure }) {
   const u = usage || {};
   const cost = (typeof u.total_cost_usd === 'number') ? u.total_cost_usd : (typeof u.cost_usd === 'number' ? u.cost_usd : null);
-  return {
+  const rec = {
     schemaVersion: SCHEMA_VERSION,
     ts: new Date().toISOString(),
     source: source || 'live',
@@ -119,6 +119,12 @@ function _buildJsonlRecord({ command, step, model, startedAt, endedAt, durationS
     notes: notes || null,
     hasUsage: !!usage,
   };
+  if (sessionId != null)  rec.session_id  = String(sessionId);
+  if (turnId != null)     rec.turn_id     = String(turnId);
+  if (sessionType != null) rec.sessionType = sessionType;
+  if (Array.isArray(toolAttribution) && toolAttribution.length) rec.tool_attribution = toolAttribution;
+  if (compactionPressure && typeof compactionPressure === 'object') rec.compaction_pressure = compactionPressure;
+  return rec;
 }
 
 function _inferMilestone(projectDir) {
@@ -163,6 +169,11 @@ function _parseStartedAt(s) {
  * @param {string|number} [opts.ctxPct]
  * @param {string} [opts.notes]
  * @param {'live'|'backfill'} [opts.source]
+ * @param {string} [opts.sessionId]          v2 — stable session identifier
+ * @param {string|number} [opts.turnId]      v2 — per-turn identifier within sessionId
+ * @param {'in-session'|'headless'} [opts.sessionType]  v2 — channel classifier
+ * @param {Array}  [opts.toolAttribution]    v2 — D2 joiner output; usually omitted by spawn callers
+ * @param {object} [opts.compactionPressure] v2 — D5 runway snapshot; usually omitted by spawn callers
  * @returns {{tokenLogPath: string, jsonlPath: string}}
  */
 function recordSpawnRow(opts) {
@@ -209,6 +220,11 @@ function recordSpawnRow(opts) {
     ctxPct: opts.ctxPct == null ? null : opts.ctxPct,
     milestone,
     source: opts.source || 'live',
+    sessionId: opts.sessionId,
+    turnId: opts.turnId,
+    sessionType: opts.sessionType,
+    toolAttribution: opts.toolAttribution,
+    compactionPressure: opts.compactionPressure,
   }));
 
   return { tokenLogPath, jsonlPath };
@@ -266,6 +282,11 @@ async function captureSpawn(opts) {
     task: opts.task,
     ctxPct,
     notes,
+    sessionId: opts.sessionId,
+    turnId: opts.turnId,
+    sessionType: opts.sessionType,
+    toolAttribution: opts.toolAttribution,
+    compactionPressure: opts.compactionPressure,
   });
 
   if (caught) throw caught;

package/bin/gsd-t-token-regenerate-log.cjs

@@ -0,0 +1,129 @@
+'use strict';
+/**
+ * GSD-T Token Log Regenerator (M43 D3)
+ *
+ * Reads `.gsd-t/metrics/token-usage.jsonl` end-to-end and writes
+ * `.gsd-t/token-log.md` deterministically. Per metrics-schema-contract v2
+ * §Derived Artifact, `token-log.md` is a regenerated view post-v2.
+ *
+ * Sort (v2 §5): startedAt asc → session_id asc → turn_id asc.
+ * Numeric turn_ids sort numerically; mixed/non-numeric falls back to lex.
+ *
+ * Idempotent and deterministic: running twice produces byte-identical output.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const capture = require('./gsd-t-token-capture.cjs');
+const { NEW_HEADER, NEW_SEP, _formatTokensCell } = capture;
+
+function _readJsonl(jsonlPath) {
+  if (!fs.existsSync(jsonlPath)) return [];
+  const text = fs.readFileSync(jsonlPath, 'utf8');
+  const rows = [];
+  for (const line of text.split('\n')) {
+    const s = line.trim();
+    if (!s) continue;
+    try { rows.push(JSON.parse(s)); }
+    catch (_) { /* skip malformed line */ }
+  }
+  return rows;
+}
+
+function _tokenCellFromRow(row) {
+  if (!row.hasUsage) return '—';
+  const u = {
+    input_tokens: row.inputTokens || 0,
+    output_tokens: row.outputTokens || 0,
+    cache_read_input_tokens: row.cacheReadInputTokens || 0,
+    cache_creation_input_tokens: row.cacheCreationInputTokens || 0,
+    total_cost_usd: (typeof row.costUSD === 'number') ? row.costUSD : undefined,
+  };
+  return _formatTokensCell(u);
+}
+
+function _cmpStart(a, b) {
+  const av = a.startedAt || '';
+  const bv = b.startedAt || '';
+  if (av < bv) return -1;
+  if (av > bv) return 1;
+  return 0;
+}
+
+function _cmpSession(a, b) {
+  const av = a.session_id == null ? '' : String(a.session_id);
+  const bv = b.session_id == null ? '' : String(b.session_id);
+  if (av < bv) return -1;
+  if (av > bv) return 1;
+  return 0;
+}
+
+function _cmpTurn(a, b) {
+  const av = a.turn_id == null ? '' : String(a.turn_id);
+  const bv = b.turn_id == null ? '' : String(b.turn_id);
+  const an = Number(av), bn = Number(bv);
+  if (av !== '' && bv !== '' && Number.isFinite(an) && Number.isFinite(bn)) {
+    return an - bn;
+  }
+  if (av < bv) return -1;
+  if (av > bv) return 1;
+  return 0;
+}
+
+function sortRows(rows) {
+  return rows.slice().sort((a, b) =>
+    _cmpStart(a, b) || _cmpSession(a, b) || _cmpTurn(a, b)
+  );
+}
+
+function _durationCell(row) {
+  const ms = Number(row.durationMs || 0);
+  return `${Math.max(0, Math.round(ms / 1000))}s`;
+}
+
+function _renderRow(row) {
+  const tokensCell = _tokenCellFromRow(row);
+  const notes  = (row.notes  == null || row.notes  === '') ? '-' : String(row.notes).replace(/\|/g, '\\|');
+  const domain = (row.domain == null || row.domain === '') ? '-' : String(row.domain);
+  const task   = (row.task   == null || row.task   === '') ? '-' : String(row.task);
+  const ctxPct = (row.ctxPct == null) ? 'N/A' : String(row.ctxPct);
+  return `| ${row.startedAt || ''} | ${row.endedAt || ''} | ${row.command || ''} | ${row.step || ''} | ${row.model || ''} | ${_durationCell(row)} | ${tokensCell} | ${notes} | ${domain} | ${task} | ${ctxPct} |`;
+}
+
+function renderMarkdown(rows) {
+  const sorted = sortRows(rows);
+  const lines = ['# GSD-T Token Log', '', NEW_HEADER, NEW_SEP];
+  for (const r of sorted) lines.push(_renderRow(r));
+  lines.push('');
+  return lines.join('\n');
+}
+
+/**
+ * Regenerate token-log.md from token-usage.jsonl.
+ * @param {object} [opts]
+ * @param {string} [opts.projectDir='.']
+ * @param {string} [opts.jsonlPath]     override input path
+ * @param {string} [opts.tokenLogPath]  override output path
+ * @returns {{ wrote: string, rowCount: number }}
+ */
+function regenerateLog(opts = {}) {
+  const projectDir = opts.projectDir || '.';
+  const jsonlPath = opts.jsonlPath || path.join(projectDir, '.gsd-t', 'metrics', 'token-usage.jsonl');
+  const tokenLogPath = opts.tokenLogPath || path.join(projectDir, '.gsd-t', 'token-log.md');
+  const rows = _readJsonl(jsonlPath);
+  const markdown = renderMarkdown(rows);
+  const dir = path.dirname(tokenLogPath);
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(tokenLogPath, markdown);
+  return { wrote: tokenLogPath, rowCount: rows.length };
+}
+
+module.exports = {
+  regenerateLog,
+  renderMarkdown,
+  sortRows,
+  _readJsonl,
+  _renderRow,
+  _tokenCellFromRow,
+};

package/bin/gsd-t-transcript-tee.cjs

@@ -0,0 +1,246 @@
+'use strict';
+/**
+ * GSD-T Transcript Tee (M42 D1)
+ *
+ * Captures raw stream-json frames from every unattended spawn to
+ * `.gsd-t/transcripts/{spawn-id}.ndjson` + maintains a registry at
+ * `.gsd-t/transcripts/.index.json` used by the dashboard sidebar.
+ *
+ * Zero external deps. Append-only. Does not parse the frames — that's the
+ * renderer's job. One frame per line; lines that fail JSON parse are still
+ * tee'd so nothing is silently dropped.
+ *
+ * Contracts:
+ *   - .gsd-t/contracts/stream-json-sink-contract.md v1.1.0 (frame shape)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const TRANSCRIPTS_DIRNAME = path.join('.gsd-t', 'transcripts');
+const INDEX_FILENAME = '.index.json';
+
+function _transcriptsDir(projectDir) {
+  return path.join(projectDir || '.', TRANSCRIPTS_DIRNAME);
+}
+
+function _indexPath(projectDir) {
+  return path.join(_transcriptsDir(projectDir), INDEX_FILENAME);
+}
+
+function _ensureDir(p) {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+/**
+ * Allocate a hierarchical spawn-id. Shape: `{parent-prefix}-{short}` where
+ * `short` is an 8-char hex from a random UUID. Root spawns get no prefix.
+ *
+ * @param {object} [opts]
+ * @param {string|null} [opts.parentId]
+ * @returns {string}
+ */
+function allocateSpawnId(opts) {
+  const parentId = opts && opts.parentId ? String(opts.parentId) : null;
+  const short = crypto.randomBytes(4).toString('hex');
+  return parentId ? `${parentId}.${short}` : `s-${short}`;
+}
+
+function _readIndex(projectDir) {
+  const p = _indexPath(projectDir);
+  if (!fs.existsSync(p)) return { spawns: [] };
+  try {
+    const raw = fs.readFileSync(p, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== 'object' || !Array.isArray(parsed.spawns)) return { spawns: [] };
+    return parsed;
+  } catch (_) {
+    return { spawns: [] };
+  }
+}
+
+function _writeIndex(projectDir, idx) {
+  const p = _indexPath(projectDir);
+  _ensureDir(path.dirname(p));
+  const tmp = p + '.tmp';
+  fs.writeFileSync(tmp, JSON.stringify(idx, null, 2));
+  fs.renameSync(tmp, p);
+}
+
+/**
+ * Register a new transcript + create the ndjson file.
+ *
+ * @param {object} opts
+ * @param {string} opts.spawnId
+ * @param {string} [opts.projectDir='.']
+ * @param {object} [opts.meta]           { parentId?, command?, description?, workerPid?, model? }
+ * @returns {{spawnId, transcriptPath, startedAt}}
+ */
+function openTranscript(opts) {
+  if (!opts || !opts.spawnId) throw new Error('openTranscript: spawnId required');
+  const projectDir = opts.projectDir || '.';
+  const meta = opts.meta || {};
+  const dir = _transcriptsDir(projectDir);
+  _ensureDir(dir);
+
+  const transcriptPath = path.join(dir, `${opts.spawnId}.ndjson`);
+  if (!fs.existsSync(transcriptPath)) {
+    fs.writeFileSync(transcriptPath, '');
+  }
+
+  const startedAt = new Date().toISOString();
+  const entry = {
+    spawnId: opts.spawnId,
+    parentId: meta.parentId || null,
+    command: meta.command || null,
+    description: meta.description || null,
+    model: meta.model || null,
+    workerPid: meta.workerPid || null,
+    startedAt,
+    endedAt: null,
+    status: 'running',
+  };
+
+  const idx = _readIndex(projectDir);
+  const existing = idx.spawns.findIndex((s) => s.spawnId === opts.spawnId);
+  if (existing >= 0) {
+    idx.spawns[existing] = { ...idx.spawns[existing], ...entry };
+  } else {
+    idx.spawns.push(entry);
+  }
+  _writeIndex(projectDir, idx);
+
+  return { spawnId: opts.spawnId, transcriptPath, startedAt };
+}
+
+/**
+ * Append a single frame (already JSON-serializable) to the transcript.
+ * `frame` may be a parsed object OR a raw string line — strings are wrapped
+ * as `{type:"raw",line}` so the ndjson shape stays uniform.
+ *
+ * @param {object} opts
+ * @param {string} opts.spawnId
+ * @param {string} [opts.projectDir='.']
+ * @param {object|string} opts.frame
+ */
+function appendFrame(opts) {
+  if (!opts || !opts.spawnId) throw new Error('appendFrame: spawnId required');
+  if (opts.frame === undefined || opts.frame === null) return;
+  const projectDir = opts.projectDir || '.';
+  const p = path.join(_transcriptsDir(projectDir), `${opts.spawnId}.ndjson`);
+  _ensureDir(path.dirname(p));
+
+  let line;
+  if (typeof opts.frame === 'string') {
+    const trimmed = opts.frame.trim();
+    if (!trimmed) return;
+    try {
+      JSON.parse(trimmed);
+      line = trimmed;
+    } catch (_) {
+      line = JSON.stringify({ type: 'raw', line: opts.frame });
+    }
+  } else {
+    try {
+      line = JSON.stringify(opts.frame);
+    } catch (_) {
+      line = JSON.stringify({ type: 'raw', line: String(opts.frame) });
+    }
+  }
+  fs.appendFileSync(p, line + '\n');
+}
+
+/**
+ * Mark a transcript as ended. Idempotent — subsequent calls update endedAt.
+ *
+ * @param {object} opts
+ * @param {string} opts.spawnId
+ * @param {string} [opts.projectDir='.']
+ * @param {'done'|'failed'|'stopped'|'ended'} [opts.status='ended']
+ */
+function closeTranscript(opts) {
+  if (!opts || !opts.spawnId) throw new Error('closeTranscript: spawnId required');
+  const projectDir = opts.projectDir || '.';
+  const idx = _readIndex(projectDir);
+  const i = idx.spawns.findIndex((s) => s.spawnId === opts.spawnId);
+  if (i < 0) return false;
+  idx.spawns[i].endedAt = new Date().toISOString();
+  idx.spawns[i].status = opts.status || 'ended';
+  _writeIndex(projectDir, idx);
+  return true;
+}
+
+/**
+ * List registered spawns (most recent first).
+ *
+ * @param {string} [projectDir='.']
+ * @returns {Array<object>}
+ */
+function listTranscripts(projectDir) {
+  const idx = _readIndex(projectDir || '.');
+  return idx.spawns.slice().sort((a, b) => {
+    const ta = Date.parse(a.startedAt) || 0;
+    const tb = Date.parse(b.startedAt) || 0;
+    return tb - ta;
+  });
+}
+
+function readTranscriptMeta(projectDir, spawnId) {
+  const idx = _readIndex(projectDir || '.');
+  return idx.spawns.find((s) => s.spawnId === spawnId) || null;
+}
+
+/**
+ * Tee a stream-json stdout stream. Returns an `onChunk(buffer)` callback that
+ * you feed chunks to (typed as Buffer or string). Frames are split at `\n`
+ * and each complete line is written to the transcript ndjson. Incomplete
+ * tails are buffered until the next chunk.
+ *
+ * Returns also a `flush()` to call on child exit — writes any stranded tail
+ * as a single `{type:"raw"}` line so nothing is dropped.
+ *
+ * @param {object} opts
+ * @param {string} opts.spawnId
+ * @param {string} [opts.projectDir='.']
+ * @returns {{onChunk: (chunk) => void, flush: () => void}}
+ */
+function makeStreamTee(opts) {
+  if (!opts || !opts.spawnId) throw new Error('makeStreamTee: spawnId required');
+  const projectDir = opts.projectDir || '.';
+  const spawnId = opts.spawnId;
+  let buf = '';
+
+  return {
+    onChunk(chunk) {
+      if (chunk == null) return;
+      buf += Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk);
+      let nl;
+      while ((nl = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, nl);
+        buf = buf.slice(nl + 1);
+        if (line.length > 0) appendFrame({ spawnId, projectDir, frame: line });
+      }
+    },
+    flush() {
+      if (buf.length > 0) {
+        appendFrame({ spawnId, projectDir, frame: buf });
+        buf = '';
+      }
+    },
+  };
+}
+
+module.exports = {
+  allocateSpawnId,
+  openTranscript,
+  appendFrame,
+  closeTranscript,
+  listTranscripts,
+  readTranscriptMeta,
+  makeStreamTee,
+  _readIndex,
+  _writeIndex,
+  TRANSCRIPTS_DIRNAME,
+  INDEX_FILENAME,
+};