@tekyzinc/gsd-t 3.26.10 → 3.27.10

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`);
+  }
+});

package/bin/runway-estimator.cjs

@@ -26,12 +26,43 @@
 
 const fs = require('fs');
 const path = require('path');
+const { SAFE_DEFAULT_WINDOW } = require('./model-windows.cjs');
 
 const DEFAULT_K = 5;
-const DEFAULT_MODEL_CONTEXT_CAP = 200000;
+// The model context cap IS the model's true window. Default to the model-aware
+// safe LARGE window (1M) — the old 200K literal was correct only for pre-4
+// models and made turn-to-compact predictions fire 5× too early on Opus/Sonnet.
+// Callers may still pass an explicit `modelContextCap`, and resolveContextCap()
+// below prefers a fresh Context Meter reading when available.
+const DEFAULT_MODEL_CONTEXT_CAP = SAFE_DEFAULT_WINDOW;
 // Claude Code starts auto-compacting ~8% before the model window fills, so the
 // effective dialog ceiling is 0.92 × modelContextCap.
 const PRE_COMPACT_HEADROOM = 0.92;
+// Context Meter state — its modelWindowSize is model-aware (bin/model-windows.cjs).
+const METER_STATE_REL = '.gsd-t/.context-meter-state.json';
+const METER_STATE_STALE_MS = 5 * 60 * 1000;
+
+/**
+ * Resolve the effective model context cap. Priority:
+ *   1. explicit opts.modelContextCap (caller override)
+ *   2. fresh Context Meter state modelWindowSize (model-aware, written by the
+ *      meter hook from the running model)
+ *   3. DEFAULT_MODEL_CONTEXT_CAP (safe large fallback)
+ */
+function resolveContextCap(projectDir, optCap) {
+  if (Number.isFinite(optCap) && optCap > 0) return optCap;
+  try {
+    const fp = path.join(projectDir || '.', METER_STATE_REL);
+    const s = JSON.parse(fs.readFileSync(fp, 'utf8'));
+    if (s && typeof s.modelWindowSize === 'number' && s.modelWindowSize > 0 && s.timestamp) {
+      const age = Date.now() - Date.parse(s.timestamp);
+      if (!isNaN(age) && age >= 0 && age <= METER_STATE_STALE_MS) {
+        return s.modelWindowSize;
+      }
+    }
+  } catch (_) { /* fall through to default */ }
+  return DEFAULT_MODEL_CONTEXT_CAP;
+}
 const DEFAULT_WARN_THRESHOLD_TURNS = 5;
 const MIN_HISTORY = 3;
 
@@ -107,7 +138,8 @@ function _sortTurns(rows) {
  * @param {string} opts.projectDir
  * @param {string} opts.sessionId                required
  * @param {number} [opts.k]                      default 5 (last K turns)
- * @param {number} [opts.modelContextCap]        default 200000
+ * @param {number} [opts.modelContextCap]        default: fresh Context Meter
+ *        modelWindowSize if available, else the model-aware safe window (1M)
  * @param {number} [opts.warnThresholdTurns]     default 5
  * @returns {{
  *   shouldWarn: boolean,
@@ -124,9 +156,7 @@ function estimateDialogGrowth(opts) {
   const projectDir = (opts && opts.projectDir) || '.';
   const sessionId = opts && opts.sessionId;
   const k = (opts && Number.isFinite(opts.k) && opts.k > 0) ? Math.floor(opts.k) : DEFAULT_K;
-  const cap = (opts && Number.isFinite(opts.modelContextCap) && opts.modelContextCap > 0)
-    ? opts.modelContextCap
-    : DEFAULT_MODEL_CONTEXT_CAP;
+  const cap = resolveContextCap(projectDir, opts && opts.modelContextCap);
   const warnThreshold = (opts && Number.isFinite(opts.warnThresholdTurns) && opts.warnThresholdTurns > 0)
     ? opts.warnThresholdTurns
     : DEFAULT_WARN_THRESHOLD_TURNS;

package/bin/token-budget.cjs

@@ -26,11 +26,18 @@
 
 const fs = require("fs");
 const path = require("path");
+const { SAFE_DEFAULT_WINDOW } = require("./model-windows.cjs");
 
 // ── Constants ────────────────────────────────────────────────────────────────
 
 const MODEL_RATIOS = { haiku: 1, sonnet: 5, opus: 25 };
 
+// Fallback context window when no per-model signal is available. Uses the
+// model-windows safe LARGE default (1M) rather than a bare 200K literal: a
+// too-small fallback re-introduces the premature-headless-handoff bug the
+// model-aware sizing was added to fix. See bin/model-windows.cjs.
+const FALLBACK_WINDOW = SAFE_DEFAULT_WINDOW;
+
 // Base token estimates per task type (in haiku-equivalent units)
 const BASE_ESTIMATES = {
   execute: 8000,
@@ -106,7 +113,9 @@ function getSessionStatus(projectDir) {
   const real = readContextMeterState(dir);
   if (real) {
     const consumed = real.inputTokens;
-    const window = real.modelWindowSize > 0 ? real.modelWindowSize : 200000;
+    // Primary: the Context Meter writes a model-aware modelWindowSize into
+    // state (bin/model-windows.cjs). Fallback only when state predates that.
+    const window = real.modelWindowSize > 0 ? real.modelWindowSize : FALLBACK_WINDOW;
     const estimated_remaining = Math.max(0, window - consumed);
     const pct = Math.round(real.pct * 10) / 10;
     const threshold = bandFor(pct, thresholdPct);
@@ -145,7 +154,7 @@ function resolveThresholdPct(dir) {
 }
 
 function getSessionStatusHeuristic(dir, thresholdPct) {
-  const window = 200000;
+  const window = FALLBACK_WINDOW;
   const consumed = readSessionConsumed(dir);
   const estimated_remaining = Math.max(0, window - consumed);
   const pct = window > 0 ? Math.round((consumed / window) * 100 * 10) / 10 : 0;
@@ -180,7 +189,7 @@ function recordUsage(usage) {
  */
 function estimateMilestoneCost(remainingTasks, projectDir) {
   const status = getSessionStatus(projectDir);
-  const window = status.consumed + status.estimated_remaining || 200000;
+  const window = status.consumed + status.estimated_remaining || FALLBACK_WINDOW;
   const estimatedTokens = remainingTasks.reduce((sum, t) => {
     return sum + estimateCost(t.model, t.taskType, { complexity: t.complexity, projectDir });
   }, 0);

package/commands/gsd-t-help.md

@@ -455,6 +455,20 @@ Use these when user asks for help on a specific command:
 - **Use when**: Final pre-merge gate. Both tracks always run; both report. `ok` is purely deterministic — LLM verdict is advisory.
 - **CLI**: `gsd-t verify-gate [--skip-track1] [--skip-track2] [--max-concurrency N] [--fail-fast] [--json]`. Exit 0/4/2/3.
 
+### build-coverage (M57)
+- **Summary**: Detects new top-level paths in a milestone commit range not referenced by a real CI build input. Coverage is decided by STRUCTURALLY parsing CI files (Dockerfile COPY/ADD source args incl. relative `--from=`; cloudbuild `args`-positional; workflow `run`-positional via a block-scalar-aware YAML walker) — never substring-matching. `node_modules` never counts. No documented false-negative residual.
+- **Auto-invoked**: Yes — by `gsd-t-verify` Step 2.6 (FAIL-blocking, never warning-only)
+- **Files**: `bin/gsd-t-build-coverage.cjs`
+- **Use when**: Final pre-merge gate. Catches the TimeTracking v1.10.12 class (new `hooks/` dir committed, absent from Dockerfile COPY, shipped broken while verify passed).
+- **CLI**: `gsd-t build-coverage [--json] [--base REF] [--head REF] [--project-dir PATH]`. Exit 0/4/2.
+
+### ci-parity (M57)
+- **Summary**: Reproduces the project's actual CI build locally instead of assuming warm-cache local tsc/test parity. Auto-detects CI config (cloudbuild → workflows → Dockerfile RUN → package.json scripts), clears build caches (containment-safe — refuses any config-derived delete resolving outside OR equal-to projectRoot), and auto-runs the real `docker build` when a Dockerfile is present (presence is the trigger, no opt-in flag).
+- **Auto-invoked**: Yes — by `gsd-t-verify` Step 2.6 (FAIL-blocking, never warning-only)
+- **Files**: `bin/gsd-t-ci-parity.cjs`
+- **Use when**: Final pre-merge gate. Catches the TimeTracking v1.10.12 class (noImplicitAny regressions passed a warm-cache local tsc but failed CI's cold build).
+- **CLI**: `gsd-t ci-parity [--project-dir PATH] [--timeout-ms MS] [--json]`. Exit 0/4/2.
+
 ## Unknown Command
 
 If user asks for help on unrecognized command:

package/commands/gsd-t-milestone.md

@@ -68,13 +68,29 @@ Ask user: "Milestone {N-1} is still {status}. Archive it and start new? Or compl
 node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-milestone --step 4 --step-label "Pre-Partition Assessment" 2>/dev/null || true
 ```
 
