@tekyzinc/gsd-t 4.2.10 → 4.4.10

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 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)
+
+M82 shipped Competition Mode as opt-in (`--competition N`). M84 makes the workflow decide for itself, per the user directive: *"I want the workflow to determine when it's optimal to create a competition."* The economic case (user's): a better artifact produced upstream makes every downstream phase — pre-mortem, execute, verify — cheaper and more likely to pass first time, so the expected downstream savings usually exceed the ~3× upstream cost. Opt-in just means forgetting to use the thing that lowers total cost.
+
+- **Solution-space probe** runs at the start of each eligible phase (partition / milestone / discuss / design-decompose), after brief, before producing. It decides: ≥2 genuinely different viable approaches → compete (3 producers + judge); one obvious answer → single draft.
+- **The probe runs on OPUS, not haiku.** Deciding "are there multiple good approaches?" is high-level reasoning, not a mechanical check — and it gates the whole 3× competition, so a weak probe would forfeit the feature. (User caught this: *"Is Haiku smart enough to make this a judgment?"* — no, it isn't; the probe is opus.)
+- **Biased toward competing**: when uncertain, compete (the asymmetry favors generating options). Probe failure → compete (fail-toward-options).
+- **Partition**: an opus probe makes the pre-produce compete/skip call; the objective file-disjointness oracle still judges the produced candidates (decision = heuristic + bias; selection = objective).
+- **Producer angles are now phase-aware** (`ANGLES_BY_PHASE`) — a discuss/milestone/design producer no longer gets a partition-framed "carve file-disjoint domains" directive (Red Team MEDIUM fix; this latent M82 defect now mattered because competition is the default path).
+- **Overrides** (rarely needed): `competition: N` (2–5) forces N; `competition: 0` / `noCompetition: true` forces off; unset = auto. An unparseable override logs a warning and falls back to auto.
+- `meta.phases` now declares all 7 stages (Preflight / Probe / Compete / Judge / Phase / Finalize / Plan Hardening) — also fixes the M83 cosmetic gap where Plan Hardening wasn't pre-declared.
+- **Verification**: real-sandbox proof — the opus probe ran through the Workflow sandbox and discriminated correctly (wide collaborative-editor scenario → compete, 3 approaches named; narrow copyright-bump → single draft). Adversarial Red Team (Opus, fresh context) GRUDGING-PASS — no CRITICAL/HIGH; state-wiring, overrides, eligibility, probe-failure, cost-bound, runtime-native, and plan-hardening interaction all verified clean. Fixed the 1 MEDIUM (phase-aware angles) + 3 LOWs. Suite 1372/0/4. Minor bump 4.2.10 → 4.3.10.
+- Contract `competition-mode-contract.md` → v2.0.0 (trigger moved opt-in → automatic; judge/selection/invariants unchanged).
+- Origin: NiceNote review — the user observed that competing on the M7 plan would have produced a better plan from the start (fewer pre-mortem blocks, less downstream cost), so competition should be automatic, not a flag to remember.
+
 ## [4.2.10] - 2026-06-05 (M83 Left-Shifted Plan Hardening - minor)
 
 ### Added - Plan-phase hardening: catch dead deliverables and edge cases BEFORE execute

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.
@@ -128,7 +128,7 @@ gsd-t traceability-gate --milestone Mxx [--project-dir P] # M83: plan-phase acce
 
 **Plan Hardening (M83).** The `plan` phase now runs two blocking gates before execute, so a plan can't ship a dead deliverable: a deterministic **acceptance-traceability gate** (`gsd-t traceability-gate` — every AC must bind to a code path + a killing test; the headline capability needs both impl and test) and an adversarial **pre-mortem** agent (opus, fresh-context, predicts edge-case/NFR/dead-deliverable failures and requires a test for each). The temporal dual of the Red Team — attack the design at plan, not just the code at verify. Origin: a build where the headline capability shipped as dead code and burned 4 verify cycles. See `.gsd-t/contracts/plan-hardening-contract.md`.
 
-**Competition Mode (M82).** Opt-in `--competition N` (N 2–5) on upstream, pre-contract phases (`/gsd-t-partition`, `/gsd-t-milestone`, `/gsd-t-design-decompose`) fans out N parallel candidate producers and a judge selects the winner — the generative dual of the orthogonal validation triad. Partition uses an *objective* file-disjointness oracle as the judge (a calculator, not a biased critic); subjective phases use a blind + different-model + rubric judge. Default off. See `.gsd-t/contracts/competition-mode-contract.md`.
+**Competition Mode (M82 · automatic since M84).** On upstream, pre-contract phases (`/gsd-t-partition`, `/gsd-t-milestone`, `/gsd-t-discuss`, `/gsd-t-design-decompose`) the workflow **automatically decides** whether to compete: an Opus solution-space probe runs at phase start and, if it finds ≥2 genuinely different viable approaches, fans out 3 parallel candidate producers + a judge to pick the winner — the generative dual of the orthogonal validation triad. No flag needed (the probe is biased toward competing, since a better upstream artifact lowers total downstream cost). Partition's judge is an *objective* file-disjointness oracle; subjective phases use a blind + different-model + rubric judge. Override with `--no-competition` or `--competition N` only on explicit request. See `.gsd-t/contracts/competition-mode-contract.md`.
 
 `gsd-t parallel` consumes the M44 task-graph (D1) and applies three pre-spawn gates (D4 depgraph validation → D5 file-disjointness → D6 economics) followed by mode-aware headroom/split math. Extends — does not replace — the M40 orchestrator. Contract: `.gsd-t/contracts/wave-join-contract.md` v1.1.0.
 
@@ -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-design-decompose.md

@@ -25,12 +25,12 @@ Capture the design reference from `$ARGUMENTS` (Figma URL / image path). If Figm
   args: {
     phase: "design-decompose",
     projectDir: ".",
-    userInput: "$ARGUMENTS",
-    // M82 Competition Mode (opt-in): `--competition N` (N 2..5) fans out N
-    // parallel decompositions; a blind, different-model, rubric judge (fidelity /
-    // completeness / reuse / simplicity) selects the winner. Useful when a design
-    // is ambiguous or the component boundaries aren't obvious.
-    competition: 1
+    userInput: "$ARGUMENTS"
+    // M84 Competition Mode is AUTOMATIC — do NOT pass `competition` by default.
+    // The workflow probes (opus) and self-decides; it competes when a design is
+    // ambiguous or the element/widget/page boundaries aren't obvious (a blind,
+    // different-model rubric judge picks the winner). Override only on explicit
+    // request: `--no-competition` → 0, `--competition N` (2-5) → N.
   }
 }
 ```

package/commands/gsd-t-help.md

@@ -481,7 +481,7 @@ Use these when user asks for help on a specific command:
 
 ### competition-judge (M82)
 - **Summary**: The selection oracle for Competition Mode (generate-and-judge — the *generative* dual of the orthogonal validation triad). Two modes: `--kind partition` scores candidate domain decompositions via the file-disjointness oracle (parallelGroups / waveDepth / validity — a calculator, not an LLM critic, so it's immune to judge bias); `--kind generic` is a deterministic rubric selector that finalizes a winner from rubric scores an upstream blind/different-model judge supplied.
-- **Auto-invoked**: Yes — by `gsd-t-phase.workflow.js` when an eligible phase (partition / milestone / design-decompose) is run with `competition: N` (N 2–5). Opt-in per phase via `/gsd-t-partition --competition N` etc. Default off.
+- **Auto-invoked**: Yes — AUTOMATICALLY (M84). On an eligible phase (partition / milestone / discuss / design-decompose), `gsd-t-phase.workflow.js` runs an Opus solution-space probe at phase start and self-decides whether to fan out 3 producers + this judge (biased toward competing). No flag needed; override with `--competition N` (force N) or `--no-competition` (force off).
 - **Files**: `bin/gsd-t-competition-judge.cjs` (reuses `bin/gsd-t-file-disjointness.cjs`).
 - **Use when**: Upstream, pre-contract, wide-solution-space decisions where the cost of a single draft is high (partition, milestone decomposition, ambiguous design decomposition). Never on post-contract phases (execute/verify/etc.) — those are owned by the adversarial triad.
 - **CLI**: `gsd-t competition-judge [--in <spec.json>] [--project-dir <dir>]` (spec via stdin or `--in`). Exit 0 winner · 4 no valid candidate · 64 bad input.
@@ -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/commands/gsd-t-milestone.md

@@ -25,17 +25,17 @@ Read `.gsd-t/progress.md` (current version + completed milestones), `docs/requir
   args: {
     phase: "milestone",
     projectDir: ".",
-    userInput: "$ARGUMENTS",
-    // M82 Competition Mode (opt-in): `--competition N` (N 2..5) fans out N
-    // parallel Self-MoA producers proposing different decomposition strategies
-    // (risk-first / value-first / dependency-first); a blind, different-model,
-    // rubric judge selects the winner. Coupled-thesis → pick-one (no Frankenstein).
-    competition: 1
+    userInput: "$ARGUMENTS"
+    // M84 Competition Mode is AUTOMATIC — do NOT pass `competition` by default.
+    // The workflow probes (opus) and self-decides; milestone decomposition is the
+    // highest-altitude decision, so it competes whenever ≥2 genuinely different
+    // strategies (risk-first / value-first / dependency-first) exist. Override only
+    // on explicit request: `--no-competition` → 0, `--competition N` (2-5) → N.
   }
 }
 ```
 
-**Competition Mode (`--competition N`).** Milestone decomposition is the highest-altitude decision in the system — different strategies are genuinely different. If the user invokes `/gsd-t-milestone --competition 3`, parse N (clamped 2..5) and pass `competition: N`. Because a milestone decomposition is a *coupled thesis*, the judge selects one winner whole (pick-one) and only salvages non-overlapping good line-items from the losers — it never Frankensteins. See `.gsd-t/contracts/competition-mode-contract.md`. Default off.
+**Competition Mode (automatic).** Milestone decomposition auto-competes when the probe finds ≥2 genuinely different strategies. Because a decomposition is a *coupled thesis*, the judge selects one winner whole (pick-one) and salvages only non-overlapping good line-items from the losers — it never Frankensteins. No flag needed; override with `--no-competition` / `--competition N` on explicit request. See `.gsd-t/contracts/competition-mode-contract.md`.
 
 ## Step 3: Interpret the result
 

package/commands/gsd-t-partition.md

@@ -30,17 +30,17 @@ Call the `Workflow` tool with:
     phase: "partition",
     milestone: "M{NN}",
     projectDir: ".",
-    userInput: "$ARGUMENTS",
-    // M82 Competition Mode (opt-in): if the user passed `--competition N` in
-    // $ARGUMENTS (N in 2..5), set competition: N. N parallel Self-MoA producers
-    // propose partitions; the OBJECTIVE oracle judge (file-disjointness scoring)
-    // picks the most-parallelizable valid decomposition. Omit / set 1 = off.
-    competition: 1
+    userInput: "$ARGUMENTS"
+    // M84 Competition Mode is AUTOMATIC — do NOT pass `competition` by default.
+    // The workflow runs a solution-space probe and self-decides whether to fan out
+    // N candidate partitions (judged by the file-disjointness oracle). Only pass an
+    // override if the user explicitly asked: `--competition 0`/`--no-competition`
+    // → competition: 0; `--competition N` (2-5) → competition: N.
   }
 }
 ```
 
