@tekyzinc/gsd-t 3.12.13 → 3.12.15

package/CHANGELOG.md

@@ -2,6 +2,54 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [3.12.15] - 2026-04-17
+
+### Fixed — Decision Log Trim — stop live progress.md bloat
+
+`commands/gsd-t-complete-milestone.md` Step 7 previously instructed "Keep all prior decision log entries — they are valuable context". Because every prior milestone's full log is already frozen into its archive snapshot by Step 4, carrying the same entries forward on the live `.gsd-t/progress.md` produced unbounded file growth (GSD-T's live file had reached 168,921 bytes / 658 lines — 10× the size of a healthy project).
+
+**Fix**: Step 7 now explicitly trims the live Decision Log to the just-completed milestone's entries after the archive snapshot is written. The instruction reads:
+
+> Delete all decision-log entries older than the just-completed milestone's start date. Those entries are preserved in the milestone archive created in Step 4. Keep only the completion entry plus any entries logged on or after the cutoff — typically the live log is near-empty when the next milestone begins.
+
+The archive at `.gsd-t/milestones/{name}-{date}/progress.md` remains the source-of-truth for the full history. A pointer line (`> Prior decision log entries preserved in .gsd-t/milestones/*/progress.md`) is added to the live file so future readers know where to look.
+
+**One-time cleanup on the GSD-T repo**: live `.gsd-t/progress.md` trimmed from 168,921 B / 658 lines to 11,733 B / 67 lines (93% reduction), cut at M38 start (2026-04-16 14:25). Historical decision log preserved by copying the pre-trim file into `.gsd-t/milestones/M38-headless-by-default-2026-04-17/progress.md` (Step 4 missed that archive copy when M38 was completed earlier today; fix-forward).
+
+**Users with bloated `.gsd-t/progress.md`** can run the same one-time cleanup manually: find the current milestone's `[milestone-defined]` start entry in the Decision Log, copy the pre-trim file to the milestone archive directory (if it's not already there), then delete all Decision Log entries older than that start date. Keep the pointer line at the top of the Decision Log section.
+
+**Tests**: Unit 1186/1186 pass (no code paths changed — pure doc/template edits + one-time live file rewrite). E2E N/A.
+
+## [3.12.14] - 2026-04-17
+
+### Fixed — Telemetry Env-Propagation Regression (Tag All Worker Events)
+
+v3.12.12 added `GSD_T_COMMAND`/`GSD_T_PHASE` env-var fallbacks to `scripts/gsd-t-event-writer.js` but two critical call sites were missed — producing mostly-null telemetry in production.
+
+**Evidence from bee-poc (50 min observation)**: 908 events, only 1/908 had `command` populated; 836 `tool_call` events had command/phase/trace_id all null; only 2 `.gsd-t/token-log.md` rows (both from the outer supervisor process; 37 inner subagents wrote zero rows); supervisor row showed `model=unknown`.
+
+**Root causes**:
+1. `scripts/gsd-t-heartbeat.js::buildEventStreamEntry` — this PostToolUse hook fires on every tool call in every child process (the source of ~90% of events) and hardcoded `{command: null, phase: null, trace_id: null}` into every event it wrote.
+2. Neither the writer nor the heartbeat read `GSD_T_TRACE_ID` or `GSD_T_MODEL` from env — so even when spawners set them, they never appeared on events.
+3. Several spawn sites (orchestrator, `spawnClaudeSession`, `runLedgerCompaction`, design-review claude spawn) never set the GSD_T_* env block at all.
+
+**Fixes**:
+- `scripts/gsd-t-event-writer.js::buildEvent` now reads `GSD_T_TRACE_ID` and `GSD_T_MODEL` env fallbacks alongside command/phase.
+- `scripts/gsd-t-heartbeat.js::buildEventStreamEntry` replaced hardcoded null triple with `process.env.GSD_T_COMMAND||null` / `GSD_T_PHASE||null` / `GSD_T_TRACE_ID||null`.
+- `bin/headless-auto-spawn.{cjs,js}` workerEnv sets `GSD_T_COMMAND` + `GSD_T_PHASE` + `GSD_T_PROJECT_DIR`, and conditionally forwards parent `GSD_T_TRACE_ID` / `GSD_T_MODEL`. `appendTokenLog` reads `process.env.GSD_T_MODEL` instead of the `"unknown"` literal.
+- `bin/gsd-t-unattended.cjs::_spawnWorker` workerEnv populates the full GSD_T_* block from `state` + env fallbacks. `_appendTokenLog` reads `process.env.GSD_T_MODEL`.
+- `bin/gsd-t.js` three sites patched: `doHeadlessExec` workerEnv, `spawnClaudeSession` (fallback command=`gsd-t-debug` / phase=`debug`), `runLedgerCompaction` (fallback model=`haiku`). `appendHeadlessTokenLog` reads `process.env.GSD_T_MODEL`.
+- `bin/orchestrator.js` new `_buildOrchestratorEnv(opts, projectDir)` helper threaded through `spawnClaude` (sync) and `spawnClaudeAsync`.
+- `scripts/gsd-t-design-review-server.js` claude spawn now injects the GSD_T_* env block.
+
+**Reproduction test**: NEW `test/telemetry-env-propagation.test.js` — 6 tests that exercise the REAL production spawn code paths (not hand-rolled mocks): writer + heartbeat env-fallback unit coverage, `autoSpawnHeadless` real-spawn via env-dump shim at `bin/gsd-t.js`, unattended `platform.spawnWorker` with a real env-dump script. Failed 3/6 before fix as expected; 6/6 pass after.
+
+**Tests**: Unit 1186/1186 pass. E2E N/A (no `playwright.config.*` or `cypress.config.*`).
+
+**Red Team** (opus, adversarial sweep categories: regression-around-fix + original-bug-variants covering context-meter hook and PostToolUse hook paths): verdict **GRUDGING PASS** — 5 additional claude-worker spawn sites found and patched in this same release; no untagged claude-worker spawn paths remain.
+
+**Doc ripple**: `.gsd-t/contracts/event-schema-contract.md` new "Env-Var Fallbacks (v3.12.14)" section with flag/env/caller table; `.gsd-t/contracts/headless-default-contract.md` new "Worker Env Propagation (v3.12.14)" section; `.gsd-t/contracts/unattended-supervisor-contract.md` §14b v1.2.0 Worker Env Propagation + version history entry.
+
 ## [3.12.13] - 2026-04-17
 
 ### Fixed — `/` Prefix Strip Sitewide