-Before formal partitioning, do a quick assessment:
+Before formal partitioning, do a quick assessment.
 
-- **Complexity estimate**: Simple (1-2 domains), Medium (3-4), Complex (5+)
+**Express scope in GSD-T-native units only.** Per `feedback_no_human_hour_estimates.md` (memory): never use developer-hours, dev-days, sprints, story points, or person-weeks. Use these instead:
+
+| Unit | Use for |
+|------|---------|
+| **Domain count** | Partition coarseness (1-2 / 3-4 / 5+) |
+| **Wave count** | How many serial gates the milestone needs |
+| **Spawn count** | Estimated `claude -p` / Task subagent invocations |
+| **Token-spend range** | `$X-Y` based on prior comparable milestones |
+| **Rate-limit-window count** | If the milestone might span > 1 5h Claude Max window |
+| **Parallel-domain count** | How many domains can run concurrently (file-disjoint) |
+
+Assessment template:
+
+- **Domain count**: Simple (1-2 domains), Medium (3-4), Complex (5+)
+- **Wave count**: estimated based on cross-domain dependencies
+- **Parallel-domain count**: how many can run in the same wave
+- **Token-spend range**: $X-Y based on prior comparable milestones (read `.gsd-t/token-log.md` for trailing-3 comparison)
 - **Recommended approach**:
