@tekyzinc/gsd-t 3.26.11 → 3.29.10

package/bin/gsd-t-test-data-adapters/sqlite-table-where.cjs

@@ -0,0 +1,71 @@
+/**
+ * Adapter: sqlite-table-where
+ *
+ * Purges a row from a SQLite table by ID, with a tagged-prefix LIKE guard.
+ * `store` is `dbPath|table|idColumn` (three pipe-separated segments).
+ *
+ * `better-sqlite3` is dynamically required at adapter-use time — adapter
+ * still loads when the module isn't installed. Tests self-skip in that case.
+ */
+const fs = require('node:fs');
+
+const KIND = 'sqlite-table-where';
+
+const IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+function parseStore(store) {
+  if (typeof store !== 'string') {
+    throw new Error('sqlite-table-where: store must be "dbPath|table|idColumn"');
+  }
+  const parts = store.split('|');
+  if (parts.length !== 3) {
+    throw new Error('sqlite-table-where: store must be "dbPath|table|idColumn"');
+  }
+  const [dbPath, table, idColumn] = parts.map((s) => s.trim());
+  if (!dbPath || !table || !idColumn) {
+    throw new Error('sqlite-table-where: empty segment in store');
+  }
+  if (!IDENT_RE.test(table)) {
+    throw new Error(`sqlite-table-where: invalid table identifier "${table}"`);
+  }
+  if (!IDENT_RE.test(idColumn)) {
+    throw new Error(`sqlite-table-where: invalid idColumn identifier "${idColumn}"`);
+  }
+  return { dbPath, table, idColumn };
+}
+
+function purge({ store, id, taggedPrefix }) {
+  const { dbPath, table, idColumn } = parseStore(store);
+  if (typeof id !== 'string' || id.length === 0) {
+    throw new Error('sqlite-table-where: id must be a non-empty string');
+  }
+  if (typeof taggedPrefix !== 'string' || taggedPrefix.length === 0) {
+    throw new Error('sqlite-table-where: taggedPrefix is required for SQL safety');
+  }
+  if (!id.startsWith(taggedPrefix)) {
+    throw new Error(`sqlite-table-where: tag prefix mismatch (id="${id}", taggedPrefix="${taggedPrefix}")`);
+  }
+  if (!fs.existsSync(dbPath)) {
+    return 'absent';
+  }
+
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch (e) {
+    throw new Error('sqlite-table-where: better-sqlite3 not installed; cannot purge');
+  }
+
+  const db = new Database(dbPath);
+  try {
+    // Identifiers are validated against IDENT_RE; values use bind parameters.
+    const sql = `DELETE FROM "${table}" WHERE "${idColumn}" = ? AND "${idColumn}" LIKE ?`;
+    const stmt = db.prepare(sql);
+    const info = stmt.run(id, taggedPrefix + '%');
+    return info.changes > 0 ? 'purged' : 'absent';
+  } finally {
+    db.close();
+  }
+}
+
+module.exports = { kind: KIND, purge };

package/bin/gsd-t-test-data-ledger.cjs

