@tekyzinc/gsd-t 3.10.13 → 3.10.14

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [3.10.14] - 2026-04-15
+
+### Fixed — transcript parser orphaned tool_use blocks cause count_tokens 400
+
+**Background**: With `ANTHROPIC_API_KEY` now set (v3.10.12-13 fix), the context meter hook passed the key check but the `count_tokens` API returned HTTP 400: `"tool_use ids were found without tool_result blocks immediately after"`. The transcript parser (`scripts/context-meter/transcript-parser.js`) faithfully reconstructed the JSONL transcript but didn't enforce the API's strict adjacency constraint: every assistant `tool_use` must be immediately followed by a user `tool_result` with matching ids. Mid-session compaction and summarization can orphan these blocks.
+
+### Changed
+- **`scripts/context-meter/transcript-parser.js`** — added `sanitizeToolPairs()` post-processing pass after message reconstruction. Walks the message list enforcing adjacency: assistant `tool_use` blocks are kept only if the immediately following user message contains a `tool_result` with a matching id, and vice versa. Messages that become empty after stripping are dropped. This is a structural fix — any transcript shape (compacted, summarized, interrupted) now produces a valid `count_tokens` payload.
+- **`scripts/context-meter/transcript-parser.test.js`** — updated 2 existing tests that created orphaned `tool_result` messages (now include matching `tool_use` predecessors). Added 1 new test: `orphaned tool_use without matching tool_result is stripped`. 1229/1229 tests pass.
+
+### Verification
+- Real transcript (626→649 messages, 473KB payload) now returns HTTP 200 with `input_tokens: 153597` (was 400 before fix)
+- Context meter state file flipped from `lastError: api_error` to `lastError: null`, `inputTokens: 158543`, `pct: 79.3%`, `threshold: warn`
+- First successful real-time context measurement since M34 was built
+
 ## [3.10.13] - 2026-04-15
 
 ### Fixed — P0 v3.10.12 propagation gap (same regression, downstream projects)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.10.13",
+  "version": "3.10.14",
   "description": "GSD-T: Contract-Driven Development for Claude Code — 61 slash commands with unattended supervisor relay, headless CI/CD mode, graph-powered code analysis, real-time agent dashboard, execution intelligence, task telemetry, doc-ripple enforcement, backlog management, impact analysis, test sync, milestone archival, and PRD generation",
   "author": "Tekyz, Inc.",
   "license": "MIT",

package/scripts/context-meter/transcript-parser.js

@@ -152,7 +152,69 @@ async function parseTranscript(transcriptPath) {
     return null;
   }
 