-  - Simple: Consider using /gsd-t-quick for each piece
-  - Medium: Standard partition → plan → execute flow
-  - Complex: Partition → discuss → plan → execute → integrate → verify
+  - 1-2 domains: Consider using /gsd-t-quick for each piece
+  - 3-4 domains: Standard partition → plan → execute flow
+  - 5+ domains: Partition → discuss → plan → execute → integrate → verify
 
 Present the assessment and ask: "Ready to partition into domains now, or want to discuss first?"
 

package/commands/gsd-t-promote-debt.md

@@ -67,7 +67,7 @@ Append to `.gsd-t/roadmap.md`:
 - [ ] {each debt item resolved and verified}
 - [ ] No regression in existing functionality
 - [ ] {item-specific criteria from techdebt.md}
-**Estimated effort**: {combined effort assessment}
+**Estimated scope**: {N domains} / {N waves} / $X-Y token-spend (express in GSD-T units only — never developer-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 **Priority**: {CRITICAL — before next feature | HIGH — soon | MEDIUM — planned}
 ```
 

package/commands/gsd-t-scan.md

@@ -351,7 +351,7 @@ Synthesize ALL findings into a **fresh** `.gsd-t/techdebt.md` (the previous vers
 - High priority: {N}
 - Medium priority: {N}
 - Low priority: {N}
-- Total estimated effort: {rough assessment}
+- Total estimated scope: {N domains} / {N waves} / $X-Y token-spend (GSD-T units only — see `feedback_no_human_hour_estimates.md`)
 - Previous scan archive: techdebt_{previous-date}.md
 
 ---
@@ -461,22 +461,22 @@ Review all items marked `Milestone candidate: YES` and group them into logical m
 
 ### Suggested: Security Hardening (Critical)
 Combines: TD-001, TD-003, TD-005
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Should be prioritized: BEFORE next feature milestone
 
 ### Suggested: Performance Optimization (High)
 Combines: TD-010, TD-012, TD-015
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Can be scheduled: AFTER current feature work
 
-### Suggested: Dependency Update Sprint (Medium)
+### Suggested: Dependency Update (Medium)
 Combines: TD-020, dependency table items with breaking=yes
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Can be scheduled: During next maintenance window
 
 ### Suggested: Shared Service Extraction (if candidates found)
 Combines: all "Shared Service Candidates" from quality.md Reusability Analysis
-Estimated effort: {assessment}
+Estimated scope: {domain-count} domains, {wave-count} waves, $X-Y token-spend (express in GSD-T units — domain/wave/spawn/token — never human-hours/days/sprints per `feedback_no_human_hour_estimates.md`)
 Should be prioritized: BEFORE adding new consumer surfaces to the system
 Note: Use `/gsd-t-partition` Step 1.6 to design the SharedCore domain
 ```

package/commands/gsd-t-verify.md

@@ -102,6 +102,52 @@ Defensive on missing `.gsd-t/ratelimit-map.json` — verify-gate falls back to
 
 Contract: `.gsd-t/contracts/verify-gate-contract.md` v1.0.0 STABLE.
 
+<!-- M57: CI-parity FAIL-blocking gate -->
+## Step 2.6: CI-Parity Gate (MANDATORY — FAIL-blocking, never warning-only)
+
+```bash
+node scripts/gsd-t-watch-state.js advance --agent-id "$GSD_T_AGENT_ID" --parent-id "${GSD_T_PARENT_AGENT_ID:-null}" --command gsd-t-verify --step 2 --step-label ".6: CI-Parity Gate" 2>/dev/null || true
+```
+
+Origin: TimeTracking v1.10.12 shipped VERIFIED + tagged while Cloud Build
+failed (a new top-level `hooks/` dir was committed but never added to the
+Dockerfile `COPY` directives, and `noImplicitAny` regressions passed a
+warm-cache local `tsc` but failed CI's cold build). `gsd-t-verify` must
+reproduce the project's *actual* CI build, not assume local parity.
+
+Run BOTH checks. **Either failing is a verify FAIL — it blocks
+complete-milestone. This is never a warning-only signal.**
+
+```bash
+# 1. Build-coverage — every new top-level path in the milestone range must be
+#    referenced by a real CI build input (structural parse, not substring).
+gsd-t build-coverage --json > /tmp/gsd-t-build-coverage.json
+BC_EXIT=$?
+
+# 2. CI-parity — reproduce the project's actual CI build locally with caches
+#    cleared; auto-runs `docker build` when a Dockerfile is present.
+gsd-t ci-parity --json > /tmp/gsd-t-ci-parity.json
+CP_EXIT=$?
+```
+
+- `build-coverage` exit **4** (`ok:false`, `missing[]` non-empty) → verify
+  FAIL. Report each uncovered path; the fix is to add the path to the
+  Dockerfile `COPY` / cloudbuild artifact / workflow build input.
+- `ci-parity` exit **4** (`ok:false` — a detected CI command or the real
+  `docker build` failed) → verify FAIL. Report the failing command.
+- exit **0** from both → gate passes.
+- exit **2** (usage error, e.g. not a git repo) → record as a structured
+  note; not a pass-by-default (investigate before proceeding).
+
+Both are pure-deterministic CLI checks (no LLM). They consume the same
+preflight envelope as the M55 verify-gate Track 1, so failing here at
+verify mirrors what CI would do — catching the TimeTracking class before
+the milestone is tagged.
+
+Contracts: `.gsd-t/contracts/cli-build-coverage-contract.md` v2.0.0 STABLE,
+`.gsd-t/contracts/ci-parity-contract.md` v2.0.0 STABLE.
+<!-- /M57: CI-parity FAIL-blocking gate -->
+
 ## Step 2.5: High-Risk Domain Gate (MANDATORY — Categories 2 and 7)
 
 ```bash

package/package.json

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

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

@@ -82,9 +82,12 @@ const readline = require("readline");
  * Parse a Claude Code transcript JSONL file.
  *
  * @param {string} transcriptPath - absolute path to a Claude Code transcript .jsonl
- * @returns {Promise<{system: string, messages: Array<{role: string, content: Array}>} | null>}
+ * @returns {Promise<{system: string, messages: Array<{role: string, content: Array}>, model: string|null} | null>}
  *          Resolves to the reconstructed body, or `null` on unreadable file /
  *          catastrophic parse failure. Caller treats `null` as "bail out, fail open".
+ *          `model` is the last-seen assistant `message.model` id (the model the
+ *          orchestrator session is running) or `null` if none observed — the
+ *          context meter uses it to size the context window correctly.
  */
 async function parseTranscript(transcriptPath) {
   if (typeof transcriptPath !== "string" || transcriptPath.length === 0) {
@@ -101,6 +104,10 @@ async function parseTranscript(transcriptPath) {
 
   const messages = [];
   let system = "";
+  // Last-seen assistant model id. Claude Code records `message.model` on every
+  // assistant turn; the orchestrator session runs one model for its lifetime,
+  // so the last value is authoritative for sizing the context window.
+  let model = null;
 
   let stream;
   try {
@@ -136,6 +143,9 @@ async function parseTranscript(transcriptPath) {
         if (!msg || typeof msg !== "object") continue;
 
         const role = msg.role || type;
+        if (type === "assistant" && typeof msg.model === "string" && msg.model.length > 0) {
+          model = msg.model;
+        }
         const content = normalizeContent(msg.content, role);
         if (content === null) continue;
 
@@ -152,7 +162,7 @@ async function parseTranscript(transcriptPath) {
     return null;
   }
 
-  return { system, messages: sanitizeToolPairs(messages) };
+  return { system, messages: sanitizeToolPairs(messages), model };
 }
 
 /**

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

@@ -39,17 +39,17 @@ test("empty path / non-string → returns null", async () => {
   assert.equal(await parseTranscript(undefined), null);
 });
 
-test("empty file → returns { system:'', messages:[] }", async () => {
+test("empty file → returns { system:'', messages:[], model:null }", async () => {
   const { dir, file } = mkTmpFile([]);
   try {
     const got = await parseTranscript(file);
-    assert.deepEqual(got, { system: "", messages: [] });
+    assert.deepEqual(got, { system: "", messages: [], model: null });
   } finally {
     cleanup(dir);
   }
 });
 
-test("file with only unknown event types → { system:'', messages:[] }", async () => {
+test("file with only unknown event types → { system:'', messages:[], model:null }", async () => {
   const { dir, file } = mkTmpFile([
     { type: "summary", foo: "bar" },
     { type: "system", subtype: "hook", hookInfos: [] },
@@ -60,7 +60,7 @@ test("file with only unknown event types → { system:'', messages:[] }", async
   ]);
   try {
     const got = await parseTranscript(file);
-    assert.deepEqual(got, { system: "", messages: [] });
+    assert.deepEqual(got, { system: "", messages: [], model: null });
   } finally {
     cleanup(dir);
   }
@@ -104,6 +104,53 @@ test("normal conversation — string-content user + text assistant", async () =>
   }
 });
 
+test("captures last-seen assistant model id (for window sizing)", async () => {
+  const { dir, file } = mkTmpFile([
+    { type: "user", message: { role: "user", content: "hi" } },
+    {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        model: "claude-opus-4-7",
+        content: [{ type: "text", text: "first" }],
+      },
+    },
+    { type: "user", message: { role: "user", content: "more" } },
+    {
+      type: "assistant",
+      message: {
+        role: "assistant",
+        model: "claude-opus-4-7-20260115",
+        content: [{ type: "text", text: "second" }],
+      },
+    },
+  ]);
+  try {
+    const got = await parseTranscript(file);
+    // Last assistant model wins (orchestrator session is single-model, but the
+    // last value is authoritative if a dated id supersedes a bare one).
+    assert.equal(got.model, "claude-opus-4-7-20260115");
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("model stays null when no assistant message carries one", async () => {
+  const { dir, file } = mkTmpFile([
+    { type: "user", message: { role: "user", content: "hi" } },
+    {
+      type: "assistant",
+      message: { role: "assistant", content: [{ type: "text", text: "no model field" }] },
+    },
+  ]);
+  try {
+    const got = await parseTranscript(file);
+    assert.equal(got.model, null);
+  } finally {
+    cleanup(dir);
+  }
+});
+
 test("tool_use / tool_result pairing by tool_use_id preserved in order", async () => {
   const TOOL_ID = "toolu_01ABC";
   const { dir, file } = mkTmpFile([

package/scripts/gsd-t-calibration-hook.js

@@ -39,9 +39,16 @@
 const fs = require("fs");
 const path = require("path");
 
+const { SAFE_DEFAULT_WINDOW } = require("../bin/model-windows.cjs");
+
 const MAX_STDIN = 1024 * 1024; // 1 MiB
 const SCHEMA_VERSION = 1;
-const DEFAULT_CW_CEILING_TOKENS = 200000; // input-token budget per CW
+// Input-token budget per CW = the model context window. Default to the
+// model-aware safe window (1M); the old 200K literal was correct only for
+// pre-4 models and skewed every actualCwPct calibration ratio 5× on
+// Opus/Sonnet. Event state may still override via cwCeilingTokens (the
+// economics estimator records the model-aware ceiling it actually used).
+const DEFAULT_CW_CEILING_TOKENS = SAFE_DEFAULT_WINDOW;
 
 if (require.main === module) {
   let input = "";