-**Competition Mode (`--competition N`).** Partition is the v1 beachhead for generate-and-judge: its judge is the file-disjointness oracle, so it is a calculator, not a biased critic. If the user invokes `/gsd-t-partition --competition 3`, parse N (clamped 2..5) and pass `competition: N`. The workflow fans out N candidate partitions, scores each on measured parallelism / wave-depth / boundary-cleanliness, and finalizes the winner. See `.gsd-t/contracts/competition-mode-contract.md`. Default off (single producer).
+**Competition Mode (automatic).** Partition auto-competes when the workflow's probe finds ≥2 genuinely different ways to carve the domains; the objective file-disjointness oracle judges the candidates and picks the most-parallelizable valid one. No flag needed. Override only on explicit request: `/gsd-t-partition --no-competition` (force single draft) or `--competition N` (force N). See `.gsd-t/contracts/competition-mode-contract.md`.
 
 ## Step 3: Interpret the result
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "4.2.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.
 
@@ -328,7 +329,7 @@ Canonical scripts:
 - `gsd-t-integrate.workflow.js` — cross-domain wire-up + light verify-gate
 - `gsd-t-debug.workflow.js` — 2-cycle diagnose/fix/verify (CLAUDE.md Prime Rule)
 - `gsd-t-quick.workflow.js` — preflight + brief + single-task + verify-gate (M56-D4)
