@tekyzinc/gsd-t 5.2.10 → 5.3.10

package/CHANGELOG.md

@@ -2,6 +2,40 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [5.3.10] - 2026-07-24
+
+### Changed — Fable 5 removed; Opus tier upgraded to Opus 5 (claude-opus-5)
+
+The 4-tier model map (haiku/sonnet/opus/fable) collapses to **3 tiers (haiku/sonnet/opus)** where `opus` = **`claude-opus-5`**. Opus 5 shipped 2026-07-24 at the SAME price as Opus 4.8 ($5/$25 per M tokens) but >2× its coding score (Frontier-Bench) and within 0.5% of Fable 5 at max effort — so Fable's cost premium ($10/$50, double Opus 5) is no longer justified. **Every stage formerly on Fable OR Opus 4.8 now runs Opus 5.** Opus 5's context window is 1M tokens (same as 4.8 — no large-context regression), knowledge cutoff May 2026.
+
+The M82 competition judge-blindness invariant is **RELAXED** from "judge model ≠ producers model" to "judge runs in a fresh independent context" — producers AND judge both run Opus 5 (fresh contexts remove memory-bias; the modest residual taste/blind-spot bias is accepted for a stronger judge). The judge≠producers clamp is removed from the tier policy, the profile resolver, and the drift lint.
+
+- `bin/gsd-t-model-tier-policy.cjs`: MODEL_IDS `opus`→`claude-opus-5`, `fable` DELETED; all 7 STAGE_TIERS → opus; `requiresThinkingOmitted` now a single-home no-op (no model requires omission post-Fable); judge blindness clamp removed.
+- `bin/gsd-t-model-profile.cjs`: 3 profiles remapped to dial OPUS-vs-SONNET (standard=probes-opus/rest-sonnet, pro=mid, premium=all-opus); blindness clamp removed.
+- `bin/gsd-t-parallel.cjs`: fable alias removed.
+- `templates/workflows/*.workflow.js` (5): every `model: "fable"` / `?? "fable"` → `"opus"`.
+- `templates/prompts/{blind-adversary,research}-subagent.md`: model annotation fable → opus.
+- Drift-enforcer lints (`test/m85-*`, `test/m86-*`, `test/m90-tier-policy-lint`) updated atomically with the policy — fable fixtures/expectations → opus/sonnet; the "cycles must differ" + "judge≠producers" assertions removed.
+- Contracts: `model-tier-policy-contract.md` v2.0.0 (BREAKING), `model-profile-config-contract.md` v1.1.0 — each with a Fable-removed banner.
+- `templates/CLAUDE-global.md` + live `~/.claude/CLAUDE.md`: Model Display doctrine updated.
+- Command files (`gsd-t-help/status/debug/partition`), README, GSD-T-README updated.
+
+Full suite: 3019/3019 pass, 13 skipped. Zero executable `fable` literal remains in bin/workflows/lints; producers AND judge both resolve to `claude-opus-5`; all 3 profiles resolve with no fable.
+
+## [5.2.11] - 2026-07-22
+
+### Changed — architect-overview cleanup (dead tool, shared reader, archived contracts)
+
+Applied the three safe findings from a `/gsd-t-architect` framework-overview pass, and recorded a correction to a wrong finding.
+
+- Deleted `bin/model-selector.js` + `test/model-selector.test.js` — the M35 model picker with zero live callers, superseded by M85's `bin/gsd-t-model-tier-policy.cjs`. Scrubbed 3 stale `selectModel()` doc references (`gsd-t-quick.md`, `gsd-t-test-sync.md`, `templates/CLAUDE-project.md`, `README.md`).
+- Extracted a shared marker-block *reader* (`extractMarkedDocBlock`) into `bin/gsd-t-doc-marker.cjs` and rewired `bin/gsd-t-env-registry.cjs::extractBlock` to it — finishing the M102 writer/reader extraction. The verify-gate's independent copy is left intact on purpose (defensive-independence invariant — a writer bug must not disable the gate).
+- Archived 13 stale `mXX-integration-points.md` contracts to `.gsd-t/milestones/_integration-points-archive/`. `m94-integration-points.md` was RESTORED — 3 live M94 tests read it by path (a live fixture, not archaeology).
+
+Recorded in `progress.md`: the overview's "graph subsystem is broken sprawl" finding was a **false negative** — it checked the pre-M99 path `.gsd-t/graph.db`; the real store moved to `.gsd-t/graphDB/graph.db` (M99 consolidation, already shipped, with a canonical resolver). The graph builds and works in every project. No code change — the correction is the deliverable.
+
+Suite: 3020/3020 pass, 13 skipped.
+
 ## [5.2.10] - 2026-07-17
 
 ### Added — Environment Registry (M102): the committed, secret-free connection map

package/README.md

@@ -1,6 +1,6 @@
 # GSD-T: Contract-Driven Development for Claude Code
 
-**v5.2.10** - A methodology for reliable, parallelizable development using Claude Code with optional Agent Teams support.
+**v5.3.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/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`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that control which stages run on Fable vs. Opus/Sonnet (see [Model Profiles](#model-profiles) below).
+**Surgical model selection** — models are assigned haiku/sonnet/opus per phase (**Fable removed 2026-07-24**; `opus` = **claude-opus-5**). **Single-source tier policy:** `bin/gsd-t-model-tier-policy.cjs` is the SINGLE source of truth; every high-stakes stage (solution-space probe, partition probe, competition judge, pre-mortem, Red Team, competition producers, debug both cycles) runs Opus 5. Opus 5 shipped at the same price as Opus 4.8 but >2× its coding score, so Fable's cost premium is no longer justified. The M82 judge-blindness invariant is relaxed to "fresh independent context" — producers and judge both run opus. Drift is mechanically enforced by the M71-family lint (`test/m85-workflow-tier-policy-lint.test.js`). **M86 model profiles:** `bin/gsd-t-model-profile.cjs` adds a per-project SECOND dimension — three named profiles (`standard` / `pro` / `premium`) that dial which stages run on Opus vs. Sonnet.
 **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.
@@ -466,7 +466,6 @@ 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/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

package/bin/gsd-t-doc-marker.cjs

@@ -62,4 +62,22 @@ function upsertMarkedDocBlock(targetPath, startMarker, endMarker, block) {
   return targetPath;
 }
 
-module.exports = { upsertMarkedDocBlock };
+// Read the marked block back OUT of `content`. Returns the slice from the START
+// marker up to (but NOT including) the END marker — i.e. the block body a parser
+// walks line-by-line — or null if either marker is absent. The complement of
+// upsertMarkedDocBlock's write. (Shared so a reader isn't re-implemented per
+// caller — the env-registry writer/reader used to copy this inline.)
+//
+// NOTE: the verify GATE (gsd-t-env-registry-check.cjs) deliberately does NOT use
+// this — it re-implements the extract independently so a bug here cannot disable
+// the gate (M102 defensive-independence invariant). That duplication is
+// load-bearing; do not "consolidate" it.
+function extractMarkedDocBlock(content, startMarker, endMarker) {
+  if (typeof content !== "string" || !startMarker || !endMarker) return null;
+  if (!content.includes(startMarker) || !content.includes(endMarker)) return null;
+  const start = content.indexOf(startMarker);
+  const end = content.indexOf(endMarker);
+  return content.slice(start, end);
+}
+
+module.exports = { upsertMarkedDocBlock, extractMarkedDocBlock };

package/bin/gsd-t-env-registry.cjs

@@ -24,7 +24,7 @@
 
 const fs = require("fs");
 const path = require("path");
-const { upsertMarkedDocBlock } = require("./gsd-t-doc-marker.cjs");
+const { upsertMarkedDocBlock, extractMarkedDocBlock } = require("./gsd-t-doc-marker.cjs");
 
 // ─── Markers + schema ────────────────────────────────────────────────────────
 
@@ -851,13 +851,11 @@ function infraDocPath(projectDir) {
   return path.join(projectDir, "docs", "infrastructure.md");
 }
 
+// Uses the ONE shared reader from gsd-t-doc-marker.cjs (complement of the shared
+// writer this file already calls) — no inline re-implementation. The verify gate
+// keeps its OWN independent copy on purpose (defensive independence).
 function extractBlock(content) {
-  if (!content.includes(ENV_MARKER_START) || !content.includes(ENV_MARKER_END)) {
-    return null;
-  }
-  const start = content.indexOf(ENV_MARKER_START);
-  const end = content.indexOf(ENV_MARKER_END);
-  return content.slice(start, end);
+  return extractMarkedDocBlock(content, ENV_MARKER_START, ENV_MARKER_END);
 }
 
 function splitRow(line) {

package/bin/gsd-t-model-profile.cjs

@@ -51,7 +51,7 @@ const GLOBAL_DEFAULT_PROFILE = 'premium';
 const VALID_PROFILES = Object.keys(PROFILE_STAGE_TIERS); // ['standard','pro','premium']
 
 /** Valid tier names. */
-const VALID_TIERS = Object.keys(MODEL_IDS); // ['opus','fable','sonnet','haiku']
+const VALID_TIERS = Object.keys(MODEL_IDS); // ['opus','sonnet','haiku'] (Fable removed 2026-07-24)
 
 /**
  * Stages that CANNOT be overridden (M82 blindness invariant).
@@ -216,12 +216,10 @@ function validateSetStage(stageKey, tier) {
     };
   }
 
-  if (stageKey === 'competition-judge' && MODEL_IDS[tier] === MODEL_IDS.opus) {
-    return {
-      ok: false,
-      error: `competition-judge cannot be set to "${tier}" (resolves to "${MODEL_IDS[tier]}") — judge model must differ from producers' model (M82 blindness invariant)`,
-    };
-  }
+  // Blindness clamp REMOVED 2026-07-24: the M82 invariant relaxed from "judge
+  // model ≠ producers model" to "judge runs in a fresh independent context", so
+  // competition-judge = opus (= producers' model) is now ALLOWED. Any valid tier
+  // is accepted for the judge.
 
   return { ok: true };
 }
