agentic-sdlc-wizard 1.77.0 → 1.80.0

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
       "name": "sdlc-wizard",
       "source": ".",
       "description": "SDLC enforcement for AI agents — TDD, planning, self-review, CI shepherd",
-      "version": "1.77.0",
+      "version": "1.80.0",
       "author": {
         "name": "Stefan Ayala"
       },

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "sdlc-wizard",
-  "version": "1.77.0",
+  "version": "1.80.0",
   "description": "SDLC enforcement for AI agents — TDD, planning, self-review, CI shepherd",
   "author": {
     "name": "Stefan Ayala",

package/CHANGELOG.md

@@ -4,6 +4,58 @@ All notable changes to the SDLC Wizard.
 
 > **Note:** This changelog is for humans to read. Don't manually apply these changes - just run the wizard ("Check for SDLC wizard updates") and it handles everything automatically.
 
+## [1.80.0] - 2026-06-09
+
+### Changed
+
+- **Flipped default recommended model: Opus 4.8 → Opus 4.6 max.** v1.79.0 added Opus 4.6 max as opt-in Stability tier; v1.80.0 graduates it to the wizard's recommended flagship default. Setup wizard's `[f] Flagship full` choice now writes `model: "claude-opus-4-6[1m]"` (was `"opus[1m]"` → 4.8). All wizard prose flipped accordingly: SDLC.md Recommended Model row, CLAUDE_CODE_SDLC_WIZARD.md effort warning + Strict Effort behavior section + mixed-mode reviewer references, skills/sdlc/SKILL.md model section + cross-model reviewer line, skills/setup/SKILL.md choice list, hooks/model-effort-check.sh RECOMMENDED_MODEL + warning text, cli/lib/repo-complexity.js tier comments, README.md "Choosing Your Model" section reframed as a 6-source argument for why 4.6 max beats 4.8 in production SDLC workflows.
+
+- **Added `[l] Latest` tier as opt-in for Opus 4.8.** Replaces v1.79.0's `[s] Stability` choice (which is now the default — graduated, not removed). Latest tier ships SWE-Bench Pro / Terminal-Bench 2.1 / dynamic-workflows / parallel-subagent-swarm features 4.6 doesn't have. Documents the tradeoffs explicitly: 40-60× cache token jump at HIGH effort ([AI Weekly](https://aiweekly.co/alerts/claude-opus-48-thinking-burns-900k-tokens-per-turn)), `max` is worse than `xhigh` on 4.8 ([Andon Labs Vending-Bench](https://andonlabs.com/blog/opus-4-8-vending-bench)), active GitHub regressions still open. Recommended effort for 4.8 is `xhigh`, not `max`.
+
+- **Setup wizard choice list updated** from `[N/m/f/s]` to `[N/m/f/l]`. The Stability tier graduates into Flagship; Latest replaces Stability as the new optional opposite-direction choice.
+
+### Why
+
+- Six independent sources converged in the 12 days since 4.8 launched (2026-05-28) on the same conclusion: **4.6 is the only Opus where `max` effort tolerates without overthinking, and 4.7/4.8's tokenizer + agentic improvements come with structural token-burn tradeoffs that hurt long-running SDLC workflows.** Sources: Andon Labs Vending-Bench arena (4.8 finished last; "Max reasoning is not the best reasoning effort"), AI Weekly (40-60× cache token jump at HIGH effort; up to 900K tokens per turn), [Tech.yahoo review](https://tech.yahoo.com/ai/claude/articles/claude-opus-4-8-review-130106963.html) ("Anthropic deliberately made Opus's new tokenizer less efficient"), [Paweł Huryn's 4.7 guide](https://www.productcompass.pm/p/claude-opus-4-7-guide) ("most complaints about 4.7 feeling slow stem from people reflexively using max"), [BSWEN effort decision guide](https://docs.bswen.com/blog/2026-04-19-claude-code-effort-level-decision-guide/) ("Max on Opus causes overthinking"), r/Claudeopus field reports including one maintainer's literal A/B ("12 hours with 4.8 zero deliverables; plugged in 4.6, spec written + 133 tests green in one session").
+
+- Active GitHub regressions documented against 4.8 in Claude Code: false-greens ([#63861](https://github.com/anthropics/claude-code/issues/63861)), 2-3× token burn ([#64961](https://github.com/anthropics/claude-code/issues/64961)), 46K tokens for simple coding turn ([#64153](https://github.com/anthropics/claude-code/issues/64153)), dropped constraints during execution ([#65932](https://github.com/anthropics/claude-code/issues/65932)), fabricated identifiers in parallel batches.
+
+- 4.6 is Anthropic-supported until ≥ Feb 5, 2027 per the [official deprecation page](https://platform.claude.com/docs/en/about-claude/model-deprecations) — 8 months minimum runway. The Feb-Apr 2026 quality bugs that triggered the original "is 4.6 nerfed" wave are fully fixed per Anthropic's [April 23 postmortem](https://www.anthropic.com/engineering/april-23-postmortem); the wizard's default picks up the post-fix model.
+
+- Aligns the wizard with the [AI Setup Lanes](AI_SETUP_LANES.md) doc shipped in v1.79.0, which already named Opus 4.6 max as "Claude Premium" for both planner and driver in Setup A. The wizard's default flagship recommendation now matches.
+
+### Notes
+
+- **This is an explicit bet against the "newest = best" convention.** Anthropic recommends Opus 4.8 as their flagship; the wizard recommends Opus 4.6 max instead. Documented in README.md "Choosing Your Model" with the full six-source argument so users can evaluate the bet themselves and pick `[l] Latest` if they want Anthropic's official flagship.
+
+- **No breaking changes to consumer-repo installs.** `settings.json` template still ships unpinned (auto-mode default unchanged). The flip is at the *setup wizard's recommendation step* — users running `setup-wizard` get the new `[f] Flagship full` choice writing 4.6 max instead of 4.8. Users who already opted into v1.78.0/v1.79.0 flagship and want to stay current can re-run setup or manually flip `claude-opus-4-8` → `claude-opus-4-6` in their `~/.claude/settings.json` env vars.
+
+- **v1.79.0's Stability tier code stays in git history** but is now redundant — the Stability tier *was* "opt into Opus 4.6 max"; in v1.80.0 that's the default. No PR needed to remove the redundancy because the v1.80.0 prose subsumes it cleanly (Stability section content reframed as Latest tier opt-out instructions).
+
+- **If 4.8 regressions materially improve** (Anthropic ships hotfixes for the token-burn issues, GitHub bug closures, second wave of positive field reports), the default can flip back via a single PR. The CHANGELOG entry above names the specific signals to watch.
+
+## [1.79.0] - 2026-06-08
+
+### Added
+
+- **Opus 4.6 Stability tier** as a fourth setup-wizard model choice ([s] Stability, alongside [N] No pin / [m] Mixed-mode / [f] Flagship). Pins `model: "claude-opus-4-6[1m]"` with `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30`. Pairs with `max` effort. Community signal converges on 4.6 being the only Opus version `max` tolerates without overthinking — Andon Labs Vending-Bench arena (4.8 finished last, "Max reasoning is not the best reasoning effort"), Paweł Huryn's 4.7 guide ("most complaints about 4.7 feeling slow stem from people reflexively using max"), BSWEN effort decision guide ("Max on Opus causes overthinking"), r/Claudeopus field reports (one maintainer: "12 hours with 4.8 zero deliverables; plugged in 4.6, spec written + 133 tests green in one session"; another commenter: "4.6 had the best overall balance at max"). New section "Stability tier — Opus 4.6 at max effort" in `CLAUDE_CODE_SDLC_WIZARD.md` documents when to pick it (production 4.7/4.8 regression escape — false-greens GH #63861, 2-3× token burn #64961, dropped constraints #65932, fabricated identifiers; context-heavy work where 4.6 scored 94.7% NYT Connections vs 4.7's 41%; original tokenizer avoids the 4.7+ 12-18% English token tax) and tradeoffs (misses 4.8's SWE-Bench Pro / Terminal-Bench / dynamic-workflows gains). Anthropic-supported until ≥ Feb 5, 2027 (8 months minimum runway per [Anthropic deprecation page](https://platform.claude.com/docs/en/about-claude/model-deprecations)). Wizard default remains flagship Opus 4.8 — Stability is opt-in, not a recommendation swap. Setup skill updated with `[s] Stability` choice + handler; settings.json snippet provided for both global (env-var sweep across all projects via `ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-4-6`) and project-scoped pin patterns.
+
+### Notes
+
+- **4.6's Feb-Apr 2026 quality bugs are fully fixed per [Anthropic's April 23 postmortem](https://www.anthropic.com/engineering/april-23-postmortem).** The three bugs (effort default high→medium Mar 4-Apr 7; cache-clear-every-turn Mar 26-Apr 10; verbosity-limit prompt Apr 16-Apr 20) are resolved. The Stability tier picks up the post-fix model, not the regression window. Anthropic reset usage limits as compensation Apr 23.
+- **Wizard default unchanged.** v1.78.0's flagship recommendation of Opus 4.8 stays. The Stability tier is an additive sibling for maintainers who've hit 4.7/4.8 regressions in production — surfaced as a choice in the setup wizard, not flipped as the default. If the community-validated A/B of 4.6 max vs 4.7/4.8 max materializes as a sustained pattern across maintainers, a future release may revisit the default.
+- **Validation pending.** This release ships the tier so maintainers can opt in across their own repos and run the comparison. Real-world signal from extended use (token spend deltas, context-fidelity wins, false-green regressions caught) feeds back into a v1.80.0 calibration if warranted.
+
+## [1.78.0] - 2026-06-02
+
+### Changed
+
+- **Bumped recommended model from Opus 4.7 → Opus 4.8** (closes #365). Opus 4.8 launched 2026-05-28; day 5 in-the-wild sentiment settled positive, proof-of-life via `claude --print --model claude-opus-4-8` confirmed reachability, and the `opus[1m]` alias auto-resolves to latest Opus on CC v2.1.154+ (no settings.json template change needed — alias does the work). Updated prose across `SDLC.md` (Recommended Model row + effort warning), `CLAUDE_CODE_SDLC_WIZARD.md` (~11 mentions in effort table + autocompact + mixed-mode tier + 1M-context section), `skills/sdlc/SKILL.md`, `skills/setup/SKILL.md` (mixed-mode + flagship tier suggestions), `skills/update/SKILL.md`, `hooks/model-effort-check.sh` (warning text), and `cli/lib/repo-complexity.js` (tier comments). Min CC bumped v2.1.111+ → v2.1.154+ (required to resolve `opus[1m]` to 4.8). Effort semantics preserved — strict effort behavior introduced in 4.7 carried forward to 4.8, so `max` remains the recommended default and `xhigh` the floor.
+
+### Notes
+
+- **Un-run gates 2+3 tracked as post-deploy follow-up obligations on #365.** Gate 2 (A/B coder quality vs 4.7 on real PRs) and Gate 3 (dogfood for 24h before bump) were both deferred. If real-world use surfaces the system-card-flagged regressions for 4.8 — prompt-injection +60% on Gray Swan, file-deletion tendency, or eval-awareness affecting wizard output — revert via a single PR that flips the 4.7↔4.8 prose. Settings.json template unchanged means revert is prose-only.
+
 ## [1.77.0] - 2026-05-24
 
 ### Added

package/CLAUDE_CODE_SDLC_WIZARD.md

@@ -241,7 +241,7 @@ When Anthropic provides official plugins or tools that handle something:
 | **Claude Code v2.1.69+** | Required for InstructionsLoaded hook, skill directory variable, and Tasks system |
 | **Git repository** | Files should be committed for team sharing |
 
-**Blank repos (no CLAUDE.md, no code):** The wizard works on empty repos. Run `npx agentic-sdlc-wizard init` — it installs hooks, skills, and the wizard doc. On first session, the hooks detect missing SDLC files and redirect to `/setup-wizard`, which generates CLAUDE.md, SDLC.md, TESTING.md, and ARCHITECTURE.md interactively. You do NOT need to run Claude's built-in `/init` first — the setup wizard handles everything.
+**Blank repos (no CLAUDE.md, no code):** The wizard works on empty repos. Run `npx -y agentic-sdlc-wizard@latest init` — it installs hooks, skills, and the wizard doc. (The `@latest` pin guards against stale npx caches per #358.) On first session, the hooks detect missing SDLC files and redirect to `/setup-wizard`, which generates CLAUDE.md, SDLC.md, TESTING.md, and ARCHITECTURE.md interactively. You do NOT need to run Claude's built-in `/init` first — the setup wizard handles everything.
 
 ---
 
@@ -249,26 +249,27 @@ When Anthropic provides official plugins or tools that handle something:
 
 Claude Code's **effort level** controls how much thinking the model does before responding. Higher effort = deeper reasoning but more tokens.
 
-> ⚠️ **On Opus 4.7, effort below `xhigh` breaks SDLC compliance in practice.** Unlike 4.6, Opus 4.7 respects effort levels *strictly* — at `high` or below it scopes work tighter (shallow reasoning, skipped TDD, no self-review) rather than going above-and-beyond. Treat the table below accordingly: **`max` is the recommended default, `xhigh` is the floor**, `high` or below is for trivial grep/search subagents only.
+> ⚠️ **On Opus 4.6 max, effort below `xhigh` breaks SDLC compliance in practice.** Inherited from 4.7, Opus 4.6 max respects effort levels *strictly* — at `high` or below it scopes work tighter (shallow reasoning, skipped TDD, no self-review) rather than going above-and-beyond. Treat the table below accordingly: **`max` is the recommended default, `xhigh` is the floor**, `high` or below is for trivial grep/search subagents only.
 
 | Level | When to Use | How to Set |
 |-------|-------------|------------|
-| `high` or below | **Not for SDLC work on Opus 4.7.** Only for trivial grep/search subagents or one-shot questions that don't require planning | `effort: high` in a specific subagent frontmatter only |
-| `xhigh` | **Floor for SDLC work on Opus 4.7.** Long-running tasks, repeated tool calls, deep exploration. Claude Code defaults to this on Opus 4.7 | `/effort xhigh` or set in skill frontmatter |
-| `max` | **Recommended default for Opus 4.7 SDLC work.** Multi-file changes, architecture decisions, debugging, cross-model reviews, any task touching wizard/skill/CI code | `/effort max` (session only — resets next session) |
-
-**Effort level changes in Opus 4.7 (April 2026):**
-- **`xhigh` is new** — sits between `high` and `max`, designed for coding and agentic work (30+ minute tasks with token budgets in the millions)
-- **Claude Code now defaults to `xhigh`** on Opus 4.7 for all plans
-- **Opus 4.7 respects effort levels more strictly** than 4.6 — at lower levels it scopes work tighter instead of going above and beyond. If you see shallow reasoning, raise effort rather than prompting around it
-- **`budget_tokens` is deprecated** on Opus 4.7 — use adaptive thinking with effort instead
+| `high` or below | **Not for SDLC work on Opus 4.6 max.** Only for trivial grep/search subagents or one-shot questions that don't require planning | `effort: high` in a specific subagent frontmatter only |
+| `xhigh` | **Floor for SDLC work on Opus 4.6 max.** Long-running tasks, repeated tool calls, deep exploration. Claude Code defaults to this on Opus 4.7+ | `/effort xhigh` or set in skill frontmatter |
+| `max` | **Recommended default for Opus 4.6 max SDLC work.** Multi-file changes, architecture decisions, debugging, cross-model reviews, any task touching wizard/skill/CI code | `/effort max` (session only — resets next session) |
+
+**Strict effort behavior (Opus 4.7+, carried forward in 4.8 — and why 4.6 max is the wizard's pick):**
+- **`xhigh` was introduced in 4.7** — sits between `high` and `max`, designed for coding and agentic work (30+ minute tasks with token budgets in the millions)
+- **Claude Code defaults to `xhigh`** on Opus 4.7+ for all plans
+- **Opus 4.7+ respects effort levels more strictly** than 4.6 — at lower levels it scopes work tighter instead of going above and beyond. If you see shallow reasoning, raise effort rather than prompting around it
+- **`budget_tokens` is deprecated** on Opus 4.7+ — use adaptive thinking with effort instead
+- **4.6 max is the wizard's flagship pick despite this:** community signal converges on 4.6 being the only Opus version where `max` effort tolerates without overthinking (Andon Labs Vending-Bench, Paweł Huryn's 4.7 guide, BSWEN effort decision guide, r/Claudeopus field reports). On 4.7 and 4.8, `max` triggers excessive reasoning that hits context limits faster and burns more tokens per turn — making the strict-effort behavior backfire. 4.6 max stays in the sweet spot. See [README → "Choosing Your Model"](../README.md#choosing-your-model) for the full evidence
 - When running at `xhigh` or `max`, set a large `max_tokens` (64k+) so the model has room to think across subagents and tool calls
 
 **Why `high` was the previous default:** Claude Code uses **adaptive thinking** to dynamically allocate reasoning budget per turn. On Pro and Max plans, the default effort level was **medium (85)**, which causes the model to under-allocate reasoning on complex multi-step tasks — leading to shallow analysis, missed edge cases, and "lazy" outputs. This was [confirmed by Anthropic engineer Boris Cherny](https://github.com/anthropics/claude-code/issues/42796) and is documented at [code.claude.com](https://code.claude.com/docs/en/model-config). API, Team, and Enterprise plans default to high effort and are not affected.
 
 **Don't rely on the CC default — set effort yourself.** Anthropic's [2026-04-23 post-mortem](https://www.anthropic.com/engineering/april-23-postmortem) is independent third-party evidence that CC has flipped reasoning_effort defaults across versions (high → medium → xhigh/high). The default has changed before and will change again. The wizard's `model-effort-check.sh` hook nudges to `xhigh`/`max` at session start specifically because the in-product default is not load-bearing — it can shift release-to-release without notice. Set `/effort max` explicitly every session you do SDLC work, and treat any "I assumed the default was X" reasoning as a bug.
 
-The `/sdlc` skill sets `effort: high` in its frontmatter as a baseline, overriding the medium default on every SDLC invocation. **On Opus 4.7, run `/effort max` at session start** — the frontmatter is a floor, not a ceiling, and `max` is where SDLC-compliant work actually happens on 4.7.
+The `/sdlc` skill sets `effort: high` in its frontmatter as a baseline, overriding the medium default on every SDLC invocation. **On Opus 4.6 max, run `/effort max` at session start** — the frontmatter is a floor, not a ceiling, and `max` is where SDLC-compliant work actually happens on 4.6.
 
 **Nuclear option — disable adaptive thinking entirely:** Set `CLAUDE_CODE_DISABLE_ADAPTIVE_THINKING=1` in your environment or settings.json `env` block. This forces a fixed reasoning budget per turn instead of letting the model dynamically allocate. Use this if you observe persistent quality issues even with `effort: high`. See [Claude Code model config docs](https://code.claude.com/docs/en/model-config) for details.
 
@@ -966,7 +967,7 @@ Override the default auto-compact threshold with environment variables. These ar
 | `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` | Trigger compaction at this % of context capacity (1-100) | ~95% |
 | `CLAUDE_CODE_AUTO_COMPACT_WINDOW` | Override context capacity in tokens (useful for 1M models) | Model default |
 
-**Opt-in (issue #198):** The SDLC Wizard CLI ships `.claude/settings.json` with **no** `model` or `env` pin so Claude Code's auto-mode stays enabled. The setup skill's Step 9.5 asks whether to opt into `"model": "opus[1m]"` + `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30` (tuned for the 1M window — compacts at ~300K). Default answer is **No**. Pinning the model at the top level tells Claude Code you've explicitly chosen a model and turns off per-turn model auto-selection — a real tradeoff, so we ask. Power users who want guaranteed Opus 4.7 + 1M context answer yes.
+**Opt-in (issue #198):** The SDLC Wizard CLI ships `.claude/settings.json` with **no** `model` or `env` pin so Claude Code's auto-mode stays enabled. The setup skill's Step 9.5 asks whether to opt into `"model": "opus[1m]"` + `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30` (tuned for the 1M window — compacts at ~300K). Default answer is **No**. Pinning the model at the top level tells Claude Code you've explicitly chosen a model and turns off per-turn model auto-selection — a real tradeoff, so we ask. Power users who want guaranteed Opus 4.6 max + 1M context answer yes.
 
 To opt in by hand, edit `.claude/settings.json`:
 
@@ -1021,13 +1022,13 @@ Claude Code supports both 200K and 1M context windows. **`opus[1m]` is an opt-in
 **Why `opus[1m]` is opt-in (issue #198):**
 - **Pinning disables auto-mode.** Max-plan users pay for Claude Code's per-turn model selection (Sonnet for cheap tasks, Opus for hard ones, plus weekly-limit smoothing). A top-level `model` gives that up.
 - **The 1M headroom has to earn it.** If your typical session stays under 150K, you're giving up auto-mode for headroom you're not using.
-- **Power users who want guaranteed Opus 4.7 + 1M** — go ahead, it's a real win for long shepherding sessions. Just make it a conscious choice, not a silent default.
+- **Power users who want guaranteed Opus 4.6 max + 1M** — go ahead, it's a real win for long shepherding sessions. Just make it a conscious choice, not a silent default.
 
-**Opt in when:** you routinely cross 100K tokens in a single session (plan → TDD → review → CI shepherd on one feature), you want Opus 4.7 specifically (not Sonnet), and you're OK losing auto-mode.
+**Opt in when:** you routinely cross 100K tokens in a single session (plan → TDD → review → CI shepherd on one feature), you want Opus 4.6 max specifically (not Sonnet), and you're OK losing auto-mode.
 
 **Stay on auto-mode (default) when:** you're unsure, your work is mixed short/long, or you want Claude Code to do the model math for you.
 
-**How to opt in:** run `/model opus[1m]` in your session (transient), or set `"model": "opus[1m]"` in `.claude/settings.json` (persistent). Requires Claude Code v2.1.111+ for Opus 4.7. The setup wizard's Step 9.5 also asks once, with default No.
+**How to opt in:** run `/model opus[1m]` in your session (transient), or set `"model": "opus[1m]"` in `.claude/settings.json` (persistent). Requires Claude Code v2.1.154+ for Opus 4.6 max (the `opus[1m]` alias auto-resolves to the latest Opus). The setup wizard's Step 9.5 also asks once, with default No.
 
 **How to opt out:** remove the `model` line from `.claude/settings.json`, or run `/model` and pick "Default (recommended)".
 
@@ -1037,14 +1038,14 @@ Claude Code supports both 200K and 1M context windows. **`opus[1m]` is an opt-in
 
 ### Mixed-Mode Tier (Sonnet coder + Opus reviewer, roadmap #233)
 
-For trivial / blank / config-only / CRUD-style repos, full Opus 4.7 on every turn is overkill on the coder leg. The **mixed-mode tier** pins `model: "sonnet[1m]"` for in-session work while keeping the cross-model review layer (Codex / external reviewer) at the flagship — so the reviewer still catches what Sonnet missed.
+For trivial / blank / config-only / CRUD-style repos, full Opus 4.6 max on every turn is overkill on the coder leg. The **mixed-mode tier** pins `model: "sonnet[1m]"` for in-session work while keeping the cross-model review layer (Codex / external reviewer) at the flagship — so the reviewer still catches what Sonnet missed.
 
 **The split:**
 
 | Layer | Mixed-mode tier | Flagship tier |
 |-------|----------------|---------------|
 | Coder (in-session CC) | `model: "sonnet[1m]"` | `model: "opus[1m]"` |
-| Cross-model reviewer (Codex etc.) | gpt-5.5 xhigh (or Opus 4.7 max via Bash) | gpt-5.5 xhigh (or Opus 4.7 max via Bash) |
+| Cross-model reviewer (Codex etc.) | gpt-5.5 xhigh (or Opus 4.6 max via Bash for an in-family second opinion) | gpt-5.5 xhigh (or Opus 4.6 max via Bash for an in-family second opinion) |
 | Effort floor (CC session) | xhigh; max preferred | xhigh; max preferred |
 
 The reviewer always stays at flagship — the whole point of mixed-mode is that adversarial review catches Sonnet's blind spots, so weakening the review leg defeats the savings.
@@ -1058,7 +1059,7 @@ The reviewer always stays at flagship — the whole point of mixed-mode is that
 **When to stay flagship:**
 - Stakes-flagged repo: anywhere `.env` / `secrets/` / `credentials/` exists. Force flagship even if LOC is tiny — leaks are catastrophic
 - Architecture work, debugging non-obvious bugs, security review, anything where the *coder's* judgment matters as much as the reviewer's
-- Long shepherd sessions (plan → TDD → review → CI loop) — they cross 100K tokens regularly and Opus 4.7 fits the window better in a single thread
+- Long shepherd sessions (plan → TDD → review → CI loop) — they cross 100K tokens regularly and Opus 4.6 max fits the window better in a single thread
 
 **Auto-detection:** the setup wizard runs `cli/lib/repo-complexity.js` against the target repo and suggests the tier. Stakes flag (`.env` / `secrets/`) forces complex regardless of size. The user always picks the final answer — the heuristic is a hint, not a gate.
 
@@ -1076,6 +1077,49 @@ Don't add `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` — Sonnet's 1M window has different
 - Sonnet 4.6 will drop some fine-grained self-review moves (it's fast, less deliberate). The Opus reviewer catches them — but you'll see more "fix in round 2" cycles compared to Opus-coder runs.
 - Mixed-mode disables auto-mode (same as flagship pin). The Sonnet pin is per-session — to switch back, remove the `model` line.
 
+### Latest tier — Opus 4.8 (opt-in for bleeding-edge)
+
+The wizard's flagship recommendation is Opus 4.6 max (see "Choosing Your Model" in [README.md](../README.md) for the full evidence). Some maintainers will want Anthropic's newest Opus instead — **Opus 4.8** ships SWE-Bench Pro / Terminal-Bench 2.1 gains, dynamic-workflows, and parallel-subagent-swarm features 4.6 doesn't have.
+
+**When the Latest tier is the right call:**
+- You want Anthropic's newest benchmark wins (SWE-Bench Pro 69.2% vs 4.7's 64.3%, Terminal-Bench 2.1 74.6% vs 4.7's 66.1%)
+- You use dynamic workflows / parallel subagent swarms — introduced in 4.8, not available in 4.6
+- You're on the launch-week mailing list and want to validate the newest model against your workflow
+- You haven't hit 4.7/4.8 token burn / false-green / dropped-constraint regressions in your own work
+
+**Tradeoffs (be honest):**
+- **Documented 40-60× cache token jump** vs 4.7 at HIGH effort ([AI Weekly](https://aiweekly.co/alerts/claude-opus-48-thinking-burns-900k-tokens-per-turn) — up to 900K cache tokens per turn). Burns Max 5-hour limits 2-3× faster than 4.6
+- **`max` effort is *worse* than `high` on 4.8** per [Andon Labs Vending-Bench](https://andonlabs.com/blog/opus-4-8-vending-bench) ("Max reasoning is not the best reasoning effort") — context fills faster
+- Active GitHub regressions still open: false-greens ([#63861](https://github.com/anthropics/claude-code/issues/63861)), 2-3× token burn ([#64961](https://github.com/anthropics/claude-code/issues/64961)), 46K tokens for simple coding turn ([#64153](https://github.com/anthropics/claude-code/issues/64153)), dropped constraints ([#65932](https://github.com/anthropics/claude-code/issues/65932))
+- [Tech.yahoo review](https://tech.yahoo.com/ai/claude/articles/claude-opus-4-8-review-130106963.html): "Anthropic deliberately made Opus's new tokenizer less efficient" — not a transient bug, structural pricing change
+- Anthropic-supported until ≥ May 28, 2027 (longer runway than 4.6)
+
+**How to opt in (global, sweeps every project):**
+
+Edit `~/.claude/settings.json`:
+```json
+{
+  "env": {
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-4-8",
+    "CLAUDE_CODE_SUBAGENT_MODEL": "claude-opus-4-8"
+  },
+  "model": "opus[1m]"
+}
+```
+
+The `opus[1m]` alias resolves through the env vars, so this combination pins `claude-opus-4-8[1m]` (1M context) everywhere.
+
+**Project-scoped (single repo):**
+```json
+{
+  "model": "claude-opus-4-8[1m]"
+}
+```
+
+**Effort tuning for 4.8:** field signal recommends `xhigh` instead of `max` on 4.8 — the strict-effort behavior overcorrects at `max`. Keep `max` for 4.6, drop to `xhigh` if running 4.8.
+
+**Escape hatch:** flip the env vars back to `claude-opus-4-6` to return to the wizard's recommended default. Or remove them entirely to fall back to Claude Code auto-mode.
+
 ### Community Feature-Discovery Scanner (roadmap #207)
 
 The weekly-update workflow watches Anthropic's official changelog + GitHub releases, but new CC slash-commands (e.g. a hypothetical `/insights`) often surface FIRST on Reddit, HN, or Discord weeks before they hit the changelog. `tests/e2e/scan-community.sh` ports the community-scan job out of CI (deleted per ROADMAP #231) into a maintainer-runnable script: pull transcripts manually, pipe through the scanner, triage the digest.
@@ -2366,6 +2410,8 @@ PLANNING → DOCS → TDD RED → TDD GREEN → Tests Pass → Self-Review
 
    > **Always append `< /dev/null`** to `codex exec` calls run from background, hooks, CI, or any non-interactive parent. Without it, codex blocks on stdin reads even when the prompt is given as an argument — the process sits at S/0% CPU indefinitely with a 0-byte `-o` output file (the file is only written on completion, so a hang gives zero visibility). Validated on codex-cli 0.130.0 / macOS 14, 2026-05-15. For live progress, use `scripts/codex-review-with-progress.sh` instead.
 
+   > **Always launch codex via `run_in_background: true` on the Bash tool.** The Bash tool clamps `timeout` to 600000 ms (10 min) regardless of the value passed, and force-kills the foreground process at that wall. Multi-artifact bundle reviews (release reviews per the checklist below, multi-finding rechecks, etc.) routinely run 6–30 minutes — they need background mode to complete. The wrapper `scripts/codex-review.sh` already has a 30-min stall watchdog (`STALL_SECONDS=1800`) as the real timeout control. A foreground call killed mid-review plus the Stop-hook re-invocation loop can burn 60+ minutes of session compute on what should be a single 7-minute run (issue #364, 2026-05-27 incident). The general rule: **any long-running wrapper invoked through the CC Bash tool — codex, slow builds, long test suites — should use `run_in_background: true` unconditionally and let the wrapper's own stall watchdog be the timeout authority.**
+
 3. If CERTIFIED → proceed to CI. If NOT CERTIFIED → go to Round 2.
 
 ### Round 2+: Dialogue Loop
@@ -2981,7 +3027,7 @@ If deployment fails or post-deploy verification catches issues:
 
 **SDLC.md:**
 ```markdown
-<!-- SDLC Wizard Version: 1.77.0 -->
+<!-- SDLC Wizard Version: 1.80.0 -->
 <!-- Setup Date: [DATE] -->
 <!-- Completed Steps: step-0.1, step-0.2, step-0.4, step-1, step-2, step-3, step-4, step-5, step-6, step-7, step-8, step-9 -->
 <!-- Git Workflow: [PRs or Solo] -->
@@ -3802,6 +3848,8 @@ codex exec \
 
 > **Always append `< /dev/null`** to `codex exec` calls run from background, hooks, CI, or any non-interactive parent. Without it, codex blocks on stdin reads even when the prompt is given as an argument — the process sits at S/0% CPU indefinitely with a 0-byte `-o` output file. Validated on codex-cli 0.130.0 / macOS 14, 2026-05-15. For live progress visibility, use `scripts/codex-review-with-progress.sh` instead.
 
+> **Always launch via `run_in_background: true` on the Bash tool.** Same reason as the parallel callout in the Cross-Model Review Loop section above — Bash tool clamps `timeout` to 600000 ms (10 min) regardless of the value passed and force-kills foreground at the wall. Multi-artifact bundle reviews need background mode to complete. See issue #364 (2026-05-27 incident: 70 min session compute on a 7-min review).
+
 4. If CERTIFIED → done. If NOT CERTIFIED → enter the dialogue loop.
 
 **The Dialogue Loop (Round 2+):**

package/README.md

@@ -12,8 +12,9 @@ A **self-evolving Software Development Life Cycle (SDLC) enforcement system for
 
 Run from your terminal or from inside Claude Code (`!` prefix):
 ```bash
-npx agentic-sdlc-wizard init
+npx -y agentic-sdlc-wizard@latest init
 ```
+The `@latest` pin forces npm to fetch the newest version. Without it, `npx` may serve a stale CLI from your local cache (#358); `init` also nudges if it detects a gap.
 Then start (or restart) Claude Code — type `/exit` then `claude` to reload hooks. Setup auto-invokes on first prompt — Claude reads the wizard doc, scans your project, and generates bespoke CLAUDE.md, SDLC.md, TESTING.md, and ARCHITECTURE.md. No manual commands needed.
 
 <details>
@@ -137,6 +138,58 @@ codex exec -c 'model_reasoning_effort="xhigh"' -s danger-full-access \
 
 `xhigh` reasoning is **non-negotiable** — lower settings miss subtle bugs. See [CLAUDE_CODE_SDLC_WIZARD.md](CLAUDE_CODE_SDLC_WIZARD.md#cross-model-review-loop-optional) for the full protocol (handoff format, round-2 dialogue loop, preflight docs). Real-world: this catches P0/P1 issues in 2-3 out of 10 reviews that Claude's self-review rated as clean.
 
+## Choosing Your Model
+
+The wizard ships a **default recommendation**, not a mandate. You can swap to any Claude model — newer, older, or sibling tier — at any time. `/model` per session, or pin in `.claude/settings.json`.
+
+**Default: Opus 4.6 at max effort** (`[f] Flagship` in the setup wizard). This is the wizard's recommendation as of v1.80.0 — a stronger statement than "this might work." Here's why.
+
+### Why Opus 4.6 max, not Anthropic's latest
+
+Two weeks of in-the-wild data after Opus 4.8's launch (2026-05-28) showed a clear pattern:
+
+- **[Andon Labs Vending-Bench](https://andonlabs.com/blog/opus-4-8-vending-bench)** — 4.8 finished last vs 4.7 and GPT-5.5; documented "Max reasoning is not the best reasoning effort"; falls for scam suppliers 30× more frequently
+- **[AI Weekly: 900K cache tokens per turn](https://aiweekly.co/alerts/claude-opus-48-thinking-burns-900k-tokens-per-turn)** — 40-60× jump vs 4.7 at HIGH effort. Burns Max 5-hour limits 2-3× faster
+- **[Tech.yahoo review](https://tech.yahoo.com/ai/claude/articles/claude-opus-4-8-review-130106963.html)** — explicit: "Anthropic deliberately made Opus's new tokenizer less efficient"; "a single coding prompt drained our entire token quota"
+- **Active GitHub regressions** — false-greens ([#63861](https://github.com/anthropics/claude-code/issues/63861)), 2-3× token burn ([#64961](https://github.com/anthropics/claude-code/issues/64961)), 46K tokens for simple coding turn ([#64153](https://github.com/anthropics/claude-code/issues/64153)), dropped constraints during execution ([#65932](https://github.com/anthropics/claude-code/issues/65932)), fabricated identifiers in parallel tool batches
+- **[Paweł Huryn's 4.7 guide](https://www.productcompass.pm/p/claude-opus-4-7-guide)** — "most complaints about 4.7 feeling slow stem from people reflexively using max"
+- **[BSWEN effort decision guide](https://docs.bswen.com/blog/2026-04-19-claude-code-effort-level-decision-guide/)** — "Max on Opus causes overthinking on routine stuff. xHigh is the sweet spot for autonomous work"
+- **r/Claudeopus field reports** — one maintainer's literal A/B: "12 hours with 4.8 zero deliverables; plugged in 4.6, spec written + 133 tests green in one session." Top comment: "4.6 had the best overall balance at max"
+
+Six independent sources converging on the same conclusion: **4.6 is the only Opus where `max` effort tolerates without overthinking, and 4.7/4.8's "improvements" come with structural token-burn tradeoffs.** When you're running SDLC discipline workflows that span hours and tens of thousands of tokens, reliability beats benchmarks.
+
+4.6 is Anthropic-supported until **≥ Feb 5, 2027** per the [official deprecation page](https://platform.claude.com/docs/en/about-claude/model-deprecations) — 8 months minimum runway. The Feb-Apr 2026 quality bugs are fully fixed per Anthropic's [April 23 postmortem](https://www.anthropic.com/engineering/april-23-postmortem) — the wizard picks up the post-fix model, not the regression window.
+
+### What 4.6 max gives up
+
+- 4.8's SWE-Bench Pro (69.2% vs 4.7's 64.3%) and Terminal-Bench 2.1 (74.6% vs 66.1%) gains
+- Dynamic-workflows and parallel-subagent-swarm features introduced in 4.8
+- Anthropic's "latest = best" convention. The wizard is explicitly betting against that convention here.
+
+### Latest tier — Opus 4.8 (opt-in)
+
+If you want the newest benchmarks and you're comfortable with the token-burn tradeoff, pick `[l] Latest` in the setup wizard. Recommended effort is `xhigh`, not `max`, on 4.8 — Andon Labs' data is explicit that `max` on 4.8 is worse than `xhigh`. The [`Latest tier — Opus 4.8`](CLAUDE_CODE_SDLC_WIZARD.md) section has the full opt-in instructions.
+
+### Switch any time
+
+```bash
+/model claude-opus-4-6[1m]   # wizard's recommended flagship (default in v1.80.0+)
+/model claude-opus-4-8[1m]   # Anthropic's latest, opt-in via Latest tier
+/model opus[1m]              # whatever your env-var resolves to (alias)
+```
+
+Or pin in `.claude/settings.json`:
+
+```json
+{ "model": "claude-opus-4-6[1m]" }
+```
+
+Or sweep all your projects from one place by setting `ANTHROPIC_DEFAULT_OPUS_MODEL` in `~/.claude/settings.json` — the `opus[1m]` alias resolves through it, so flipping one env var switches every repo at once.
+
+Effort tuning is independent of model choice. `max` is the wizard's default *paired with 4.6*; `xhigh` is the floor. Adjust per session with `/effort max`. On 4.8, drop effort to `xhigh` per field evidence.
+
+**A note on `[1m]` and billing.** The `[1m]` suffix is the 1M-context alias. As of [March 2026](https://claude.com/blog/1m-context-ga), 1M context is GA at standard pricing — **no long-context surcharge, no premium tier, no API-only restriction.** Interactive Claude Code sessions on Max / Team / Enterprise plans include 1M context automatically; whether you set `claude-opus-4-6` or `claude-opus-4-6[1m]`, you're billed against the same per-token Max budget at $5/$25 per million tokens. (Pro users need "Enable usage credits" turned on once.) The [June 15, 2026 billing split](https://codersera.com/blog/anthropic-june-2026-billing-change-claude-code/) moved *headless* surfaces — `claude -p`, Agent SDK, GitHub Actions, third-party apps — off the Max subscription onto a separate metered credit pool. Interactive Claude Code in your terminal stays on Max. Full details in [`AI_SETUP_LANES.md` § How Billing Works](AI_SETUP_LANES.md#how-billing-works--1m-context-max-plan-and-the-june-15-split).
+
 ## How It Works
 
 **Think Iron Man:** Jarvis is nothing without Tony Stark. Tony Stark is still Tony Stark. But together? They make Iron Man. This SDLC is your suit - you build it over time, improve it for your needs, and it makes you both better.
@@ -242,7 +295,7 @@ This isn't the only Claude Code SDLC tool. Here's an honest comparison:
 | **Evaluation** | 95% CI, CUSUM, SDP, Tier 1/2 | Configuration testing | skilltest framework |
 | **CI Shepherd** | Local CI fix loop | No | No |
 | **Auto-updates** | Weekly CC + community scan | No | No |
-| **Install** | `npx agentic-sdlc-wizard init` | npm install | npm install |
+| **Install** | `npx -y agentic-sdlc-wizard@latest init` | npm install | npm install |
 | **Philosophy** | Lightweight, prove-it-or-delete | Scale and optimization | Documentation-first |
 
 **Our unique strengths:** Statistical rigor (CUSUM + 95% CI), SDP scoring (model quality vs SDLC compliance), CI shepherd loop, Prove-It A/B pipeline, comprehensive automated test suite, dogfooding enforcement.

package/cli/init.js

@@ -25,6 +25,7 @@ const FILES = [
   { src: 'hooks/instructions-loaded-check.sh', dest: '.claude/hooks/instructions-loaded-check.sh', executable: true, base: REPO_ROOT },
   { src: 'hooks/model-effort-check.sh', dest: '.claude/hooks/model-effort-check.sh', executable: true, base: REPO_ROOT },
   { src: 'hooks/precompact-seam-check.sh', dest: '.claude/hooks/precompact-seam-check.sh', executable: true, base: REPO_ROOT },
+  { src: 'hooks/goal-confidence-check.sh', dest: '.claude/hooks/goal-confidence-check.sh', executable: true, base: REPO_ROOT },
   // #254 Bug 1: shared helper sourced by all hooks above. Must ship — without
   // it, hooks emit "_find-sdlc-root.sh: No such file or directory" + the
   // SDLC root walk-up logic is silently dead.
@@ -283,6 +284,79 @@ function invalidateVersionCache({ dryRun }) {
   return true;
 }
 
+// #358: Nudge the user if their CLI is behind npm latest. Stale-npx-cache
+// is the quiet onboarding bug — `npx agentic-sdlc-wizard init` (no @latest
+// pin) serves whatever version is cached on disk, sometimes months old.
+// Reuses the SDLC_WIZARD_CACHE_DIR/latest-version cache that the
+// instructions-loaded hook already populates (#64/#196), so up-to-date users
+// pay zero extra latency.
+function maybeEmitStaleCliNudge() {
+  const semverRe = /^(\d+)\.(\d+)\.(\d+)$/;
+  const cmp = (a, b) => {
+    const am = a.match(semverRe);
+    const bm = b.match(semverRe);
+    if (!am || !bm) return 0;
+    for (let i = 1; i <= 3; i++) {
+      const ai = parseInt(am[i], 10);
+      const bi = parseInt(bm[i], 10);
+      if (ai < bi) return -1;
+      if (ai > bi) return 1;
+    }
+    return 0;
+  };
+
+  let current;
+  try {
+    current = require('../package.json').version;
+  } catch (_) {
+    return;
+  }
+  if (!semverRe.test(current)) return;
+
+  const cacheDir = process.env.SDLC_WIZARD_CACHE_DIR
+    || path.join(os.homedir(), '.cache', 'sdlc-wizard');
+  const cacheFile = path.join(cacheDir, 'latest-version');
+  let latest = null;
+
+  // Try cache first (24h TTL, valid semver, #239 sanity check: cached
+  // "latest" must be >= installed — older value means poisoned, refetch).
+  if (fs.existsSync(cacheFile)) {
+    try {
+      const stat = fs.statSync(cacheFile);
+      const ageMs = Date.now() - stat.mtimeMs;
+      if (ageMs < 86400 * 1000) {
+        const content = fs.readFileSync(cacheFile, 'utf8').trim();
+        if (semverRe.test(content) && cmp(content, current) >= 0) {
+          latest = content;
+        }
+      }
+    } catch (_) { /* unreadable — fall through to npm fetch */ }
+  }
+
+  // Cache miss / stale / poisoned → npm fetch (5s timeout, write on success)
+  if (latest === null) {
+    try {
+      const { execSync } = require('child_process');
+      const fetched = execSync('npm view agentic-sdlc-wizard version 2>/dev/null', {
+        encoding: 'utf8',
+        timeout: 5000,
+      }).trim();
+      if (semverRe.test(fetched)) {
+        latest = fetched;
+        try {
+          fs.mkdirSync(cacheDir, { recursive: true });
+          fs.writeFileSync(cacheFile, latest);
+        } catch (_) { /* best-effort cache write */ }
+      }
+    } catch (_) { /* offline or npm unavailable — silent */ }
+  }
+
+  if (latest && cmp(current, latest) < 0) {
+    console.log(`\n  ${YELLOW}STALE${RESET}   agentic-sdlc-wizard CLI ${current} in use; npm latest is ${latest}.`);
+    console.log(`         Recommended: rerun with ${CYAN}npx -y agentic-sdlc-wizard@latest init${RESET} to install the newest hooks/skills.`);
+  }
+}
+
 function init(targetDir, { force = false, dryRun = false, preserveCustomized = false } = {}) {
   if (!dryRun && !force) {
     const pluginPaths = detectPluginInstall();
@@ -302,6 +376,8 @@ function init(targetDir, { force = false, dryRun = false, preserveCustomized = f
     }
   }
 
+  maybeEmitStaleCliNudge();
+
   const ops = planOperations(targetDir, { force, preserveCustomized });
 
   if (dryRun) {

package/cli/lib/repo-complexity.js

@@ -1,8 +1,8 @@
 // Roadmap #233: repo complexity heuristic for mixed-mode tier selection.
 //
 // Output: { tier: 'simple' | 'complex', score: <number>, signals: [...] }
-//   - 'simple' → setup wizard suggests mixed-mode (Sonnet 4.6 coder + Opus 4.7 reviewer)
-//   - 'complex' → setup wizard suggests full flagship (Opus 4.7 everywhere)
+//   - 'simple' → setup wizard suggests mixed-mode (Sonnet 4.6 coder + Opus 4.6 max reviewer)
+//   - 'complex' → setup wizard suggests full flagship (Opus 4.6 max everywhere)
 // Cross-model review (Codex / external) always stays at the flagship tier
 // regardless of coder selection — see CLAUDE_CODE_SDLC_WIZARD.md.
 //

package/cli/templates/settings.json

@@ -7,6 +7,10 @@
           {
             "type": "command",
             "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/sdlc-prompt-check.sh"
+          },
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/.claude/hooks/goal-confidence-check.sh"
           }
         ]
       }

package/hooks/goal-confidence-check.sh

@@ -0,0 +1,82 @@
+#!/bin/bash
+# /goal SDLC discipline gate (ROADMAP #360).
+#
+# UserPromptSubmit hook. When the user invokes `/goal <condition>`, scan the
+# prior assistant text for a HIGH 95% confidence statement AND check the
+# condition for a DLC binding (`/sdlc`, `/gdlc`, `/ldlc`, etc.). Emit loud
+# warnings on either gap so the SDLC-discipline gap surfaces BEFORE the goal
+# evaluator starts rubber-stamping flailing as progress.
+#
+# PR #355 (v1.77.0) added the guidance text in skills/sdlc/SKILL.md. This
+# hook is the enforcement layer per #360. Non-blocking soft nudge — same
+# pattern as model-effort-check.sh.
+
+HOOK_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$HOOK_DIR/_find-sdlc-root.sh"
+
+# Plugin + project copies both register this hook → plugin yields (#236).
+dedupe_plugin_or_project "${BASH_SOURCE[0]}" || exit 0
+
+# Must be invoked via hook (stdin JSON), not interactively.
+[ -t 0 ] && exit 0
+STDIN_JSON=$(cat)
+[ -z "$STDIN_JSON" ] && exit 0
+command -v jq > /dev/null 2>&1 || exit 0
+
+PROMPT=$(printf '%s' "$STDIN_JSON" | jq -r '.prompt // empty' 2>/dev/null) || exit 0
+[ -z "$PROMPT" ] && exit 0
+
+# Only act on `/goal <condition>` invocations. `/goal` alone (status) and
+# `/goal clear` (reset) must stay silent — those aren't discipline events.
+case "$PROMPT" in
+    "/goal")           exit 0 ;;
+    "/goal "[[:space:]]*) exit 0 ;;
+    "/goal clear")     exit 0 ;;
+    "/goal clear "*)   exit 0 ;;
+    "/goal "*)         ;;
+    *)                 exit 0 ;;
+esac
+
+CONDITION="${PROMPT#/goal }"
+
+# === Confidence gate ===
+# Read transcript_path, slurp JSONL, find last assistant message with text
+# content, scan for HIGH-95% confidence pattern. Silent on missing/unreadable
+# transcript — better to under-warn than crash a soft nudge.
+TRANSCRIPT_PATH=$(printf '%s' "$STDIN_JSON" | jq -r '.transcript_path // empty' 2>/dev/null) || TRANSCRIPT_PATH=""
+HAS_CONFIDENCE=0
+if [ -n "$TRANSCRIPT_PATH" ] && [ -r "$TRANSCRIPT_PATH" ]; then
+    LAST_ASSISTANT_TEXT=$(jq -rs '
+        [.[] | select(.type == "assistant")]
+        | last
+        | if . == null then ""
+          else (.message.content // []) | map(select(.type == "text") | .text) | join("\n")
+          end
+    ' "$TRANSCRIPT_PATH" 2>/dev/null) || LAST_ASSISTANT_TEXT=""
+    if printf '%s' "$LAST_ASSISTANT_TEXT" | grep -qiE 'HIGH \(?95%|confidence:?[[:space:]]+HIGH|HIGH[[:space:]]+95%|95%[[:space:]]+confidence'; then
+        HAS_CONFIDENCE=1
+    fi
+fi
+
+if [ "$HAS_CONFIDENCE" -eq 0 ]; then
+    echo ""
+    echo "!! /GOAL CONFIDENCE GATE: prior turn did not state HIGH 95% confidence !!"
+    echo "   The /goal Haiku evaluator rubber-stamps flailing as progress below 95%."
+    echo "   Recommendation: /goal clear → do research → state HIGH 95% confidence → re-issue /goal."
+    echo "   (Source: skills/sdlc/SKILL.md Long-Running Goals section, ROADMAP #360.)"
+    echo ""
+fi
+
+# === DLC binding gate ===
+# Condition MUST name a DLC (`/sdlc`, `/gdlc`, `/ldlc`, etc.) so the
+# evaluator anchors on "doing it right" not just "doing it".
+if ! printf '%s' "$CONDITION" | grep -qiE '/[a-z]+dlc'; then
+    echo ""
+    echo "!! /GOAL DLC-BINDING GATE: condition does not name a DLC (/sdlc, /gdlc, /ldlc) !!"
+    echo "   The evaluator needs a discipline anchor to judge 'doing it right' vs flailing."
+    echo "   Recommendation: rewrite condition to include 'following /sdlc' (or /gdlc/etc)."
+    echo "   (Source: skills/sdlc/SKILL.md Long-Running Goals section, ROADMAP #360.)"
+    echo ""
+fi
+
+exit 0

package/hooks/hooks.json

@@ -7,6 +7,10 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/sdlc-prompt-check.sh"
+          },
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/goal-confidence-check.sh"
           }
         ]
       }

package/hooks/model-effort-check.sh

@@ -3,17 +3,17 @@
 #
 # Behavior (per ROADMAP #217):
 #   effort=max    -> silent (preferred default, above floor)
-#   effort=xhigh  -> silent (minimum floor on Opus 4.7)
+#   effort=xhigh  -> silent (minimum floor on Opus 4.6 max)
 #   effort=high|medium|low (or unset) -> LOUD WARNING:
-#     Opus 4.7 needs xhigh floor for SDLC compliance (TDD, self-review, deep reasoning).
-#     Recommends `/effort max`. Also reminds about recommended model `opus[1m]`.
+#     Opus 4.6 max needs xhigh floor for SDLC compliance (TDD, self-review, deep reasoning).
+#     Recommends `/effort max`. Also reminds about recommended model `claude-opus-4-6[1m]`.
 #
 # CC does not expose the current model to hooks, so the model nudge is emitted as
 # guidance for Claude to compare against its own system prompt.
 #
 # Non-blocking: always exits 0.
 
-RECOMMENDED_MODEL="opus[1m]"
+RECOMMENDED_MODEL="claude-opus-4-6[1m]"
 
 # Token-bloat fix: when both project + plugin register this hook, plugin yields.
 HOOK_DIR="${BASH_SOURCE[0]%/*}"
@@ -57,7 +57,7 @@ else
 fi
 
 echo "=============================================================================="
-echo " WARNING: effort '$effort_display' breaks SDLC compliance on Opus 4.7."
+echo " WARNING: effort '$effort_display' breaks SDLC compliance on Opus 4.6 max."
 echo " Below xhigh = shallow reasoning, skipped TDD, dropped self-review."
 echo ""
 echo " Run: /effort max    (preferred, full SDLC compliance)"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-sdlc-wizard",
-  "version": "1.77.0",
+  "version": "1.80.0",
   "description": "SDLC enforcement for Claude Code — hooks, skills, and wizard setup in one command",
   "bin": {
     "sdlc-wizard": "cli/bin/sdlc-wizard.js"

package/skills/sdlc/SKILL.md

@@ -114,7 +114,7 @@ Native `/goal <condition>` (**v2.1.143+**). Haiku evaluator re-checks transcript
 
 ## Recommended Model
 
-**Opt-in: `opus[1m]` (Opus 4.7 with 1M context).** `/model opus[1m]` at the start of non-trivial sessions — understand the tradeoff (issue #198). A top-level `model` pin in `.claude/settings.json` disables CC's per-turn auto-selection; pin only when you need 1M headroom. Requires CC v2.1.111+.
+**Opt-in: `claude-opus-4-6[1m]` (Opus 4.6 max + 1M context — wizard's flagship).** `/model claude-opus-4-6[1m]` at session start (issue #198). Top-level `model` pin disables CC auto-selection; pin only when you need 1M headroom. CC v2.1.154+. For 4.8 opt-in, see wizard "Latest tier".
 
 **Pair with `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30` when you opt in.** Without it, the default fires at ~76K on 1M. **Pick ONE — do NOT set both `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30` AND `CLAUDE_CODE_AUTO_COMPACT_WINDOW=400000`** — they compound to 30% × 400K = 120K trigger ≈ 12% of 1M, fires almost immediately (#207). See wizard "Autocompact Tuning" for details.
 
@@ -130,18 +130,20 @@ The loop goes back to PLANNING, not TDD RED. Run `/code-review`; issues at confi
 
 ## Cross-Model Review (If Configured)
 
-**When to run:** high-stakes changes (auth, payments, data), releases/publishes, complex refactors. **When to skip:** trivial changes, time-sensitive hotfixes, risk < review cost. **Prerequisites:** Codex CLI (`npm i -g @openai/codex`) + OpenAI API key. **Reviewer at flagship tier (#233):** even when project pins `sonnet[1m]`, reviewer runs `gpt-5.5` / Opus 4.7 max — adversarial diversity is the point.
+**When to run:** high-stakes changes (auth, payments, data), releases/publishes, complex refactors. **When to skip:** trivial changes, time-sensitive hotfixes, risk < review cost. **Prerequisites:** Codex CLI (`npm i -g @openai/codex`) + OpenAI API key. **Reviewer at flagship tier (#233):** even when project pins `sonnet[1m]`, reviewer runs `gpt-5.5` / Opus 4.6 max — adversarial diversity is the point.
 
 PROTOCOL is universal across domains; only `review_instructions` and `verification_checklist` change.
 
 1. **Preflight** (`.reviews/preflight-{review_id}.md`) — what you already checked: `/code-review` passed, tests passing, manual verifications, known limits. Reduces reviewer findings to 0-1/round.
-2. **Mission-first handoff** (`.reviews/handoff.json`) — required JSON keys: `"review_id"`, `"status": "PENDING_REVIEW"`, `"round": 1`, `"mission"` / `"success"` / `"failure"` (2-3 sentences each — without them you get "looks good"), `"files_changed"`, `"verification_checklist"` — the **verification checklist** is specific items with file:line refs (NOT a generic "review this"), `"review_instructions"`, `"preflight_path"`. Optional `"pr_number":` opts into the PreCompact self-heal (#209): if PR is MERGED, `/compact` treats handoff as implicit CERTIFIED.
-3. **Run reviewer:** `codex exec -c 'model_reasoning_effort="xhigh"' -s danger-full-access -o .reviews/latest-review.md "<prompt>" < /dev/null`. Always `xhigh`. **Always append `< /dev/null`** — codex blocks on stdin reads from non-interactive parents (background, hooks, CI, CC Bash tool); without the redirect it hangs at S/0% CPU indefinitely. CC sandbox blocks Codex's Rust binary (`SCDynamicStore`) — use `dangerouslyDisableSandbox: true` on Bash; Codex has its own sandbox. xhigh runs take 1-5 min; for a heartbeat use `scripts/codex-review-with-progress.sh` (already redirects child stdin).
+2. **Mission-first handoff** (`.reviews/handoff.json`) — required keys: `"review_id"`, `"status": "PENDING_REVIEW"`, `"round": 1`, `"mission"`/`"success"`/`"failure"` (without them you get "looks good"), `"files_changed"`, `"verification_checklist"` (verification checklist with file:line refs — NOT generic), `"review_instructions"`, `"preflight_path"`. Optional `"pr_number":` opts into PreCompact self-heal (#209: PR MERGED → implicit CERTIFIED).
+3. **Run reviewer:** `codex exec -c 'model_reasoning_effort="xhigh"' -s danger-full-access -o .reviews/latest-review.md "<prompt>" < /dev/null`. Always `xhigh`. Bash tool requires `run_in_background: true` + `dangerouslyDisableSandbox: true`; append `< /dev/null` always. **Why:** `< /dev/null` prevents codex stdin-hang at S/0% CPU; `run_in_background: true` avoids the Bash 10-min (`600000` ms) `timeout` cap that force-kills foreground codex (multi-artifact bundles take 5–30 min). xhigh 1–30 min; wrapper's `STALL_SECONDS=1800` is the real control. Heartbeat: `scripts/codex-review-with-progress.sh`. Foreground burned 70 min on a 7-min review (#364).
 4. **Dialogue loop:** per-finding response (`{"finding": "1", "action": "FIXED|DISPUTED|ACCEPTED", "summary": "..."}` in `.reviews/response.json`). Bump round, set status `PENDING_RECHECK`, add `fixes_applied` (numbered, file:line). Recheck prompt: "TARGETED RECHECK. FIXED → verify certify condition. DISPUTED → ACCEPT if sound, REJECT with reasoning. ACCEPTED → verify applied. No new findings unless P0."
 
-**Convergence:** 2 rounds sweet spot, 3 max (research: 14 repos + 7 papers). After 3 still NOT CERTIFIED → escalate.
+**Convergence:** 2 rounds sweet spot, 3 max. After 3 NOT CERTIFIED → escalate.
 
-**Multi-reviewer:** parallel reviewers → respond per-reviewer (different blind spots, no shared anchoring). **Non-code domains:** same handoff + add `"audience"`/`"stakes"` keys.
+**Enforcement:** `hooks/goal-confidence-check.sh` warns when `/goal` skips the 95%-confidence or DLC-binding gates (#360).
+
+**Multi-reviewer:** respond to each reviewer independently (no shared anchoring). **Non-code domains:** add `"audience"`/`"stakes"` keys to handoff.
 
 ### Release Review Focus
 

package/skills/setup/SKILL.md

@@ -247,10 +247,11 @@ The output is JSON: `{ tier: "simple" | "complex", score, signals }`. Use the re
 > How do you want to configure the model for this repo?
 >
 > - **[N] No pin (default, recommended for most repos):** Leaves auto-mode enabled. Claude Code picks the model per turn. Compaction follows upstream defaults. Simplest, lowest friction.
-> - **[m] Mixed-mode** *(suggested for **simple** tier — roadmap #233):* Pins `model: "sonnet[1m]"` for the coder (Sonnet 4.6 with 1M context). The cross-model review layer (Codex / external reviewer) **always stays at the flagship** (Opus 4.7 max or gpt-5.5 xhigh) regardless. Saves cost/quota on simple repos; reviewer catches what Sonnet misses. Requires comfort with losing per-turn auto-selection.
-> - **[f] Flagship full** *(suggested for **complex** / stakes-flagged tier):* Pins `model: "opus[1m]"` (Opus 4.7 with 1M context) and sets `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30`. Long SDLC sessions cross 100K tokens regularly; the 1M window gives headroom and 30% autocompact fires at ~300K. Requires Claude Code v2.1.111+.
+> - **[m] Mixed-mode** *(suggested for **simple** tier — roadmap #233):* Pins `model: "sonnet[1m]"` for the coder (Sonnet 4.6 with 1M context). The cross-model review layer (Codex / external reviewer) **always stays at the flagship** (Opus 4.6 max or gpt-5.5 xhigh) regardless. Saves cost/quota on simple repos; reviewer catches what Sonnet misses. Requires comfort with losing per-turn auto-selection.
+> - **[f] Flagship full** *(wizard's recommended default — suggested for complex / stakes-flagged):* Pins `model: "claude-opus-4-6[1m]"` + `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30`. 4.6 max is the only Opus/max combo that doesn't overthink (Andon Labs, Huryn, BSWEN, r/Claudeopus). Avoids 4.7+ tokenizer tax. Anthropic-supported until ≥ Feb 5, 2027. Requires CC v2.1.154+.
+> - **[l] Latest** *(opt-in for Anthropic's newest Opus):* Pins `model: "claude-opus-4-8[1m]"`. Ships SWE-Bench Pro / Terminal-Bench / dynamic-workflows gains. Tradeoff: 40-60× cache token jump at HIGH, active false-green / token-burn regressions. Drop to `xhigh` (4.8's `max` is worse than `xhigh`).
 >
-> `[N/m/f]`
+> `[N/m/f/l]`
 
 **If the user answers `N` (default):** Make no edits to `.claude/settings.json`. Auto-mode stays on. Done.
 
@@ -268,14 +269,29 @@ Do NOT add `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE` for Sonnet — Sonnet's 1M window h
 
 ```json
 {
-  "model": "opus[1m]",
+  "model": "claude-opus-4-6[1m]",
   "env": {
     "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "30"
   }
 }
 ```
 
-Mention the escape hatch in all three cases:
+Tell the user: "Pair this with `/effort max` — 4.6 is the only Opus version where `max` doesn't overthink. See [`README.md` § Choosing Your Model](../README.md#choosing-your-model) and `CLAUDE_CODE_SDLC_WIZARD.md` → 'Latest tier — Opus 4.8' for the full rationale + the opt-in alternative if you want Anthropic's newest model."
+
+**If the user answers `l` (latest):** Edit `.claude/settings.json` and add:
+
+```json
+{
+  "model": "claude-opus-4-8[1m]",
+  "env": {
+    "CLAUDE_AUTOCOMPACT_PCT_OVERRIDE": "30"
+  }
+}
+```
+
+Tell the user: "Recommend dropping to `/effort xhigh` instead of `max` on 4.8 — strict effort behavior overcorrects at `max`. You'll want this if you're chasing SWE-Bench Pro / Terminal-Bench 2.1 / dynamic-workflows wins; otherwise the wizard's `[f] Flagship` (4.6 max) is the safer pick. Escape hatch: change the `model` value back to `claude-opus-4-6[1m]` or remove the line to fall back to auto-mode."
+
+Mention the escape hatch in all four cases:
 - To opt out later: remove the `model` line (and optionally the `env` block) from `.claude/settings.json`, or run `/model` and pick "Default (recommended)".
 - To switch tiers later: edit `.claude/settings.json` and replace the `model` value, or re-run `/setup-wizard` Step 9.5.
 - For CI pipelines with short tasks (flagship only), consider `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=60` — compact early to stay fast.

package/skills/update/SKILL.md

@@ -93,9 +93,12 @@ Parse CHANGELOG entries between the user's installed version and latest. Present
 
 ```
 Installed: 1.42.0
-Latest:    1.77.0
+Latest:    1.80.0
 
 What changed:
+- [1.80.0] Flip default: Opus 4.6 max becomes recommended flagship; Opus 4.8 demoted to opt-in `[l] Latest` tier.
+- [1.79.0] Opus 4.6 Stability tier added as flagship alternative (now graduated to default in 1.80.0).
+- [1.78.0] Opus 4.7 → 4.8 model recommendation (#365) + min CC v2.1.154+.
 - [1.77.0] release-dry-run.yml + cc-version-drift.yml (#350) + /goal SDLC gates (95% + DLC binding).
 - [1.76.0] /goal /sdlc wrapper (#347) + CC v2.1.150 feature adoption + ROADMAP demand-signal gate (4 excise, 4 kill).
 - [1.75.1] release-workflow fix — Node 22 → 24 (ships npm 11.x), dropped flaky `npm install -g` self-upgrade (hit MODULE_NOT_FOUND on v1.75.0 publish). Explicit npm-version guard.
@@ -104,7 +107,6 @@ What changed:
 - [1.73.0] precompact stale REBASE_HEAD fix + 15 stale artifact deletes (-460 LOC).
 - [1.72.0] #323 closed — customization-aware `check` recommendation + new `--preserve-customized` flag. `init --force --preserve-customized` skips CUSTOMIZED files (action `PRESERVE`), still OVERWRITEs MATCH and CREATEs MISSING. Default `init --force` unchanged. 10 tests.
 - [1.71.0–1.69.0] token-bloat sweep #236 — BASELINE + TDD CHECK fire once per `session_id` (-12K, -0.5-1.5K); sdlc-skill Cross-Model Review trimmed.
-- [1.68.0–1.65.0] roadmap hygiene — five paperwork closes: #97 Anthropic Policy NO-GO + AAR-paper validating parallel; #99 AutoGPT NO-GO; #95 Nous NO-GO; #243 token-history liveness verified; #210 Node-24 false-green; #235 Thoughtworks AI Evals NO-GO. **6/6 external-product audits NO-GO** (continues #76, #77). Research write-ups in `.reviews/research-*.md`.
 - [1.64.0] XDLC ecosystem cross-references — README, wizard doc, and ROADMAP now cross-reference all three sibling packages (`agentic-sdlc-wizard`, `codex-sdlc-wizard`, `claude-gdlc-wizard`). New "Ecosystem (Sibling Projects)" section in README. 3 new doc-consistency tests prevent drift.
 - [1.63.0] cache-cost observability closeout (#204 absorbed by #220) — token-spike test gains explicit cache-miss + negative-control coverage. "Cache-Cost Surprises" docs added (10-20× silent blowups from mid-session CLAUDE.md edits, idle pruning).
 - [1.62.0] roadmap hygiene + #211 backfill — closes paperwork-stale rows. Backfilled 5 corrupted `score-history.jsonl` rows from `max_score:10` → `:11` (UI scenarios). Codex strategic review confirmed scope.
@@ -170,7 +172,7 @@ Check user's `.claude/settings.json`:
 1. **`model: "opus[1m]"` AND `env.CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: "30"`** — likely the old wizard-installed pair, not an intentional choice. Ask:
    > Your `.claude/settings.json` pins `model: "opus[1m]"` with `CLAUDE_AUTOCOMPACT_PCT_OVERRIDE=30`. This pair was the wizard default in 1.31.0–1.33.x, but it disables Claude Code's auto-mode (issue #198).
    > - **Remove the pin** (recommended) — keeps auto-mode enabled
-   > - **Keep the pin** — guaranteed Opus 4.7 + 1M, OK with no auto-selection
+   > - **Keep the pin** — guaranteed Opus 4.6 max + 1M, OK with no auto-selection
    > Remove, keep, or decide later? `[r/k/l]`
 
 2. **Only one of the two fields matches** — treat as intentional customization. Do not prompt.