@tekyzinc/gsd-t 4.2.10 → 4.3.10

package/CHANGELOG.md

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

package/README.md

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

package/commands/gsd-t-design-decompose.md

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

package/commands/gsd-t-help.md

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

package/commands/gsd-t-milestone.md

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

package/commands/gsd-t-partition.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "4.2.10",
+  "version": "4.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

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

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

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