@tekyzinc/gsd-t 3.11.10 → 3.11.11

package/bin/gsd-t.js

@@ -1232,9 +1232,6 @@ async function doInstall(opts = {}) {
   saveInstalledVersion();
 
   showInstallSummary(gsdtCommands.length, utilityCommands.length);
-
-  // Interactive prompt (skipped silently in non-TTY shells)
-  await promptForApiKeyIfMissing(resolveApiKeyEnvVar(process.cwd()));
 }
 
 function showInstallSummary(gsdtCount, utilCount) {
@@ -1444,9 +1441,6 @@ async function doInit(projectName) {
   if (registerProject(projectDir)) success("Registered in ~/.claude/.gsd-t-projects");
 
   showInitTree(projectDir);
-
-  // Interactive prompt (skipped silently in non-TTY shells)
-  await promptForApiKeyIfMissing(resolveApiKeyEnvVar(projectDir));
 }
 
 function showInitTree(projectDir) {
@@ -1523,12 +1517,7 @@ function showStatusContextMeter() {
     const rel = state.timestamp ? formatRelativeTime(state.timestamp) : "never measured";
     log(`  ${RED}${BOLD}✗ CONTEXT METER DEAD${RESET} ${RED}— error: ${code}, last check: ${rel}${RESET}`);
     log(`    ${RED}The context-window guardrail is NOT working. Long sessions will hit /compact.${RESET}`);
-    if (code === "missing_key") {
-      log(`    ${YELLOW}Fix: export ANTHROPIC_API_KEY in your shell profile${RESET}`);
-      log(`    ${YELLOW}     (measurement only — inference stays on Claude Code subscription)${RESET}`);
-    } else {
-      log(`    ${YELLOW}Fix: run 'gsd-t doctor' for diagnostics${RESET}`);
-    }
+    log(`    ${YELLOW}Fix: run 'gsd-t doctor' for diagnostics${RESET}`);
     return;
   }
 
@@ -2308,8 +2297,8 @@ function checkDoctorCgc() {
   return issues;
 }
 
-// Verify context meter wiring: API key env var, hook registration,
-// hook script presence, config validity, and a live count_tokens dry-run.
+// Verify context meter wiring: hook registration, hook script presence,
+// config validity, and a local estimation dry-run.
 // Returns number of issues (RED results). Mirrors checkDoctorCgc shape.
 async function checkDoctorContextMeter(projectDir) {
   let issues = 0;
@@ -2317,8 +2306,8 @@ async function checkDoctorContextMeter(projectDir) {
 
   const cwd = projectDir || process.cwd();
 
-  // Load config (used by checks 1, 4, and 5). Missing file → defaults; invalid
-  // JSON or schema-mismatch → throws (handled in Check 4).
+  // Load config (used by checks 3 and 4). Missing file → defaults; invalid
+  // JSON or schema-mismatch → throws (handled in Check 3).
   let cfg = null;
   let cfgLoadErr = null;
   try {
@@ -2327,19 +2316,8 @@ async function checkDoctorContextMeter(projectDir) {
   } catch (e) {
     cfgLoadErr = e;
   }
-  const apiKeyEnvVar = (cfg && cfg.apiKeyEnvVar) || "ANTHROPIC_API_KEY";
-
-  // Check 1: API key env var present
-  const apiKeyValue = process.env[apiKeyEnvVar];
-  const apiKeyPresent = typeof apiKeyValue === "string" && apiKeyValue.length > 0;
-  if (apiKeyPresent) {
-    success(`API key present ($${apiKeyEnvVar})`);
-  } else {
-    error(`Missing API key: set $${apiKeyEnvVar} — https://console.anthropic.com/settings/keys`);
-    issues++;
-  }
 
-  // Check 2: Hook registered in ~/.claude/settings.json
+  // Check 1: Hook registered in ~/.claude/settings.json
   let hookRegistered = false;
   try {
     if (fs.existsSync(SETTINGS_JSON)) {
@@ -2367,7 +2345,7 @@ async function checkDoctorContextMeter(projectDir) {
     issues++;
   }
 
-  // Check 3: Hook script file exists in project
+  // Check 2: Hook script file exists in project
   const scriptPath = path.join(cwd, "scripts", CONTEXT_METER_SCRIPT);
   if (fs.existsSync(scriptPath)) {
     success("Hook script present");
@@ -2376,7 +2354,7 @@ async function checkDoctorContextMeter(projectDir) {
     issues++;
   }
 
-  // Check 4: Config file parses via loader
+  // Check 3: Config file parses via loader
   const configPath = path.join(cwd, CONTEXT_METER_CONFIG_DEST);
   if (cfgLoadErr) {
     error(`Config file invalid: ${cfgLoadErr.message} — fix ${CONTEXT_METER_CONFIG_DEST}`);
@@ -2387,34 +2365,27 @@ async function checkDoctorContextMeter(projectDir) {
     warn("Using default config — run gsd-t install to copy template");
   }
 
-  // Check 5: Dry-run count_tokens API call (skip if no API key)
-  if (!apiKeyPresent) {
-    log(`  ${DIM}Skipped count_tokens dry-run (no API key)${RESET}`);
+  // Check 4: Dry-run local token estimation
+  const estimatorPath = path.join(cwd, "scripts", "context-meter", "estimate-tokens.js");
+  if (!fs.existsSync(estimatorPath)) {
+    error("Token estimator missing at scripts/context-meter/estimate-tokens.js — run gsd-t update");
+    issues++;
   } else {
-    const clientPath = path.join(cwd, "scripts", "context-meter", "count-tokens-client.js");
-    if (!fs.existsSync(clientPath)) {
-      error("count_tokens client missing at scripts/context-meter/count-tokens-client.js — run gsd-t update");
-      issues++;
-    } else {
-      try {
-        const { countTokens } = require(clientPath);
-        const result = await countTokens({
-          apiKey: apiKeyValue,
-          model: "claude-opus-4-6",
-          system: "",
-          messages: [{ role: "user", content: [{ type: "text", text: "ping" }] }],
-          timeoutMs: 5000,
-        });
-        if (result && typeof result.inputTokens === "number") {
-          success(`count_tokens dry-run OK (${result.inputTokens} tokens)`);
-        } else {
-          error("count_tokens API call failed — check API key and network");
-          issues++;
-        }
-      } catch (e) {
-        error(`count_tokens dry-run threw: ${e.message}`);
+    try {
+      const { estimateTokens } = require(estimatorPath);
+      const result = estimateTokens({
+        system: "",
+        messages: [{ role: "user", content: [{ type: "text", text: "ping" }] }],
+      });
+      if (result && typeof result.inputTokens === "number") {
+        success(`Token estimator dry-run OK (${result.inputTokens} tokens)`);
+      } else {
+        error("Token estimator returned null");
         issues++;
       }
+    } catch (e) {
+      error(`Token estimator dry-run threw: ${e.message}`);
+      issues++;
     }
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "3.11.10",
+  "version": "3.11.11",
   "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/estimate-tokens.js

@@ -0,0 +1,96 @@
+/**
+ * estimate-tokens.js
+ *
+ * Local token estimator — replaces the Anthropic count_tokens API call.
+ * Uses byte-length heuristics to estimate token count from a parsed transcript.
+ *
+ * Claude's BPE tokenizer averages ~3.5 chars per token for English text/code
+ * (range: 3.0 for dense prose, 4.5 for simple ASCII). We use 3.5 as the
+ * divisor, which slightly overestimates token count — this is the safe
+ * direction for a context-window guard (triggers pause earlier, not later).
+ *
+ * The estimate includes JSON structural overhead from the messages array
+ * (keys, brackets, commas) since that's what the API would count too.
+ *
+ * Accuracy: within ~5-10% of the real count_tokens API. For threshold bands
+ * with 15-point gaps (normal < 70%, warn < 85%), this is more than sufficient.
+ *
+ * @module scripts/context-meter/estimate-tokens
+ */
+
+"use strict";
+
+const CHARS_PER_TOKEN = 3.5;
+
+/**
+ * Estimate token count from a parsed transcript.
+ *
+ * @param {object} opts
+ * @param {string} opts.system - system prompt text
+ * @param {Array}  opts.messages - messages array from transcript-parser.js
+ * @returns {{ inputTokens: number } | null}
+ */
+function estimateTokens(opts) {
+  try {
+    if (!opts || typeof opts !== "object") return null;
+
+    const { system, messages } = opts;
+    if (!Array.isArray(messages)) return null;
+
+    let totalChars = 0;
+
+    if (typeof system === "string") {
+      totalChars += system.length;
+    }
+
+    for (const msg of messages) {
+      if (!msg || typeof msg !== "object") continue;
+      totalChars += measureContent(msg.content);
+    }
+
+    const inputTokens = Math.ceil(totalChars / CHARS_PER_TOKEN);
+    return { inputTokens };
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Recursively measure character length of a message content value.
+ * Handles strings, arrays of blocks, and nested tool_result content.
+ */
+function measureContent(content) {
+  if (typeof content === "string") return content.length;
+  if (!Array.isArray(content)) return 0;
+
+  let chars = 0;
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+
+    if (block.type === "text" && typeof block.text === "string") {
+      chars += block.text.length;
+    } else if (block.type === "tool_use") {
+      chars += (typeof block.name === "string" ? block.name.length : 0);
+      if (block.input != null) {
+        try {
+          chars += JSON.stringify(block.input).length;
+        } catch (_) {
+          // skip
+        }
+      }
+    } else if (block.type === "tool_result") {
+      chars += measureContent(block.content);
+    } else if (block.type === "image" && block.source) {
+      // base64 images: ~0.75 bytes per base64 char, tokenized differently
+      // but we count the source data length as a rough proxy
+      try {
+        chars += JSON.stringify(block.source).length;
+      } catch (_) {
+        // skip
+      }
+    }
+  }
+  return chars;
+}
+
+module.exports = { estimateTokens, CHARS_PER_TOKEN };

package/scripts/context-meter/estimate-tokens.test.js

@@ -0,0 +1,158 @@
+/**
+ * estimate-tokens.test.js — unit tests for the local token estimator.
+ *
+ * @module scripts/context-meter/estimate-tokens.test
+ */
+
+"use strict";
+
+const { test } = require("node:test");
+const assert = require("node:assert/strict");
+const { estimateTokens, CHARS_PER_TOKEN } = require("./estimate-tokens");
+
+test("null/undefined opts returns null", () => {
+  assert.equal(estimateTokens(null), null);
+  assert.equal(estimateTokens(undefined), null);
+});
+
+test("missing messages returns null", () => {
+  assert.equal(estimateTokens({ system: "hi" }), null);
+  assert.equal(estimateTokens({ system: "hi", messages: "not-array" }), null);
+});
+
+test("empty messages returns 0 tokens (system empty)", () => {
+  const r = estimateTokens({ system: "", messages: [] });
+  assert.ok(r);
+  assert.equal(r.inputTokens, 0);
+});
+
+test("system-only content counted", () => {
+  const sys = "a".repeat(350);
+  const r = estimateTokens({ system: sys, messages: [] });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(350 / CHARS_PER_TOKEN));
+});
+
+test("text message content counted", () => {
+  const r = estimateTokens({
+    system: "",
+    messages: [
+      { role: "user", content: [{ type: "text", text: "a".repeat(700) }] },
+    ],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(700 / CHARS_PER_TOKEN));
+});
+
+test("string content (user shorthand) counted", () => {
+  const r = estimateTokens({
+    system: "",
+    messages: [{ role: "user", content: "hello world" }],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(11 / CHARS_PER_TOKEN));
+});
+
+test("tool_use input JSON counted", () => {
+  const input = { file_path: "/some/long/path/to/file.js" };
+  const inputJson = JSON.stringify(input);
+  const toolName = "Read";
+  const r = estimateTokens({
+    system: "",
+    messages: [
+      {
+        role: "assistant",
+        content: [{ type: "tool_use", id: "t1", name: toolName, input }],
+      },
+    ],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil((toolName.length + inputJson.length) / CHARS_PER_TOKEN));
+});
+
+test("tool_result content counted (string)", () => {
+  const resultText = "file contents here".repeat(10);
+  const r = estimateTokens({
+    system: "",
+    messages: [
+      {
+        role: "user",
+        content: [
+          { type: "tool_result", tool_use_id: "t1", content: resultText },
+        ],
+      },
+    ],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(resultText.length / CHARS_PER_TOKEN));
+});
+
+test("tool_result content counted (array of text blocks)", () => {
+  const r = estimateTokens({
+    system: "",
+    messages: [
+      {
+        role: "user",
+        content: [
+          {
+            type: "tool_result",
+            tool_use_id: "t1",
+            content: [
+              { type: "text", text: "abc" },
+              { type: "text", text: "defgh" },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(8 / CHARS_PER_TOKEN));
+});
+
+test("multiple messages accumulate", () => {
+  const r = estimateTokens({
+    system: "sys".repeat(100),
+    messages: [
+      { role: "user", content: [{ type: "text", text: "a".repeat(200) }] },
+      { role: "assistant", content: [{ type: "text", text: "b".repeat(300) }] },
+    ],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil((300 + 200 + 300) / CHARS_PER_TOKEN));
+});
+
+test("skips blocks with missing type", () => {
+  const r = estimateTokens({
+    system: "",
+    messages: [
+      { role: "user", content: [{ text: "no type field" }, { type: "text", text: "ok" }] },
+    ],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(2 / CHARS_PER_TOKEN));
+});
+
+test("handles null/non-object messages gracefully", () => {
+  const r = estimateTokens({
+    system: "",
+    messages: [null, undefined, 42, { role: "user", content: [{ type: "text", text: "ok" }] }],
+  });
+  assert.ok(r);
+  assert.equal(r.inputTokens, Math.ceil(2 / CHARS_PER_TOKEN));
+});
+
+test("realistic conversation produces reasonable estimate", () => {
+  const msgs = [];
+  for (let i = 0; i < 20; i++) {
+    msgs.push({ role: "user", content: [{ type: "text", text: "Tell me about X. ".repeat(5) }] });
+    msgs.push({
+      role: "assistant",
+      content: [{ type: "text", text: "Here is info about X. ".repeat(20) }],
+    });
+  }
+  const r = estimateTokens({ system: "You are a helpful assistant.", messages: msgs });
+  assert.ok(r);
+  assert.ok(r.inputTokens > 500, `expected >500 tokens, got ${r.inputTokens}`);
+  assert.ok(r.inputTokens < 10000, `expected <10000 tokens, got ${r.inputTokens}`);
+});

package/scripts/gsd-t-context-meter.e2e.test.js

@@ -4,30 +4,20 @@
  * TEST-ONLY FILE. Not shipped to users. Does not participate in production
  * require graphs. Spawned as part of `node --test` only.
  *
- * Tasks 1–4 of the context-meter-hook domain unit-tested `runMeter()` via
- * dependency injection. This test exercises the real child-process hook as
- * Claude Code would invoke it:
+ * Exercises the real child-process hook as Claude Code would invoke it:
  *
  *   1. A temporary project root is constructed under os.tmpdir() containing:
  *        - .gsd-t/context-meter-config.json (real config loader target)
  *        - transcript.jsonl (minimal Claude-Code-shaped transcript)
- *   2. A local stub HTTP server mimics POST /v1/messages/count_tokens and
- *      returns a configurable `input_tokens` value.
- *   3. `node scripts/gsd-t-context-meter.js` is spawned as a child process
- *      with cwd = tempdir, NODE_OPTIONS = --require <test-injector>, and
- *      GSD_T_CONTEXT_METER_TEST_BASE_URL pointing at the stub.
- *   4. We write the PostToolUse JSON payload to the child's stdin, close
+ *   2. `node scripts/gsd-t-context-meter.js` is spawned as a child process
+ *      with cwd = tempdir.
+ *   3. We write the PostToolUse JSON payload to the child's stdin, close
  *      stdin, collect stdout, and assert both the stdout shape and the
  *      on-disk state file.
  *
- * The test-injector.js file is the single unavoidable bit of test-only
- * infrastructure: the production hook's CLI shim takes no base-URL override
- * (by design — production must not be routable to a non-Anthropic host),
- * so redirecting HTTP in a black-box test requires a --require-level
- * monkey-patch inside the child process. See that file's comment block.
- *
- * Timing budget: each test < 2s, whole suite < 10s. Hard timeouts on every
- * async wait prevent suite hangs on unclosed sockets or child processes.
+ * Since v3.12 the context meter uses local token estimation (no API call),
+ * so no stub HTTP server is needed. The transcript content determines the
+ * estimated token count via chars/3.5 heuristic.
  *
  * @module scripts/gsd-t-context-meter.e2e.test
  */
@@ -37,27 +27,18 @@
 const { test, beforeEach, afterEach } = require("node:test");
 const assert = require("node:assert/strict");
 const { spawn } = require("node:child_process");
-const http = require("node:http");
 const fs = require("node:fs");
 const path = require("node:path");
 const os = require("node:os");
 
 const HOOK_SCRIPT = path.resolve(__dirname, "gsd-t-context-meter.js");
-const INJECTOR = path.resolve(__dirname, "context-meter", "test-injector.js");
 const HARD_TIMEOUT_MS = 12000;
 
 /* ──────────────────────────── test fixtures ──────────────────────────── */
 
-/**
- * Sandbox state for a single test. Holds the tempdir, stub server, and a
- * dispose() that guarantees everything is torn down — even on failure.
- */
 class Sandbox {
   constructor() {
     this.tempdir = null;
-    this.server = null;
-    this.serverUrl = null;
-    this.hitCount = 0;
     this.childProcs = [];
   }
 
@@ -89,15 +70,17 @@ class Sandbox {
   }
 
   /**
-   * Write a minimal Claude-Code transcript JSONL containing one user turn and
-   * one assistant turn — enough for parseTranscript() to return a non-empty
-   * messages array.
+   * Write a Claude-Code transcript JSONL with configurable content size.
+   * The charCount parameter controls how many characters of text content
+   * are in the transcript, which determines the estimated token count.
    */
-  writeTranscript(filename = "transcript.jsonl") {
+  writeTranscript(filename = "transcript.jsonl", charCount = 100) {
+    const userText = "x".repeat(Math.floor(charCount / 2));
+    const assistantText = "y".repeat(Math.ceil(charCount / 2));
     const lines = [
       JSON.stringify({
         type: "user",
-        message: { role: "user", content: "hello world" },
+        message: { role: "user", content: userText },
         uuid: "u1",
         sessionId: "sess-1",
       }),
@@ -105,7 +88,7 @@ class Sandbox {
         type: "assistant",
         message: {
           role: "assistant",
-          content: [{ type: "text", text: "hi there" }],
+          content: [{ type: "text", text: assistantText }],
           model: "claude-opus-4-6",
         },
         uuid: "a1",
@@ -117,10 +100,6 @@ class Sandbox {
     return p;
   }
 
-  /**
-   * Optional: pre-seed the state file so we can test the checkFrequency skip
-   * path (where runMeter increments but does not call the API).
-   */
   writeState(state) {
     const full = Object.assign(
       {
@@ -142,52 +121,8 @@ class Sandbox {
     );
   }
 
-  /**
-   * Start a local stub HTTP server that responds to every request with the
-   * given inputTokens value. Tracks hit count so tests can assert the API
-   * was (or was not) called.
-   */
-  async startStub({ inputTokens }) {
-    this.server = http.createServer((req, res) => {
-      this.hitCount++;
-      // Drain the request body (even though we don't inspect it) so the
-      // client sees a clean close.
-      req.on("data", () => {});
-      req.on("end", () => {
-        res.writeHead(200, { "content-type": "application/json" });
-        res.end(JSON.stringify({ input_tokens: inputTokens }));
-      });
-    });
-    await new Promise((resolve, reject) => {
-      const t = setTimeout(
-        () => reject(new Error("stub server listen timeout")),
-        HARD_TIMEOUT_MS
-      );
-      this.server.on("error", (err) => {
-        clearTimeout(t);
-        reject(err);
-      });
-      this.server.listen(0, "127.0.0.1", () => {
-        clearTimeout(t);
-        const { port } = this.server.address();
-        this.serverUrl = `http://127.0.0.1:${port}`;
-        resolve();
-      });
-    });
-  }
-
-  /**
-   * Spawn the real hook as a child process, write a payload to stdin, and
-   * resolve with { stdout, stderr, code }. Enforces a hard timeout so the
-   * test can never hang the suite.
-   */
   async runHook({ payload, env }) {
-    const fullEnv = Object.assign({}, process.env, {
-      ANTHROPIC_API_KEY: "test-key-ignored",
-      GSD_T_CONTEXT_METER_TEST_BASE_URL: this.serverUrl || "",
-      NODE_OPTIONS: `--require ${INJECTOR}`,
-    });
-    // Allow caller to override any env (including unsetting ANTHROPIC_API_KEY).
+    const fullEnv = Object.assign({}, process.env, {});
     if (env) {
       for (const [k, v] of Object.entries(env)) {
         if (v === null || v === undefined) {
@@ -257,7 +192,6 @@ class Sandbox {
   }
 
   async dispose() {
-    // Kill any lingering children first.
     for (const c of this.childProcs) {
       try {
         if (!c.killed) c.kill("SIGKILL");
@@ -267,17 +201,6 @@ class Sandbox {
     }
     this.childProcs = [];
 
-    if (this.server) {
-      await new Promise((resolve) => {
-        try {
-          this.server.close(() => resolve());
-        } catch (_) {
-          resolve();
-        }
-      });
-      this.server = null;
-    }
-
     if (this.tempdir) {
       try {
         fs.rmSync(this.tempdir, { recursive: true, force: true });
@@ -307,10 +230,10 @@ afterEach(async () => {
 
 /* ──────────────────────────── tests ──────────────────────────── */
 
-test("E2E 1. below threshold — stdout {} and state reflects 25%", async () => {
+test("E2E 1. below threshold — stdout {} and state reflects estimate", async () => {
+  // 100 chars of text content → ~29 tokens (100/3.5) → 0.014% of 200K window
   sandbox.writeConfig({ thresholdPct: 75, modelWindowSize: 200000, checkFrequency: 1 });
-  const transcriptPath = sandbox.writeTranscript();
-  await sandbox.startStub({ inputTokens: 50000 });
+  const transcriptPath = sandbox.writeTranscript("transcript.jsonl", 100);
 
   const { stdout, code } = await sandbox.runHook({
     payload: { session_id: "test-below", transcript_path: transcriptPath },
@@ -323,22 +246,21 @@ test("E2E 1. below threshold — stdout {} and state reflects 25%", async () =>
   const state = sandbox.readState();
   assert.ok(state, "state file should exist");
   assert.equal(state.version, 1);
-  assert.equal(state.inputTokens, 50000);
+  assert.ok(state.inputTokens > 0, "should have estimated some tokens");
+  assert.ok(state.inputTokens < 1000, "small transcript should estimate < 1K tokens");
   assert.equal(state.modelWindowSize, 200000);
-  assert.ok(Math.abs(state.pct - 25) < 0.0001, `pct ${state.pct} should ≈ 25`);
+  assert.ok(state.pct < 1, "pct should be well below threshold");
   assert.equal(state.threshold, "normal");
   assert.equal(state.checkCount, 1);
   assert.equal(state.lastError, null);
   assert.ok(typeof state.timestamp === "string" && state.timestamp.length > 0);
-
   assert.equal(sandbox.tmpFileExists(), false, "no leftover .tmp file");
-  assert.equal(sandbox.hitCount, 1, "stub server should have been called exactly once");
 });
 
-test("E2E 2. above threshold — stdout additionalContext and state reflects 80%", async () => {
+test("E2E 2. above threshold — stdout additionalContext with large transcript", async () => {
+  // 600K chars → ~171K tokens → 85.7% of 200K window → warn band + additionalContext
   sandbox.writeConfig({ thresholdPct: 75, modelWindowSize: 200000, checkFrequency: 1 });
-  const transcriptPath = sandbox.writeTranscript();
-  await sandbox.startStub({ inputTokens: 160000 });
+  const transcriptPath = sandbox.writeTranscript("transcript.jsonl", 600000);
 
   const { stdout, code } = await sandbox.runHook({
     payload: { session_id: "test-above", transcript_path: transcriptPath },
@@ -348,33 +270,26 @@ test("E2E 2. above threshold — stdout additionalContext and state reflects 80%
   const parsed = JSON.parse(stdout || "{}");
   assert.ok(parsed.additionalContext, "must emit additionalContext");
   assert.ok(parsed.additionalContext.includes("MANDATORY STOP"), "must be MANDATORY STOP");
-  assert.ok(parsed.additionalContext.includes("80.0%"), "must include pct");
-  assert.ok(parsed.additionalContext.includes("200000"), "must include window size");
   assert.ok(parsed.additionalContext.includes("/user:gsd-t-pause"), "must instruct pause");
   assert.ok(parsed.additionalContext.includes("/user:gsd-t-resume"), "must instruct resume");
 
   const state = sandbox.readState();
   assert.ok(state);
-  assert.equal(state.inputTokens, 160000);
-  assert.equal(state.modelWindowSize, 200000);
-  assert.ok(Math.abs(state.pct - 80) < 0.0001, `pct ${state.pct} should ≈ 80`);
-  // v3.0.0 three-band (M35): 80% ∈ [70, 85) → warn
-  assert.equal(state.threshold, "warn");
+  assert.ok(state.inputTokens > 100000, "large transcript should estimate >100K tokens");
+  assert.ok(state.pct > 50, "pct should be above threshold");
   assert.equal(state.checkCount, 1);
   assert.equal(state.lastError, null);
-
   assert.equal(sandbox.tmpFileExists(), false);
-  assert.equal(sandbox.hitCount, 1);
 });
 
-test("E2E 3. API key missing — stdout {}, state has lastError.code='missing_key'", async () => {
+test("E2E 3. missing transcript — stdout {}, state has parse error", async () => {
   sandbox.writeConfig({ thresholdPct: 75, checkFrequency: 1 });
-  const transcriptPath = sandbox.writeTranscript();
-  await sandbox.startStub({ inputTokens: 50000 });
 
   const { stdout, code } = await sandbox.runHook({
-    payload: { session_id: "test-nokey", transcript_path: transcriptPath },
-    env: { ANTHROPIC_API_KEY: null }, // explicitly unset
+    payload: {
+      session_id: "test-nofile",
+      transcript_path: path.join(sandbox.tempdir, "nonexistent.jsonl"),
+    },
   });
 
   assert.equal(code, 0);
@@ -385,18 +300,13 @@ test("E2E 3. API key missing — stdout {}, state has lastError.code='missing_ke
   assert.ok(state);
   assert.equal(state.checkCount, 1);
   assert.ok(state.lastError && typeof state.lastError === "object");
-  assert.equal(state.lastError.code, "missing_key");
-
-  // API must NOT have been called.
-  assert.equal(sandbox.hitCount, 0, "stub server must not be hit when key is missing");
+  assert.equal(state.lastError.code, "parse_failure");
 });
 
-test("E2E 4. checkFrequency skip — API not called, checkCount increments", async () => {
+test("E2E 4. checkFrequency skip — estimation not run, checkCount increments", async () => {
   sandbox.writeConfig({ thresholdPct: 75, checkFrequency: 5 });
-  const transcriptPath = sandbox.writeTranscript();
-  // Pre-seed state so that checkCount goes 3 → 4, which is NOT a multiple of 5.
+  const transcriptPath = sandbox.writeTranscript("transcript.jsonl", 100);
   sandbox.writeState({ checkCount: 3 });
-  await sandbox.startStub({ inputTokens: 50000 });
 
   const { stdout, code } = await sandbox.runHook({
     payload: { session_id: "test-skip", transcript_path: transcriptPath },
@@ -409,9 +319,6 @@ test("E2E 4. checkFrequency skip — API not called, checkCount increments", asy
   const state = sandbox.readState();
   assert.ok(state);
   assert.equal(state.checkCount, 4, "counter increments even on skipped turn");
-  // lastError/inputTokens unchanged from seed on skipped turn.
   assert.equal(state.inputTokens, 0);
-
-  assert.equal(sandbox.hitCount, 0, "stub server must not be hit on skipped turn");
   assert.equal(sandbox.tmpFileExists(), false);
 });

package/scripts/gsd-t-context-meter.js

@@ -7,7 +7,7 @@
  * Wires together:
  *   - bin/context-meter-config.cjs            (loadConfig)
  *   - scripts/context-meter/transcript-parser.js  (parseTranscript)
- *   - scripts/context-meter/count-tokens-client.js (countTokens)
+ *   - scripts/context-meter/estimate-tokens.js    (estimateTokens — local, zero API cost)
  *   - scripts/context-meter/threshold.js      (computePct/bandFor/buildAdditionalContext)
  *
  * Contract: .gsd-t/contracts/context-meter-contract.md
@@ -20,8 +20,8 @@
  *   failure of its own stdin. See contract rule #1.
  *
  * Testability:
- *   `runMeter({ payload, projectRoot, env, clock?, baseUrl?, _parseTranscript?,
- *               _countTokens?, _loadConfig? })` is the pure async core. Tests
+ *   `runMeter({ payload, projectRoot, env, clock?, _parseTranscript?,
+ *               _estimateTokens?, _loadConfig? })` is the pure async core. Tests
  *   fabricate payloads and inject stubs; production code uses only the CLI
  *   shim at the bottom of the file (runs when `require.main === module`).
  *
@@ -35,11 +35,10 @@ const path = require("path");
 
 const { loadConfig: realLoadConfig } = require("../bin/context-meter-config.cjs");
 const { parseTranscript: realParseTranscript } = require("./context-meter/transcript-parser");
-const { countTokens: realCountTokens } = require("./context-meter/count-tokens-client");
+const { estimateTokens: realEstimateTokens } = require("./context-meter/estimate-tokens");
 const { computePct, bandFor, buildAdditionalContext } = require("./context-meter/threshold");
 
 const STATE_VERSION = 1;
-const MODEL_ID = "claude-opus-4-6";
 
 /* ─────────────────────────── state file helpers ─────────────────────────── */
 
@@ -119,10 +118,9 @@ function appendLog(logPath, level, category, detail, clock) {
  * @param {string}   opts.projectRoot    normally process.cwd()
  * @param {object}   opts.env            normally process.env
  * @param {Function} [opts.clock]        optional () => Date (test seam)
- * @param {string}   [opts.baseUrl]      optional countTokens _baseUrl override (test seam)
  * @param {Function} [opts._loadConfig]  optional loadConfig stub (test seam)
  * @param {Function} [opts._parseTranscript] optional parseTranscript stub (test seam)
- * @param {Function} [opts._countTokens] optional countTokens stub (test seam)
+ * @param {Function} [opts._estimateTokens] optional estimateTokens stub (test seam)
  * @returns {Promise<object>} `{}` or `{ additionalContext: "..." }`
  */
 async function runMeter(opts) {
@@ -133,10 +131,9 @@ async function runMeter(opts) {
       projectRoot,
       env,
       clock,
-      baseUrl,
       _loadConfig = realLoadConfig,
       _parseTranscript = realParseTranscript,
-      _countTokens = realCountTokens,
+      _estimateTokens = realEstimateTokens,
     } = opts || {};
 
     const root = projectRoot || process.cwd();
@@ -187,20 +184,7 @@ async function runMeter(opts) {
       return {};
     }
 
-    // 5. API key env var check.
-    const apiKey = envObj[cfg.apiKeyEnvVar];
-    if (typeof apiKey !== "string" || apiKey.length === 0) {
-      state.lastError = {
-        code: "missing_key",
-        message: `env var ${cfg.apiKeyEnvVar} not set`,
-        timestamp: now().toISOString(),
-      };
-      writeStateAtomic(statePath, state);
-      appendLog(logPath, "ERROR", "missing_key", `env var ${cfg.apiKeyEnvVar} unset`, clock);
-      return {};
-    }
-
-    // 6. Parse transcript (streaming, async). null → bail out.
+    // 5. Parse transcript (streaming, async). null → bail out.
     let parsed;
     try {
       parsed = await _parseTranscript(transcriptPath);
@@ -224,19 +208,12 @@ async function runMeter(opts) {
       return {};
     }
 
-    // 7. Call count_tokens. null → fail open (keep prior inputTokens? reset to 0?)
-    //    CHOICE: reset inputTokens to 0 on failure to avoid stale-reading-based
-    //    false-positive threshold trips. lastError still records the failure so
-    //    consumers can see we didn't get a fresh count.
+    // 6. Estimate tokens locally (no API call, zero cost).
     let tokenResp;
     try {
-      tokenResp = await _countTokens({
-        apiKey,
-        model: MODEL_ID,
+      tokenResp = _estimateTokens({
         system: parsed.system || "",
         messages: parsed.messages,
-        timeoutMs: cfg.timeoutMs,
-        _baseUrl: baseUrl,
       });
     } catch (_) {
       tokenResp = null;
@@ -248,12 +225,12 @@ async function runMeter(opts) {
       state.threshold = "normal";
       state.timestamp = now().toISOString();
       state.lastError = {
-        code: "api_error",
-        message: "count_tokens returned null",
+        code: "estimate_error",
+        message: "estimateTokens returned null",
         timestamp: state.timestamp,
       };
       writeStateAtomic(statePath, state);
-      appendLog(logPath, "ERROR", "api_error", "count_tokens null", clock);
+      appendLog(logPath, "ERROR", "estimate_error", "estimateTokens null", clock);
       return {};
     }
 

package/scripts/gsd-t-context-meter.test.js

@@ -3,20 +3,21 @@
 /**
  * Unit tests for scripts/gsd-t-context-meter.js (M34 Task 4 — CP2 satisfaction).
  *
- * Covers 10 scenarios from the task spec:
+ * Covers scenarios:
  *   1. check-frequency skip
  *   2. check-frequency hit — under threshold
  *   3. check-frequency hit — over threshold
- *   4. missing API key
- *   5. transcript parse failure
- *   6. API timeout / failure
- *   7. state file corruption
- *   8. missing transcript_path in payload
- *   9. atomic write — no stale .tmp file after success
- *  10. fail-open on unexpected throw (loadConfig throws)
+ *   4. transcript parse failure
+ *   5. estimation failure — returns null
+ *   6. state file corruption
+ *   7. missing transcript_path in payload
+ *   8. atomic write — no stale .tmp file after success
+ *   9. fail-open on unexpected throw (loadConfig throws)
+ *  10. log never contains message content
+ *  11. clock injection
  *
  * All dependencies are injected via runMeter's test seams so no real network
- * calls, no real Anthropic API, and no real config-file reads are needed.
+ * calls and no real config-file reads are needed.
  */
 
 const { test, beforeEach, afterEach } = require("node:test");
@@ -75,8 +76,6 @@ function seedState(root, partial) {
 }
 
 function makePayload() {
-  // A phony transcript path — tests inject a fake parseTranscript, so the path
-  // doesn't actually need to exist.
   return {
     session_id: "test-session",
     transcript_path: path.join(tmpRoot, "fake-transcript.jsonl"),
@@ -93,26 +92,26 @@ const FAKE_PARSED = {
 
 /* ───────────────────────────── tests ───────────────────────────── */
 
-test("1. check-frequency skip — API NOT called, counter incremented, stdout {}", async () => {
+test("1. check-frequency skip — estimator NOT called, counter incremented, stdout {}", async () => {
   seedState(tmpRoot, { checkCount: 3 });
 
-  const apiCalls = [];
+  const estimateCalls = [];
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig({ checkFrequency: 5 }),
     _parseTranscript: async () => {
       throw new Error("parseTranscript should not be called on skip");
     },
-    _countTokens: async () => {
-      apiCalls.push("called");
-      throw new Error("countTokens should not be called on skip");
+    _estimateTokens: () => {
+      estimateCalls.push("called");
+      throw new Error("estimateTokens should not be called on skip");
     },
   });
 
   assert.deepEqual(out, {});
-  assert.equal(apiCalls.length, 0);
+  assert.equal(estimateCalls.length, 0);
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
   assert.equal(state.checkCount, 4);
   assert.equal(state.lastError, null);
@@ -124,10 +123,10 @@ test("2. check-frequency hit — under threshold → {} + state updated", async
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 10000 }),
+    _estimateTokens: () => ({ inputTokens: 10000 }),
   });
 
   assert.deepEqual(out, {});
@@ -146,10 +145,10 @@ test("3. check-frequency hit — over threshold → additionalContext emitted",
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 160000 }),
+    _estimateTokens: () => ({ inputTokens: 160000 }),
   });
 
   assert.equal(typeof out.additionalContext, "string");
@@ -160,54 +159,21 @@ test("3. check-frequency hit — over threshold → additionalContext emitted",
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
   assert.equal(state.checkCount, 5);
   assert.equal(state.pct, 80);
-  // v3.0.0 three-band (M35): 80% ∈ [70, 85) → warn
   assert.equal(state.threshold, "warn");
   assert.equal(state.inputTokens, 160000);
 });
 
-test("4. missing API key — stdout {}, lastError.code='missing_key', no API call", async () => {
+test("4. transcript parse failure — returns null → lastError 'parse_failure'", async () => {
   seedState(tmpRoot, { checkCount: 4 });
 
-  const apiCalls = [];
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: {}, // no ANTHROPIC_API_KEY
-    _loadConfig: () => makeConfig(),
-    _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => {
-      apiCalls.push("x");
-      return { inputTokens: 1 };
-    },
-  });
-
-  assert.deepEqual(out, {});
-  assert.equal(apiCalls.length, 0);
-
-  const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
-  assert.equal(state.checkCount, 5);
-  assert.ok(state.lastError, "lastError populated");
-  assert.equal(state.lastError.code, "missing_key");
-
-  // Log file exists and contains the missing_key diagnostic
-  assert.ok(fs.existsSync(logFile(tmpRoot)));
-  const log = fs.readFileSync(logFile(tmpRoot), "utf8");
-  assert.match(log, /missing_key/);
-  // And NEVER the API key itself
-  assert.ok(!log.includes("sk-test"));
-});
-
-test("5. transcript parse failure — returns null → lastError 'parse_failure'", async () => {
-  seedState(tmpRoot, { checkCount: 4 });
-
-  const out = await runMeter({
-    payload: makePayload(),
-    projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => null,
-    _countTokens: async () => {
-      throw new Error("should not call API when parse fails");
+    _estimateTokens: () => {
+      throw new Error("should not estimate when parse fails");
     },
   });
 
@@ -217,29 +183,27 @@ test("5. transcript parse failure — returns null → lastError 'parse_failure'
   assert.equal(state.lastError.code, "parse_failure");
 });
 
-test("6. API timeout / failure — countTokens null → lastError 'api_error', inputTokens reset", async () => {
+test("5. estimation failure — returns null → lastError 'estimate_error', inputTokens reset", async () => {
   seedState(tmpRoot, { checkCount: 4, inputTokens: 99999 });
 
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig({ timeoutMs: 50 }),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => null,
+    _estimateTokens: () => null,
   });
 
   assert.deepEqual(out, {});
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
-  assert.equal(state.lastError.code, "api_error");
-  // Choice documented in hook: reset inputTokens to 0 on failure to avoid stale
-  // readings tripping threshold false-positives.
+  assert.equal(state.lastError.code, "estimate_error");
   assert.equal(state.inputTokens, 0);
   assert.equal(state.pct, 0);
   assert.equal(state.threshold, "normal");
 });
 
-test("7. state file corruption — overwritten with valid defaults + fresh count", async () => {
+test("6. state file corruption — overwritten with valid defaults + fresh count", async () => {
   const sp = stateFile(tmpRoot);
   fs.mkdirSync(path.dirname(sp), { recursive: true });
   fs.writeFileSync(sp, "not json{");
@@ -247,22 +211,19 @@ test("7. state file corruption — overwritten with valid defaults + fresh count
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig({ checkFrequency: 5 }),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 100 }),
+    _estimateTokens: () => ({ inputTokens: 100 }),
   });
 
   assert.deepEqual(out, {});
-  // Post-write must be valid JSON with defaults + checkCount == 1
   const state = JSON.parse(fs.readFileSync(sp, "utf8"));
   assert.equal(state.version, 1);
   assert.equal(state.checkCount, 1);
-  // checkCount=1 % checkFrequency=5 !== 0, so this was a skip path; API not called.
-  // Verify API was NOT called on this path by re-running with a throwing stub.
 });
 
-test("7b. state file corruption + frequency hit — API called once, state valid", async () => {
+test("6b. state file corruption + frequency hit — estimator called once, state valid", async () => {
   const sp = stateFile(tmpRoot);
   fs.mkdirSync(path.dirname(sp), { recursive: true });
   fs.writeFileSync(sp, "not json{");
@@ -270,10 +231,10 @@ test("7b. state file corruption + frequency hit — API called once, state valid
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig({ checkFrequency: 1 }),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 500 }),
+    _estimateTokens: () => ({ inputTokens: 500 }),
   });
 
   assert.deepEqual(out, {});
@@ -284,19 +245,19 @@ test("7b. state file corruption + frequency hit — API called once, state valid
   assert.equal(state.lastError, null);
 });
 
-test("8. missing transcript_path in payload — lastError 'no_transcript', counter increments", async () => {
+test("7. missing transcript_path in payload — lastError 'no_transcript', counter increments", async () => {
   seedState(tmpRoot, { checkCount: 4 });
 
   const out = await runMeter({
-    payload: { session_id: "x" }, // no transcript_path
+    payload: { session_id: "x" },
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => {
       throw new Error("should not parse when transcript_path missing");
     },
-    _countTokens: async () => {
-      throw new Error("should not call API when transcript_path missing");
+    _estimateTokens: () => {
+      throw new Error("should not estimate when transcript_path missing");
     },
   });
 
@@ -306,16 +267,16 @@ test("8. missing transcript_path in payload — lastError 'no_transcript', count
   assert.equal(state.lastError.code, "no_transcript");
 });
 
-test("9. atomic write — no .tmp file on disk after successful run", async () => {
+test("8. atomic write — no .tmp file on disk after successful run", async () => {
   seedState(tmpRoot, { checkCount: 4 });
 
   await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 1000 }),
+    _estimateTokens: () => ({ inputTokens: 1000 }),
   });
 
   const tmp = stateFile(tmpRoot) + ".tmp";
@@ -323,32 +284,32 @@ test("9. atomic write — no .tmp file on disk after successful run", async () =
   assert.equal(fs.existsSync(stateFile(tmpRoot)), true, "state file should exist");
 });
 
-test("10. fail-open on unexpected throw — loadConfig throws → runMeter returns {}", async () => {
+test("9. fail-open on unexpected throw — loadConfig throws → runMeter returns {}", async () => {
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => {
       throw new Error("boom");
     },
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 1 }),
+    _estimateTokens: () => ({ inputTokens: 1 }),
   });
 
   assert.deepEqual(out, {});
 });
 
-test("10b. fail-open — parseTranscript throws synchronously → {}", async () => {
+test("9b. fail-open — parseTranscript throws synchronously → {}", async () => {
   seedState(tmpRoot, { checkCount: 4 });
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: () => {
       throw new Error("sync boom");
     },
-    _countTokens: async () => ({ inputTokens: 1 }),
+    _estimateTokens: () => ({ inputTokens: 1 }),
   });
 
   assert.deepEqual(out, {});
@@ -356,32 +317,32 @@ test("10b. fail-open — parseTranscript throws synchronously → {}", async ()
   assert.equal(state.lastError.code, "parse_failure");
 });
 
-test("10c. fail-open — countTokens throws → {}", async () => {
+test("9c. fail-open — estimateTokens throws → {}", async () => {
   seedState(tmpRoot, { checkCount: 4 });
   const out = await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: () => {
+    _estimateTokens: () => {
       throw new Error("sync boom");
     },
   });
 
   assert.deepEqual(out, {});
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));
-  assert.equal(state.lastError.code, "api_error");
+  assert.equal(state.lastError.code, "estimate_error");
 });
 
-test("11. log never contains message content — only categories/counts", async () => {
+test("10. log never contains message content — only categories/counts", async () => {
   seedState(tmpRoot, { checkCount: 4 });
   const secretText = "SECRET_MESSAGE_CONTENT_XYZ";
 
   await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => ({
       system: "",
@@ -389,7 +350,7 @@ test("11. log never contains message content — only categories/counts", async
         { role: "user", content: [{ type: "text", text: secretText }] },
       ],
     }),
-    _countTokens: async () => ({ inputTokens: 42 }),
+    _estimateTokens: () => ({ inputTokens: 42 }),
   });
 
   const log = fs.readFileSync(logFile(tmpRoot), "utf8");
@@ -398,18 +359,18 @@ test("11. log never contains message content — only categories/counts", async
   assert.match(log, /tokens=42/);
 });
 
-test("12. clock injection — timestamp uses injected clock", async () => {
+test("11. clock injection — timestamp uses injected clock", async () => {
   seedState(tmpRoot, { checkCount: 4 });
   const fixed = new Date("2026-04-14T18:00:00.000Z");
 
   await runMeter({
     payload: makePayload(),
     projectRoot: tmpRoot,
-    env: { ANTHROPIC_API_KEY: "sk-test" },
+    env: {},
     clock: () => fixed,
     _loadConfig: () => makeConfig(),
     _parseTranscript: async () => FAKE_PARSED,
-    _countTokens: async () => ({ inputTokens: 1000 }),
+    _estimateTokens: () => ({ inputTokens: 1000 }),
   });
 
   const state = JSON.parse(fs.readFileSync(stateFile(tmpRoot), "utf8"));