@@ -281,14 +279,9 @@ function buildResolveEnvelope(profile, stageOverrides, specificStage, configErro
     if (r.configError && !envelopeConfigError) envelopeConfigError = r.configError;
   }
 
-  // Verify competition-judge !== producers' model (final assertion)
-  if (overrides['competition-judge'] === MODEL_IDS.opus) {
-    // This should never reach here (resolveProfile clamps it), but defense in depth
-    envelopeConfigError = envelopeConfigError || 'blindness clamp: competition-judge resolved to producers model — using profile fallback';
-    const fallbackR = resolveProfile('competition-judge', { profile, stageOverrides: {} });
-    overrides['competition-judge'] = fallbackR.model;
-    thinkingMap['competition-judge'] = fallbackR.requiresThinkingOmitted;
-  }
+  // Blindness clamp REMOVED 2026-07-24: competition-judge = opus (= producers'
+  // model) is now permitted (invariant relaxed to "fresh independent context").
+  // No rewrite of the judge model.
 
   const result = {
     ok: true,

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

@@ -18,11 +18,16 @@
  * 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}>}
+ * THREE tiers (Fable removed 2026-07-24): `opus` is now `claude-opus-5` — the
+ * default top tier. Opus 5 shipped at the SAME price as Opus 4.8 ($5/$25 per M
+ * tokens) but >2× its coding score and within 0.5% of Fable 5 at max effort, so
+ * the Fable cost premium ($10/$50 — double Opus 5) is no longer justified. Every
+ * stage formerly on `fable` OR `opus` (4.8) now runs `opus` = claude-opus-5.
+ *
+ * @type {Readonly<{opus: string, sonnet: string, haiku: string}>}
  */
 const MODEL_IDS = Object.freeze({
-  opus:   'claude-opus-4-8',
-  fable:  'claude-fable-5',
+  opus:   'claude-opus-5',
   sonnet: 'claude-sonnet-4-6',
   haiku:  'claude-haiku-4-5-20251001',
 });
@@ -33,18 +38,23 @@ const MODEL_IDS = Object.freeze({
 
 /**
  * Frozen map: stage key → tier alias.
- * 6 stages → fable; competition-producers held at opus (M82 blindness invariant).
+ * Fable removed 2026-07-24: all 7 stages resolve to `opus` (= claude-opus-5).
+ * The M82 competition judge-blindness invariant is RELAXED from "different model"
+ * to "fresh independent context" — producers AND judge both run Opus 5 (fresh
+ * contexts remove memory-bias; the modest residual taste/blind-spot bias is
+ * accepted for a stronger judge — user-locked 2026-07-24). See
+ * competition-mode-contract.md §Different-context judge.
  *
  * @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',
+  'solution-space-probe':  'opus',
+  'partition-probe':       'opus',
+  'competition-judge':     'opus',  // was fable; blindness now via fresh context, not different model
+  'competition-producers': 'opus',
+  'pre-mortem':            'opus',
+  'red-team':              'opus',
+  'debug-cycle-2':         'opus',
 });
 
 // ---------------------------------------------------------------------------
@@ -55,18 +65,22 @@ const STAGE_TIERS = Object.freeze({
  * 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.
+ * This predicate existed for `claude-fable-5`, which returned HTTP 400 when the
+ * explicit thinking-disabled parameter was sent. Fable was removed 2026-07-24;
+ * NO current tier model (opus=claude-opus-5, sonnet, haiku) is known to require
+ * omission — Opus 5 and Sonnet 5 default `effort:high` on the API and accept the
+ * thinking params normally. Kept as a single-home predicate (callers still import
+ * it) so a future model that needs omission is added HERE, never re-hardcoded.
  *
  * @param {string} model — concrete model id or tier alias or any string
  * @returns {boolean}
  */
+const MODELS_REQUIRING_THINKING_OMITTED = Object.freeze([]); // none post-Fable
 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 + '[');
+  return MODELS_REQUIRING_THINKING_OMITTED.some(
+    (id) => model === id || model.startsWith(id + '[')
+  );
 }
 
 // ---------------------------------------------------------------------------
@@ -98,16 +112,15 @@ function resolve(stageKey) {
 /**
  * Frozen profile → stage-key → tier map.
  *
- * Three named profiles:
- *   standard  — ZERO fable (pre-M85 tiers: probes→opus, judge→sonnet,
- *                pre-mortem→opus, red-team→opus, debug both cycles→opus).
- *   pro       — red-team + pre-mortem + debug-cycle-2 → fable; everything
- *                else reverts to standard.
- *   premium   — all 6 M85 fable stages (the full M85 posture).
+ * Fable removed 2026-07-24 — profiles now dial OPUS-vs-SONNET spend (not Fable):
+ *   standard  — cost-leanest: the high-stakes reasoning stages run sonnet,
+ *                only the probes stay opus.
+ *   pro       — mid: red-team + pre-mortem + debug-cycle-2 → opus; the rest sonnet.
+ *   premium   — full opus posture: all 6 designated stages → opus (= claude-opus-5).
  *
- * competition-producers is HELD at opus in ALL profiles (M82 blindness
- * invariant — never fable). It is NOT included here because it is never
- * overridable; the resolver enforces this separately.
+ * competition-producers is held at opus in ALL profiles (always opus-5). The
+ * former judge≠producers blindness clamp is REMOVED — the invariant is now
+ * "fresh independent context," so the judge may equal producers' model.
  *
  * @type {Readonly<Record<string, Readonly<Record<string, string>>>>}
  */
@@ -116,25 +129,25 @@ const PROFILE_STAGE_TIERS = Object.freeze({
     'solution-space-probe': 'opus',
     'partition-probe':      'opus',
     'competition-judge':    'sonnet',
-    'pre-mortem':           'opus',
-    'red-team':             'opus',
-    'debug-cycle-2':        'opus',
+    'pre-mortem':           'sonnet',
+    'red-team':             'sonnet',
+    'debug-cycle-2':        'sonnet',
   }),
   pro: Object.freeze({
     'solution-space-probe': 'opus',
     'partition-probe':      'opus',
     'competition-judge':    'sonnet',
-    'pre-mortem':           'fable',
-    'red-team':             'fable',
-    'debug-cycle-2':        'fable',
+    'pre-mortem':           'opus',
+    'red-team':             'opus',
+    'debug-cycle-2':        'opus',
   }),
   premium: Object.freeze({
-    'solution-space-probe': 'fable',
-    'partition-probe':      'fable',
-    'competition-judge':    'fable',
-    'pre-mortem':           'fable',
-    'red-team':             'fable',
-    'debug-cycle-2':        'fable',
+    'solution-space-probe': 'opus',
+    'partition-probe':      'opus',
+    'competition-judge':    'opus',
+    'pre-mortem':           'opus',
+    'red-team':             'opus',
+    'debug-cycle-2':        'opus',
   }),
 });
 
@@ -148,18 +161,19 @@ const INJECTABLE_STAGES = Object.freeze([
   'debug-cycle-2',
 ]);
 
