@tekyzinc/gsd-t 4.3.10 → 4.4.10

package/CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [4.4.10] - 2026-06-09 (M85 Model-Tier Policy + Fable 5 — minor)
+
+### Added — single source of truth for model-tier assignments + the Fable 5 tier
+
+Model-tier policy previously lived in 4 unsynced authorities with zero drift enforcement, and the parallel alias map was provably stale (`opus → claude-opus-4-7`). M85 centralizes the policy, fixes the live bug, and slots Claude Fable 5 (tier above Opus, $10/$50 per MTok) into the highest-leverage stages — gated by a lint so drift is impossible. The cost tradeoff was MEASURED, not asserted: a Fable single-draft tied a judged 3-Opus competition at 42% of the cost (n=1, discuss-class).
+
+- `bin/gsd-t-model-tier-policy.cjs`: NEW — frozen `MODEL_IDS` + `STAGE_TIERS` (6 fable stage keys; competition producers HELD at opus per the M82 blindness invariant), `requiresThinkingOmitted()` (Fable's thinking-disabled-400 breaking change encoded once; accepts the runtime bracket-suffix form), `resolve()` + CLI resolver emitting the M69 JSON envelope; `gsd-t model-tier-policy` dispatcher + registered in both bin-propagation lists.
+- `bin/gsd-t-parallel.cjs`: alias map now `require()`s the policy module (zero bare model-id literals; stale opus-4-7 gone); cache-warm probe passes `--model` explicitly (the `ANTHROPIC_MODEL` env pin was measured silently ignored by the current CLI).
+- `bin/model-selector.js`: FABLE tier + `cycle_2_escalation` rule via the existing `selectModel` signature; debug default byte-identical.
+- `templates/workflows/gsd-t-{phase,verify,debug}.workflow.js`: 5 Fable assignments — M84 solution-space/partition probes, competition judge (`judge:rubric`), M83 pre-mortem, Red Team (stays non-skippable), debug `cycle === 1 ? "opus" : "fable"` ternary.
+- `test/m85-workflow-tier-policy-lint.test.js`: NEW M71-family drift enforcer — 8-file discovery, stage-key→label mapping with per-stage non-empty-match, negative drift fixtures, real-file + debug-ternary meta-tests.
+- `test/m85-model-tier-policy.test.js` + `test/model-selector.test.js`: 25 + 57 tests incl. dispatcher/propagation killing tests.
+- Contracts: `model-tier-policy-contract.md` v1.0.0 STABLE (new); `model-selection-contract.md` → v1.1.0.
+
+No migration needed for consumer projects: workflows keep using tier aliases; `gsd-t update-all` propagates the new module. Suite 1462/0.
+
 ## [4.3.10] - 2026-06-05 (M84 Auto-Competition - minor)
 
 ### Changed - Competition Mode is now AUTOMATIC (was opt-in)

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v4.0.27** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v4.4.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
 
 **Eliminates context rot** — task-level fresh dispatch (one subagent per task, ~10-20% context each) means compaction never triggers.
 **Compaction-proof debug loops** — `gsd-t headless --debug-loop` runs test-fix-retest cycles as separate `claude -p` sessions. A JSONL debug ledger persists all hypothesis/fix/learning history across fresh sessions. Anti-repetition preamble injection prevents retrying failed hypotheses. Escalation tiers (sonnet → opus → human) and a hard iteration ceiling enforced externally.
@@ -18,7 +18,7 @@
 **Rigorous User-Journey Coverage + Anti-Drift Test Quality** — `bin/journey-coverage.cjs` regex listener detector + `gsd-t check-coverage` CLI + `scripts/hooks/pre-commit-journey-coverage` commit gate blocks viewer-source commits when uncovered listeners exist. Journey specs in `e2e/journeys/` use functional assertions (zero `toBeVisible`-only tests) per the E2E Test Quality Standard in CLAUDE.md.
 **Universal Playwright Bootstrap + Deterministic UI Enforcement (M50)** — three executable enforcement layers: (1) `bin/playwright-bootstrap.cjs` + `bin/ui-detection.cjs` - idempotent installer detects package manager, installs `@playwright/test` + chromium, scaffolds `e2e/`; (2) Workflow runtime runs `playwright-bootstrap.cjs::installPlaywright()` before any E2E stage when `hasUI && !hasPlaywright`; install failure halts with `blocked-needs-human`; (3) `scripts/hooks/pre-commit-playwright-gate` (opt-in via `gsd-t doctor --install-hooks`) blocks viewer-source commits when staged files are newer than `.gsd-t/.last-playwright-pass`. The `gsd-t setup-playwright [path]` subcommand handles manual install.
 **Visualizer (`/gsd-t-visualize`)** — launches a real-time browser dashboard with dual-pane view: top pane streams the main session, bottom pane streams whichever spawn the user clicks. Left rail shows Live Spawns and Completed (last 100 spawns, status-badged, collapsible). Right rail shows Spawn Plan / Parallelism / Tool Cost. Powered by `gsd-t-stream-feed-server.js` + `gsd-t-dashboard.html`.
-**Surgical model selection** — `bin/model-selector.js` assigns haiku/sonnet/opus per phase via a declarative rules table; `/advisor` escalation path with convention-based fallback.
+**Surgical model selection** — `bin/model-selector.js` assigns haiku/sonnet/opus/fable per phase via a declarative rules table; `/advisor` escalation path with convention-based fallback. **M85 single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth for model-tier assignments; the 5 highest-leverage stages (solution-space probe, partition probe, competition judge, pre-mortem, Red Team) run on `fable` (Claude Fable 5, tier above Opus); competition producers stay `opus` (M82 blindness); debug escalates cycle-1→opus, cycle-2→fable. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`).
 **Token Telemetry** — `gsd-t-calibration-hook.js` records token usage per spawn to `.gsd-t/token-metrics.jsonl` (18-field rows). `gsd-t-token-aggregator.js` aggregates across tasks for the `/gsd-t-metrics` view. Use the native Claude Code `/context` command for live in-session context percentage.
 **Quality North Star** — projects define a `## Quality North Star` section in CLAUDE.md (1–3 sentences, e.g., "This is a published npm library. Every public API must be intuitive and backward-compatible."). `gsd-t-init` auto-detects preset (library/web-app/cli) from package.json signals; `gsd-t-setup` configures it for existing projects. Subagents read it as a quality lens; absent = silent skip (backward compatible).
 **Design Brief Artifact** — during partition, UI/frontend projects (React, Vue, Svelte, Flutter, Tailwind) automatically get `.gsd-t/contracts/design-brief.md` with color palette, typography, spacing system, component patterns, and tone/voice. Non-UI projects skip silently. User-customized briefs are preserved. Referenced in plan phase for visual consistency.
@@ -391,7 +391,7 @@ Verify with: `/gsd-t-help`
 ```
 get-stuff-done-teams/
 ├── README.md
-├── package.json                       # @tekyzinc/gsd-t v4.0.27
+├── package.json                       # @tekyzinc/gsd-t v4.4.10
 ├── LICENSE
 ├── bin/                               # CLI entry + orchestrators + support modules (52 modules)
 │   ├── gsd-t.js                       # CLI installer + all subcommands
@@ -407,7 +407,8 @@ get-stuff-done-teams/
 │   ├── graph-*.js                     # Code graph engine (CGC/Neo4j integration)
 │   ├── journey-coverage.cjs           # Listener detector + coverage gap reporting
 │   ├── playwright-bootstrap.cjs       # Idempotent Playwright installer
-│   ├── model-selector.js              # Phase-to-model assignment (haiku/sonnet/opus)
+│   ├── model-selector.js              # Phase-to-model assignment (haiku/sonnet/opus/fable)
+│   ├── gsd-t-model-tier-policy.cjs    # M85: single-source tier policy (haiku/sonnet/opus/fable), resolver CLI
 │   ├── rule-engine.js                 # Declarative failure-pattern rules
 │   ├── patch-lifecycle.js             # 5-stage patch candidate→graduated lifecycle
 │   └── metrics-collector.js           # Task telemetry + ELO tracking

package/bin/gsd-t-model-tier-policy.cjs

@@ -0,0 +1,168 @@
+/**
+ * gsd-t-model-tier-policy.cjs
+ *
+ * SINGLE source of truth for GSD-T model-tier policy.
+ * Zero external runtime deps — installer-package invariant.
+ * No top-level side effects.
+ *
+ * Contract: .gsd-t/contracts/model-tier-policy-contract.md v1.0.0 STABLE
+ */
+
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Published Model-ID Constants (M85 — authoritative, contract v1.0.0)
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen map: tier alias → concrete model id.
+ * Consumers MUST import from here — never re-hardcode these strings.
+ *
+ * @type {Readonly<{opus: string, fable: string, sonnet: string, haiku: string}>}
+ */
+const MODEL_IDS = Object.freeze({
+  opus:   'claude-opus-4-8',
+  fable:  'claude-fable-5',
+  sonnet: 'claude-sonnet-4-6',
+  haiku:  'claude-haiku-4-5-20251001',
+});
+
+// ---------------------------------------------------------------------------
+// Stage Policy (M85 Fable assignments — contract v1.0.0 § "Stage Policy")
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen map: stage key → tier alias.
+ * 6 stages → fable; competition-producers held at opus (M82 blindness invariant).
+ *
+ * @type {Readonly<Record<string, string>>}
+ */
+const STAGE_TIERS = Object.freeze({
+  'solution-space-probe':  'fable',
+  'partition-probe':       'fable',
+  'competition-judge':     'fable',
+  'competition-producers': 'opus',  // HELD — M82 judge-blindness invariant; do NOT move to fable
+  'pre-mortem':            'fable',
+  'red-team':              'fable',
+  'debug-cycle-2':         'fable',
+});
+
+// ---------------------------------------------------------------------------
+// requiresThinkingOmitted predicate (encoding the Fable HTTP-400 breaking change)
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns true IFF the model requires the explicit thinking-disabled parameter
+ * to be OMITTED from the API call.
+ *
+ * Rationale (canonical, single home): `claude-fable-5` returns HTTP 400 when
+ * the explicit thinking-disabled parameter is sent. The parameter must therefore
+ * be OMITTED for Fable. No other file may re-implement or re-state this predicate.
+ *
+ * @param {string} model — concrete model id or tier alias or any string
+ * @returns {boolean}
+ */
+function requiresThinkingOmitted(model) {
+  if (typeof model !== 'string') return false;
+  // Source the id from MODEL_IDS (single-source — no second literal), and accept
+  // the runtime's bracket-suffixed display form (e.g. "claude-fable-5[1m]").
+  return model === MODEL_IDS.fable || model.startsWith(MODEL_IDS.fable + '[');
+}
+
+// ---------------------------------------------------------------------------
+// resolve(stageKey) → concreteModelId
+// ---------------------------------------------------------------------------
+
+/**
+ * Returns the concrete model id for the given stage key, or null for unknown keys.
+ * Never throws.
+ *
+ * @param {string} stageKey
+ * @returns {string|null}
+ */
+function resolve(stageKey) {
+  try {
+    const tier = STAGE_TIERS[stageKey];
+    if (!tier) return null;
+    const modelId = MODEL_IDS[tier];
+    return modelId !== undefined ? modelId : null;
+  } catch (_) {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  MODEL_IDS,
+  STAGE_TIERS,
+  requiresThinkingOmitted,
+  resolve,
+};
+
+// ---------------------------------------------------------------------------
+// CLI dispatch (M69 invoke-time injection surface)
+// run: node bin/gsd-t-model-tier-policy.cjs resolve <stageKey> [--json]
+// ---------------------------------------------------------------------------
+
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const jsonFlag = args.includes('--json');
+  const positional = args.filter(a => !a.startsWith('-'));
+
+  const command = positional[0];
+
+  if (command === 'resolve') {
+    const stageKey = positional[1];
+
+    if (!stageKey) {
+      const msg = 'Usage: gsd-t-model-tier-policy.cjs resolve <stageKey> [--json]';
+      if (jsonFlag) {
+        process.stdout.write(JSON.stringify({ ok: false, error: msg }) + '\n');
+      } else {
+        process.stderr.write(msg + '\n');
+      }
+      process.exit(1);
+    }
+
+    const tier = STAGE_TIERS[stageKey];
+    const modelId = resolve(stageKey);
+
+    if (modelId === null) {
+      const envelope = { ok: false, stageKey, error: `Unknown stage key: "${stageKey}"` };
+      if (jsonFlag) {
+        process.stdout.write(JSON.stringify(envelope) + '\n');
+      } else {
+        process.stderr.write(`Unknown stage key: "${stageKey}"\n`);
+      }
+      process.exit(1);
+    }
+
+    const envelope = {
+      ok: true,
+      stageKey,
+      tier,
+      model: modelId,
+      requiresThinkingOmitted: requiresThinkingOmitted(modelId),
+    };
+
+    if (jsonFlag) {
+      process.stdout.write(JSON.stringify(envelope) + '\n');
+    } else {
+      process.stdout.write(`stageKey: ${stageKey}\ntier: ${tier}\nmodel: ${modelId}\nrequiresThinkingOmitted: ${envelope.requiresThinkingOmitted}\n`);
+    }
+
+    process.exit(0);
+  }
+
+  // Unknown command
+  const usage = `Usage: gsd-t-model-tier-policy.cjs resolve <stageKey> [--json]`;
+  if (jsonFlag) {
+    process.stdout.write(JSON.stringify({ ok: false, error: usage }) + '\n');
+  } else {
+    process.stderr.write(usage + '\n');
+  }
+  process.exit(1);
+}

package/bin/gsd-t-parallel.cjs

@@ -36,6 +36,8 @@ const path = require("node:path");
 const { buildTaskGraph, getReadyTasks } = require(path.join(__dirname, "gsd-t-task-graph.cjs"));
 const { validateDepGraph } = require(path.join(__dirname, "gsd-t-depgraph-validate.cjs"));
 const { proveDisjointness } = require(path.join(__dirname, "gsd-t-file-disjointness.cjs"));
+// M85: single source of truth for model ids — sourced from policy module, never re-hardcoded here
+const { MODEL_IDS } = require(path.join(__dirname, "gsd-t-model-tier-policy.cjs"));
 // M61 D3: gsd-t-economics retired. estimateTaskFootprint produced a per-task
 // token+cost estimate the planner could consult for in-session-headroom
 // math. Native budget primitives (Workflow `budget` + /usage) replace it.
@@ -420,14 +422,18 @@ function _runCacheWarmProbe(opts) {
     "then reply with the single word `warm` and nothing else:\n" +
     filesRead.map((f) => `- ${f}`).join("\n");
 
-  const env = Object.assign({}, process.env);
-  if (model) env.ANTHROPIC_MODEL = model;
+  // M85: pass model via --model flag ONLY (env var ANTHROPIC_MODEL is silently
+  // ignored by the current claude CLI — measured probe 2026-06-09 r3: env form
+  // ran opus-4-8 regardless of the env value). No env mutation here.
+  const env = process.env;
+  const cliArgs = ["-p", prompt, "--dangerously-skip-permissions"];
+  if (model) cliArgs.push("--model", model);
 
   try {
     // GSD-T-LINT: skip stream-json (reason: cache-warm probe — single-word "warm" reply, no progress to stream)
     const r = spawnSync(
       "claude",
-      ["-p", prompt, "--dangerously-skip-permissions"],
+      cliArgs,
       {
         cwd: projectDir,
         env,
@@ -580,11 +586,15 @@ function runDispatch(opts) {
   // A task can opt back to Opus by declaring "[opus]" in its tasks.md line;
   // the planner surfaces this via per-task metadata (future; today the per-
   // subset opt-in is an all-or-nothing knob passed by the caller).
-  const DEFAULT_WORKER_MODEL = "claude-sonnet-4-6";
+  const DEFAULT_WORKER_MODEL = MODEL_IDS.sonnet;
+  // M85: alias map sources from policy module — MODEL_IDS is the single authority.
+  // No bare model-id literals here; changing a model id in the policy module alone
+  // is sufficient (single-source thesis, AC b).
   const modelAlias = {
-    opus: "claude-opus-4-7",
-    sonnet: "claude-sonnet-4-6",
-    haiku: "claude-haiku-4-5-20251001",
+    opus:   MODEL_IDS.opus,
+    fable:  MODEL_IDS.fable,
+    sonnet: MODEL_IDS.sonnet,
+    haiku:  MODEL_IDS.haiku,
   };
   const callerModel = opts && opts.workerModel;
   const workerModel = callerModel === false

package/bin/gsd-t.js

@@ -1186,6 +1186,8 @@ const GLOBAL_BIN_TOOLS = [
   "gsd-t-competition-judge.cjs",
   // M83 — Plan-phase acceptance-traceability gate.
   "gsd-t-traceability-gate.cjs",
+  // M85 — Model-tier policy single source of truth (resolver + predicate).
+  "gsd-t-model-tier-policy.cjs",
 ];
 
 function installGlobalBinTools() {
@@ -2479,6 +2481,9 @@ const PROJECT_BIN_TOOLS = [
   "gsd-t-competition-judge.cjs", "gsd-t-file-disjointness.cjs",
   // M83 — Plan-phase acceptance-traceability gate (runs in the plan workflow).
   "gsd-t-traceability-gate.cjs",
+  // M85 — Model-tier policy resolver, so command invokers in consumer projects
+  // can resolve stage tiers at invoke time (M69 injection pattern).
+  "gsd-t-model-tier-policy.cjs",
 ];
 
 // Files that older versions of this installer copied into project bin/ but
@@ -4575,6 +4580,16 @@ if (require.main === module) {
       });
       process.exit(res.status == null ? 1 : res.status);
     }
+    case "model-tier-policy": {
+      // M85 — `gsd-t model-tier-policy` thin dispatcher to the tier-policy
+      // resolver (single source of truth for model-tier assignments).
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-model-tier-policy.cjs");
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
     case "metrics":
       doMetrics(args.slice(1));
       break;

package/bin/model-selector.js

@@ -16,11 +16,14 @@
  */
 
 // ── Tiers ───────────────────────────────────────────────────────────────────
+// M85: FABLE tier added alongside HAIKU/SONNET/OPUS.
+// Contract: .gsd-t/contracts/model-tier-policy-contract.md v1.0.0 § "Stage Policy"
 
 const TIERS = Object.freeze({
   HAIKU: "haiku",
   SONNET: "sonnet",
   OPUS: "opus",
+  FABLE: "fable",
 });
 
 const DEFAULT_TIER = TIERS.SONNET;
@@ -90,9 +93,16 @@ const PHASE_RULES = Object.freeze([
   { phase: "integrate",                            model: TIERS.SONNET, reason: "Integration wiring is routine coordination work" },
 
   // Phase: debug
-  { phase: "debug", task_type: "fix_apply",        model: TIERS.SONNET, reason: "Applying a known fix is routine code work" },
-  { phase: "debug", task_type: "root_cause",       model: TIERS.OPUS,   reason: "Root-cause analysis is high-stakes reasoning" },
-  { phase: "debug",                                model: TIERS.OPUS,   reason: "Debug default is high-stakes — prefer opus unless the task_type says otherwise" },
+  { phase: "debug", task_type: "fix_apply",           model: TIERS.SONNET, reason: "Applying a known fix is routine code work" },
+  { phase: "debug", task_type: "root_cause",          model: TIERS.OPUS,   reason: "Root-cause analysis is high-stakes reasoning" },
+  // M85: cycle-2 escalation — when debug cycle-1 (opus) has not resolved the issue,
+  // cycle-2 escalates to Fable. The debug DEFAULT (cycle-1/general) remains opus —
+  // no existing rule is altered (AC f, no silent degradation). This is a DOCUMENTED
+  // MIRROR for Task-based/bin/ callers; the live enforcement is in the debug workflow
+  // ternary (D3-T3); the D4 lint guards that ternary.
+  // API shape: selectModel({ phase: "debug", task_type: "cycle_2_escalation" }) → fable
+  { phase: "debug", task_type: "cycle_2_escalation",  model: TIERS.FABLE,  reason: "Cycle-2 debug escalation — Fable after opus cycle-1 has not resolved; no existing rule altered (AC f)" },
+  { phase: "debug",                                   model: TIERS.OPUS,   reason: "Debug default is high-stakes — prefer opus unless the task_type says otherwise" },
 
   // Phase: partition — high-stakes architectural decomposition
   { phase: "partition",                            model: TIERS.OPUS,   reason: "Domain partitioning is architectural reasoning — high stakes" },

package/commands/gsd-t-help.md

@@ -495,6 +495,13 @@ Use these when user asks for help on a specific command:
 - **CLI**: `gsd-t traceability-gate [--milestone <Mxx>] [--project-dir <dir>] [--tasks <file>]`. Exit 0 all traceable · 4 ≥1 untraceable AC (blocks execute) · 64 no tasks files.
 - **Contract**: `.gsd-t/contracts/plan-hardening-contract.md` v1.0.0 STABLE.
 
+### model-tier-policy (M85)
+- **Summary**: SINGLE source of truth for GSD-T model-tier assignments. Publishes the authoritative tier set (haiku/sonnet/opus/fable), the 7 designated stage→tier mappings, and the `requiresThinkingOmitted(model)` predicate (encoding Fable's HTTP-400 breaking change ONCE). M85 slots the Fable tier into the 5 highest-leverage stages (solution-space probe, partition probe, competition judge, pre-mortem, Red Team) where one call's judgment gates the most downstream spend; competition producers STAY opus (M82 blindness invariant); debug cycle-1→opus, cycle-2→fable. A M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`) proves every workflow `model:` literal matches the policy — a drifted literal FAILS the lint (mandatory negative test).
+- **Files**: `bin/gsd-t-model-tier-policy.cjs` (zero external deps — installer invariant).
+- **Use when**: Any phase that needs to resolve a concrete model id from a stage key at invoke time (M69 pattern). Workflows NEVER `require` this module (sandbox ban) — they use hard-coded tier alias literals the lint proves match the policy.
+- **CLI**: `gsd-t model-tier-policy resolve <stageKey> [--json]`. Emits `{ok, stageKey, tier, model, requiresThinkingOmitted}`. Exit 0 resolved · 1 unknown stage key.
+- **Contract**: `.gsd-t/contracts/model-tier-policy-contract.md` v1.0.0 STABLE.
+
 ## Unknown Command
 
 If user asks for help on unrecognized command:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "4.3.10",