-- `gsd-t-phase.workflow.js` — generic upper-stage runner (partition / plan / discuss / impact / milestone / prd / design-decompose / doc-ripple). **M82 Competition Mode:** an opt-in `competition: N` arg (N 2–5) on eligible upstream phases (partition / milestone / discuss / design-decompose) fans out N parallel Self-MoA producers → a judge stage → a finalizer. Partition's judge is the OBJECTIVE file-disjointness oracle (`gsd-t competition-judge --kind partition` — a calculator, not an LLM critic, immune to judge bias, the v1 beachhead); subjective phases use a blind + shuffled + different-model + rubric judge whose pick is finalized deterministically by `--kind generic`. The generative dual of the orthogonal validation triad; watershed rule = generate-and-judge ABOVE the contract, attack-and-filter BELOW. Default off. Contract: `competition-mode-contract.md` v1.0.0. **M83 Plan Hardening:** the `plan` phase runs two blocking gates before execute — a deterministic acceptance-traceability gate (`gsd-t traceability-gate`: every AC binds to a code path + a killing test; the `Headline:` task needs both impl and test) and an adversarial pre-mortem agent (opus, fresh-context, protocol `pre-mortem-subagent.md`: predicts edge-case/dead-deliverable/NFR failures, each → a required test). The temporal dual of the Red Team (attack the design at plan, not just code at verify). Contract: `plan-hardening-contract.md` v1.0.0.
+- `gsd-t-phase.workflow.js` — generic upper-stage runner (partition / plan / discuss / impact / milestone / prd / design-decompose / doc-ripple). **M82/M84 Competition Mode (AUTOMATIC):** on eligible upstream phases (partition / milestone / discuss / design-decompose) an Opus solution-space probe runs at phase start and self-decides whether to compete (biased toward competing — a better upstream artifact lowers total downstream cost); when it fires, 3 parallel Self-MoA producers → a judge stage → a finalizer. No flag needed; override with `competition: N` / `competition: 0` / `noCompetition: true`. Partition's judge is the OBJECTIVE file-disjointness oracle (`gsd-t competition-judge --kind partition` — a calculator, not an LLM critic, immune to judge bias, the v1 beachhead); subjective phases use a blind + shuffled + different-model + rubric judge whose pick is finalized deterministically by `--kind generic`. The generative dual of the orthogonal validation triad; watershed rule = generate-and-judge ABOVE the contract, attack-and-filter BELOW. Default off. Contract: `competition-mode-contract.md` v1.0.0. **M83 Plan Hardening:** the `plan` phase runs two blocking gates before execute — a deterministic acceptance-traceability gate (`gsd-t traceability-gate`: every AC binds to a code path + a killing test; the `Headline:` task needs both impl and test) and an adversarial pre-mortem agent (opus, fresh-context, protocol `pre-mortem-subagent.md`: predicts edge-case/dead-deliverable/NFR failures, each → a required test). The temporal dual of the Red Team (attack the design at plan, not just code at verify). Contract: `plan-hardening-contract.md` v1.0.0.
 - `gsd-t-scan.workflow.js` — preflight → volume-probe → pipeline(per-slice deep finder → single verify) → synthesis → document → render (M66: fans out by codebase VOLUME, not a fixed 5-teammate dimension count; M67: deep document phase deterministically produces the full living-doc set + dimension files, per-doc fan-out)
 
 **Runtime-native invariant (M81 — v4.0.29+):** the Workflow sandbox provides ONLY `agent/parallel/pipeline/log/phase/budget/args` — NO `require`/`fs`/`path`/`child_process`/`process`, and `args` arrives as a JSON STRING. Each workflow is self-contained: it `JSON.parse`s `args` and delegates every CLI call (preflight, verify-gate, brief, build-coverage, ci-parity, test-data, disjointness) to inline `async` helpers that run the command via an `agent()`'s Bash (preferring project-local `bin/<tool>.cjs`, else the global `gsd-t` PATH binary) and parse the JSON envelope — preserving the M55-D5 project-local-bin invariant. The old `require("./_lib.js")` pattern threw `ReferenceError` on first eval and silently broke every workflow except scan (TD-113, fixed M81); `_lib.js` is retired as a workflow dependency.

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