-/** The HELD producers model id — used by blindness clamps. */
-const PRODUCERS_MODEL_ID = MODEL_IDS.opus; // claude-opus-4-8
+/** The HELD producers model id (always opus = claude-opus-5). */
+const PRODUCERS_MODEL_ID = MODEL_IDS.opus; // claude-opus-5
 
 /**
  * Resolves the concrete model id for a given stage key under a profile,
  * honoring precedence: stageOverrides[stage] ?? profile-tier ?? global-default.
  *
- * Blindness clamps (M82 / pre-mortem c2 #4 — enforced at RESOLVE, not only at
- * write time because the config file is hand-editable):
- *   - competition-producers key in stageOverrides: silently dropped (never in overrides map).
- *   - competition-judge resolved to the producers' model id: BLOCKED — drops the override
- *     and uses the profile tier for competition-judge instead.
+ * Blindness (M82, RELAXED 2026-07-24 to "fresh independent context"):
+ *   - competition-producers key in stageOverrides: still silently dropped (producers
+ *     are always opus — not profile-overridable).
+ *   - competition-judge may now equal the producers' model (both opus) — the old
+ *     judge≠producers clamp is REMOVED; isolation is enforced by fresh context, not
+ *     by a different model.
  *
  * @param {string} stageKey
  * @param {{ profile?: string, stageOverrides?: Record<string,string> }} opts
@@ -222,11 +236,10 @@ function resolveProfile(stageKey, opts) {
       // (Red Team M86 r2 LOW: unknown stage + invalid override resolved fable on standard).
       errors.push(`stageOverrides["${stageKey}"] has invalid tier "${rawOverrideTier}"; falling back to profile tier`);
       resolvedTier = stageKnown ? profileTierMap[stageKey] : 'sonnet';
-    } else if (stageKey === 'competition-judge' && MODEL_IDS[rawOverrideTier] === PRODUCERS_MODEL_ID) {
-      // Blindness clamp: competition-judge must not equal producers' model
-      errors.push(`stageOverrides["competition-judge"] resolves to "${MODEL_IDS[rawOverrideTier]}" (=producers' model); blindness clamp rejected — falling back to profile tier`);
-      resolvedTier = stageKnown ? profileTierMap[stageKey] : 'sonnet';
     } else {
+      // Blindness clamp REMOVED (2026-07-24): competition-judge may equal the
+      // producers' model — isolation is now enforced by fresh context, not a
+      // different model. Any valid tier override is honored.
       resolvedTier = rawOverrideTier;
     }
   } else {

package/bin/gsd-t-parallel.cjs

@@ -610,10 +610,9 @@ function runDispatch(opts) {
   // is sufficient (single-source thesis, AC b).
   const modelAlias = {
     opus:   MODEL_IDS.opus,
-    fable:  MODEL_IDS.fable,
     sonnet: MODEL_IDS.sonnet,
     haiku:  MODEL_IDS.haiku,
-  };
+  }; // fable removed 2026-07-24
   const callerModel = opts && opts.workerModel;
   const workerModel = callerModel === false
     ? null // explicit opt-out: inherit parent's ANTHROPIC_MODEL

package/commands/gsd-t-debug.md

@@ -62,7 +62,7 @@ Call the `Workflow` tool with:
     symptom: "describe the failing test or runtime error in one sentence",
     projectDir: ".",
     // M86: inject the resolved overrides map so the workflow's ?? form for debug-cycle-2
-    // picks up the profile-tier assignment instead of the premium fable literal.
+    // picks up the profile-tier assignment instead of the premium opus literal.
     // Pass {} when the resolver failed AND you chose the loud-warning path (not halt).
     overrides: { /* ...from resolver result.overrides, or {} on failure */ }
   }

package/commands/gsd-t-help.md

@@ -519,16 +519,16 @@ Use these when user asks for help on a specific command:
 - **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).
+- **Summary**: SINGLE source of truth for GSD-T model-tier assignments. Publishes the authoritative tier set (haiku/sonnet/opus — **Fable removed 2026-07-24**; `opus` = claude-opus-5) and the 7 designated stage→tier mappings (all → opus). Opus 5 shipped at the same price as Opus 4.8 but >2× its coding score, so every stage formerly on Fable OR Opus 4.8 now runs Opus 5. The M82 competition judge-blindness invariant is RELAXED to "fresh independent context" — producers AND judge both run opus. 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.1.0 STABLE.
 
 ### model-profile (M86)
-- **Summary**: Per-project model-tier profile switcher — a SECOND dimension over the M85 stage-tier policy. Manages `.gsd-t/model-profile.json` and resolves which concrete model id each workflow stage runs on under the active profile. Three named profiles: `standard` (zero Fable — pre-M85 posture), `pro` (Fable on red-team + pre-mortem + debug-cycle-2), `premium` (all 6 M85 designated Fable stages — global default). Switching profiles injects the overrides into workflow args at invoke time (M69 pattern — NO tracked-file rewriting). Competition producers are HELD at opus in ALL profiles (M82 blindness invariant). The active profile is surfaced in the session banner (`[GSD-T PROFILE]`), the statusline, and `gsd-t status` — always named, never an implicit fallback (SC(f)).
+- **Summary**: Per-project model-tier profile switcher — a SECOND dimension over the stage-tier policy. Manages `.gsd-t/model-profile.json` and resolves which concrete model id each workflow stage runs on under the active profile. Three named profiles (Fable removed 2026-07-24 — they now dial OPUS-vs-SONNET spend): `standard` (probes opus, high-stakes stages sonnet — cost-leanest), `pro` (probes + pre-mortem + red-team + debug-cycle-2 opus, judge sonnet), `premium` (all 6 designated stages opus — global default). Switching profiles injects the overrides into workflow args at invoke time (M69 pattern — NO tracked-file rewriting). Competition producers are held at opus in ALL profiles. The active profile is surfaced in the session banner (`[GSD-T PROFILE]`), the statusline, and `gsd-t status` — always named, never an implicit fallback (SC(f)).
 - **Files**: `bin/gsd-t-model-profile.cjs` (zero external deps — installer invariant). Config: `.gsd-t/model-profile.json` (`{ "profile": "pro", "stageOverrides": { ... } }`).
-- **Use when**: A project needs a different spend posture than the global default (e.g., run `standard` on a CI cost budget, or `pro` for a production release with targeted Fable quality gates). Per-stage overrides allow fine-grained control beyond the named profiles.
+- **Use when**: A project needs a different spend posture than the global default (e.g., run `standard` on a CI cost budget, or `pro` for a production release with targeted opus quality gates). Per-stage overrides allow fine-grained control beyond the named profiles.
 - **CLI**:
   - `gsd-t model-profile show [--json]` — display active profile + per-stage resolution
   - `gsd-t model-profile set <standard|pro|premium>` — switch the project profile
@@ -540,7 +540,7 @@ Use these when user asks for help on a specific command:
 - **Contract**: `.gsd-t/contracts/model-profile-config-contract.md` v1.0.0 STABLE.
 
 ### research-gate (M89)
-- **Summary**: Deterministic CLASSIFY step of the M89 auto-research pipeline. Takes a load-bearing claim the agent tagged `[GUESSED:*]` in its Stated Claims section. The classifier is a MECHANICAL STRING-FACT FILTER (NOT a semantic oracle) returning one of THREE classes: `internal` (grep/Read, route `grep`), `external` (web-research, route `web`), or `ambiguous` (route `judge`). No LLM call in the classifier itself — semantic judgment is deferred to the wiring's LLM judge. An `ambiguous` claim is routed to a small LLM `classify-judge` stage (model: "fable") that decides internal/external/uncertain; **uncertain → research** (never guess-internal). The research `agent()` stage (model: "fable") runs for external guesses. An ENFORCE marker (`<!-- auto-research-claim: ... status=uncited -->`) is written into the artifact (a deterministic `.gsd-t/research/...` fallback if the stage reports no artifact path — fail-closed); the verify gate FAILs if it stays uncited.
+- **Summary**: Deterministic CLASSIFY step of the M89 auto-research pipeline. Takes a load-bearing claim the agent tagged `[GUESSED:*]` in its Stated Claims section. The classifier is a MECHANICAL STRING-FACT FILTER (NOT a semantic oracle) returning one of THREE classes: `internal` (grep/Read, route `grep`), `external` (web-research, route `web`), or `ambiguous` (route `judge`). No LLM call in the classifier itself — semantic judgment is deferred to the wiring's LLM judge. An `ambiguous` claim is routed to a small LLM `classify-judge` stage (model: "opus") that decides internal/external/uncertain; **uncertain → research** (never guess-internal). The research `agent()` stage (model: "opus") runs for external guesses. An ENFORCE marker (`<!-- auto-research-claim: ... status=uncited -->`) is written into the artifact (a deterministic `.gsd-t/research/...` fallback if the stage reports no artifact path — fail-closed); the verify gate FAILs if it stays uncited.
 - **Files**: `bin/gsd-t-research-gate.cjs` (D1). Contract: `.gsd-t/contracts/auto-research-contract.md` v1.3.2 STABLE. Stage prompt: `templates/prompts/research-subagent.md`. DETECT snippet: `templates/prompts/stated-claims-snippet.md`. Cite-format test: `test/m89-research-stage-cite-format.test.js`.
 - **Use when**: A workflow stage needs to classify a guessed claim before deciding whether to grep, run a web-research sub-agent, or route to the LLM judge. Called by D3 (upper phases: plan, pre-mortem, partition, discuss, milestone) and D4 (worker phases: execute, debug, quick). NOT called manually — the wiring invokes it per `[GUESSED:*]` entry in the `## Stated Claims` section.
 - **CLI**: `gsd-t research-gate classify "<guessed claim text>"`. Emits `{ok, gap, class, route, reason}` where `class` ∈ {internal, external, ambiguous} and `route` ∈ {grep, web, judge}. Exit 0 on classify · 1 on bad input.
