@tekyzinc/gsd-t 3.29.10 → 4.0.12

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

@@ -1,364 +0,0 @@
-/**
- * gsd-t-context-meter.e2e.test.js — black-box E2E integration test for M34.
- *
- * TEST-ONLY FILE. Not shipped to users. Does not participate in production
- * require graphs. Spawned as part of `node --test` only.
- *
- * 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. `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.
- *
- * 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
- */
-
-"use strict";
-
-const { test, beforeEach, afterEach } = require("node:test");
-const assert = require("node:assert/strict");
-const { spawn } = require("node:child_process");
-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 HARD_TIMEOUT_MS = 12000;
-
-/* ──────────────────────────── test fixtures ──────────────────────────── */
-
-class Sandbox {
-  constructor() {
-    this.tempdir = null;
-    this.childProcs = [];
-  }
-
-  async setup() {
-    this.tempdir = fs.mkdtempSync(path.join(os.tmpdir(), "gsd-t-cm-e2e-"));
-    fs.mkdirSync(path.join(this.tempdir, ".gsd-t"), { recursive: true });
-  }
-
-  writeConfig(config) {
-    const full = Object.assign(
-      {
-        version: 1,
-        thresholdPct: 75,
-        modelWindowSize: 200000,
-        checkFrequency: 1,
-        apiKeyEnvVar: "ANTHROPIC_API_KEY",
-        statePath: ".gsd-t/.context-meter-state.json",
-        logPath: ".gsd-t/context-meter.log",
-        timeoutMs: 2000,
-      },
-      config || {}
-    );
-    fs.writeFileSync(
-      path.join(this.tempdir, ".gsd-t", "context-meter-config.json"),
-      JSON.stringify(full, null, 2),
-      "utf8"
-    );
-    return full;
-  }
-
-  /**
-   * 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", charCount = 100, model = "claude-opus-4-6") {
-    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: userText },
-        uuid: "u1",
-        sessionId: "sess-1",
-      }),
-      JSON.stringify({
-        type: "assistant",
-        message: {
-          role: "assistant",
-          content: [{ type: "text", text: assistantText }],
-          model,
-        },
-        uuid: "a1",
-        sessionId: "sess-1",
-      }),
-    ];
-    const p = path.join(this.tempdir, filename);
-    fs.writeFileSync(p, lines.join("\n") + "\n", "utf8");
-    return p;
-  }
-
-  writeState(state) {
-    const full = Object.assign(
-      {
-        version: 1,
-        timestamp: null,
-        inputTokens: 0,
-        modelWindowSize: 0,
-        pct: 0,
-        threshold: "normal",
-        checkCount: 0,
-        lastError: null,
-      },
-      state || {}
-    );
-    fs.writeFileSync(
-      path.join(this.tempdir, ".gsd-t", ".context-meter-state.json"),
-      JSON.stringify(full, null, 2),
-      "utf8"
-    );
-  }
-
-  async runHook({ payload, env }) {
-    const fullEnv = Object.assign({}, process.env, {});
-    if (env) {
-      for (const [k, v] of Object.entries(env)) {
-        if (v === null || v === undefined) {
-          delete fullEnv[k];
-        } else {
-          fullEnv[k] = v;
-        }
-      }
-    }
-
-    const child = spawn(process.execPath, [HOOK_SCRIPT], {
-      cwd: this.tempdir,
-      env: fullEnv,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
-    this.childProcs.push(child);
-
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    child.stdout.on("data", (c) => stdoutChunks.push(c));
-    child.stderr.on("data", (c) => stderrChunks.push(c));
-
-    child.stdin.write(JSON.stringify(payload || {}));
-    child.stdin.end();
-
-    const result = await new Promise((resolve, reject) => {
-      const killTimer = setTimeout(() => {
-        try {
-          child.kill("SIGKILL");
-        } catch (_) {
-          /* ignore */
-        }
-        reject(new Error(`hook child process timeout after ${HARD_TIMEOUT_MS}ms`));
-      }, HARD_TIMEOUT_MS);
-
-      child.on("close", (code) => {
-        clearTimeout(killTimer);
-        resolve({
-          stdout: Buffer.concat(stdoutChunks).toString("utf8"),
-          stderr: Buffer.concat(stderrChunks).toString("utf8"),
-          code,
-        });
-      });
-      child.on("error", (err) => {
-        clearTimeout(killTimer);
-        reject(err);
-      });
-    });
-
-    return result;
-  }
-
-  readState() {
-    const p = path.join(this.tempdir, ".gsd-t", ".context-meter-state.json");
-    if (!fs.existsSync(p)) return null;
-    return JSON.parse(fs.readFileSync(p, "utf8"));
-  }
-
-  stateFileExists() {
-    const p = path.join(this.tempdir, ".gsd-t", ".context-meter-state.json");
-    return fs.existsSync(p);
-  }
-
-  tmpFileExists() {
-    const p = path.join(this.tempdir, ".gsd-t", ".context-meter-state.json.tmp");
-    return fs.existsSync(p);
-  }
-
-  async dispose() {
-    for (const c of this.childProcs) {
-      try {
-        if (!c.killed) c.kill("SIGKILL");
-      } catch (_) {
-        /* ignore */
-      }
-    }
-    this.childProcs = [];
-
-    if (this.tempdir) {
-      try {
-        fs.rmSync(this.tempdir, { recursive: true, force: true });
-      } catch (_) {
-        /* ignore */
-      }
-      this.tempdir = null;
-    }
-  }
-}
-
-/* ──────────────────────────── shared state ──────────────────────────── */
-
-let sandbox;
-
-beforeEach(async () => {
-  sandbox = new Sandbox();
-  await sandbox.setup();
-});
-
-afterEach(async () => {
-  if (sandbox) {
-    await sandbox.dispose();
-    sandbox = null;
-  }
-});
-
-/* ──────────────────────────── tests ──────────────────────────── */
-
-test("E2E 1. below threshold — stdout {} and state reflects estimate", async () => {
-  // 100 chars → ~29 tokens. The transcript declares claude-opus-4-6, so the
-  // EFFECTIVE window is the real 1M (model-aware sizing), not the config's
-  // legacy 200K — ~0.003% of 1M, well below threshold.
-  sandbox.writeConfig({ thresholdPct: 75, modelWindowSize: 200000, checkFrequency: 1 });
-  const transcriptPath = sandbox.writeTranscript("transcript.jsonl", 100);
-
-  const { stdout, code } = await sandbox.runHook({
-    payload: { session_id: "test-below", transcript_path: transcriptPath },
-  });
-
-  assert.equal(code, 0, "hook should always exit 0");
-  const parsed = JSON.parse(stdout || "{}");
-  assert.deepEqual(parsed, {}, "below-threshold stdout must be exactly {}");
-
-  const state = sandbox.readState();
-  assert.ok(state, "state file should exist");
-  assert.equal(state.version, 1);
-  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,
-    1_000_000,
-    "window resolved from the transcript's claude-opus-4-6 model (1M), not config 200K"
-  );
-  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");
-});
-
-test("E2E 2. above threshold — stdout additionalContext with large transcript", async () => {
-  // Haiku → real 200K window. 600K chars → ~171K tokens → ~85.7% of 200K →
-  // threshold band + additionalContext. (Model-aware sizing means we pin a
-  // 200K-window model here rather than relying on a stale config default.)
-  sandbox.writeConfig({ thresholdPct: 75, modelWindowSize: 200000, checkFrequency: 1 });
-  const transcriptPath = sandbox.writeTranscript(
-    "transcript.jsonl",
-    600000,
-    "claude-haiku-4-5-20251001"
-  );
-
-  const { stdout, code } = await sandbox.runHook({
-    payload: { session_id: "test-above", transcript_path: transcriptPath },
-  });
-
-  assert.equal(code, 0);
-  const parsed = JSON.parse(stdout || "{}");
-  assert.ok(parsed.additionalContext, "must emit additionalContext");
-  // v3.12 (M38): additionalContext is a short silent marker, not a MANDATORY STOP banner.
-  assert.equal(parsed.additionalContext, "next-spawn-headless:true");
-  assert.ok(!/MANDATORY STOP/.test(parsed.additionalContext));
-  assert.ok(!/\/gsd-t-pause/.test(parsed.additionalContext));
-
-  const state = sandbox.readState();
-  assert.ok(state);
-  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);
-});
-
-test("E2E 2b. REGRESSION — large Opus transcript stays 'normal' on the 1M window", async () => {
-  // The reported bug, end-to-end: ~600K chars → ~171K tokens. Under the old
-  // hardcoded 200K window this read as ~85% → false headless handoff while
-  // ~64% of context REMAINED. With model-aware sizing (claude-opus-4-7 → 1M),
-  // 171K is only ~17% → stdout {} → no premature handoff.
-  sandbox.writeConfig({ thresholdPct: 75, modelWindowSize: 200000, checkFrequency: 1 });
-  const transcriptPath = sandbox.writeTranscript(
-    "transcript.jsonl",
-    600000,
-    "claude-opus-4-7"
-  );
-
-  const { stdout, code } = await sandbox.runHook({
-    payload: { session_id: "test-regression", transcript_path: transcriptPath },
-  });
-
-  assert.equal(code, 0);
-  const parsed = JSON.parse(stdout || "{}");
-  assert.deepEqual(parsed, {}, "must NOT hand off — the reported regression");
-
-  const state = sandbox.readState();
-  assert.equal(state.modelWindowSize, 1_000_000);
-  assert.ok(state.inputTokens > 100000, "large transcript, >100K tokens");
-  assert.ok(state.pct < 75, `pct ${state.pct} must be below threshold on a 1M window`);
-  assert.equal(state.threshold, "normal");
-});
-
-test("E2E 3. missing transcript — stdout {}, state has parse error", async () => {
-  sandbox.writeConfig({ thresholdPct: 75, checkFrequency: 1 });
-
-  const { stdout, code } = await sandbox.runHook({
-    payload: {
-      session_id: "test-nofile",
-      transcript_path: path.join(sandbox.tempdir, "nonexistent.jsonl"),
-    },
-  });
-
-  assert.equal(code, 0);
-  const parsed = JSON.parse(stdout || "{}");
-  assert.deepEqual(parsed, {});
-
-  const state = sandbox.readState();
-  assert.ok(state);
-  assert.equal(state.checkCount, 1);
-  assert.ok(state.lastError && typeof state.lastError === "object");
-  assert.equal(state.lastError.code, "parse_failure");
-});
-
-test("E2E 4. checkFrequency skip — estimation not run, checkCount increments", async () => {
-  sandbox.writeConfig({ thresholdPct: 75, checkFrequency: 5 });
-  const transcriptPath = sandbox.writeTranscript("transcript.jsonl", 100);
-  sandbox.writeState({ checkCount: 3 });
-
-  const { stdout, code } = await sandbox.runHook({
-    payload: { session_id: "test-skip", transcript_path: transcriptPath },
-  });
-
-  assert.equal(code, 0);
-  const parsed = JSON.parse(stdout || "{}");
-  assert.deepEqual(parsed, {});
-
-  const state = sandbox.readState();
-  assert.ok(state);
-  assert.equal(state.checkCount, 4, "counter increments even on skipped turn");
-  assert.equal(state.inputTokens, 0);
-  assert.equal(sandbox.tmpFileExists(), false);
-});

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