@@ -37,8 +37,13 @@ export const meta = {
   name: "gsd-t-phase",
   description: "Generic upper-stage phase runner (partition/plan/discuss/etc.)",
   phases: [
-    { title: "Preflight", detail: "preflight + brief" },
-    { title: "Phase",     detail: "primary agent with phase-specific protocol" },
+    { title: "Preflight",      detail: "preflight + brief" },
+    { title: "Probe",          detail: "M84 auto-competition solution-space probe (opus; eligible phases only)" },
+    { title: "Compete",        detail: "M82/M84 N parallel producers (when competition fires)" },
+    { title: "Judge",          detail: "select/synthesize the winning candidate" },
+    { title: "Phase",          detail: "primary agent (or finalizer) with phase-specific protocol" },
+    { title: "Finalize",       detail: "commit the winning approach (competition path)" },
+    { title: "Plan Hardening", detail: "M83 traceability gate + adversarial pre-mortem (plan phase only)" },
   ],
 };
 
@@ -128,9 +133,77 @@ async function runCompetitionJudge(projectDir, spec, label = "judge", phaseNameO
 }
 
 // Phases where competition pays off (wide solution space, pre-contract, high blast
-// radius). A competition arg on any other phase is ignored (single producer runs).
+// radius). Competition is AUTOMATIC on these (M84) — the workflow probes the
+// solution space and self-decides; on any other phase it never runs.
 const COMPETITION_ELIGIBLE = new Set(["partition", "milestone", "discuss", "design-decompose"]);
 