-  return { system, messages };
+  return { system, messages: sanitizeToolPairs(messages) };
+}
+
+/**
+ * Enforce the count_tokens adjacency constraint: every assistant tool_use
+ * must be immediately followed by a user message whose tool_result ids match
+ * ALL tool_use ids from the preceding assistant message.  Walk the message
+ * list and strip tool_use / tool_result blocks from any pair that violates
+ * this rule. Drop messages that become empty after stripping.
+ */
+function sanitizeToolPairs(messages) {
+  const out = [];
+  for (let i = 0; i < messages.length; i++) {
+    const m = messages[i];
+    if (!Array.isArray(m.content)) { out.push(m); continue; }
+
+    if (m.role === "assistant") {
+      const toolUseIds = new Set();
+      for (const b of m.content) {
+        if (b.type === "tool_use" && typeof b.id === "string") toolUseIds.add(b.id);
+      }
+
+      if (toolUseIds.size === 0) { out.push(m); continue; }
+
+      const next = messages[i + 1];
+      const nextResultIds = new Set();
+      if (next && next.role === "user" && Array.isArray(next.content)) {
+        for (const b of next.content) {
+          if (b.type === "tool_result" && typeof b.tool_use_id === "string") {
+            nextResultIds.add(b.tool_use_id);
+          }
+        }
+      }
+
+      const validIds = new Set([...toolUseIds].filter((id) => nextResultIds.has(id)));
+      const filtered = m.content.filter((b) => {
+        if (b.type === "tool_use") return validIds.has(b.id);
+        return true;
+      });
+      if (filtered.length > 0) out.push({ role: m.role, content: filtered });
+      continue;
+    }
+
+    if (m.role === "user") {
+      const prev = out[out.length - 1];
+      const prevUseIds = new Set();
+      if (prev && prev.role === "assistant" && Array.isArray(prev.content)) {
+        for (const b of prev.content) {
+          if (b.type === "tool_use" && typeof b.id === "string") prevUseIds.add(b.id);
+        }
+      }
+
+      const filtered = m.content.filter((b) => {
+        if (b.type === "tool_result") return prevUseIds.has(b.tool_use_id);
+        return true;
+      });
+      if (filtered.length > 0) out.push({ role: m.role, content: filtered });
+      continue;
+    }
+
+    out.push(m);
+  }
+  return out;
 }
 
 /**

package/scripts/context-meter/transcript-parser.test.js

@@ -176,6 +176,15 @@ test("tool_use / tool_result pairing by tool_use_id preserved in order", async (
 
 test("tool_result with array content (text blocks) is normalized", async () => {
   const { dir, file } = mkTmpFile([
+    {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "toolu_02", name: "Read", input: { file_path: "/tmp/x" } },
+        ],
+      },
+    },
     {
       type: "user",
       message: {
@@ -196,8 +205,8 @@ test("tool_result with array content (text blocks) is normalized", async () => {
   ]);
   try {
     const got = await parseTranscript(file);
-    assert.equal(got.messages.length, 1);
-    const tr = got.messages[0].content[0];
+    const userMsg = got.messages.find(m => m.role === "user");
+    const tr = userMsg.content[0];
     assert.equal(tr.type, "tool_result");
     assert.deepEqual(tr.content, [
       { type: "text", text: "line 1" },
@@ -210,6 +219,15 @@ test("tool_result with array content (text blocks) is normalized", async () => {
 
 test("tool_result with is_error:true preserved", async () => {
   const { dir, file } = mkTmpFile([
+    {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "tool_use", id: "toolu_03", name: "Bash", input: { command: "false" } },
+        ],
+      },
+    },
     {
       type: "user",
       message: {
@@ -222,7 +240,8 @@ test("tool_result with is_error:true preserved", async () => {
   ]);
   try {
     const got = await parseTranscript(file);
-    assert.equal(got.messages[0].content[0].is_error, true);
+    const userMsg = got.messages.find(m => m.role === "user");
+    assert.equal(userMsg.content[0].is_error, true);
   } finally {
     cleanup(dir);
   }
@@ -318,3 +337,34 @@ test("message with content array but no recognized blocks → message skipped",
     cleanup(dir);
   }
 });
+
+test("orphaned tool_use without matching tool_result is stripped", async () => {
+  const { dir, file } = mkTmpFile([
+    { type: "user", message: { role: "user", content: "hello" } },
+    {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        content: [
+          { type: "text", text: "I will read a file" },
+          { type: "tool_use", id: "toolu_orphan", name: "Read", input: { file_path: "/tmp/x" } },
+        ],
+      },
+    },
+    { type: "user", message: { role: "user", content: "thanks" } },
+  ]);
+  try {
+    const got = await parseTranscript(file);
+    const assistantMsg = got.messages.find(
+      (m) => m.role === "assistant" && m.content.some((b) => b.type === "text")
+    );
+    assert.ok(assistantMsg, "assistant message preserved");
+    assert.ok(
+      !assistantMsg.content.some((b) => b.type === "tool_use"),
+      "orphaned tool_use stripped"
+    );
+    assert.equal(assistantMsg.content[0].text, "I will read a file");
+  } finally {
+    cleanup(dir);
+  }
+});