@@ -0,0 +1,290 @@
+#!/usr/bin/env node
+/**
+ * gsd-t-test-data-ledger — M58 D1
+ *
+ * Append-only JSONL ledger tracking test data inserted during a Verify run,
+ * plus a purge engine that removes those records from the underlying store
+ * after the suite completes.
+ *
+ * Contract: .gsd-t/contracts/test-data-ledger-contract.md
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const LEDGER_RELPATH = path.join('.gsd-t', 'test-data-ledger.jsonl');
+
+// ─── Adapter registry ─────────────────────────────────────────────────────
+
+const adapters = new Map();
+
+function registerAdapter(kind, adapter) {
+  if (typeof kind !== 'string' || kind.length === 0) {
+    throw new Error('registerAdapter: kind must be a non-empty string');
+  }
+  if (!adapter || typeof adapter.purge !== 'function') {
+    throw new Error('registerAdapter: adapter must export a purge(...) function');
+  }
+  adapters.set(kind, adapter);
+}
+
+// Built-in adapters auto-register on module load.
+registerAdapter('file-json-array', require('./gsd-t-test-data-adapters/file-json-array.cjs'));
+registerAdapter('localStorage-key-prefix', require('./gsd-t-test-data-adapters/localstorage-key-prefix.cjs'));
+registerAdapter('sqlite-table-where', require('./gsd-t-test-data-adapters/sqlite-table-where.cjs'));
+
+// ─── Public API ───────────────────────────────────────────────────────────
+
+function ledgerPathFor(projectDir) {
+  return path.join(projectDir, LEDGER_RELPATH);
+}
+
+function appendInsert({ projectDir, runId, kind, store, id, taggedPrefix, insertedAt }) {
+  if (typeof projectDir !== 'string' || projectDir.length === 0) {
+    throw new Error('appendInsert: projectDir is required');
+  }
+  if (typeof runId !== 'string' || runId.length === 0) {
+    throw new Error('appendInsert: runId is required');
+  }
+  if (typeof kind !== 'string' || kind.length === 0) {
+    throw new Error('appendInsert: kind is required');
+  }
+  if (typeof store !== 'string' || store.length === 0) {
+    throw new Error('appendInsert: store is required');
+  }
+  if (typeof id !== 'string' || id.length === 0) {
+    throw new Error('appendInsert: id is required');
+  }
+  const finalTaggedPrefix = typeof taggedPrefix === 'string' && taggedPrefix.length > 0
+    ? taggedPrefix
+    : 'E2E_';
+  if (!id.startsWith(finalTaggedPrefix)) {
+    throw new Error(`appendInsert: id "${id}" does not start with taggedPrefix "${finalTaggedPrefix}"`);
+  }
+  const finalInsertedAt = typeof insertedAt === 'string' && insertedAt.length > 0
+    ? insertedAt
+    : new Date().toISOString();
+
+  const row = {
+    runId,
+    kind,
+    store,
+    id,
+    taggedPrefix: finalTaggedPrefix,
+    insertedAt: finalInsertedAt,
+  };
+
+  const ledgerPath = ledgerPathFor(projectDir);
+  fs.mkdirSync(path.dirname(ledgerPath), { recursive: true });
+  fs.appendFileSync(ledgerPath, JSON.stringify(row) + '\n', 'utf8');
+  return { ok: true, ledgerPath };
+}
+
+function listInserts({ projectDir, runId }) {
+  if (typeof projectDir !== 'string' || projectDir.length === 0) {
+    throw new Error('listInserts: projectDir is required');
+  }
+  const ledgerPath = ledgerPathFor(projectDir);
+  if (!fs.existsSync(ledgerPath)) return [];
+  const raw = fs.readFileSync(ledgerPath, 'utf8');
+  const rows = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (runId && parsed.runId !== runId) continue;
+      rows.push(parsed);
+    } catch {
+      // skip malformed lines (audit-trail is permissive)
+    }
+  }
+  return rows;
+}
+
+async function purgeRunInserts({ projectDir, runId, dryRun }) {
+  if (typeof projectDir !== 'string' || projectDir.length === 0) {
+    throw new Error('purgeRunInserts: projectDir is required');
+  }
+  if (typeof runId !== 'string' || runId.length === 0) {
+    throw new Error('purgeRunInserts: runId is required');
+  }
+  const rows = listInserts({ projectDir, runId });
+  const purged = [];
+  const skipped = [];
+  const errors = [];
+
+  for (const row of rows) {
+    if (dryRun === true) {
+      purged.push(row); // dry-run treats every targeted row as 'would be purged'
+      continue;
+    }
+    const adapter = adapters.get(row.kind);
+    if (!adapter) {
+      errors.push({ record: row, message: `no adapter registered for kind "${row.kind}"` });
+      continue;
+    }
+    try {
+      const result = await adapter.purge({
+        store: row.store,
+        id: row.id,
+        taggedPrefix: row.taggedPrefix,
+      });
+      if (result === 'purged') {
+        purged.push(row);
+      } else if (result === 'absent') {
+        skipped.push(row);
+      } else {
+        errors.push({ record: row, message: `adapter returned unexpected value "${String(result)}"` });
+      }
+    } catch (e) {
+      errors.push({ record: row, message: e && e.message ? e.message : String(e) });
+    }
+  }
+
+  return { purged, skipped, errors };
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────
+
+const COLOR = {
+  reset: '\x1b[0m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  dim: '\x1b[2m',
+};
+
+function parseArgs(argv) {
+  const opts = {
+    mode: null, // 'list' | 'purge'
+    runId: null,
+    dryRun: false,
+    json: false,
+    projectDir: process.cwd(),
+  };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === '--list') opts.mode = 'list';
+    else if (a === '--purge') opts.mode = 'purge';
+    else if (a === '--dry-run') opts.dryRun = true;
+    else if (a === '--json') opts.json = true;
+    else if (a === '--run' || a === '--run-id') {
+      opts.runId = argv[++i] || null;
+    } else if (a === '--project') {
+      opts.projectDir = argv[++i] || process.cwd();
+    } else if (a === '-h' || a === '--help') {
+      opts.mode = 'help';
+    }
+  }
+  return opts;
+}
+
+function printHelp() {
+  process.stdout.write(`Usage: gsd-t test-data --list [--run <id>] [--json]
+       gsd-t test-data --purge --run <id> [--dry-run] [--json]
+
+Options:
+  --list           List ledger entries (optionally filtered by --run)
+  --purge          Purge ledger entries for a given --run
+  --run <id>       Verify run id (e.g., verify-m58-20260527T091800Z)
+  --dry-run        With --purge: report what would be purged without calling adapters
+  --json           Emit JSON envelope instead of pretty output
+  --project <dir>  Project directory (defaults to CWD)
+  -h, --help       Show this help
+
+Exit codes:
+  0   success
+  4   one or more adapter errors (purge mode)
+  64  CLI argument error
+`);
+}
+
+async function main(argv) {
+  const opts = parseArgs(argv);
+  if (opts.mode === 'help' || !opts.mode) {
+    printHelp();
+    return opts.mode === 'help' ? 0 : 64;
+  }
+
+  if (opts.mode === 'list') {
+    const rows = listInserts({ projectDir: opts.projectDir, runId: opts.runId });
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ ok: true, rows }) + '\n');
+    } else {
+      if (rows.length === 0) {
+        process.stdout.write(`${COLOR.dim}No ledger entries${opts.runId ? ` for run "${opts.runId}"` : ''}.${COLOR.reset}\n`);
+      } else {
+        process.stdout.write(`${COLOR.bold}Test data ledger${opts.runId ? ` — run ${opts.runId}` : ''}${COLOR.reset}\n`);
+        for (const r of rows) {
+          process.stdout.write(`  ${COLOR.blue}${r.kind}${COLOR.reset} ${r.id} ${COLOR.dim}(${r.store})${COLOR.reset}\n`);
+        }
+        process.stdout.write(`\n${COLOR.bold}Total:${COLOR.reset} ${rows.length}\n`);
+      }
+    }
+    return 0;
+  }
+
+  if (opts.mode === 'purge') {
+    if (!opts.runId) {
+      process.stderr.write('gsd-t test-data --purge requires --run <id>\n');
+      return 64;
+    }
+    const envelope = await purgeRunInserts({
+      projectDir: opts.projectDir,
+      runId: opts.runId,
+      dryRun: opts.dryRun,
+    });
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({
+        ok: envelope.errors.length === 0,
+        runId: opts.runId,
+        dryRun: !!opts.dryRun,
+        purged: envelope.purged.length,
+        skipped: envelope.skipped.length,
+        errors: envelope.errors,
+      }) + '\n');
+    } else {
+      const tag = opts.dryRun ? '[DRY RUN] ' : '';
+      process.stdout.write(`${COLOR.bold}${tag}Purge run ${opts.runId}${COLOR.reset}\n`);
+      process.stdout.write(`  ${COLOR.green}purged:${COLOR.reset}  ${envelope.purged.length}\n`);
+      process.stdout.write(`  ${COLOR.yellow}skipped:${COLOR.reset} ${envelope.skipped.length}\n`);
+      process.stdout.write(`  ${COLOR.red}errors:${COLOR.reset}  ${envelope.errors.length}\n`);
+      if (envelope.errors.length > 0) {
+        process.stdout.write(`\n${COLOR.red}Errors:${COLOR.reset}\n`);
+        for (const e of envelope.errors.slice(0, 5)) {
+          process.stdout.write(`  - ${e.record.id} (${e.record.kind}): ${e.message}\n`);
+        }
+        if (envelope.errors.length > 5) {
+          process.stdout.write(`  … and ${envelope.errors.length - 5} more\n`);
+        }
+      }
+    }
+    return envelope.errors.length === 0 ? 0 : 4;
+  }
+
+  printHelp();
+  return 64;
+}
+
+module.exports = {
+  appendInsert,
+  listInserts,
+  purgeRunInserts,
+  registerAdapter,
+  main,
+  ledgerPathFor,
+  LEDGER_RELPATH,
+};
+
+if (require.main === module) {
+  main(process.argv.slice(2)).then(
+    (code) => process.exit(code),
+    (err) => {
+      process.stderr.write(`gsd-t test-data: ${err && err.message ? err.message : String(err)}\n`);
+      process.exit(1);
+    }
+  );
+}

package/bin/gsd-t-time-format.cjs

@@ -0,0 +1,94 @@
+/**
+ * gsd-t-time-format — M59
+ *
+ * Shared helpers for the v3.29.10 timestamp-precision format.
+ *
+ * Exports:
+ *   localIsoWithOffset([date])  → "YYYY-MM-DDTHH:MM:SS±HH:MM" (local offset)
+ *   localTimestampForProgress([date]) → "YYYY-MM-DD HH:MM TZ"  (human-readable, for progress.md fields)
+ *
+ * Both helpers source the current time from `new Date()` by default. The
+ * `[GSD-T NOW]` UserPromptSubmit signal feeds the system clock, so these
+ * are correct in any GSD-T spawn.
+ */
+
+const TZ_ABBR_FALLBACK = 'UTC';
+
+function pad2(n) {
+  const s = String(n);
+  return s.length < 2 ? `0${s}` : s;
+}
+
+/**
+ * ISO 8601 timestamp with local timezone offset (NOT UTC `Z`).
+ *
+ * Example: `2026-05-27T10:15:30-07:00` (PDT, summer)
+ *          `2026-12-15T10:15:30-08:00` (PST, winter)
+ */
+function localIsoWithOffset(date) {
+  const d = date instanceof Date ? date : new Date();
+  const yyyy = d.getFullYear();
+  const mm = pad2(d.getMonth() + 1);
+  const dd = pad2(d.getDate());
+  const hh = pad2(d.getHours());
+  const mi = pad2(d.getMinutes());
+  const ss = pad2(d.getSeconds());
+
+  const offsetMinTotal = -d.getTimezoneOffset(); // east of UTC is positive
+  const sign = offsetMinTotal >= 0 ? '+' : '-';
+  const offsetAbs = Math.abs(offsetMinTotal);
+  const offH = pad2(Math.floor(offsetAbs / 60));
+  const offM = pad2(offsetAbs % 60);
+
+  return `${yyyy}-${mm}-${dd}T${hh}:${mi}:${ss}${sign}${offH}:${offM}`;
+}
+
+/**
+ * Resolve a short human-readable TZ abbreviation (e.g., "PDT", "PST").
+ * Uses Intl.DateTimeFormat short timezone where available; falls back to
+ * the numeric offset string if the platform doesn't provide one.
+ */
+function shortTzAbbr(date) {
+  const d = date instanceof Date ? date : new Date();
+  try {
+    const parts = new Intl.DateTimeFormat('en-US', {
+      timeZoneName: 'short',
+    }).formatToParts(d);
+    const tzPart = parts.find((p) => p.type === 'timeZoneName');
+    if (tzPart && tzPart.value) return tzPart.value;
+  } catch {
+    /* fall through */
+  }
+  // Fallback — numeric offset like "GMT-07:00"
+  const offsetMin = -d.getTimezoneOffset();
+  const sign = offsetMin >= 0 ? '+' : '-';
+  const abs = Math.abs(offsetMin);
+  return `GMT${sign}${pad2(Math.floor(abs / 60))}:${pad2(abs % 60)}`;
+}
+
+/**
+ * Human-readable timestamp for progress.md visible fields:
+ *   "YYYY-MM-DD HH:MM TZ"
+ *
+ * Example: `2026-05-27 10:15 PDT`
+ *
+ * This is the M59 format for:
+ *   - `## Date:` line in progress.md frontmatter
+ *   - "Completed" cell in the Completed Milestones table
+ *   - "Date" cell in the Session Log table
+ */
+function localTimestampForProgress(date) {
+  const d = date instanceof Date ? date : new Date();
+  const yyyy = d.getFullYear();
+  const mm = pad2(d.getMonth() + 1);
+  const dd = pad2(d.getDate());
+  const hh = pad2(d.getHours());
+  const mi = pad2(d.getMinutes());
+  return `${yyyy}-${mm}-${dd} ${hh}:${mi} ${shortTzAbbr(d) || TZ_ABBR_FALLBACK}`;
+}
+
+module.exports = {
+  localIsoWithOffset,
+  localTimestampForProgress,
+  shortTzAbbr,
+};