@@ -549,7 +549,7 @@ Use these when user asks for help on a specific command:
 
 ### architectural-trigger (M90)
 - **Summary**: Deterministic architectural-assumption trigger (M90 §2). Two fire paths: **R-ARCH-1** (divergence-sampling — N fresh-context producer answers → divergence score; competition-arm only, EXPERIMENTAL+MEASURED) and **R-ARCH-2** (protocol-class — any task whose `**Touches**` lists an EXISTING file triggers unconditionally; everywhere feed). Fires produce an instrumentation record in `.gsd-t/metrics/arch-trigger-events.jsonl`; a `provenByAdversaryOnly=true` flag from either path surfaces at the §4 fail-closed verify gate (R-FAIL-2). The module NEVER asserts it works — it emits measurement data only.
-- **Files**: `bin/gsd-t-architectural-trigger.cjs`. Contract: `.gsd-t/contracts/unproven-assumption-doctrine-contract.md` §2. Blind-adversary prompt: `templates/prompts/blind-adversary-subagent.md`. Model: `fable` (M85 RULE-ARCH-TIER).
+- **Files**: `bin/gsd-t-architectural-trigger.cjs`. Contract: `.gsd-t/contracts/unproven-assumption-doctrine-contract.md` §2. Blind-adversary prompt: `templates/prompts/blind-adversary-subagent.md`. Model: `opus` (RULE-ARCH-TIER; Fable removed 2026-07-24).
 - **Use when**: Workflows detect that a task extends existing code (R-ARCH-2 everywhere feed) or that competition producers diverged (R-ARCH-1 competition-arm only). Called automatically by `gsd-t-execute`, `gsd-t-quick`, and `gsd-t-phase` competition arm via inline runCli helper (M81 runtime-native).
 - **CLI**: `gsd-t architectural-trigger trigger '<JSON>'`. JSON shapes: `{"type":"extend-existing-code","context":"...","basis":"..."}` or `{"type":"divergence-sampling","answers":[...],"basis":"..."}`. Emits `{ok, firePath, fired, basis, reason, ...}`. Exit 0 on success · 1 on bad input.
 - **Contract**: `.gsd-t/contracts/unproven-assumption-doctrine-contract.md` §2 v1.0.0 STABLE.

package/commands/gsd-t-partition.md