package/bin/gsd-t-unattended.cjs

@@ -1087,8 +1087,10 @@ function _appendTokenLog(projectDir, entry) {
     const note = entry.exitCode === 0
       ? `supervisor iter=${entry.iter}: ok`
       : `supervisor iter=${entry.iter}: exit ${entry.exitCode}`;
+    // v3.12.14: prefer env-var model over the hardcoded "unknown" placeholder.
+    const model = process.env.GSD_T_MODEL || "unknown";
     const row =
-      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | supervisor-iter-${entry.iter} | unknown | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
+      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | supervisor-iter-${entry.iter} | ${model} | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
     const gsdtDir = path.join(projectDir, ".gsd-t");
     if (!fs.existsSync(gsdtDir)) fs.mkdirSync(gsdtDir, { recursive: true });
     if (!fs.existsSync(logPath)) {
@@ -1119,15 +1121,23 @@ function _appendTokenLog(projectDir, entry) {
  */
 function _spawnWorker(state, opts) {
   const bin = (state && state.claudeBin) || resolveClaudePath();
-  // Inject command/phase so event-stream tool_call entries are tagged in worker
-  // contexts (Fix 2, v3.12.12). Supervisor always runs gsd-t-resume workers;
-  // phase is inferred from state when available.
+  // Inject command/phase/trace/model/project-dir so event-stream tool_call
+  // entries (writer CLI + heartbeat hook) are tagged in worker contexts
+  // (Fix 2, v3.12.12; trace/model/project-dir added v3.12.14 for the
+  // null-telemetry regression fix). Supervisor always runs gsd-t-resume
+  // workers; phase is inferred from state when available. Trace/model flow
+  // through from parent process.env when set.
   const workerEnv = {
     ...process.env,
     GSD_T_UNATTENDED_WORKER: "1",
     GSD_T_COMMAND: "gsd-t-resume",
     GSD_T_PHASE: (state && state.phase) || "execute",
+    GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || opts.cwd || state.projectDir,
   };
+  if (state && state.traceId) workerEnv.GSD_T_TRACE_ID = state.traceId;
+  else if (process.env.GSD_T_TRACE_ID) workerEnv.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+  if (state && state.model) workerEnv.GSD_T_MODEL = state.model;
+  else if (process.env.GSD_T_MODEL) workerEnv.GSD_T_MODEL = process.env.GSD_T_MODEL;
   const res = platformSpawnWorker(opts.cwd, opts.timeout, {
     bin,
     args: [

package/bin/gsd-t.js

@@ -2743,8 +2743,10 @@ function appendHeadlessTokenLog(projectDir, entry) {
   try {
     const logPath = path.join(projectDir, ".gsd-t", "token-log.md");
     const note = entry.exitCode === 0 ? "headless exec: ok" : `headless exec: exit ${entry.exitCode}`;
+    // v3.12.14: prefer env-var model over hardcoded "unknown".
+    const model = process.env.GSD_T_MODEL || "unknown";
     const row =
-      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | headless | unknown | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
+      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | headless | ${model} | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
     const gsdtDir = path.join(projectDir, ".gsd-t");
     if (!fs.existsSync(gsdtDir)) fs.mkdirSync(gsdtDir, { recursive: true });
     if (!fs.existsSync(logPath)) {
@@ -2879,12 +2881,17 @@ function doHeadlessExec(command, cmdArgs, flags) {
   let output = "";
   let processExitCode = 0;
 
-  // Inject command/phase env vars so worker event-stream entries are tagged
-  // (Fix 2, v3.12.12).
+  // Inject command/phase/trace/model/project-dir env vars so worker
+  // event-stream entries (writer CLI + heartbeat hook) are tagged in the
+  // child's context (Fix 2, v3.12.12; trace/model/project-dir added v3.12.14
+  // for the null-telemetry regression fix).
   const workerEnv = Object.assign({}, process.env, {
     GSD_T_COMMAND: `gsd-t-${command}`,
     GSD_T_PHASE: process.env.GSD_T_PHASE || "execute",
+    GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || process.cwd(),
   });
+  if (process.env.GSD_T_TRACE_ID) workerEnv.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+  if (process.env.GSD_T_MODEL) workerEnv.GSD_T_MODEL = process.env.GSD_T_MODEL;
 
   try {
     const result = execFileSync("claude", ["-p", "--dangerously-skip-permissions", prompt], {
@@ -3169,9 +3176,22 @@ function getEscalationModel(iteration) {
  */
 function spawnClaudeSession(prompt, model) {
   try {
+    // v3.12.14: propagate GSD_T_* env vars so the worker's heartbeat hook +
+    // event-writer entries are tagged with the parent command/phase/trace and
+    // this session's model. Without these, tool_call events from the debug
+    // worker appear as command=null/phase=null.
+    const env = Object.assign({}, process.env, {
+      GSD_T_COMMAND: process.env.GSD_T_COMMAND || "gsd-t-debug",
+      GSD_T_PHASE: process.env.GSD_T_PHASE || "debug",
+      GSD_T_MODEL: model || process.env.GSD_T_MODEL || null,
+      GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || process.cwd(),
+    });
+    if (env.GSD_T_MODEL === null) delete env.GSD_T_MODEL;
+    if (process.env.GSD_T_TRACE_ID) env.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
     return execFileSync("claude", ["-p", prompt, "--model", model], {
       encoding: "utf8", timeout: 300000,
       stdio: ["pipe", "pipe", "pipe"],
+      env,
     });
   } catch (e) {
     return (e.stdout || "") + (e.stderr || "") || null;
@@ -3208,8 +3228,17 @@ function runLedgerCompaction(projectDir, jsonMode) {
     JSON.stringify(entries, null, 2);
   let summary = "Compacted — see previous entries.";
   try {
+    // v3.12.14: propagate GSD_T_* env for telemetry tagging.
+    const env = Object.assign({}, process.env, {
+      GSD_T_COMMAND: process.env.GSD_T_COMMAND || "gsd-t-debug",
+      GSD_T_PHASE: process.env.GSD_T_PHASE || "debug",
+      GSD_T_MODEL: "haiku",
+      GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || projectDir,
+    });
+    if (process.env.GSD_T_TRACE_ID) env.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
     const out = execFileSync("claude", ["-p", compactPrompt, "--model", "haiku"], {
       encoding: "utf8", timeout: 120000, stdio: ["pipe", "pipe", "pipe"],
+      env,
     });
     summary = (out || "").trim() || summary;
   } catch (e) {

package/bin/headless-auto-spawn.cjs

@@ -135,12 +135,27 @@ function autoSpawnHeadless(opts) {
     const gsdtCli = path.join(projectDir, "bin", "gsd-t.js");
     const childArgs = [gsdtCli, "headless", stripGsdtPrefix(command), ...args, "--log"];
 
-    // Inject command/phase into worker env so event-stream entries are tagged
-    // (Fix 2, v3.12.12). GSD_T_PHASE defaults to "execute" for primary spawns.
+    // Inject command/phase/trace/model into worker env so event-stream entries
+    // (both the writer CLI and the heartbeat PostToolUse hook) are tagged in
+    // the child's context (Fix 2, v3.12.12; trace/model/project-dir added
+    // v3.12.14 to close the null-telemetry regression).
+    //
+    // GSD_T_PHASE defaults to "execute" for primary spawns.
+    // GSD_T_TRACE_ID / GSD_T_MODEL are inherited from parent env if set;
+    // parents (orchestrator, command files) should set them before spawning.
+    // GSD_T_PROJECT_DIR gives the writer a stable target when the child cwd
+    // drifts (e.g., temp dirs in subagents).
     const workerEnv = Object.assign({}, process.env, {
       GSD_T_COMMAND: command,
       GSD_T_PHASE: process.env.GSD_T_PHASE || "execute",
+      GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || projectDir,
     });
+    if (process.env.GSD_T_TRACE_ID) {
+      workerEnv.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+    }
+    if (process.env.GSD_T_MODEL) {
+      workerEnv.GSD_T_MODEL = process.env.GSD_T_MODEL;
+    }
 
     const child = spawn("node", childArgs, {
       cwd: projectDir,
@@ -392,8 +407,12 @@ function appendTokenLog(projectDir, entry) {
   try {
     const logPath = path.join(projectDir, ".gsd-t", "token-log.md");
     const note = entry.exitCode === 0 ? "headless spawn: ok" : `headless spawn: exit ${entry.exitCode}`;
+    // v3.12.14: prefer env-var model over the old hardcoded "unknown". The
+    // parent session should have set GSD_T_MODEL before invoking spawn; fall
+    // back to "unknown" if not (graceful).
+    const model = process.env.GSD_T_MODEL || "unknown";
     const row =
-      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | headless | unknown | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
+      `| ${entry.dtStart} | ${entry.dtEnd} | ${entry.command} | headless | ${model} | ${entry.durationS}s | ${note} | - | - | unknown |\n`;
     if (!fs.existsSync(logPath)) {
       // Create with header
       ensureDir(path.dirname(logPath));

package/bin/headless-auto-spawn.js

@@ -135,11 +135,22 @@ function autoSpawnHeadless(opts) {
     const gsdtCli = path.join(projectDir, "bin", "gsd-t.js");
     const childArgs = [gsdtCli, "headless", stripGsdtPrefix(command), ...args, "--log"];
 
+    // v3.12.14 — env-var propagation for telemetry tagging (mirror of the
+    // authoritative .cjs variant). PRODUCTION consumers import the .cjs; this
+    // .js copy is retained only to keep the legacy test green.
+    const workerEnv = Object.assign({}, process.env, {
+      GSD_T_COMMAND: command,
+      GSD_T_PHASE: process.env.GSD_T_PHASE || "execute",
+      GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || projectDir,
+    });
+    if (process.env.GSD_T_TRACE_ID) workerEnv.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+    if (process.env.GSD_T_MODEL) workerEnv.GSD_T_MODEL = process.env.GSD_T_MODEL;
+
     const child = spawn("node", childArgs, {
       cwd: projectDir,
       detached: true,
       stdio: ["ignore", logFd, logFd],
-      env: process.env,
+      env: workerEnv,
     });
 
     child.unref();

package/bin/orchestrator.js

@@ -82,6 +82,25 @@ function isPortInUse(port) {
   }
 }
 
+/**
+ * Build the env block for orchestrator-spawned `claude -p` sessions.
+ * v3.12.14 — propagates GSD_T_COMMAND/PHASE/TRACE_ID/MODEL/PROJECT_DIR so the
+ * worker's heartbeat hook and event-writer entries are tagged. Accepts the
+ * opts object (for `label`) that callers already pass and defaults missing
+ * fields from the parent process env.
+ */
+function _buildOrchestratorEnv(opts, projectDir) {
+  opts = opts || {};
+  const env = Object.assign({}, process.env, {
+    GSD_T_COMMAND: process.env.GSD_T_COMMAND || "gsd-t-orchestrator",
+    GSD_T_PHASE: process.env.GSD_T_PHASE || opts.label || "orchestrator",
+    GSD_T_PROJECT_DIR: process.env.GSD_T_PROJECT_DIR || projectDir,
+  });
+  if (process.env.GSD_T_TRACE_ID) env.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+  if (process.env.GSD_T_MODEL) env.GSD_T_MODEL = process.env.GSD_T_MODEL;
+  return env;
+}
+
 // ─── Orchestrator Class ────────────────────────────────────────────────────
 
 class Orchestrator {
@@ -212,11 +231,15 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
     const signalFile = path.join(this.getReviewDir(projectDir), `_sync-done-${Date.now()}.json`);
     let result = { output: "", exitCode: 1, duration: 0 };
 
+    // v3.12.14: propagate GSD_T_* env so the worker's heartbeat hook and
+    // event-writer entries are tagged. opts.label → phase/command hints.
+    const env = _buildOrchestratorEnv(opts, projectDir);
     const child = execFile("claude", args, {
       encoding: "utf8",
       timeout: effectiveTimeout,
       cwd: projectDir,
       maxBuffer: 10 * 1024 * 1024,
+      env,
     }, (err, stdout, stderr) => {
       this.untrackChild(child.pid);
       const raw = err ? ((err.stdout || "") + (err.stderr || "")) : (stdout || "");
@@ -264,12 +287,15 @@ ${BOLD}Phases:${RESET} ${this.wf.phases.join(" → ")}
       );
     }
 
+    // v3.12.14: propagate GSD_T_* env for telemetry tagging in the child.
+    const env = _buildOrchestratorEnv(opts, projectDir);
     return new Promise((resolve) => {
       const child = execFile("claude", args, {
         encoding: "utf8",
         timeout: timeout || 120_000,
         cwd: projectDir,
         maxBuffer: 10 * 1024 * 1024,
+        env,
       }, (err, stdout, stderr) => {
         this.untrackChild(child.pid);
         const raw = err ? ((err.stdout || "") + (err.stderr || "")) : (stdout || "");

package/commands/gsd-t-complete-milestone.md

@@ -351,6 +351,14 @@ Reset `.gsd-t/` for next milestone:
 4. Clear `.gsd-t/impact-report.md`, `.gsd-t/test-coverage.md`
 5. Update `.gsd-t/progress.md`:
 
+**CRITICAL — Decision Log Trim**: This trim happens AFTER Step 4's archive copy of `.gsd-t/progress.md` is written. The archive snapshot at `.gsd-t/milestones/{name}-{date}/progress.md` is the source-of-truth for full history. The live Decision Log is reset to the just-completed milestone's entries only — everything dated before the milestone's start date is deleted from the live file (it remains in the archive). This prevents the live progress.md from growing without bound.
+
+Steps to apply the trim:
+- Identify the just-completed milestone's start date (typically the `[milestone-defined]` entry for this milestone)
+- Delete all Decision Log entries dated BEFORE that start date from the live `.gsd-t/progress.md`
+- Keep entries from the start date onward (they cover the milestone arc + the completion entry you're about to add)
+- Prepend the pointer line shown below
+
 ```markdown
 # GSD-T Progress
 
@@ -365,8 +373,11 @@ None — ready for next milestone
 | {previous} | {version} | {date} | v{version} |
 
 ## Decision Log
+
+> Prior decision log entries preserved in `.gsd-t/milestones/*/progress.md` — see archive snapshots for pre-{next-milestone-name} history.
+
 - {date}: [success] Milestone "{name}" completed — {summary of what was built}. v{version}
-{Keep all prior decision log entries — they are valuable context}
+{Trim: delete all decision-log entries older than the just-completed milestone's start date. Those entries are preserved in the milestone archive created in Step 4. Keep only the completion entry above plus any entries logged on or after the cutoff — typically the live log is near-empty when the next milestone begins.}
 ```
 
 ## Step 8: Update README.md

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.12.13",
+  "version": "3.12.15",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 54 slash commands with headless-by-default workflow spawning, unattended supervisor relay with event stream, graph-powered code analysis, real-time agent dashboard, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/scripts/gsd-t-design-review-server.js

@@ -685,12 +685,22 @@ const server = http.createServer((req, res) => {
           "Access-Control-Allow-Origin": "*",
         });
 
+        // v3.12.14: propagate GSD_T_* env for telemetry tagging in the worker.
+        const childEnv = {
+          ...process.env,
+          NO_COLOR: "1",
+          GSD_T_COMMAND: process.env.GSD_T_COMMAND || "gsd-t-design-review",
+          GSD_T_PHASE: process.env.GSD_T_PHASE || "design-review",
+          GSD_T_MODEL: model || process.env.GSD_T_MODEL || "unknown",
+        };
+        if (process.env.GSD_T_TRACE_ID) childEnv.GSD_T_TRACE_ID = process.env.GSD_T_TRACE_ID;
+        if (process.env.GSD_T_PROJECT_DIR) childEnv.GSD_T_PROJECT_DIR = process.env.GSD_T_PROJECT_DIR;
         const claude = spawn("claude", [
           "-p", fullPrompt,
           "--model", model,
           "--output-format", "stream-json",
           "--verbose",
-        ], { env: { ...process.env, NO_COLOR: "1" } });
+        ], { env: childEnv });
 
         let buf = "";
         let textSent = 0;

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

@@ -72,10 +72,13 @@ function nullify(val) {
 
 function buildEvent(args) {
   // Env-var fallbacks: workers spawned by supervisor/headless-auto-spawn inherit
-  // GSD_T_COMMAND and GSD_T_PHASE so tool_call events are tagged even when the
-  // worker doesn't pass --command/--phase explicitly (Fix 2, v3.12.12).
+  // GSD_T_COMMAND, GSD_T_PHASE, GSD_T_TRACE_ID, GSD_T_MODEL so tool_call events
+  // are tagged even when the worker doesn't pass --command/--phase/--trace-id/
+  // --model explicitly (Fix 2, v3.12.12; trace/model added v3.12.14).
   const envCommand = process.env.GSD_T_COMMAND || null;
   const envPhase = process.env.GSD_T_PHASE || null;
+  const envTraceId = process.env.GSD_T_TRACE_ID || null;
+  const envModel = process.env.GSD_T_MODEL || null;
 
   return {
     ts: new Date().toISOString(),
@@ -84,10 +87,10 @@ function buildEvent(args) {
     phase: nullify(args["phase"]) || envPhase,
     agent_id: nullify(args["agent-id"]),
     parent_agent_id: nullify(args["parent-id"]),
-    trace_id: nullify(args["trace-id"]),
+    trace_id: nullify(args["trace-id"]) || envTraceId,
     reasoning: nullify(args["reasoning"]),
     outcome: nullify(args["outcome"]),
-    model: nullify(args["model"]),
+    model: nullify(args["model"]) || envModel,
   };
 }
 

package/scripts/gsd-t-heartbeat.js

@@ -187,7 +187,17 @@ function shortPath(p) {
 
 function buildEventStreamEntry(hook) {
   const ts = new Date().toISOString();
-  const base = { ts, command: null, phase: null, trace_id: null };
+  // Env-var fallbacks: supervisor/headless spawned workers inherit these on
+  // their process.env so PostToolUse tool_call events are tagged instead of
+  // landing as null/null/null in the stream (v3.12.14 telemetry fix — the
+  // writer had these fallbacks since v3.12.12 but the heartbeat hook — source
+  // of ~90% of tool_call events — hardcoded nulls).
+  const base = {
+    ts,
+    command: process.env.GSD_T_COMMAND || null,
+    phase: process.env.GSD_T_PHASE || null,
+    trace_id: process.env.GSD_T_TRACE_ID || null,
+  };
   const n = hook.hook_event_name;
   if (n === "SessionStart") {
     return { ...base, event_type: "session_start",