+  "version": "4.4.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/hooks/gsd-t-ctx-cue.sh

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+# gsd-t-ctx-cue.sh — GSD-T low-context visual cue (M85)
+#
+# A Stop hook: fires mechanically at the end of EVERY turn. Computes remaining
+# context window % from the current session's JSONL (the same source the status
+# line uses) and, when it drops below the threshold, prints a STRONG red banner
+# so the user knows to checkpoint (/gsd-t-pause) and /clear before compaction.
+#
+# Deterministic by design — does not rely on the model remembering to check
+# (per feedback_deterministic_orchestration). Synchronous (NOT async) so its
+# stdout reaches the terminal. Fails silently/open on any error — a status cue
+# must never block or break a turn.
+#
+# Threshold: default 40 (% left). Override with GSD_T_CTX_CUE_THRESHOLD.
+# Window: 1,000,000 (Opus 4.7/4.8 + Sonnet 4.x); 200,000 (Haiku).
+
+set -o pipefail
+THRESHOLD="${GSD_T_CTX_CUE_THRESHOLD:-40}"
+
+# The hook receives the same JSON on stdin that other hooks do.
+input=$(cat 2>/dev/null)
+
+cwd=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // ""' 2>/dev/null)
+[ -z "$cwd" ] && cwd="$PWD"
+model=$(printf '%s' "$input" | jq -r '.model.id // ""' 2>/dev/null)
+
+# Only act inside GSD-T projects (a .gsd-t dir present) — the cue is GSD-T's.
+[ -d "${cwd}/.gsd-t" ] || exit 0
+
+proj_slug=$(printf '%s' "$cwd" | sed 's:/:-:g')
+sess_dir="$HOME/.claude/projects/$proj_slug"
+[ -d "$sess_dir" ] || exit 0
+latest=$(ls -t "$sess_dir"/*.jsonl 2>/dev/null | head -1)
+[ -n "$latest" ] || exit 0
+
+case "$model" in
+  *haiku*) win=200000 ;;
+  *)       win=1000000 ;;
+esac
+
+used=$(grep '"usage"' "$latest" 2>/dev/null | tail -1 \
+  | jq -r '(.message.usage // {}) | (.input_tokens//0)+(.cache_creation_input_tokens//0)+(.cache_read_input_tokens//0)' 2>/dev/null)
+[ -n "$used" ] && [ "$used" -gt 0 ] 2>/dev/null || exit 0
+
+pct=$(awk -v u="$used" -v w="$win" 'BEGIN { printf "%d", (100 - (u / w * 100)) + 0.5 }')
+
+# Above threshold → silent (no cue).
+[ "$pct" -lt "$THRESHOLD" ] 2>/dev/null || exit 0
+
+# ── Strong red banner ──────────────────────────────────────────────────────
+RED=$'\033[1;37;41m'   # bold white on red
+RST=$'\033[0m'
+BAR="████████████████████████████████████████"
+printf '\n%s %s %s\n' "$RED" "$BAR" "$RST"
+printf '%s  ⚠  CONTEXT LOW — %d%% LEFT %s\n' "$RED" "$pct" "$RST"
+printf '%s  Checkpoint now: /gsd-t-pause → /clear → /gsd-t-resume %s\n' "$RED" "$RST"
+printf '%s %s %s\n\n' "$RED" "$BAR" "$RST"
+exit 0

package/scripts/statusline-command.sh

@@ -0,0 +1,119 @@
+#!/usr/bin/env bash
+# Claude Code status line — GSD-T project status bar  (CANONICAL SOURCE)
+#
+# This is the SHIPPED source of truth for the GSD-T status line. The installer
+# copies it to ~/.claude/statusline-command.sh and wires the `statusLine` setting
+# to it, so edits here survive `gsd-t install` / `update` / `update-all`.
+# (Supersedes scripts/gsd-t-statusline.js, whose context source was retired in M61.)
+#
+# Layout (M85):
+#   Line 1: [GSD-T] | vX.Y.ZZ | ctx N% left | project | git branch | model id | HH:MM TZ
+#   Line 2: the full milestone/Status string (wraps to its own row instead of
+#           being truncated with a trailing "…" at terminal width).
+set -o pipefail
+
+input=$(cat)
+
+# --- 1. [GSD-T] prefix (bright cyan when ANSI available) ---
+PREFIX=$'\033[1;36m[GSD-T]\033[0m'
+
+# --- 1b. GSD-T version — the installed framework version, project-independent.
+#       Source from ~/.claude/.gsd-t-version (written by the installer/update-all);
+#       fall back to the global package.json, then to empty (field omitted). ---
+gsdt_version=""
+if [ -f "$HOME/.claude/.gsd-t-version" ]; then
+  gsdt_version=$(tr -d '[:space:]' < "$HOME/.claude/.gsd-t-version" 2>/dev/null)
+fi
+if [ -z "$gsdt_version" ] && command -v gsd-t >/dev/null 2>&1; then
+  gsdt_version=$(gsd-t --version 2>/dev/null | tr -d '[:space:]')
+fi
+[ -n "$gsdt_version" ] && gsdt_version="v${gsdt_version#v}"
+
+# --- 2. Project name — basename of cwd from JSON ---
+cwd=$(printf '%s' "$input" | jq -r '.workspace.current_dir // .cwd // ""')
+project=""
+if [ -n "$cwd" ]; then
+  project=$(basename "$cwd")
+fi
+
+# --- 3. Milestone + phase — single grep of .gsd-t/progress.md ---
+milestone=""
+if [ -n "$cwd" ] && [ -f "${cwd}/.gsd-t/progress.md" ]; then
+  milestone=$(grep -m1 '^## Status:' "${cwd}/.gsd-t/progress.md" | sed 's/^## Status:[[:space:]]*//' | tr -d '\r')
+fi
+
+# --- 4. Git branch (skip gracefully if not a repo) ---
+branch=""
+if [ -n "$cwd" ]; then
+  branch=$(git -C "$cwd" rev-parse --abbrev-ref HEAD 2>/dev/null || true)
+fi
+
+# --- 5. Model id ---
+model=$(printf '%s' "$input" | jq -r '.model.id // ""')
+
+# --- 6. Context window % left (M61: read latest usage envelope from Claude
+#       Code's session JSONL; falls back silently if unreadable).
+#       Window: 1,000,000 for Opus 4.7/4.8 + Sonnet 4.x; 200,000 for Haiku.
+#       Computed as input_tokens + cache_creation_input_tokens +
+#       cache_read_input_tokens to capture the full window pressure. ---
+ctx_left=""
+if [ -n "$cwd" ]; then
+  proj_slug=$(printf '%s' "$cwd" | sed 's:/:-:g')
+  sess_dir="$HOME/.claude/projects/$proj_slug"
+  if [ -d "$sess_dir" ]; then
+    latest_jsonl=$(ls -t "$sess_dir"/*.jsonl 2>/dev/null | head -1)
+    if [ -n "$latest_jsonl" ]; then
+      # Window size by model family. Haiku = 200k; everything else = 1M.
+      case "$model" in
+        *haiku*) win=200000 ;;
+        *)       win=1000000 ;;
+      esac
+      # Grab the last "usage" record in the file and sum input fields.
+      used=$(grep '"usage"' "$latest_jsonl" 2>/dev/null \
+             | tail -1 \
+             | jq -r '
+               (.message.usage // {})
+               | (.input_tokens // 0)
+                 + (.cache_creation_input_tokens // 0)
+                 + (.cache_read_input_tokens // 0)
+             ' 2>/dev/null)
+      if [ -n "$used" ] && [ "$used" -gt 0 ] 2>/dev/null; then
+        ctx_left=$(awk -v u="$used" -v w="$win" \
+          'BEGIN { p = 100 - (u / w * 100); printf "ctx %d%% left", (p + 0.5) }')
+      fi
+    fi
+  fi
+fi
+
+# --- 7. Local time ---
+timestamp=$(date +"%H:%M %Z")
+
+# --- Assemble ---
+# Line 1: short fields only. ctx% sits right after the version (per user).
+#         The verbose milestone status moves to line 2 so it wraps instead of
+#         being truncated with a trailing "…" at terminal width.
+parts=("$PREFIX")
+[ -n "$gsdt_version" ] && parts+=("$gsdt_version")
+[ -n "$ctx_left" ]  && parts+=("$ctx_left")
+[ -n "$project" ]   && parts+=("$project")
+[ -n "$branch" ]    && parts+=("$branch")
+[ -n "$model" ]     && parts+=("$model")
+parts+=("$timestamp")
+
+# Join line 1 with " | "
+line1=""
+for part in "${parts[@]}"; do
+  if [ -z "$line1" ]; then
+    line1="$part"
+  else
+    line1="${line1} | ${part}"
+  fi
+done
+
+# Line 2: the milestone/status string on its own line (Claude Code renders \n as a
+# second status row). Omitted when there's no milestone status.
+if [ -n "$milestone" ]; then
+  printf '%s\n%s' "$line1" "$milestone"
+else
+  printf '%s' "$line1"
+fi

package/templates/CLAUDE-global.md

@@ -295,7 +295,7 @@ After the E2E suite, `gsd-t-verify` Step 4.5 runs `gsd-t test-data --purge --run
 Every code-producing phase ends with `gsd-t-verify.workflow.js`, which runs three orthogonal validators as `parallel()` `agent()` stages with schema-validated output. Per `.gsd-t/contracts/orthogonal-validation-contract.md` v1.0.0 STABLE, they are declared orthogonal objective functions — no collapse, no substitution, no transitive trust.
 
 - **`/code-review ultra`** — cooperative correctness + cleanup. Severity: `important` / `nit` / `pre-existing`. Skippable via `args.skipUltra=true` + `args.skipUltraReason`. `skipUltra=true` is INELIGIBLE for `VERIFIED`.
-- **Red Team** — adversarial / security / boundaries. Non-skippable. Protocol: `templates/prompts/red-team-subagent.md`. Verdict: `FAIL` (any CRITICAL or HIGH bug — blocks completion) or `GRUDGING-PASS` (exhaustive search, nothing found). CRITICAL/HIGH bugs get up to 2 fix cycles before deferral. Runs on `model: "opus"`.
+- **Red Team** — adversarial / security / boundaries. Non-skippable. Protocol: `templates/prompts/red-team-subagent.md`. Verdict: `FAIL` (any CRITICAL or HIGH bug — blocks completion) or `GRUDGING-PASS` (exhaustive search, nothing found). CRITICAL/HIGH bugs get up to 2 fix cycles before deferral. Runs on `model: "fable"` (M85).
 - **QA** — test execution + shallow-test detection + contract compliance. Non-skippable. Protocol: `templates/prompts/qa-subagent.md`. Writes ZERO feature code. Any shallow E2E test blocks phase completion. Runs on `model: "sonnet"`.
 
 When `.gsd-t/contracts/design-contract.md` or `.gsd-t/contracts/design/` exists, a fourth stage runs Design Verification (protocol: `templates/prompts/design-verify-subagent.md`) — opens a browser, compares the build against the design, returns a structured element-by-element MATCH/DEVIATION schema. Deviations block completion.
@@ -304,12 +304,13 @@ Synthesis stage merges results without category collapse. Verdict: `VERIFIED` /
 
 ## Model Display (MANDATORY)
 
-**Each Workflow `agent()` call declares its model explicitly** via the `model:` option (`"haiku"` / `"sonnet"` / `"opus"`). The Workflow runtime emits a `⚙ [{model}] {label}` line per stage in `/workflows`, giving the user real-time visibility into which model handles each operation.
+**Each Workflow `agent()` call declares its model explicitly** via the `model:` option (`"haiku"` / `"sonnet"` / `"opus"` / `"fable"`). The Workflow runtime emits a `⚙ [{model}] {label}` line per stage in `/workflows`, giving the user real-time visibility into which model handles each operation.
 
 **Model assignments:**
 - `model: "haiku"` — strictly mechanical tasks: run test suites and report counts, check file existence, validate JSON structure, branch guard checks
 - `model: "sonnet"` — mid-tier reasoning: routine code changes, standard refactors, test writing, QA evaluation, straightforward synthesis
-- `model: "opus"` — high-stakes reasoning: architecture decisions, security analysis, complex debugging, cross-module refactors, Red Team adversarial QA, quality judgment on critical paths
+- `model: "opus"` — high-stakes reasoning: architecture decisions, security analysis, complex debugging, cross-module refactors, quality judgment on critical paths
+- `model: "fable"` — highest-stakes calls where one judgment gates the most downstream spend (M85): solution-space probe, partition probe, competition judge, pre-mortem, Red Team. Competition producers STAY `opus` (M82 blindness invariant — judge must differ from producers). Debug cycle-1 → `opus`, cycle-2 → `fable` (escalation). **Single source of truth for tier assignments:** `bin/gsd-t-model-tier-policy.cjs` + `.gsd-t/contracts/model-tier-policy-contract.md` v1.0.0 STABLE. The M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`) proves every workflow `model:` literal matches the policy and a drifted literal FAILS the lint (mandatory negative test).
 
 **Context budget:** Workflow scripts receive a `budget` global (`budget.total`, `budget.spent()`, `budget.remaining()`) tied to the user's per-turn token target. Use it for dynamic loops (`while (budget.total && budget.remaining() > 50_000) { ... }`) or to scale fleet size. Opus 4.7/4.8 ship 1M context windows; the legacy meter at `bin/token-budget.cjs` was retired in M61 — use native `/context` for live in-session usage.
 

package/templates/workflows/gsd-t-debug.workflow.js

@@ -94,7 +94,7 @@ for (let cycle = 1; cycle <= 2; cycle++) {
     label: `debug-cycle-${cycle}`,
     phase: `Cycle ${cycle}`,
     schema: DEBUG_CYCLE_SCHEMA,
-    model: "opus",
+    model: cycle === 1 ? "opus" : "fable",
   }).catch((e) => ({
     resolved: false,
     rootCause: `agent error: ${e && e.message}`,

package/templates/workflows/gsd-t-phase.workflow.js

@@ -169,7 +169,7 @@ async function runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPa
     `BIAS TOWARD COMPETING: if you are uncertain, or can name even two plausibly-different approaches, choose compete=true. A wasted competition costs ~3× this one phase; a missed-better-approach costs far more downstream (more pre-mortem blocks, more bugs, more verify cycles). Err on the side of generating options.`,
     `Return JSON per the schema: { "compete": true|false, "reason": "<one sentence>", "approaches": ["<a>","<b>",...] }.`,
   ].filter(Boolean).join("\n");
-  const opts = { label: "solution-space-probe", schema: _PROBE_SCHEMA, model: "opus" };
+  const opts = { label: "solution-space-probe", schema: _PROBE_SCHEMA, model: "fable" };
   if (phaseNameOpt) opts.phase = phaseNameOpt;
   const r = await agent(prompt, opts).catch(() => null);
   // Probe failure → bias toward competing (fail-toward-options, per the cost logic).
@@ -195,7 +195,7 @@ async function runPartitionProbe(projectDir, { milestone, briefPath, userInput,
     `BIAS TOWARD COMPETING: if ≥3 files/areas are in play or you're unsure, choose compete=true — the file-disjointness oracle will objectively pick the most-parallelizable valid carving among the candidates, so competing is low-risk and high-reward.`,
     `Return JSON per the schema.`,
   ].filter(Boolean).join("\n");
-  const opts = { label: "partition-probe", schema: _PROBE_SCHEMA, model: "opus" };
+  const opts = { label: "partition-probe", schema: _PROBE_SCHEMA, model: "fable" };
   if (phaseNameOpt) opts.phase = phaseNameOpt;
   const r = await agent(prompt, opts).catch(() => null);
   if (!r || typeof r.compete !== "boolean") {
@@ -473,7 +473,7 @@ if (!competitionOn) {
         `IMPORTANT: use the CANDIDATE LABEL (A, B, C…) shown above as the "id" in your scores.`,
       ].join("\n"),
       {
-        label: "judge:rubric", phase: "Judge", model: "sonnet",
+        label: "judge:rubric", phase: "Judge", model: "fable",
         schema: {
           type: "object", required: ["scores"], additionalProperties: true,
           properties: { scores: { type: "array", items: { type: "object", additionalProperties: true } } },
@@ -653,7 +653,7 @@ if (phaseName === "plan" && result && result.status !== "failed") {
       `Every blocking finding MUST convert to a concrete requiredTest the plan must adopt. Advisory notes are forbidden.`,
       `Verdict BLOCK if any concrete, falsifiable failure condition lacks a named required test; else CLEARED. Return JSON per the schema.`,
     ].join("\n"),
-    { label: "pre-mortem", phase: "Plan Hardening", schema: PRE_MORTEM_SCHEMA, model: "opus" }
+    { label: "pre-mortem", phase: "Plan Hardening", schema: PRE_MORTEM_SCHEMA, model: "fable" }
   ).catch((e) => ({ verdict: "BLOCK", findings: [{ severity: "HIGH", condition: `pre-mortem agent error: ${e && e.message}`, requiredTest: "re-run pre-mortem" }], notes: "agent-error" }));
 
   result.preMortem = preMortem;

package/templates/workflows/gsd-t-verify.workflow.js

@@ -304,7 +304,7 @@ const stages = [
       `Verdict is FAIL if you found any CRITICAL or HIGH severity bug; GRUDGING-PASS`,
       `if you searched exhaustively and found nothing. Return JSON per the schema.`,
     ].join("\n"),
-    { label: "red-team", phase: "Orthogonal Triad", schema: RED_TEAM_SCHEMA, model: "opus" }
+    { label: "red-team", phase: "Orthogonal Triad", schema: RED_TEAM_SCHEMA, model: "fable" }
   ),
 
   // Stage C — QA (test execution + shallow-test detection + contract compliance)