@@ -58,7 +58,7 @@ binary), do NOT silently proceed on the premium fallback. Either:
     (configured profile unknown; stale global binary may lack model-profile subcommand)
   ```
 
-A configured-standard project silently billing premium fable post-promo is the exact inverse of
+A configured-standard project silently billing premium opus post-promo is the exact inverse of
 the spend-switch goal. Never silently fall through.
 
 Also surface a SUCCESSFUL resolve that carries a `configError` field (the resolver returns a

package/commands/gsd-t-quick.md

@@ -25,8 +25,8 @@ Spawn path is `autoSpawnHeadless({command, spawnType, projectDir, sessionContext
 
 Per `.gsd-t/contracts/model-selection-contract.md` v1.0.0.
 
-- **Default**: `sonnet` (`selectModel({phase: "quick"})`) — routine one-off task.
-- **Mechanical subroutines** (demote to `haiku`): test runners (`selectModel({phase: "quick", task_type: "test_runner"})`).
+- **Default**: `sonnet` (per `bin/gsd-t-model-tier-policy.cjs`, phase `quick`) — routine one-off task.
+- **Mechanical subroutines** (demote to `haiku`): test runners.
 - **Red Team (Step 5.5)**: `opus` — adversarial reasoning always runs at top tier.
 - **Escalation**: `/advisor` convention-based fallback from `bin/advisor-integration.js` at declared high-stakes sub-decisions (see `.gsd-t/M35-advisor-findings.md`). Never silently downgrade the model or skip Red Team / doc-ripple under context pressure — M35 removed that behavior.
 

package/commands/gsd-t-status.md

@@ -81,10 +81,10 @@ The **Model Profile** line MUST always name the active profile — never blank,
 - If the file is absent, display the global default by name with the `(default)` marker: `Model Profile: premium (default)`.
 - If the file is present but malformed or contains an unknown profile, display: `Model Profile: premium (default, config-error)` — never silently promote to the most expensive posture.
 
-Profiles control which workflow stages run on Fable vs. Opus/Sonnet:
-- `standard` — zero Fable stages (pre-M85 posture)
-- `pro` — Fable on red-team + pre-mortem + debug-cycle-2
-- `premium` — all 6 M85 designated Fable stages (full posture, global default)
+Profiles control which workflow stages run on Opus vs. Sonnet (Fable removed 2026-07-24 — `opus` = claude-opus-5):
+- `standard` — probes opus; high-stakes stages (judge/pre-mortem/red-team/debug-cycle-2) sonnet (cost-leanest)
+- `pro` — probes + pre-mortem + red-team + debug-cycle-2 opus; judge sonnet
+- `premium` — all 6 designated stages opus (full posture, global default)
 
 ### Backlog Section
 

package/commands/gsd-t-test-sync.md

@@ -6,7 +6,7 @@ You are maintaining test coverage as code changes. Your job is to identify stale
 
 Per `.gsd-t/contracts/model-selection-contract.md` v1.0.0.
 
-- **Default**: `sonnet` (`selectModel({phase: "test-sync"})`) — test alignment is routine refactoring work.
+- **Default**: `sonnet` (per `bin/gsd-t-model-tier-policy.cjs`, phase `test-sync`) — test alignment is routine refactoring work.
 - **Escalation**: `/advisor` convention-based fallback from `bin/advisor-integration.js` when a test touches a contract boundary or requires judgment about what "missing coverage" means. Never silently skip test-sync under context pressure — M35 removed that behavior.
 
 This command is:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "5.2.10",
+  "version": "5.3.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/templates/CLAUDE-global.md

@@ -251,7 +251,7 @@ Every GSD-T project gets TWO logging streams scaffolded by default at `gsd-t-ini
 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: "fable"` (M85).
+- **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"` (= claude-opus-5; Fable removed 2026-07-24).
 - **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.
@@ -260,13 +260,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"` / `"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.
+**Each Workflow `agent()` call declares its model explicitly** via the `model:` option (`"haiku"` / `"sonnet"` / `"opus"` — **Fable removed 2026-07-24**; `opus` = claude-opus-5). 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, 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).
+- **Fable removed 2026-07-24** — `opus` (= claude-opus-5) is the top tier and the default for every high-stakes stage: solution-space probe, partition probe, competition judge, pre-mortem, Red Team, competition producers, debug both cycles. Opus 5 shipped at the same price as Opus 4.8 but >2× its coding score, so every stage formerly on Fable OR Opus 4.8 now runs Opus 5. The M82 competition judge-blindness invariant is RELAXED to "fresh independent context" — producers AND judge both run `opus` (fresh contexts remove memory-bias; the modest residual taste/blind-spot bias is accepted for a stronger judge). **Single source of truth for tier assignments:** `bin/gsd-t-model-tier-policy.cjs` + `.gsd-t/contracts/model-tier-policy-contract.md`. 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.
 
@@ -421,9 +421,9 @@ For every load-bearing claim, tag it:
 - **`[GUESSED:stale]`** — external/time-varying fact that may have changed.
 
 A `[GUESSED:*]` claim is then CLASSIFIED — mechanical string-fact filter, three classes:
-- **`class: external`** → research agent (`model: "fable"`) writes a `## Verified Facts (auto-research)` block (URL + fetch date); ENFORCE marker `<!-- auto-research-claim: class=external key=<key> status=uncited -->` is written; verify FAILs if it stays `status=uncited` (R-FAIL-1).
+- **`class: external`** → research agent (`model: "opus"`) writes a `## Verified Facts (auto-research)` block (URL + fetch date); ENFORCE marker `<!-- auto-research-claim: class=external key=<key> status=uncited -->` is written; verify FAILs if it stays `status=uncited` (R-FAIL-1).
 - **`class: internal`** → grep/Read only; escalate to external if grep empty.
-- **`class: ambiguous`** → LLM judge (`model: "fable"`) decides; uncertain → research (never guess-internal).
+- **`class: ambiguous`** → LLM judge (`model: "opus"`) decides; uncertain → research (never guess-internal).
 
 **§2 — Architectural Trigger (`gsd-t architectural-trigger trigger '<JSON>'`):**
 Two fire paths — both INSTRUMENTED (fire-rate emitted to `.gsd-t/metrics/arch-trigger-events.jsonl`):

package/templates/CLAUDE-project.md

@@ -23,7 +23,7 @@ Contract-driven development methodology for Claude Code. npm package providing s
 
 ```
 bin/                     — CLI entry (gsd-t.js) + orchestrators (orchestrator.js, design-orchestrator.js)
-                           + support modules (gsd-t-context-brief.cjs, cli-preflight.cjs, gsd-t-verify-gate.cjs, model-selector.js, …)
+                           + support modules (gsd-t-context-brief.cjs, cli-preflight.cjs, gsd-t-verify-gate.cjs, gsd-t-model-tier-policy.cjs, …)
 commands/                — slash commands for Claude Code (GSD-T workflow + utility)
 templates/               — document + prompt + stack templates
   CLAUDE-{global,project}.md, requirements.md, architecture.md, workflows.md,

package/templates/prompts/blind-adversary-subagent.md

@@ -4,7 +4,7 @@
 **Report concisely:** verdict/answer first, no preamble. Gloss every code/jargon term (e.g. `M93-D2` = milestone 93, domain 2) in plain words on first use. Bullets over paragraphs. Expand only if asked.
 <!-- /reader-contract -->
 
-**Model:** `fable` (M85 tier policy — highest-leverage judgment; separate context from the proposing agent)
+**Model:** `opus` (= claude-opus-5; Fable removed 2026-07-24 — highest-leverage judgment; separate context from the proposing agent)
 
 **Framing:** You are reviewing someone ELSE's architectural design — you did NOT propose it and have no attachment to it. Your goal is to find the **fatal flaw** in the premise being challenged, before a single line of code is committed to that premise. This framing (independent reviewer, not the author) is essential for escaping self-preference bias: the proposing agent's prior context makes it systematically less able to see its own premise's failures (source: https://arxiv.org/abs/2310.08118 — LLM self-evaluation is biased toward confirming prior outputs; https://arxiv.org/abs/2404.13076 — blind adversarial framing surfaces failures that self-critique misses).
 
@@ -32,7 +32,7 @@ You are NOT checking whether the code is correct. You are attacking the **archit
 3. **Has someone else solved this class of problem? How?** Grep the repo, check the brief, research prior art. Do NOT confirm the premise by default — search for evidence that it is WRONG or that a different approach is clearly superior.
 4. **What is the minimal falsifying test?** What single experiment would prove the premise is wrong? Propose it.
 
-## Extends M83 Pre-Mortem + Red-Team-on-fable
+## Extends M83 Pre-Mortem + Red-Team-on-opus
 
 This prompt is the **architectural dual** of the M83 pre-mortem: the pre-mortem attacks a PLAN before execution; this prompt attacks an ARCHITECTURAL PREMISE before the plan is written. It also extends the Red Team (which attacks finished code at verify) by moving the adversarial review LEFT to the assumption stage.
 

package/templates/prompts/research-subagent.md

@@ -6,7 +6,7 @@ ZERO feature code writes. You do NOT answer questions about what the claim PROBA
 it up and cite it.
 
 <!-- M89 — Workflow-stage invocation -->
-**Invocation context.** This protocol runs as a native Workflow `agent()` stage (bare `model: "fable"`,
+**Invocation context.** This protocol runs as a native Workflow `agent()` stage (bare `model: "opus"`,
 Fable tier — the single highest-leverage web call per phase). Your **final emission MUST be a single
 StructuredOutput object** matching the schema declared by the calling Workflow. The Verified-Facts block
 is embedded in the artifact; the StructuredOutput envelope carries the block text + the gap-key.

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

@@ -7,11 +7,11 @@
 // M89: Stated-Claims→classify→research wiring (auto-research-contract v1.2.0 §6.5/§1/§2/§3/§4/§7).
 // Each debug cycle embeds the Stated-Claims snippet (§6.5) so the debug agent tags failure-root
 // claims KNOWN|GUESSED. After each cycle, GUESSED claims are classified: external failure-root
-// → write §7 marker (status=uncited) → research agent (model:"fable") → cite → flip marker
+// → write §7 marker (status=uncited) → research agent (model:"opus") → cite → flip marker
 // (status=cited) — instead of a patch-guess (pairs with #33 circuit-breaker). Internal →
 // grep/Read; grep-empty → escalate to external (§5.1). The existing debug-cycle ternary
-// (model: cycle===1?"opus":(overrides["debug-cycle-2"]??"fable")) is PRESERVED; the research
-// stage is a SEPARATE agent() with its own bare "fable" literal. Idempotent per §4.1.
+// (model: cycle===1?"opus":(overrides["debug-cycle-2"]??"opus")) is PRESERVED; the research
+// stage is a SEPARATE agent() with its own bare "opus" literal. Idempotent per §4.1.
 //
 // M94-D11 WRITER pattern (graph-consumer-wiring-contract.md §WRITER Pattern):
 // READER half: before the fix agent, query blast-radius + who-calls to localize the
@@ -57,7 +57,7 @@ const _args = (typeof args === "string") ? (() => { try { return JSON.parse(args
 // Default to {} so the premium fallback literals apply when no invoker injects overrides.
 // overrides values are CONCRETE model ids (resolver envelope); the bare literals below
 // are tier ALIASES. The sandbox runtime accepts BOTH forms in model: — proven live for
-// the concrete-id fable path by probe wf_c9faf817-373 (no HTTP 400).
+// the tier alias resolves to claude-opus-5 (Fable removed 2026-07-24).
 const overrides = (_args.overrides && typeof _args.overrides === "object") ? _args.overrides : {};
 const _CLI_ENVELOPE_SCHEMA = {
   type: "object", required: ["ok", "exitCode"], additionalProperties: true,
@@ -184,7 +184,7 @@ async function grepForClaim(projectDir, claimText, phaseName) {
   return r || { found: false, matches: [] };
 }
 
-// M89 §1.1 — AMBIGUOUS → LLM JUDGE (bare model:"fable" — NOT the ?? form; "judge" is not
+// M89 §1.1 — AMBIGUOUS → LLM JUDGE (bare model:"opus" — NOT the ?? form; "judge" is not
 // a designated stage, so the bare literal passes the M85 tier-set check and stays DISTINCT
 // from the debug-cycle ternary). internal/external/uncertain; uncertain → research (never
 // guess-internal). On error → "uncertain" (fail toward research).
@@ -201,7 +201,7 @@ async function judgeAmbiguous(claimText, phaseName) {
     `- "uncertain" = you cannot CONFIDENTLY place it internal — per M89 doctrine it is RESEARCHED, never guessed.`,
     `Return JSON: { "verdict": "internal"|"external"|"uncertain", "reason": "<one line>" }. No file/web work in THIS step.`,
   ].join("\n");
-  const r = await agent(prompt, { label: "classify-judge", model: "fable", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
+  const r = await agent(prompt, { label: "classify-judge", model: "opus", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
     .catch((e) => ({ verdict: "uncertain", reason: `judge error: ${e && e.message}` }));
   return (r && r.verdict) || "uncertain";
 }
@@ -263,7 +263,7 @@ async function runResearchForClaim(projectDir, claimText, artifactPath, phaseNam
 
   // External-claim handler closure (reused by the ambiguous→judge path).
   const doExternal = async () => {
-    log(`Research: external failure-root → research(fable) instead of patch-guess for "${claimKey.slice(0, 50)}"`);
+    log(`Research: external failure-root → research(opus) instead of patch-guess for "${claimKey.slice(0, 50)}"`);
     await appendUncitedMarker(externalArtifact, claimKey);
     const rr = await agent(
       [
@@ -272,7 +272,7 @@ async function runResearchForClaim(projectDir, claimText, artifactPath, phaseNam
         `Gap-key: "${claimKey}"`,
         `Emit ## Verified Facts (auto-research) block with source URL + fetch date. Append the trailer \`key: ${claimKey}\` on every fact line so the §7 gate matches by claim-key (Red Team MEDIUM #2). Return StructuredOutput JSON.`,
       ].join("\n"),