+// M84: the solution-space probe. Decides AUTOMATICALLY whether a phase is
+// competition-worthy (≥2 genuinely different viable approaches). This is a
+// high-level reasoning step — NOT a mechanical check — so it runs on OPUS, not
+// haiku (a weak probe forfeits the whole point: it gates a 3× competition whose
+// upstream cost buys down far larger downstream cost). It is BIASED TOWARD
+// COMPETING: when uncertain, compete — because a better artifact upstream makes
+// every downstream phase (pre-mortem, execute, verify) cheaper and more likely to
+// pass first time, so the expected savings usually exceed the 3× probe-and-produce
+// cost. Returns { compete: bool, reason, approaches? }.
+//
+// Partition has its OWN probe (runPartitionProbe, also opus): the disjointness
+// oracle can't decide before candidates exist, so an opus probe makes the
+// compete/skip call and the oracle JUDGES the candidates afterward. This
+// (runSolutionSpaceProbe) is for the other subjective phases.
+const _PROBE_SCHEMA = {
+  type: "object", required: ["compete"], additionalProperties: true,
+  properties: {
+    compete: { type: "boolean" },
+    reason: { type: "string" },
+    approaches: { type: "array", items: { type: "string" } },
+  },
+};
+async function runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPath, userInput, phaseNameOpt } = {}) {
+  const prompt = [
+    `You are the Solution-Space Probe for the ${phaseName} phase${milestone ? ` of ${milestone}` : ""}. Decide ONE thing: should this phase generate MULTIPLE competing candidates (then a judge picks the best), or is a single draft sufficient?`,
+    `**Brief:** ${briefPath || "(none — read the relevant .gsd-t docs/contracts/requirements directly)"}`,
+    userInput ? `\nUser input:\n${userInput}\n` : "",
+    `Compete WHEN there are ≥2 genuinely DIFFERENT, viable approaches whose trade-offs matter — different architectures, decomposition strategies, data models, sequencing, or design directions that a reasonable expert could disagree about. List them in "approaches".`,
+    `Do NOT compete only when there is ONE obvious correct approach and any variation would be cosmetic.`,
+    `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: "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).
+  if (!r || typeof r.compete !== "boolean") {
+    return { compete: true, reason: "probe unavailable — defaulting to compete (bias toward options)", approaches: [] };
+  }
+  return { compete: r.compete, reason: r.reason || "", approaches: r.approaches || [] };
+}
+
+// M84: PARTITION's pre-produce decision. The objective disjointness oracle needs
+// candidates to score, so it can't DECIDE before any exist — it runs later as the
+// JUDGE. For the pre-produce compete/skip decision we use an OPUS heuristic probe
+// (biased toward compete): partition is competition-worthy unless the milestone is
+// trivially single-domain. So: opus probe DECIDES whether to compete; the objective
+// file-disjointness oracle JUDGES the produced candidates. (Decision = heuristic +
+// bias; selection = objective.)
+async function runPartitionProbe(projectDir, { milestone, briefPath, userInput, phaseNameOpt } = {}) {
+  const prompt = [
+    `You are the Partition Solution-Space Probe${milestone ? ` for ${milestone}` : ""}. Decide: are there ≥2 genuinely different ways to CARVE this milestone into file-disjoint domains (different boundaries / groupings / parallelism), or is there one obvious single decomposition?`,
+    `**Brief:** ${briefPath || "(none — read .gsd-t docs/contracts/requirements directly)"}`,
+    userInput ? `\nUser input:\n${userInput}\n` : "",
+    `Compete=true when the work spans multiple files/areas that could be grouped more than one sensible way. Compete=false ONLY for a trivial single-file / single-domain milestone.`,
+    `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: "fable" };
+  if (phaseNameOpt) opts.phase = phaseNameOpt;
+  const r = await agent(prompt, opts).catch(() => null);
+  if (!r || typeof r.compete !== "boolean") {
+    return { compete: true, reason: "probe unavailable — defaulting to compete", approaches: [] };
+  }
+  return { compete: r.compete, reason: r.reason || "", approaches: r.approaches || [] };
+}
+
 // Rubric axes for the SUBJECTIVE judge (non-partition eligible phases). Partition
 // uses the objective oracle instead and ignores these.
 const RUBRIC_AXES_BY_PHASE = {
@@ -170,13 +243,27 @@ const milestone  = _args.milestone || null;
 const userInput  = _args.userInput || "";
 const phaseName  = _args.phase;
 
-// M82: clamp competition N to [1,5]. Evidence (Self-MoA, Large Language Monkeys):
-// gains plateau fast; N=3 captures the elbow, >5 is wasteful. N<=1 = off (single producer).
-const _rawN = Number(_args.competition) || 1;
-const competitionN = Math.max(1, Math.min(5, Math.floor(_rawN)));
-const competitionOn = competitionN > 1 && COMPETITION_ELIGIBLE.has(phaseName);
-if (competitionN > 1 && !competitionOn) {
-  log(`competition: N=${competitionN} ignored — phase "${phaseName}" is not competition-eligible (single producer runs). Eligible: ${[...COMPETITION_ELIGIBLE].join(", ")}.`);
+// M84: competition is AUTOMATIC. By default the workflow PROBES the solution space
+// (after brief) and self-decides whether to run a 3-producer + judge competition —
+// no flag needed. Optional manual OVERRIDES: `competition: N` (2-5) forces N
+// producers; `competition: 0` or `noCompetition: true` forces it off. Default
+// (`competition` unset) = let the workflow decide.
+// Evidence (Self-MoA, Large Language Monkeys): gains plateau fast; N=3 is the elbow,
+// >5 wasteful. The auto path fires 3.
+const AUTO_COMPETITION_N = 3;
+const _hasCompetitionArg = _args.competition !== undefined && _args.competition !== null;
+const _forceOff = _args.noCompetition === true || (_hasCompetitionArg && Number(_args.competition) <= 1);
+const _forcedN = _hasCompetitionArg && Number(_args.competition) >= 2
+  ? Math.max(2, Math.min(5, Math.floor(Number(_args.competition))))
+  : null;
+// competitionN/competitionOn are resolved LATER (after preflight+brief) by the
+// auto-probe, unless an override pins them now. Declared with `let` so the
+// post-brief decision block can set them.
+let competitionN = 1;
+let competitionOn = false;
+const _competitionEligible = COMPETITION_ELIGIBLE.has(phaseName);
+if (_forcedN && !_competitionEligible) {
+  log(`competition: forced N=${_forcedN} ignored — phase "${phaseName}" is not competition-eligible. Eligible: ${[...COMPETITION_ELIGIBLE].join(", ")}.`);
 }
 
 if (!phaseName || !VALID_PHASES.includes(phaseName)) {
@@ -189,7 +276,35 @@ const pre = await runPreflight(projectDir);
 if (!pre.ok) return { status: "failed", reason: "preflight-failed", preflight: pre.envelope };
 const brief = await generateBrief(projectDir, { kind: phaseName, milestone, id: `${phaseName}-${(milestone || "m").toLowerCase()}` });
 
-phase("Phase");
+// ── M84: resolve competition AUTOMATICALLY (after brief, before producing) ──
+// Default: probe the solution space and self-decide. Overrides pin it.
+if (_competitionEligible) {
+  if (_forceOff) {
+    competitionOn = false;
+    log(`competition: OFF (overridden via competition≤1 / noCompetition).`);
+  } else if (_forcedN) {
+    competitionN = _forcedN; competitionOn = true;
+    log(`competition: ON, N=${_forcedN} (overridden).`);
+  } else {
+    // M84 Red Team LOW: warn on an unparseable override so a typo (competition:"off")
+    // isn't silently swallowed into the auto path.
+    if (_hasCompetitionArg && Number.isNaN(Number(_args.competition))) {
+      log(`competition: override value ${JSON.stringify(_args.competition)} is not a number — ignoring it, using AUTO. (Use 0/noCompetition to force off, 2-5 to force N.)`);
+    }
+    // Automatic decision — the workflow probes and decides. Opus probe (or the
+    // partition-specific probe); biased toward competing.
+    phase("Probe");
+    const probe = phaseName === "partition"
+      ? await runPartitionProbe(projectDir, { milestone, briefPath: brief.briefPath, userInput, phaseNameOpt: "Probe" })
+      : await runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPath: brief.briefPath, userInput, phaseNameOpt: "Probe" });
+    competitionOn = !!probe.compete;
+    competitionN = competitionOn ? AUTO_COMPETITION_N : 1;
+    log(`competition: AUTO → ${competitionOn ? `COMPETE (${AUTO_COMPETITION_N} producers)` : "single draft"} — ${probe.reason}${probe.approaches && probe.approaches.length ? ` [approaches: ${probe.approaches.join("; ")}]` : ""}`);
+  }
+}
+
+// M84 Red Team LOW: announce "Phase" only on the single-draft path (the
+// competition path announces Compete/Judge/Finalize instead) so no empty stage shows.
 const promptByPhase = {
   partition: `Decompose the milestone into 2-5 independent domains. Write .gsd-t/domains/{domain}/{scope,constraints,tasks}.md. Cross-domain contracts in .gsd-t/contracts/.`,
   plan: `For each domain, write atomic tasks.md entries with files, contract refs, dependencies, acceptance criteria. Update .gsd-t/contracts/integration-points.md with wave groupings.
@@ -209,6 +324,7 @@ const briefLine = `**Brief (REQUIRED):** ${brief.briefPath || "(no brief — re-
 let result;
 if (!competitionOn) {
   // ── Single-producer path (default, unchanged behavior) ──
+  phase("Phase");
   result = await agent(
     [
       `You are the ${phaseName} phase agent.`,
@@ -224,15 +340,49 @@ if (!competitionOn) {
     { label: phaseName, phase: "Phase", schema: PHASE_RESULT_SCHEMA, model: "opus" }
   ).catch((e) => ({ status: "failed", artifacts: [], summary: `agent error: ${e && e.message}` }));
 } else {
-  // ── M82 Competition Mode: generate -> judge -> finalize ──
-  // Distinct "angles" so the N Self-MoA producers explore different regions of
-  // the solution space (diversity by prompt, not by model — Self-MoA > Mixed-MoA).
-  const ANGLES = [
-    "Optimize for MAXIMUM parallelism: carve the most file-disjoint domains that can run concurrently.",
-    "Optimize for SIMPLICITY: the fewest domains with the cleanest, most obvious boundaries.",
-    "Optimize for RISK ISOLATION: isolate the riskiest/most-coupled work into its own domain so the rest stays safe.",
-    "Optimize for DEPENDENCY DEPTH: minimize serial gates (waves) between domains.",
-    "Optimize for BALANCE: roughly equal-sized domains with minimal cross-talk.",
+  // ── M82/M84 Competition Mode: generate -> judge -> finalize ──
+  // Distinct "angles" so the N Self-MoA producers explore different regions of the
+  // solution space (diversity by prompt, not by model — Self-MoA > Mixed-MoA).
+  // M84 Red Team MEDIUM: angles must be PHASE-AWARE — the old partition-only set
+  // gave a discuss/milestone producer a contradictory "carve file-disjoint domains"
+  // directive, degrading 3 of 4 now-automatic phases. Each eligible phase gets its
+  // own angle set (analogous to RUBRIC_AXES_BY_PHASE).
+  const ANGLES_BY_PHASE = {
+    partition: [
+      "Optimize for MAXIMUM parallelism: carve the most file-disjoint domains that can run concurrently.",
+      "Optimize for SIMPLICITY: the fewest domains with the cleanest, most obvious boundaries.",
+      "Optimize for RISK ISOLATION: isolate the riskiest/most-coupled work into its own domain so the rest stays safe.",
+      "Optimize for DEPENDENCY DEPTH: minimize serial gates (waves) between domains.",
+      "Optimize for BALANCE: roughly equal-sized domains with minimal cross-talk.",
+    ],
+    milestone: [
+      "Optimize for FASTEST TIME-TO-VALUE: the leanest milestone sequence that ships something usable soonest.",
+      "Optimize for RISK-FIRST: front-load the riskiest/most-uncertain work so failure is cheap and early.",
+      "Optimize for DEPENDENCY ORDER: sequence strictly by what unblocks the most downstream work.",
+      "Optimize for USER-VALUE-FIRST: order milestones by the value each delivers to the end user.",
+      "Optimize for SIMPLICITY: the fewest, most self-contained milestones with minimal cross-cutting.",
+    ],
+    discuss: [
+      "Argue the SIMPLEST viable architecture, even if it sacrifices some flexibility.",
+      "Argue the most ROBUST/CORRECT architecture, accepting more upfront complexity.",
+      "Argue the most EXTENSIBLE architecture, optimizing for future change.",
+      "Argue a PRAGMATIC middle path, naming the explicit trade-offs it accepts.",
+      "Argue a CONTRARIAN approach that questions an assumption the others take for granted.",
+    ],
+    "design-decompose": [
+      "Decompose ATOMIC-FIRST: smallest reusable elements up, composed into widgets then pages.",
+      "Decompose PAGE-FIRST: whole pages down into sections, widgets, then elements.",
+      "Decompose TOKEN-DRIVEN: design tokens + primitives first, structure follows the system.",
+      "Decompose by REUSE: maximize shared components; minimize one-off bespoke pieces.",
+      "Decompose by FEATURE: group elements/widgets by the user-facing feature they serve.",
+    ],
+  };
+  const ANGLES = ANGLES_BY_PHASE[phaseName] || [
+    "Explore a materially different approach, optimizing for simplicity.",
+    "Explore a materially different approach, optimizing for robustness/correctness.",
+    "Explore a materially different approach, optimizing for extensibility.",
+    "Explore a pragmatic middle path, naming its trade-offs.",
+    "Explore a contrarian approach that questions a shared assumption.",
   ];
 
   const PRODUCER_SCHEMA = phaseName === "partition"
@@ -323,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 } } },
@@ -503,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)