package/bin/gsd-t.js

@@ -1185,6 +1185,9 @@ const GLOBAL_BIN_TOOLS = [
   "gsd-t-verify-gate-judge.cjs",
   // M55 D2 substrate — parallel-cli engine (added v3.25.11 patch — missed in initial M55 D5 wire-in).
   "parallel-cli.cjs",
+  // M57 — CI-parity verify-gate checks (structural build-coverage + containment-safe ci-parity).
+  "gsd-t-build-coverage.cjs",
+  "gsd-t-ci-parity.cjs",
 ];
 
 function installGlobalBinTools() {
@@ -4559,6 +4562,33 @@ if (require.main === module) {
       });
       process.exit(res.status == null ? 1 : res.status);
     }
+    case "build-coverage": {
+      // M57 D1 — `gsd-t build-coverage` thin dispatcher to bin/gsd-t-build-coverage.cjs.
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-build-coverage.cjs");
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
+    case "ci-parity": {
+      // M57 D2 — `gsd-t ci-parity` thin dispatcher to bin/gsd-t-ci-parity.cjs.
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-ci-parity.cjs");
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
+    case "test-data": {
+      // M58 D1 — `gsd-t test-data --list|--purge` thin dispatcher.
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-test-data-ledger.cjs");
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
     case "stream-feed": {
       doStreamFeed(args.slice(1));
       break;

package/bin/model-windows.cjs

@@ -0,0 +1,99 @@
+/**
+ * bin/model-windows.cjs
+ *
+ * Single source of truth for Claude model → context-window size (in input
+ * tokens). The context meter and every downstream budget module must size the
+ * window from the MODEL ACTUALLY RUNNING, not a hardcoded constant.
+ *
+ * Why this exists
+ * ---------------
+ * Prior to this module every budget site hardcoded `200000` with a comment
+ * "claude-opus-4-6 default". Opus 4.6 and 4.7 (and Sonnet 4.x) ship a
+ * 1,000,000-token context window. Hardcoding 200k made the context meter
+ * overcount usage 5× and fire the headless handoff at ~64% of context
+ * REMAINING. This map fixes that at the source.
+ *
+ * Resolution strategy
+ * -------------------
+ * GSD-T jumps between models per-subagent, so a static config value is wrong.
+ * The orchestrator session whose transcript the meter reads, however, runs a
+ * single model for its lifetime, and every assistant message in the transcript
+ * records its `model` id. `windowForModel(modelId)` maps that id to a window.
+ *
+ * Matching is by longest-prefix so versioned ids resolve even if a future
+ * dated suffix appears (e.g. "claude-opus-4-7-20260115" → opus 4.x entry).
+ * Unknown / missing model → SAFE_DEFAULT_WINDOW (the large 1M window: a guard
+ * that triggers late is worse than one that never undercounts a real 1M
+ * session — but see note below; we deliberately pick the large default so the
+ * meter does NOT regress to premature handoffs on an unrecognized new model).
+ *
+ * Zero dependencies. CommonJS. Pure functions.
+ */
+
+"use strict";
+
+// The conservative fallback when a model can't be resolved. We choose the
+// LARGE window (1M) on purpose: the bug we are fixing is premature handoff
+// from a too-SMALL assumed window. An unknown future model is far more likely
+// to have a >=1M window than a 200k one, and an over-large window degrades
+// gracefully (handoff a little late) whereas an under-small one breaks the
+// workflow (handoff way too early, the reported symptom).
+const SAFE_DEFAULT_WINDOW = 1_000_000;
+
+// The legacy small window, kept as a named export for the few call sites that
+// must preserve old behavior explicitly (e.g. fixtures, back-compat configs).
+const LEGACY_SMALL_WINDOW = 200_000;
+
+// Longest-prefix map: key is a model-id prefix, value is the input-token
+// context window for that model family. Order does not matter — resolution
+// picks the LONGEST matching prefix.
+const MODEL_WINDOWS = Object.freeze({
+  // Opus 4.6 / 4.7 — 1M context window.
+  "claude-opus-4-6": 1_000_000,
+  "claude-opus-4-7": 1_000_000,
+  // Generic opus-4 fallback (covers any 4.x point release not listed above).
+  "claude-opus-4": 1_000_000,
+
+  // Sonnet 4.x — 1M context window.
+  "claude-sonnet-4": 1_000_000,
+
+  // Haiku 4.x — 200k context window.
+  "claude-haiku-4": 200_000,
+
+  // Pre-4 families (defensive — older long sessions / replayed transcripts).
+  "claude-3-7-sonnet": 200_000,
+  "claude-3-5-sonnet": 200_000,
+  "claude-3-5-haiku": 200_000,
+  "claude-3-opus": 200_000,
+});
+
+/**
+ * Resolve a context-window size (input tokens) for a Claude model id.
+ *
+ * @param {string|null|undefined} modelId  e.g. "claude-opus-4-7" or
+ *        "claude-opus-4-7-20260115". Non-string / empty → SAFE_DEFAULT_WINDOW.
+ * @returns {number} positive integer window size
+ */
+function windowForModel(modelId) {
+  if (typeof modelId !== "string" || modelId.length === 0) {
+    return SAFE_DEFAULT_WINDOW;
+  }
+  const id = modelId.trim().toLowerCase();
+
+  let best = null;
+  let bestLen = -1;
+  for (const prefix of Object.keys(MODEL_WINDOWS)) {
+    if (id.startsWith(prefix) && prefix.length > bestLen) {
+      best = MODEL_WINDOWS[prefix];
+      bestLen = prefix.length;
+    }
+  }
+  return best != null ? best : SAFE_DEFAULT_WINDOW;
+}
+
+module.exports = {
+  windowForModel,
+  MODEL_WINDOWS,
+  SAFE_DEFAULT_WINDOW,
+  LEGACY_SMALL_WINDOW,
+};

package/bin/model-windows.test.cjs

@@ -0,0 +1,75 @@
+/**
+ * Tests for bin/model-windows.cjs — model → context-window resolution.
+ *
+ * The bug this fixes: the context meter hardcoded a 200k window so an Opus 4.7
+ * session (1M window) read as 5× over budget, firing the headless handoff at
+ * ~64% of context REMAINING. These tests pin the corrected windows.
+ */
+
+"use strict";
+
+const test = require("node:test");
+const assert = require("node:assert/strict");
+
+const {
+  windowForModel,
+  MODEL_WINDOWS,
+  SAFE_DEFAULT_WINDOW,
+  LEGACY_SMALL_WINDOW,
+} = require("./model-windows.cjs");
+
+test("Opus 4.7 resolves to a 1M window (the reported regression)", () => {
+  assert.equal(windowForModel("claude-opus-4-7"), 1_000_000);
+});
+
+test("Opus 4.6 resolves to a 1M window", () => {
+  assert.equal(windowForModel("claude-opus-4-6"), 1_000_000);
+});
+
+test("dated/versioned suffix still resolves via longest-prefix", () => {
+  assert.equal(windowForModel("claude-opus-4-7-20260115"), 1_000_000);
+  assert.equal(windowForModel("claude-sonnet-4-6-20251201"), 1_000_000);
+});
+
+test("Sonnet 4.x resolves to a 1M window", () => {
+  assert.equal(windowForModel("claude-sonnet-4-6"), 1_000_000);
+  assert.equal(windowForModel("claude-sonnet-4"), 1_000_000);
+});
+
+test("Haiku 4.x resolves to the 200k window", () => {
+  assert.equal(windowForModel("claude-haiku-4-5-20251001"), 200_000);
+  assert.equal(windowForModel("claude-haiku-4"), 200_000);
+});
+
+test("longest-prefix wins over a shorter generic prefix", () => {
+  // "claude-opus-4-7" (15) must beat "claude-opus-4" (13). Both map to 1M
+  // here, so assert the resolution mechanism via a value-independent check:
+  // a hypothetical future divergence would surface if this regressed.
+  assert.equal(windowForModel("claude-opus-4-7"), MODEL_WINDOWS["claude-opus-4-7"]);
+});
+
+test("case-insensitive and whitespace-tolerant", () => {
+  assert.equal(windowForModel("  CLAUDE-OPUS-4-7  "), 1_000_000);
+});
+
+test("unknown / missing model falls back to the SAFE large default", () => {
+  assert.equal(windowForModel("claude-future-99"), SAFE_DEFAULT_WINDOW);
+  assert.equal(windowForModel(""), SAFE_DEFAULT_WINDOW);
+  assert.equal(windowForModel(null), SAFE_DEFAULT_WINDOW);
+  assert.equal(windowForModel(undefined), SAFE_DEFAULT_WINDOW);
+  assert.equal(windowForModel(42), SAFE_DEFAULT_WINDOW);
+});
+
+test("SAFE_DEFAULT_WINDOW is the large (1M) window, not the legacy 200k", () => {
+  // Core anti-regression assertion: the fallback must NOT reintroduce the
+  // premature-handoff bug for an unrecognized model.
+  assert.equal(SAFE_DEFAULT_WINDOW, 1_000_000);
+  assert.equal(LEGACY_SMALL_WINDOW, 200_000);
+  assert.notEqual(SAFE_DEFAULT_WINDOW, LEGACY_SMALL_WINDOW);
+});
+
+test("every mapped window is a positive integer", () => {
+  for (const [k, v] of Object.entries(MODEL_WINDOWS)) {
+    assert.ok(Number.isInteger(v) && v > 0, `${k} → ${v} must be a positive int`);
+  }
+});