-      { label: "research", model: "fable", schema: RESEARCH_RESULT_SCHEMA, phase: phaseName }
+      { label: "research", model: "opus", schema: RESEARCH_RESULT_SCHEMA, phase: phaseName }
     ).catch((e) => ({ ok: false, gapKey: claimKey, reason: String(e && e.message) }));
 
     if (rr && rr.ok && rr.citedBlock) {
@@ -300,7 +300,7 @@ async function runResearchForClaim(projectDir, claimText, artifactPath, phaseNam
           `Gap-key: "${claimKey}"`,
           `Emit ## Verified Facts (auto-research) block. Append the trailer \`key: ${claimKey}\` on every fact line so the §7 gate matches by claim-key (Red Team MEDIUM #2). Return StructuredOutput JSON.`,
         ].join("\n"),
-        { label: "research", model: "fable", schema: RESEARCH_RESULT_SCHEMA, phase: phaseName }
+        { label: "research", model: "opus", schema: RESEARCH_RESULT_SCHEMA, phase: phaseName }
       ).catch((e) => ({ ok: false, gapKey: claimKey, reason: String(e && e.message) }));
 
       if (er && er.ok && er.citedBlock) {
@@ -449,7 +449,7 @@ for (let cycle = 1; cycle <= 2; cycle++) {
     label: `debug-cycle-${cycle}`,
     phase: `Cycle ${cycle}`,
     schema: DEBUG_CYCLE_SCHEMA,
-    model: cycle === 1 ? "opus" : (overrides["debug-cycle-2"] ?? "fable"),
+    model: cycle === 1 ? "opus" : (overrides["debug-cycle-2"] ?? "opus"),
   }).catch((e) => ({
     resolved: false,
     rootCause: `agent error: ${e && e.message}`,

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

@@ -17,7 +17,7 @@
 // Domain workers embed the Stated-Claims snippet (§6.5) so agents tag load-bearing claims
 // KNOWN|GUESSED. After domain workers, the Research phase iterates GUESSED entries through
 // bin/gsd-t-research-gate.cjs: external → write §7 marker (status=uncited) → research agent
-// (model:"fable") → cite → flip marker (status=cited). Internal → grep/Read; grep-empty →
+// (model:"opus") → cite → flip marker (status=cited). Internal → grep/Read; grep-empty →
 // escalate to external research + cite + marker (§5.1 ambiguous escalation). Idempotent per §4.1
 // (exact normalized claim-key match only). Wave is a pure composer and does NOT embed this wiring
 // (M85 zero-model: invariant; research reaches wave via its execute sub-workflow).
@@ -142,7 +142,7 @@ async function grepForClaim(projectDir, claimText, phaseName) {
 
 // M89 §1.1 — the AMBIGUOUS → LLM JUDGE. When the mechanical classifier finds no string
 // fact (class:ambiguous), the LLM decides internal/external/uncertain in natural language.
-// Bare model:"fable" (the research tier — NOT the ?? override form; "judge" is not a
+// Bare model:"opus" (the research tier — NOT the ?? override form; "judge" is not a
 // designated stage). Returns the verdict string; on any error → "uncertain" (fail toward
 // research — never guess-internal). The caller treats external/uncertain as research.
 const CLASSIFY_JUDGE_SCHEMA = {
@@ -165,7 +165,7 @@ async function judgeAmbiguous(claimText, phaseName) {
     `Return JSON: { "verdict": "internal"|"external"|"uncertain", "reason": "<one line>" }.`,
     `Do NOT modify files. Do NOT run web searches in THIS step — only decide the verdict.`,
   ].join("\n");
-  const r = await agent(prompt, { label: "classify-judge", model: "fable", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
+  const r = await agent(prompt, { label: "classify-judge", model: "opus", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
     .catch((e) => ({ verdict: "uncertain", reason: `judge error: ${e && e.message}` }));
   return (r && r.verdict) || "uncertain";
 }
@@ -422,14 +422,14 @@ if (allGuessedClaims.length === 0) {
       continue;
     }
 
-    // External-claim handler (§7 marker → research(fable) → cite → flip). Closure so the
+    // External-claim handler (§7 marker → research(opus) → cite → flip). Closure so the
     // ambiguous→judge path reuses it for an "external"/"uncertain" verdict.
     const doExternal = async () => {
-      log(`Research: external claim → write §7 marker + fable research for "${claimKey.slice(0, 50)}"${artifactPath ? "" : " (FALLBACK artifact — worker reported no path)"}`);
+      log(`Research: external claim → write §7 marker + opus research for "${claimKey.slice(0, 50)}"${artifactPath ? "" : " (FALLBACK artifact — worker reported no path)"}`);
       // §7: write uncited marker at classify time (to the real OR fallback artifact — fail-CLOSED)
       await writeUncitedMarker(externalArtifact, claimKey);
 
-      // §2: research agent — bare "fable" tier literal (NOT the ??-override form; contract §2)
+      // §2: research agent — bare "opus" tier literal (NOT the ??-override form; contract §2)
       const researchPrompt = [
         `Read \`${projectDir}/templates/prompts/research-subagent.md\` for the full research protocol.`,
         `Your task: verify this external guessed claim via live web sources.`,
@@ -440,7 +440,7 @@ if (allGuessedClaims.length === 0) {
       ].join("\n");
       const researchResult = await agent(researchPrompt, {
         label: "research",
-        model: "fable",
+        model: "opus",
         schema: RESEARCH_RESULT_SCHEMA,
         phase: "Research",
       }).catch((e) => ({ ok: false, gapKey: claimKey, reason: `research agent error: ${e && e.message}` }));

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

@@ -49,10 +49,10 @@
 //   iterates each [GUESSED:*] entry through the D1 classifier, which is a MECHANICAL
 //   STRING-FACT FILTER returning internal | external | AMBIGUOUS (v1.3.0). On
 //   class:external write a §7 status=uncited marker, run the research agent (bare
-//   model:"fable"), write a ## Verified Facts (auto-research) block, flip the marker to
+//   model:"opus"), write a ## Verified Facts (auto-research) block, flip the marker to
 //   status=cited. On class:internal: grep first; if grep empty, escalate to external
 //   (§5.1). On class:AMBIGUOUS (the regex has no string fact — semantic placement is the
-//   LLM's call, NOT regex's): run a small LLM JUDGE (model:"fable") that decides
+//   LLM's call, NOT regex's): run a small LLM JUDGE (model:"opus") that decides
 //   internal/external/uncertain in natural language. internal→grep; external→research;
 //   UNCERTAIN→treat as external→research (uncertain = verify, NEVER guess-internal — a
 //   silent miss is the one unacceptable outcome). Idempotent: an already-cited marker
@@ -83,7 +83,7 @@ const _args = (typeof args === "string") ? (() => { try { return JSON.parse(args
 // (preserves byte-identical M85 behavior for callers that have not been updated yet).
 // overrides values are CONCRETE model ids (resolver envelope); the bare literals below
 // are tier ALIASES. The sandbox runtime accepts BOTH forms in model: — proven live for
-// the concrete-id fable path by probe wf_c9faf817-373 (no HTTP 400).
+// the tier alias resolves to claude-opus-5 (Fable removed 2026-07-24).
 const overrides = (_args.overrides && typeof _args.overrides === "object") ? _args.overrides : {};
 const _CLI_ENVELOPE_SCHEMA = {
   type: "object", required: ["ok", "exitCode"], additionalProperties: true,
@@ -486,7 +486,7 @@ async function runStatedClaimsPipeline(projectDir, phaseName, phaseResult, state
 
     log(`m89: claim "${claimKey}" → class:${claimClass} route:${claimRoute} — ${envelope.reason || ""}`);
 
-    // External-claim handler (§7 marker → research(fable) → cite → flip). Closure so the
+    // External-claim handler (§7 marker → research(opus) → cite → flip). Closure so the
     // ambiguous→judge path can reuse it for an "external"/"uncertain" verdict.
     const doExternal = async () => {
       // §7: Write status=uncited marker into the (real OR fallback) artifact — ALWAYS written
@@ -504,7 +504,7 @@ async function runStatedClaimsPipeline(projectDir, phaseName, phaseResult, state
       ).catch((e) => ({ ok: false, error: String(e && e.message) }));
       log(`m89: wrote status=uncited marker for claim "${claimKey}" into ${externalArtifact}${primaryArtifact ? "" : " (FALLBACK artifact — worker reported no path)"}`);
 
-      // §2: Run the research agent (bare model: "fable" — not the ?? override form).
+      // §2: Run the research agent (bare model: "opus" — not the ?? override form).
       // The research agent reads its own protocol from research-subagent.md.
       log(`m89: running research agent for external claim "${claimKey}"`);
       const researchResult = await agent(
@@ -519,7 +519,7 @@ async function runStatedClaimsPipeline(projectDir, phaseName, phaseResult, state
           `Use WebSearch + WebFetch to find authoritative sources. Emit a ## Verified Facts (auto-research) block per §3 format. On every fact line append the trailer \`key: ${claimKey}\` so the §7 gate matches by claim-key (Red Team MEDIUM #2).`,
           `Return JSON per the schema with ok:true and citedBlock (the full markdown block) on success, or ok:false and reason on STAGE-FAILURE.`,
         ].join("\n"),
-        { label: "research-stage", phase: "Phase", schema: RESEARCH_RESULT_SCHEMA, model: "fable" }
+        { label: "research-stage", phase: "Phase", schema: RESEARCH_RESULT_SCHEMA, model: "opus" }
       ).catch((e) => ({ ok: false, gapKey: claimKey, reason: `research agent error: ${e && e.message}` }));
 
       if (researchResult && researchResult.ok && researchResult.citedBlock) {
@@ -598,7 +598,7 @@ async function runStatedClaimsPipeline(projectDir, phaseName, phaseResult, state
       await doInternal();
     } else {
       // class:AMBIGUOUS — the mechanical filter found NO string fact. Semantic placement
-      // is the LLM's call, NOT regex's. Run the LLM JUDGE (fable). internal→grep;
+      // is the LLM's call, NOT regex's. Run the LLM JUDGE (opus). internal→grep;
       // external→research; UNCERTAIN→research (uncertain = verify, NEVER guess-internal —
       // a silent miss is the one unacceptable outcome). The classifier never guessed a
       // default — it deferred, and now the LLM decides (and on doubt we research).
@@ -623,7 +623,7 @@ async function runStatedClaimsPipeline(projectDir, phaseName, phaseResult, state
           `Return JSON: { "verdict": "internal" | "external" | "uncertain", "reason": "<one line>" }.`,
           `Do NOT modify files. Do NOT run web searches in THIS step — only decide the verdict.`,
         ].join("\n"),
-        { label: "classify-judge", phase: "Phase", schema: CLASSIFY_JUDGE_SCHEMA, model: "fable" }
+        { label: "classify-judge", phase: "Phase", schema: CLASSIFY_JUDGE_SCHEMA, model: "opus" }
       ).catch((e) => ({ verdict: "uncertain", reason: `judge error: ${e && e.message} — failing toward research` }));
 
       const verdict = (judge && judge.verdict) || "uncertain";
@@ -674,7 +674,7 @@ async function runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPa
   // probe shifts UP — it competes over high-level APPROACHES (what/why/when, actors,
   // one-breath thesis), NOT lower-altitude implementation detail. This changes WHAT
   // the producers compete on, never WHO competes (producers stay opus, judge differs —
-  // M82 blindness invariant preserved) nor the probe's model (stays fable).
+  // M82 blindness now via fresh context) — probe + judge run opus (Fable removed 2026-07-24).
   const atApproachAltitude = altitude === "high-level-approach";
   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?`,
@@ -688,7 +688,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: overrides["solution-space-probe"] ?? "fable" };
+  const opts = { label: "solution-space-probe", schema: _PROBE_SCHEMA, model: overrides["solution-space-probe"] ?? "opus" };
   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).
@@ -714,7 +714,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: overrides["partition-probe"] ?? "fable" };
+  const opts = { label: "partition-probe", schema: _PROBE_SCHEMA, model: overrides["partition-probe"] ?? "opus" };
   if (phaseNameOpt) opts.phase = phaseNameOpt;
   const r = await agent(prompt, opts).catch(() => null);
   if (!r || typeof r.compete !== "boolean") {
@@ -1099,7 +1099,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: overrides["competition-judge"] ?? "fable",
+        label: "judge:rubric", phase: "Judge", model: overrides["competition-judge"] ?? "opus",
         schema: {
           type: "object", required: ["scores"], additionalProperties: true,
           properties: { scores: { type: "array", items: { type: "object", additionalProperties: true } } },
@@ -1353,7 +1353,7 @@ if (phaseName === "plan" && result && result.status !== "failed") {
       ``,
       `M89 ${STATED_CLAIMS_INSTRUCTION}`,
     ].join("\n"),
-    { label: "pre-mortem", phase: "Plan Hardening", schema: PRE_MORTEM_SCHEMA, model: overrides["pre-mortem"] ?? "fable" }
+    { label: "pre-mortem", phase: "Plan Hardening", schema: PRE_MORTEM_SCHEMA, model: overrides["pre-mortem"] ?? "opus" }
   ).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-quick.workflow.js

@@ -8,7 +8,7 @@
 // The task agent embeds the Stated-Claims snippet (§6.5) and tags load-bearing claims KNOWN|GUESSED.
 // After the Execute phase, the Research phase iterates GUESSED entries through
 // bin/gsd-t-research-gate.cjs: external → write §7 marker (status=uncited) → research agent
-// (model:"fable") → cite → flip marker (status=cited). Internal → grep/Read; grep-empty →
+// (model:"opus") → cite → flip marker (status=cited). Internal → grep/Read; grep-empty →
 // escalate to external (§5.1). Idempotent per §4.1 (exact normalized claim-key match only).
 //
 // M90 §2 D4-T4: Architectural-trigger wiring (protocol-class path, R-ARCH-2 "everywhere" feed).
@@ -179,7 +179,7 @@ async function grepForClaim(projectDir, claimText, phaseName) {
   return r || { found: false, matches: [] };
 }
 
-// M89 §1.1 — AMBIGUOUS → LLM JUDGE (bare model:"fable"). internal/external/uncertain;
+// M89 §1.1 — AMBIGUOUS → LLM JUDGE (bare model:"opus"). internal/external/uncertain;
 // uncertain → research (never guess-internal). On error → "uncertain" (fail toward research).
 const CLASSIFY_JUDGE_SCHEMA = {
   type: "object", required: ["verdict"], additionalProperties: true,
@@ -194,7 +194,7 @@ async function judgeAmbiguous(claimText, phaseName) {
     `- "uncertain" = you cannot CONFIDENTLY place it internal — per M89 doctrine it is RESEARCHED, never guessed.`,
     `Return JSON: { "verdict": "internal"|"external"|"uncertain", "reason": "<one line>" }. No file/web work in THIS step.`,
   ].join("\n");
-  const r = await agent(prompt, { label: "classify-judge", model: "fable", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
+  const r = await agent(prompt, { label: "classify-judge", model: "opus", schema: CLASSIFY_JUDGE_SCHEMA, phase: phaseName })
     .catch((e) => ({ verdict: "uncertain", reason: `judge error: ${e && e.message}` }));
   return (r && r.verdict) || "uncertain";
 }
@@ -383,7 +383,7 @@ if (guessedClaims.length === 0) {
 
     // External-claim handler closure (reused by the ambiguous→judge path).
     const doExternal = async () => {
-      log(`Research: external → marker + research(fable) for "${claimKey.slice(0, 50)}"${artifactPath ? "" : " (FALLBACK artifact — no reported path)"}`);
+      log(`Research: external → marker + research(opus) for "${claimKey.slice(0, 50)}"${artifactPath ? "" : " (FALLBACK artifact — no reported path)"}`);
       // §7 write uncited marker to the real OR fallback artifact — ALWAYS (fail-CLOSED)
       {
         const m = uncitedMarker(claimKey);
@@ -394,7 +394,7 @@ if (guessedClaims.length === 0) {
         ).catch(() => {});
         delete artifactCache[externalArtifact];
       }
-      // §2 research agent — bare literal model: "fable"
+      // §2 research agent — bare literal model: "opus"
       const rr = await agent(
         [
           `Read \`${projectDir}/templates/prompts/research-subagent.md\` for the research protocol.`,
@@ -402,7 +402,7 @@ if (guessedClaims.length === 0) {
           `Gap-key: "${claimKey}"`,
           `Emit ## Verified Facts (auto-research) block with source URL + fetch date. Append the trailer \`key: ${claimKey}\` on every fact line so the §7 gate matches by claim-key (Red Team MEDIUM #2). Return StructuredOutput JSON.`,
         ].join("\n"),
-        { label: "research", model: "fable", schema: RESEARCH_RESULT_SCHEMA, phase: "Research" }
+        { label: "research", model: "opus", schema: RESEARCH_RESULT_SCHEMA, phase: "Research" }
       ).catch((e) => ({ ok: false, gapKey: claimKey, reason: String(e && e.message) }));
 
       if (rr && rr.ok && rr.citedBlock) {

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

@@ -56,7 +56,7 @@ const _args = (typeof args === "string") ? (() => { try { return JSON.parse(args
 // Default to {} so the premium fallback literals apply when no invoker injects overrides.
 // overrides values are CONCRETE model ids (resolver envelope); the bare literals below
 // are tier ALIASES. The sandbox runtime accepts BOTH forms in model: — proven live for
-// the concrete-id fable path by probe wf_c9faf817-373 (no HTTP 400).
+// the tier alias resolves to claude-opus-5 (Fable removed 2026-07-24).
 const overrides = (_args.overrides && typeof _args.overrides === "object") ? _args.overrides : {};
 const _CLI_ENVELOPE_SCHEMA = {
   type: "object", required: ["ok", "exitCode"], additionalProperties: true,
@@ -771,7 +771,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: overrides["red-team"] ?? "fable" }
+    { label: "red-team", phase: "Orthogonal Triad", schema: RED_TEAM_SCHEMA, model: overrides["red-team"] ?? "opus" }
   ),
 
   // Stage C — QA (test execution + shallow-test detection + contract compliance)

package/bin/model-selector.js

@@ -1,234 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * GSD-T Model Selector — surgical per-phase model tier assignment
- *
- * Replaces the v2.x "silent downgrade under context pressure" behavior with
- * declarative per-phase tier assignments. Callers ask `selectModel({phase, ...})`
- * and get back `{model, reason, escalation_hook}` — the tier decision is
- * deterministic, driven by the rules table below, and does NOT depend on
- * session context percentage.
- *
- * Contract: .gsd-t/contracts/model-selection-contract.md v1.0.0 (M35 T4)
- * Findings: .gsd-t/M35-advisor-findings.md (convention-based /advisor fallback)
- *
- * Zero external dependencies.
- */
-
-// ── 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;
-
-// ── Escalation hook block (convention-based /advisor fallback) ──────────────
-//
-// Per `.gsd-t/M35-advisor-findings.md`, Claude Code's native /advisor has no
-// programmable API at subagent scope. This block is injected into the subagent
-// prompt at declared escalation points on sonnet-tier phases where the
-// orchestrator has flagged a high-stakes sub-decision.
-//
-// Kept as a constant so all consumers (command files, advisor-integration.js,
-// M35-advisor-findings.md) reference the same canonical text.
-
-const ESCALATION_HOOK = [
-  "## Escalation Hook — /advisor convention-based fallback",
-  "",
-  "Before finalizing your answer for this phase, stop and consider:",
-  "1. Is this decision high-stakes? (architecture, contract design, security boundary,",
-  "   data-loss risk, cross-module refactor, adversarial QA verdict)",
-  "2. Would a more capable model produce a materially better answer?",
-  "3. Are you confident in the assumptions you're making?",
-  "",
-  "If YES to any of the above, do ONE of the following:",
-  "- Escalate internally: spend an extra reasoning pass re-examining the decision",
-  "  from first principles. Document the re-examination in your output.",
-  "- Spawn a nested opus subagent: use the Task tool with",
-  "  `subagent_type: \"general-purpose\"` and include `model: opus` in the spawn.",
-  "",
-  "Record in your output whether you escalated: set `ESCALATED_VIA_ADVISOR=true` or",
-  "`ESCALATED_VIA_ADVISOR=false` on a line by itself near the end of your report.",
-].join("\n");
-
-// ── Declarative phase rules table ───────────────────────────────────────────
-//
-// Each rule maps (phase, task_type) → tier. The first matching rule wins.
-// `task_type` is optional — when absent, the rule matches any task within
-// that phase. Order the rules from most-specific to least-specific.
-//
-// Tier assignments mirror `.gsd-t/M35-definition.md` Part B and the Model
-// Assignments section of the GSD-T global CLAUDE template:
-//   - haiku:  strictly mechanical — test runners, branch guards, file checks,
-//             JSON validation, no judgment
-//   - sonnet: routine code work — execute step 2, test-sync, doc-ripple wiring,
-//             quick fixes, integration wiring, debug fix-apply
-//   - opus:   high-stakes reasoning — partition, discuss, Red Team, verify
-//             judgment, debug root-cause, contract/architecture design
-
-const PHASE_RULES = Object.freeze([
-  // Phase: execute
-  { phase: "execute", task_type: "test_runner",    model: TIERS.HAIKU,  reason: "Mechanical test-suite runner — zero judgment" },
-  { phase: "execute", task_type: "branch_guard",   model: TIERS.HAIKU,  reason: "Mechanical branch-name check — zero judgment" },
-  { phase: "execute", task_type: "file_check",     model: TIERS.HAIKU,  reason: "Mechanical file-existence check — zero judgment" },
-  { phase: "execute", task_type: "qa",             model: TIERS.SONNET, reason: "QA evaluation needs judgment per M31 tier refinement" },
-  { phase: "execute", task_type: "red_team",       model: TIERS.OPUS,   reason: "Adversarial QA benefits most from top tier" },
-  { phase: "execute",                              model: TIERS.SONNET, reason: "Routine task execution — sonnet is the M35 default for routine work", hasEscalation: true },
-
-  // Phase: wave (the wave orchestrator itself)
-  { phase: "wave",                                 model: TIERS.SONNET, reason: "Wave orchestration dispatches per-phase subagents; the orchestrator itself is routine coordination", hasEscalation: true },
-
-  // Phase: quick
-  { phase: "quick", task_type: "test_runner",      model: TIERS.HAIKU,  reason: "Mechanical test-suite runner — zero judgment" },
-  { phase: "quick",                                model: TIERS.SONNET, reason: "Routine one-off task — sonnet default" },
-
-  // Phase: integrate
-  { phase: "integrate", task_type: "test_runner",  model: TIERS.HAIKU,  reason: "Mechanical integration test runner — zero judgment" },
-  { 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" },
-  // 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" },
-
-  // Phase: discuss — multi-perspective design exploration
-  { phase: "discuss",                              model: TIERS.OPUS,   reason: "Design exploration benefits from top-tier reasoning" },
-
-  // Phase: plan — task-list authoring
-  { phase: "plan",                                 model: TIERS.SONNET, reason: "Task decomposition is structured work — sonnet with escalation hook", hasEscalation: true },
-
-  // Phase: verify — final quality judgment before milestone complete
-  { phase: "verify",                               model: TIERS.OPUS,   reason: "Milestone verification is the final quality gate — high stakes" },
-
-  // Phase: test-sync — keeping tests aligned with code
-  { phase: "test-sync",                            model: TIERS.SONNET, reason: "Test alignment is routine refactoring work" },
-
-  // Phase: doc-ripple — downstream document updates
-  { phase: "doc-ripple",                           model: TIERS.SONNET, reason: "Documentation updates are routine prose editing" },
-
-  // Phase: red_team — explicit adversarial QA phase (separate from execute task_type)
-  { phase: "red_team",                             model: TIERS.OPUS,   reason: "Adversarial QA — always opus, the incentive is to find bugs" },
-
-  // Phase: qa — explicit standalone QA phase
-  { phase: "qa",                                   model: TIERS.SONNET, reason: "QA per M31 refinement — sonnet produces fewer false negatives than haiku" },
-]);
-
-// Complexity-signal overrides. If the caller provides `complexity_signals`,
-// these can bump a sonnet decision to opus regardless of phase rule.
-const COMPLEXITY_OVERRIDES = Object.freeze({
-  cross_module_refactor: TIERS.OPUS,
-  security_boundary:     TIERS.OPUS,
-  data_loss_risk:        TIERS.OPUS,
-  contract_design:       TIERS.OPUS,
-});
-
-// ── Public API ──────────────────────────────────────────────────────────────
-
-/**
- * Select the model tier for a subagent spawn.
- *
- * @param {object} args
- * @param {string} args.phase           — required; one of the phase names above
- * @param {string} [args.task_type]     — optional task_type for finer-grained rules
- * @param {string} [args.domain_type]   — optional, currently unused (reserved for future per-domain rules)
- * @param {object} [args.complexity_signals] — optional object, keys matching COMPLEXITY_OVERRIDES escalate sonnet→opus
- * @returns {{model: string, reason: string, escalation_hook: string|null}}
- */
-function selectModel(args) {
-  if (!args || typeof args !== "object") {
-    return {
-      model: DEFAULT_TIER,
-      reason: "No args provided — default to routine tier (sonnet)",
-      escalation_hook: null,
-    };
-  }
-
-  const { phase, task_type, complexity_signals } = args;
-
-  if (!phase || typeof phase !== "string") {
-    return {
-      model: DEFAULT_TIER,
-      reason: "No phase provided — default to routine tier (sonnet)",
-      escalation_hook: null,
-    };
-  }
-
-  // First pass: find the most-specific matching rule.
-  let matched = null;
-  for (const rule of PHASE_RULES) {
-    if (rule.phase !== phase) continue;
-    if (rule.task_type && rule.task_type !== task_type) continue;
-    matched = rule;
-    break;
-  }
-
-  if (!matched) {
-    return {
-      model: DEFAULT_TIER,
-      reason: `Unknown phase "${phase}" — fallback to routine tier (sonnet)`,
-      escalation_hook: null,
-    };
-  }
-
-  let model = matched.model;
-  let reason = matched.reason;
-
-  // Complexity-signal overrides: bump sonnet → opus if any flagged signal is truthy.
-  if (model === TIERS.SONNET && complexity_signals && typeof complexity_signals === "object") {
-    for (const key of Object.keys(complexity_signals)) {
-      if (!complexity_signals[key]) continue;
-      const override = COMPLEXITY_OVERRIDES[key];
-      if (override && override !== model) {
-        model = override;
-        reason = `${reason} (escalated to ${override} by complexity signal: ${key})`;
-        break;
-      }
-    }
-  }
-
-  // Escalation hook is only injected on sonnet phases flagged as high-stakes-adjacent.
-  // Haiku phases have no hook (mechanical, no judgment). Opus phases have no hook
-  // (already at top tier — nowhere to escalate).
-  let escalation_hook = null;
-  if (model === TIERS.SONNET && matched.hasEscalation) {
-    escalation_hook = ESCALATION_HOOK;
-  }
-
-  return { model, reason, escalation_hook };
-}
-
-/**
- * Return the canonical list of phase names the selector knows about.
- * Used by tests and documentation tooling to assert coverage.
- */
-function listPhases() {
-  const seen = new Set();
-  for (const rule of PHASE_RULES) seen.add(rule.phase);
-  return [...seen].sort();
-}
-
-module.exports = {
-  selectModel,
-  listPhases,
-  TIERS,
-  DEFAULT_TIER,
-  ESCALATION_HOOK,
-  PHASE_RULES,
-  COMPLEXITY_OVERRIDES,
-};