@@ -1,341 +0,0 @@
-#!/usr/bin/env node
-/**
- * gsd-t-context-meter.js
- *
- * PostToolUse hook entry point for GSD-T's Context Meter (M34).
- *
- * Wires together:
- *   - bin/context-meter-config.cjs            (loadConfig)
- *   - scripts/context-meter/transcript-parser.js  (parseTranscript)
- *   - 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
- *
- * CRITICAL INVARIANT — FAIL OPEN:
- *   Every failure path resolves to `{}` on stdout and exits 0. This hook must
- *   NEVER throw, NEVER exit non-zero, and NEVER log message content. The
- *   entire `runMeter` body is wrapped in a try/catch that swallows anything
- *   unexpected and returns `{}` — the same shape the CLI shim emits on parse
- *   failure of its own stdin. See contract rule #1.
- *
- * Testability:
- *   `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`).
- *
- * @module scripts/gsd-t-context-meter
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-const { loadConfig: realLoadConfig } = require("../bin/context-meter-config.cjs");
-const { parseTranscript: realParseTranscript } = require("./context-meter/transcript-parser");
-const { estimateTokens: realEstimateTokens } = require("./context-meter/estimate-tokens");
-const { computePct, bandFor, buildAdditionalContext } = require("./context-meter/threshold");
-const { windowForModel } = require("../bin/model-windows.cjs");
-
-const STATE_VERSION = 1;
-
-/* ─────────────────────────── state file helpers ─────────────────────────── */
-
-/**
- * Read the current state file. Returns a fresh default on missing file or
- * corruption (never throws).
- */
-function readState(statePath) {
-  try {
-    const raw = fs.readFileSync(statePath, "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object" || parsed.version !== STATE_VERSION) {
-      return defaultState();
-    }
-    return parsed;
-  } catch (_) {
-    return defaultState();
-  }
-}
-
-function defaultState() {
-  return {
-    version: STATE_VERSION,
-    timestamp: null,
-    inputTokens: 0,
-    modelWindowSize: 0,
-    pct: 0,
-    threshold: "normal",
-    checkCount: 0,
-    lastError: null,
-  };
-}
-
-/**
- * Atomically write state to disk: write to `{statePath}.tmp` → rename to
- * `{statePath}`. Creates parent directories as needed. Never throws.
- */
-function writeStateAtomic(statePath, state) {
-  try {
-    const dir = path.dirname(statePath);
-    fs.mkdirSync(dir, { recursive: true });
-    const tmp = `${statePath}.tmp`;
-    fs.writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
-    fs.renameSync(tmp, statePath);
-  } catch (_) {
-    /* fail open — logging will also be best-effort */
-  }
-}
-
-/* ──────────────────────────── logging helper ─────────────────────────── */
-
-/**
- * Append a short line-based diagnostic to logPath. Line format:
- *   "{ISO-timestamp} {LEVEL} {category} {short-detail}"
- *
- * NEVER logs transcript content, message text, or API request bodies.
- */
-function appendLog(logPath, level, category, detail, clock) {
-  try {
-    const dir = path.dirname(logPath);
-    fs.mkdirSync(dir, { recursive: true });
-    const ts = (clock ? clock() : new Date()).toISOString();
-    const line = `${ts} ${level} ${category} ${detail || ""}\n`;
-    fs.appendFileSync(logPath, line, "utf8");
-  } catch (_) {
-    /* logging failure must not affect fail-open behavior */
-  }
-}
-
-/* ──────────────────────── core: runMeter() ──────────────────────── */
-
-/**
- * Run the context meter once.
- *
- * @param {object}   opts
- * @param {object}   opts.payload        parsed PostToolUse JSON (with transcript_path)
- * @param {string}   opts.projectRoot    normally process.cwd()
- * @param {object}   opts.env            normally process.env
- * @param {Function} [opts.clock]        optional () => Date (test seam)
- * @param {Function} [opts._loadConfig]  optional loadConfig stub (test seam)
- * @param {Function} [opts._parseTranscript] optional parseTranscript stub (test seam)
- * @param {Function} [opts._estimateTokens] optional estimateTokens stub (test seam)
- * @returns {Promise<object>} `{}` or `{ additionalContext: "..." }`
- */
-async function runMeter(opts) {
-  // Outer try/catch guarantees we NEVER throw. Any unexpected error → `{}`.
-  try {
-    const {
-      payload,
-      projectRoot,
-      env,
-      clock,
-      _loadConfig = realLoadConfig,
-      _parseTranscript = realParseTranscript,
-      _estimateTokens = realEstimateTokens,
-    } = opts || {};
-
-    const root = projectRoot || process.cwd();
-    const envObj = env || {};
-    const now = () => (clock ? clock() : new Date());
-
-    // 1. Load config (missing file → defaults). Any throw → bail out fail-open.
-    let cfg;
-    try {
-      cfg = _loadConfig(root);
-    } catch (_) {
-      return {};
-    }
-
-    const statePath = path.isAbsolute(cfg.statePath)
-      ? cfg.statePath
-      : path.join(root, cfg.statePath);
-    const logPath = path.isAbsolute(cfg.logPath)
-      ? cfg.logPath
-      : path.join(root, cfg.logPath);
-
-    // 2. Read (possibly corrupt) state, increment checkCount immediately.
-    const state = readState(statePath);
-    state.version = STATE_VERSION;
-    state.modelWindowSize = cfg.modelWindowSize;
-    state.checkCount = (Number.isInteger(state.checkCount) ? state.checkCount : 0) + 1;
-
-    // 3. Check-frequency gate: not our turn → persist counter and bail out `{}`.
-    if (state.checkCount % cfg.checkFrequency !== 0) {
-      writeStateAtomic(statePath, state);
-      return {};
-    }
-
-    // 4. Extract transcript_path from payload (fail open if missing).
-    const transcriptPath =
-      payload && typeof payload === "object" && typeof payload.transcript_path === "string"
-        ? payload.transcript_path
-        : null;
-
-    if (!transcriptPath) {
-      state.lastError = {
-        code: "no_transcript",
-        message: "payload missing transcript_path",
-        timestamp: now().toISOString(),
-      };
-      writeStateAtomic(statePath, state);
-      appendLog(logPath, "ERROR", "no_transcript", "payload missing transcript_path", clock);
-      return {};
-    }
-
-    // 5. Parse transcript (streaming, async). null → bail out.
-    let parsed;
-    try {
-      parsed = await _parseTranscript(transcriptPath);
-    } catch (_) {
-      parsed = null;
-    }
-    if (!parsed || !Array.isArray(parsed.messages)) {
-      state.lastError = {
-        code: "parse_failure",
-        message: `parseTranscript returned null for ${path.basename(transcriptPath)}`,
-        timestamp: now().toISOString(),
-      };
-      writeStateAtomic(statePath, state);
-      appendLog(
-        logPath,
-        "ERROR",
-        "parse_failure",
-        `${path.basename(transcriptPath)}`,
-        clock
-      );
-      return {};
-    }
-
-    // 5b. Resolve the EFFECTIVE context window from the model the orchestrator
-    // session is actually running (parsed.model). Opus 4.6/4.7 and Sonnet 4.x
-    // ship a 1M window; the config default (200k) is a legacy fallback that
-    // overcounts usage 5× and fires the headless handoff far too early. We
-    // only override when the transcript reports a model — a missing model or
-    // an explicit project config value falls through to cfg.modelWindowSize.
-    const effectiveWindow =
-      typeof parsed.model === "string" && parsed.model.length > 0
-        ? windowForModel(parsed.model)
-        : cfg.modelWindowSize;
-    state.modelWindowSize = effectiveWindow;
-
-    // 6. Estimate tokens locally (no API call, zero cost).
-    let tokenResp;
-    try {
-      tokenResp = _estimateTokens({
-        system: parsed.system || "",
-        messages: parsed.messages,
-      });
-    } catch (_) {
-      tokenResp = null;
-    }
-
-    if (!tokenResp || !Number.isFinite(tokenResp.inputTokens)) {
-      state.inputTokens = 0;
-      state.pct = 0;
-      state.threshold = "normal";
-      state.timestamp = now().toISOString();
-      state.lastError = {
-        code: "estimate_error",
-        message: "estimateTokens returned null",
-        timestamp: state.timestamp,
-      };
-      writeStateAtomic(statePath, state);
-      appendLog(logPath, "ERROR", "estimate_error", "estimateTokens null", clock);
-      return {};
-    }
-
-    // 8. Success path — compute pct, band, possibly emit additionalContext.
-    const pct = computePct({
-      inputTokens: tokenResp.inputTokens,
-      modelWindowSize: effectiveWindow,
-    });
-    const band = bandFor(pct, cfg.thresholdPct);
-
-    state.inputTokens = tokenResp.inputTokens;
-    state.pct = pct;
-    state.threshold = band;
-    state.timestamp = now().toISOString();
-    state.lastError = null;
-    writeStateAtomic(statePath, state);
-    appendLog(
-      logPath,
-      "INFO",
-      "measure",
-      `tokens=${tokenResp.inputTokens} pct=${pct.toFixed(1)} band=${band} ` +
-        `window=${effectiveWindow}${parsed.model ? ` model=${parsed.model}` : ""}`,
-      clock
-    );
-
-    const additionalContext = buildAdditionalContext({
-      pct,
-      modelWindowSize: effectiveWindow,
-      thresholdPct: cfg.thresholdPct,
-    });
-    if (additionalContext) {
-      return { additionalContext };
-    }
-    return {};
-  } catch (_) {
-    // Absolute safety net — fail open no matter what.
-    return {};
-  }
-}
-
-/* ──────────────────────────── CLI shim ──────────────────────────── */
-
-function readStdin() {
-  return new Promise((resolve) => {
-    let data = "";
-    try {
-      if (process.stdin.isTTY) {
-        resolve("");
-        return;
-      }
-      process.stdin.setEncoding("utf8");
-      process.stdin.on("data", (chunk) => {
-        data += chunk;
-      });
-      process.stdin.on("end", () => resolve(data));
-      process.stdin.on("error", () => resolve(""));
-    } catch (_) {
-      resolve("");
-    }
-  });
-}
-
-async function main() {
-  let payload = null;
-  try {
-    const raw = await readStdin();
-    payload = raw ? JSON.parse(raw) : null;
-  } catch (_) {
-    payload = null;
-  }
-
-  let out = {};
-  try {
-    out = await runMeter({
-      payload: payload || {},
-      projectRoot: process.cwd(),
-      env: process.env,
-    });
-  } catch (_) {
-    out = {};
-  }
-
-  try {
-    process.stdout.write(JSON.stringify(out || {}));
-  } catch (_) {
-    process.stdout.write("{}");
-  }
-  process.exit(0);
-}
-
-module.exports = { runMeter, readState, writeStateAtomic, defaultState };
-
-if (require.main === module) {
-  main();
-}