@tekyzinc/gsd-t 4.0.29 → 4.1.10

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to GSD-T are documented here. Updated with each release.
 
+## [4.1.10] - 2026-06-05 (M82 Competition Mode - minor)
+
+### Added - Competition Mode: generate-and-judge for upstream, pre-contract phases
+
+The *generative* dual of the orthogonal validation triad. The triad is adversarial (many critics, one candidate → a filter); Competition Mode is generative (many candidates, one judge → a generator). GSD-T historically filtered hard but **generated singly** — every upstream artifact was a single draft. Competition Mode adds the missing generator on the phases where it pays. **Watershed rule:** generate-and-judge ABOVE the contract; attack-and-filter BELOW it.
+
+- **Opt-in `--competition N`** (N clamped 2–5; default off) on eligible upstream phases: `partition`, `milestone`, `discuss`, `design-decompose`. Ignored (single producer, logged) on ineligible phases (plan/impact/prd/doc-ripple) and impossible on post-contract phases (execute/verify/…).
+- **Producers = Self-MoA** — N samples of ONE strong model (opus), diversified by prompt *angle* (max-parallelism / simplicity / risk-isolation / dependency-depth / balance), not by a model zoo. Evidence (Self-MoA, arXiv 2502.00674): aggregation is far more sensitive to candidate quality than diversity; mixing models injects low-quality candidates. No debate — producers stay independent.
+- **Objective judge for partition (the v1 beachhead)** — `bin/gsd-t-competition-judge.cjs --kind partition` scores candidate decompositions via the SAME file-disjointness oracle the dispatcher uses (`bin/gsd-t-file-disjointness.cjs`): parallelGroups / waveDepth / validity. A calculator, not an LLM critic → immune to position/verbosity/self-preference bias. Touch paths normalized (`./a` ≡ `a`, `//`, backslashes, trailing slash, dedupe; case preserved).
+- **Subjective judge for milestone/discuss/design** — blind + deterministically-shuffled + different-model (sonnet) + rubric-scored; the winner is finalized deterministically by `--kind generic` (highest weighted score; reproducible tiebreak; zero inference in the substrate).
+- **Two-gate selection policy** (synthesize only when candidate-quality-uniform AND artifact-is-list-shaped; else pick-one) + three artifact classes (coupled-thesis → pick-one; line-items → union/dedup; structurally-validated → synthesize+re-validate). The finalizer does pick-one-at-thesis + union-at-line-item-level, then partition re-validates the graft via the oracle and BLOCKS on a reintroduced overlap.
+- **New CLI**: `gsd-t competition-judge [--in SPEC.json] [--project-dir P]` (exit 0 winner / 4 no valid candidate / 64 bad input). Added to project + global bin tools.
+- **Contract**: `.gsd-t/contracts/competition-mode-contract.md` v1.0.0 STABLE (6 invariants).
+- **Verification**: orthogonal triad ran. Adversarial Workflow Red Team (Opus, fresh context) FAILed first pass (3 HIGH + 2 MEDIUM), all fixed, re-validation Red Team GRUDGING-PASS (all 5 fixed, no new HIGH/CRITICAL). Real-sandbox acceptance gate passed (judge integration ran end-to-end in the Workflow sandbox). Suite 1357/0/4 (+6 M82 tests). **SC#1 measured on M82's own partition: competition (3 producers) → 3 parallel groups vs N=1 baseline's 1 (3× parallelism), invalid overlap candidate correctly disqualified.** SC#3 position-bias probe: order-invariant winner (100%).
+- Origin: brainstorm 2026-06-05 grounded in 2 deep-research runs (best-of-N/judge/debate + synthesis-vs-pick-one/MoA/Frankenstein).
+
+### Versioning
+
+Minor bump 4.0.29 → 4.1.10 (new feature, additive; patch reset to 10).
+
 ## [4.0.29] - 2026-06-05 (M81 Workflows Runtime-Native - patch)
 
 ### Fixed - TD-113: 6 of 7 workflows (+ quick) crashed in the Workflow sandbox and had never run

package/README.md

@@ -122,8 +122,11 @@ gsd-t build-coverage --json                             # M57: new top-level pat
 gsd-t ci-parity --json                                  # M57: reproduce the project's actual CI build locally (auto docker build)
 gsd-t test-data --list [--run ID] [--json]              # M58: list test-data ledger entries
 gsd-t test-data --purge --run ID [--dry-run] [--json]   # M58: purge tagged test data after Verify (Step 4.5)
+gsd-t competition-judge --in SPEC.json [--project-dir P] # M82: generate-and-judge selection oracle (partition / generic)
 ```
 
+**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`.
+
 `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.
 
 Each iteration runs as a fresh `claude -p` session. A cumulative debug ledger (`.gsd-t/debug-state.jsonl`) preserves hypothesis/fix/learning history across sessions. An anti-repetition preamble prevents retrying failed approaches.

package/bin/gsd-t-competition-judge.cjs

@@ -0,0 +1,344 @@
+"use strict";
+
+/**
+ * gsd-t-competition-judge — M82 D1
+ *
+ * The selection oracle for Competition Mode (generate-and-judge on upstream,
+ * pre-contract phases). Given N candidate artifacts produced by parallel
+ * producers, score them and emit a winner — the GENERATIVE dual of the
+ * orthogonal validation triad (which is adversarial: many critics, one
+ * candidate). Contract: .gsd-t/contracts/competition-mode-contract.md v1.0.0.
+ *
+ * Two judge modes, chosen by `--kind`:
+ *
+ *   --kind partition  → OBJECTIVE judge (the v1 beachhead). Each candidate is a
+ *       proposed domain decomposition: a list of domains, each with a write-
+ *       touch list. We score it with the SAME disjointness oracle the real
+ *       parallel dispatcher uses (bin/gsd-t-file-disjointness.cjs), so the judge
+ *       is a CALCULATOR, not a critic — it sidesteps every LLM-judge bias
+ *       (position / verbosity / self-preference). Metrics, higher-is-better
+ *       unless noted:
+ *         - valid             : zero write-target overlaps across domains (HARD gate)
+ *         - parallelGroups    : count of disjoint domains that can fan out at once
+ *         - waveDepth         : serial gates (sequential groups + 1 if any) — LOWER better
+ *         - unprovableCount   : domains with no touch list — LOWER better (safe-default seq)
+ *       Ranking: invalid candidates are disqualified; among valid ones, rank by
+ *       (parallelGroups desc, waveDepth asc, unprovableCount asc, domainCount asc).
+ *
+ *   --kind generic   → records a SUBJECTIVE judge's verdict. The numeric scoring
+ *       lives in the rubric the Workflow's judge agent fills in (blind+shuffled,
+ *       different-model, rubric-scored — see the contract). This CLI only
+ *       validates/normalizes the rubric scores the agent supplies and picks the
+ *       winner deterministically (highest weighted score; ties → lowest index of
+ *       the ORIGINAL, pre-shuffle order to keep selection reproducible). It does
+ *       NOT call an LLM — keeping inference out of the deterministic substrate
+ *       (per feedback_deterministic_orchestration + anthropic-key-measurement-only).
+ *
+ * Input: a JSON spec on stdin OR via --in <path>. Shapes:
+ *
+ *   partition: {
+ *     "kind": "partition",
+ *     "candidates": [
+ *       { "id": "A", "domains": [ { "name": "d1", "touches": ["a.js","b.js"] }, ... ] },
+ *       ...
+ *     ]
+ *   }
+ *
+ *   generic: {
+ *     "kind": "generic",
+ *     "axes": [ { "key": "coherence", "weight": 1 }, { "key": "completeness", "weight": 1 }, ... ],
+ *     "candidates": [
+ *       { "id": "A", "scores": { "coherence": 4, "completeness": 3, ... } },
+ *       ...
+ *     ]
+ *   }
+ *
+ * Output (JSON envelope, the shape runCli parses):
+ *   {
+ *     ok: boolean,            // true unless input was unusable
+ *     exitCode: 0 | 4 | 64,
+ *     kind, n,
+ *     winner: <candidateId|null>,
+ *     ranked: [ { id, valid?, parallelGroups?, waveDepth?, unprovableCount?, score?, rank } ],
+ *     reason?: string
+ *   }
+ *
+ * Exit codes: 0 ok+winner · 4 ok but NO valid candidate (all disqualified) · 64 bad input.
+ *
+ * Hard rules (mirrors the disjointness prover's discipline):
+ *   - Zero external runtime deps (Node built-ins only).
+ *   - Never throws — always emits an envelope.
+ *   - Pure / read-only — no project mutation. Deterministic given the same input.
+ */
+
+const fs = require("node:fs");
+
+// The objective partition judge reuses the production disjointness oracle so the
+// judge's notion of "parallelizable" is byte-identical to the dispatcher's.
+let proveDisjointness;
+try {
+  ({ proveDisjointness } = require("./gsd-t-file-disjointness.cjs"));
+} catch {
+  proveDisjointness = null;
+}
+
+// ─── Partition scoring (objective) ───────────────────────────────────────
+
+/**
+ * Score one candidate partition by running its domains through the disjointness
+ * oracle. Each domain becomes a pseudo-task {id, domain, touches}; we never hit
+ * git history (every domain carries an explicit touch list or is counted
+ * unprovable), so scoring is pure and deterministic.
+ *
+ * @returns {{valid, domainCount, parallelGroups, sequentialGroups, unprovableCount, waveDepth}}
+ */
+// Normalize a touch path to a stable file identity so two spellings of the SAME
+// file (./bin/x.js vs bin/x.js, trailing slash, backslashes, redundant ./ or //)
+// are detected as a conflict. Without this, an overlapping partition could be
+// scored `valid` and WIN — then the real dispatcher would hit a write conflict.
+// Note: case is preserved (most CI runs on case-sensitive Linux); collapsing case
+// here would create false conflicts on case-sensitive repos. Path identity only.
+function _normPath(p) {
+  if (typeof p !== "string") return "";
+  let s = p.trim().replace(/\\/g, "/");        // backslashes -> forward
+  s = s.replace(/\/+/g, "/");                    // collapse repeated slashes
+  s = s.replace(/^\.\//, "");                    // drop leading ./
+  while (s.includes("/./")) s = s.replace("/./", "/"); // drop interior /./
+  s = s.replace(/\/+$/, "");                      // drop trailing slash
+  return s;
+}
+
+function scorePartition(candidate, projectDir) {
+  const domains = Array.isArray(candidate.domains) ? candidate.domains : [];
+  const tasks = domains.map((d, i) => ({
+    id: `${candidate.id}:${d.name || `d${i}`}`,
+    domain: d.name || `d${i}`,
+    // Only honor an explicit touch list — never let the oracle fall through to
+    // git history during scoring (would make the judge non-deterministic).
+    // Normalize + de-dupe so path-spelling variants are caught as real conflicts.
+    touches: Array.isArray(d.touches)
+      ? Array.from(new Set(d.touches.map(_normPath).filter(Boolean)))
+      : [],
+  }));
+
+  // Run the real oracle when available; otherwise fall back to a self-contained
+  // overlap check so the judge still works if the lib isn't co-located.
+  const res = proveDisjointness
+    ? proveDisjointness({ tasks, projectDir })
+    : _localDisjoint(tasks);
+
+  const parallelGroups = (res.parallel || []).length;
+  const sequentialGroups = (res.sequential || []).filter(
+    (g) => !(g.length === 1 && (res.unprovable || []).includes(g[0])),
+  ).length;
+  const unprovableCount = (res.unprovable || []).length;
+
+  // VALID = no two domains with declared touch lists write the same file. An
+  // overlap shows up as a sequential group of size ≥2 among provable tasks.
+  const overlapGroup = (res.sequential || []).some((g) => g.length >= 2);
+  const valid = !overlapGroup;
+
+  // waveDepth: 1 wave for the disjoint fan-out, +1 per serial bottleneck
+  // (overlapping/unprovable domains that must run after). Fewer = better.
+  const serialBottlenecks = sequentialGroups + unprovableCount;
+  const waveDepth = (parallelGroups > 0 ? 1 : 0) + (serialBottlenecks > 0 ? 1 : 0) || 1;
+
+  return {
+    valid,
+    domainCount: domains.length,
+    parallelGroups,
+    sequentialGroups,
+    unprovableCount,
+    waveDepth,
+  };
+}
+
+// Self-contained overlap fallback (only used if the oracle lib is absent).
+function _localDisjoint(tasks) {
+  const parallel = [];
+  const sequential = [];
+  const unprovable = [];
+  const provable = [];
+  for (const t of tasks) {
+    if (!t.touches || t.touches.length === 0) {
+      unprovable.push(t);
+      sequential.push([t]);
+    } else {
+      provable.push(t);
+    }
+  }
+  // union-find over file overlap
+  const parent = provable.map((_, i) => i);
+  const find = (i) => {
+    while (parent[i] !== i) { parent[i] = parent[parent[i]]; i = parent[i]; }
+    return i;
+  };
+  for (let i = 0; i < provable.length; i++) {
+    for (let j = i + 1; j < provable.length; j++) {
+      const a = new Set(provable[i].touches);
+      if (provable[j].touches.some((f) => a.has(f))) {
+        const ra = find(i), rb = find(j);
+        if (ra !== rb) parent[ra] = rb;
+      }
+    }
+  }
+  const groups = new Map();
+  for (let i = 0; i < provable.length; i++) {
+    const r = find(i);
+    if (!groups.has(r)) groups.set(r, []);
+    groups.get(r).push(provable[i]);
+  }
+  for (const g of groups.values()) (g.length === 1 ? parallel : sequential).push(g);
+  return { parallel, sequential, unprovable };
+}
+
+// Drop candidates that are not usable objects with a string id (Red Team MED-4:
+// the 'never throws' guarantee is on the function, not just the CLI shell — an
+// in-process caller passing [null] or {id:{}} must not crash, and a non-string id
+// could never match `c.id === winnerId` in the workflow anyway).
+function _safeCandidates(candidates) {
+  return (Array.isArray(candidates) ? candidates : []).filter(
+    (c) => c && typeof c === "object" && typeof c.id === "string" && c.id.length > 0,
+  );
+}
+
+function rankPartitions(rawCandidates, projectDir) {
+  const candidates = _safeCandidates(rawCandidates);
+  const scored = candidates.map((c) => ({ id: c.id, ...scorePartition(c, projectDir) }));
+  // Disqualify invalid (file-overlap) candidates from winning, but keep them in
+  // the ranking so the caller can see why they lost.
+  const valid = scored.filter((s) => s.valid);
+  const cmp = (a, b) =>
+    b.parallelGroups - a.parallelGroups ||      // more concurrency wins
+    a.waveDepth - b.waveDepth ||                 // fewer serial gates wins
+    a.unprovableCount - b.unprovableCount ||     // fewer unknowns wins
+    a.domainCount - b.domainCount;               // simpler (fewer domains) wins
+  valid.sort(cmp);
+  const invalid = scored.filter((s) => !s.valid);
+  const ordered = [...valid, ...invalid];
+  ordered.forEach((s, i) => { s.rank = i + 1; });
+  return { ranked: ordered, winner: valid.length ? valid[0].id : null };
+}
+
+// ─── Generic scoring (subjective rubric, deterministic selection) ────────
+
+function rankGeneric(spec) {
+  const axes = Array.isArray(spec.axes) && spec.axes.length
+    ? spec.axes
+    : [{ key: "quality", weight: 1 }];
+  const candidates = _safeCandidates(spec.candidates);
+  const scored = candidates.map((c, idx) => {
+    const scores = c.scores || {};
+    let total = 0;
+    let weightSum = 0;
+    for (const ax of axes) {
+      const w = Number(ax.weight) || 0;
+      const v = Number(scores[ax.key]) || 0;
+      total += w * v;
+      weightSum += w;
+    }
+    const score = weightSum > 0 ? total / weightSum : 0;
+    return { id: c.id, score: Number(score.toFixed(4)), _idx: idx };
+  });
+  // Highest weighted score wins; ties broken by ORIGINAL index (reproducible,
+  // immune to candidate-order shuffling done for bias control upstream).
+  scored.sort((a, b) => b.score - a.score || a._idx - b._idx);
+  scored.forEach((s, i) => { s.rank = i + 1; delete s._idx; });
+  return { ranked: scored, winner: scored.length ? scored[0].id : null };
+}
+
+// ─── Driver ──────────────────────────────────────────────────────────────
+
+function judge(spec, projectDir) {
+  const candidates = Array.isArray(spec && spec.candidates) ? spec.candidates : [];
+  if (!candidates.length) {
+    return { ok: false, exitCode: 64, kind: spec && spec.kind, n: 0, winner: null, ranked: [], reason: "no-candidates" };
+  }
+  const kind = spec.kind === "generic" ? "generic" : "partition";
+  const { ranked, winner } = kind === "partition"
+    ? rankPartitions(candidates, projectDir)
+    : rankGeneric(spec);
+  const ok = winner != null;
+  return {
+    ok,
+    exitCode: ok ? 0 : 4,
+    kind,
+    n: candidates.length,
+    winner,
+    ranked,
+    ...(ok ? {} : { reason: kind === "partition" ? "no-valid-candidate" : "no-candidates" }),
+  };
+}
+
+function readInput(opts) {
+  if (opts.in) return fs.readFileSync(opts.in, "utf8");
+  // stdin
+  try {
+    return fs.readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function parseArgs(argv) {
+  const opts = { json: true, in: null, projectDir: process.cwd(), help: false };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--help" || a === "-h") opts.help = true;
+    else if (a === "--in") opts.in = argv[++i];
+    else if (a === "--project-dir") opts.projectDir = argv[++i];
+    else if (a === "--json") opts.json = true;
+  }
+  return opts;
+}
+
+const HELP = `Usage: gsd-t competition-judge [--in PATH] [--project-dir PATH]
+
+Reads a candidate-set JSON spec (stdin or --in) and emits a ranked winner.
+
+  --in PATH          Read spec from file instead of stdin.
+  --project-dir PATH Project root (default: cwd).
+  --json             Emit JSON envelope (default; always on).
+
+Spec.kind:
+  "partition"  Objective oracle judge — scores domain decompositions via the
+               file-disjointness prover (parallelGroups / waveDepth / validity).
+  "generic"    Deterministic rubric selector — picks the highest weighted score
+               from rubric values an upstream judge agent supplied.
+
+Exit codes: 0 winner · 4 no valid candidate · 64 bad input.`;
+
+function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  if (opts.help) {
+    process.stdout.write(HELP + "\n");
+    process.exit(0);
+  }
+  let spec;
+  try {
+    const raw = readInput(opts);
+    spec = JSON.parse(raw);
+  } catch (e) {
+    const env = { ok: false, exitCode: 64, kind: null, n: 0, winner: null, ranked: [], reason: `bad-input: ${e && e.message}` };
+    process.stdout.write(JSON.stringify(env, null, 2) + "\n");
+    process.exit(64);
+  }
+  let result;
+  try {
+    result = judge(spec, opts.projectDir);
+  } catch (e) {
+    result = { ok: false, exitCode: 64, kind: spec && spec.kind, n: 0, winner: null, ranked: [], reason: `judge-error: ${e && e.message}` };
+  }
+  process.stdout.write(JSON.stringify(result, null, 2) + "\n");
+  process.exit(result.exitCode);
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  judge,
+  scorePartition,
+  rankPartitions,
+  rankGeneric,
+  _internal: { _localDisjoint, _normPath },
+};

package/bin/gsd-t.js

@@ -1182,6 +1182,8 @@ const GLOBAL_BIN_TOOLS = [
   // M57 — CI-parity verify-gate checks (structural build-coverage + containment-safe ci-parity).
   "gsd-t-build-coverage.cjs",
   "gsd-t-ci-parity.cjs",
+  // M82 — Competition Mode generate-and-judge selection oracle.
+  "gsd-t-competition-judge.cjs",
 ];
 
 function installGlobalBinTools() {
@@ -2469,6 +2471,10 @@ const PROJECT_BIN_TOOLS = [
   "cli-preflight.cjs", "parallel-cli.cjs", "parallel-cli-tee.cjs",
   "gsd-t-context-brief.cjs",
   "gsd-t-verify-gate.cjs", "gsd-t-verify-gate-judge.cjs",
+  // M82 — Competition Mode judge + its disjointness oracle dependency, so a
+  // project's gsd-t-phase workflow can score candidate partitions via the
+  // project-local bin (runCli prefers bin/<tool>.cjs over the global binary).
+  "gsd-t-competition-judge.cjs", "gsd-t-file-disjointness.cjs",
 ];
 
 // Files that older versions of this installer copied into project bin/ but
@@ -4546,6 +4552,16 @@ if (require.main === module) {
       });
       process.exit(res.status == null ? 1 : res.status);
     }
+    case "competition-judge": {
+      // M82 D1 — `gsd-t competition-judge` thin dispatcher to the generate-and-judge
+      // selection oracle (objective partition judge + deterministic rubric selector).
+      const { spawnSync } = require("child_process");
+      const js = path.join(__dirname, "gsd-t-competition-judge.cjs");
+      const res = spawnSync(process.execPath, [js, ...args.slice(1)], {
+        stdio: "inherit",
+      });
+      process.exit(res.status == null ? 1 : res.status);
+    }
     case "metrics":
       doMetrics(args.slice(1));
       break;

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

@@ -25,14 +25,21 @@ Capture the design reference from `$ARGUMENTS` (Figma URL / image path). If Figm
   args: {
     phase: "design-decompose",
     projectDir: ".",
-    userInput: "$ARGUMENTS"
+    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
   }
 }
 ```
 
+**Competition Mode (`--competition N`).** When a design is ambiguous or the element/widget/page boundaries aren't obvious, `/gsd-t-design-decompose --competition 3` fans out N candidate decompositions and a blind, different-model rubric judge picks the best. Parse N (clamped 2..5). See `.gsd-t/contracts/competition-mode-contract.md`. Default off.
+
 ## Step 3: Interpret the result
 
-The Workflow returns `{ status, artifacts, summary, decisions }`.
+The Workflow returns `{ status, artifacts, summary, decisions }` (plus `competition: { n, winner, ranked }` when Competition Mode ran).
 
 - `status === "complete"`: the element → widget → page contract tree is written under `.gsd-t/contracts/design/`.
 - `status === "partial" | "blocked"`: the agent needs the design source (e.g. Figma auth) or a stack-capability decision. Surface it.

package/commands/gsd-t-help.md

@@ -479,6 +479,14 @@ Use these when user asks for help on a specific command:
 - **Use when**: Test data hygiene. Catches the GSD-T-Board class (2442 orphaned `E2E_TEST_*` / `E2E_DRAG_*` ideas left in the production data store after a passing Verify run).
 - **CLI**: `gsd-t test-data --list [--run <id>] [--json]` / `gsd-t test-data --purge --run <id> [--dry-run] [--json] [--project <dir>]`. Exit 0 on success, 4 on adapter errors, 64 on usage error.
 
+### 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.
+- **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.
+- **Contract**: `.gsd-t/contracts/competition-mode-contract.md` v1.0.0 STABLE.
+
 ## Unknown Command
 
 If user asks for help on unrecognized command:

package/commands/gsd-t-milestone.md

@@ -25,14 +25,21 @@ Read `.gsd-t/progress.md` (current version + completed milestones), `docs/requir
   args: {
     phase: "milestone",
     projectDir: ".",
-    userInput: "$ARGUMENTS"
+    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
   }
 }
 ```
 
+**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.
+
 ## Step 3: Interpret the result
 
-The Workflow returns `{ status, artifacts, summary, decisions }`.
+The Workflow returns `{ status, artifacts, summary, decisions }` (plus `competition: { n, winner, ranked }` when Competition Mode ran).
 
 - `status === "complete"`: milestone defined and appended to progress.md with falsifiable SCs. Do NOT auto-partition for large/risky milestones — show the Next Up hint.
 - `status === "blocked"`: the agent needs a scoping decision from the user.

package/commands/gsd-t-partition.md

@@ -30,14 +30,21 @@ Call the `Workflow` tool with:
     phase: "partition",
     milestone: "M{NN}",
     projectDir: ".",
-    userInput: "$ARGUMENTS"
+    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
   }
 }
 ```
 
+**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).
+
 ## Step 3: Interpret the result
 
-The Workflow returns `{ status, artifacts, summary, decisions }`.
+The Workflow returns `{ status, artifacts, summary, decisions }` (plus `competition: { n, winner, ranked }` when Competition Mode ran).
 
 - `status === "complete"`: domains scoped, contracts drafted. Auto-advance to `/gsd-t-plan`.
 - `status === "partial" | "blocked"`: read `summary` for what's missing (e.g. ambiguous scope needing discussion).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tekyzinc/gsd-t",
-  "version": "4.0.29",
+  "version": "4.1.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)
+- `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.
 - `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

@@ -15,7 +15,23 @@
 //   milestone?: "M61",
 //   projectDir?: ".",
 //   userInput?: string,   // arbitrary input to the phase (e.g. "$ARGUMENTS")
+//   competition?: number, // M82: N>1 enables Competition Mode (generate-and-judge)
+//                         // on eligible upstream phases. N parallel Self-MoA
+//                         // producers -> judge stage -> winner. Default 1 (off).
 // }
+//
+// M82 Competition Mode (generate-and-judge — the GENERATIVE dual of the
+// orthogonal validation triad). Contract: competition-mode-contract.md v1.0.0.
+//   - Eligible phases: partition, milestone, discuss, design-decompose (pre-contract,
+//     wide-solution-space). INELIGIBLE: plan/impact/prd/doc-ripple (narrow / one
+//     right answer) — competition there is wasted, so a competition arg is ignored.
+//   - Producers: N samples of ONE strong model (Self-MoA beats a model zoo), varied
+//     by an explicit per-candidate "angle" so they explore different regions.
+//   - Judge: partition uses the OBJECTIVE oracle (gsd-t competition-judge --kind
+//     partition, scoring via the disjointness prover — a calculator, not a critic,
+//     immune to LLM-judge bias). Other phases use a blind+shuffled+rubric judge whose
+//     numeric selection is finalized deterministically by competition-judge --kind
+//     generic.
 
 export const meta = {
   name: "gsd-t-phase",
@@ -34,6 +50,8 @@ const _CLI_ENVELOPE_SCHEMA = {
   type: "object", required: ["ok", "exitCode"], additionalProperties: true,
   properties: { ok: { type: "boolean" }, exitCode: { type: "integer" }, envelope: {}, stdout: { type: "string" }, stderr: { type: "string" }, via: { type: "string" } },
 };
+// Single-quote a value for safe shell interpolation (Red Team MED-5).
+function _shq(s) { return `'${String(s).replace(/'/g, "'\\''")}'`; }
 async function runCli(projectDir, subcmd, argv, localBin, label, parseJson = true, phaseNameOpt) {
   const argStr = (argv || []).map((a) => `'${String(a).replace(/'/g, "'\\''")}'`).join(" ");
   const prompt = [
@@ -57,6 +75,71 @@ async function generateBrief(projectDir, { kind = "execute", milestone, domain,
   return { ok: r.ok, briefPath: `${projectDir}/.gsd-t/briefs/${id}.json`, via: r.via };
 }
 
+// M82: run the deterministic selection oracle over a candidate-set spec. The spec
+// is written to a file via the agent's Bash (no fs in this sandbox), then judged by
+// `gsd-t competition-judge --in <file>`. The agent MUST copy the judge's rich output
+// (winner/ranked) up to the TOP LEVEL of its reply — a permissive free-form
+// `envelope:{}` schema let a haiku agent silently drop winner/ranked (caught in the
+// M82 real-sandbox proof: via=local ok=true but winner=undefined). Explicit required
+// fields fix that. Returns { ok, winner, ranked }.
+const _JUDGE_ENVELOPE_SCHEMA = {
+  type: "object", required: ["ok", "winner"], additionalProperties: true,
+  properties: {
+    ok: { type: "boolean" },
+    exitCode: { type: "integer" },
+    winner: { type: ["string", "null"] },
+    ranked: { type: "array", items: { type: "object", additionalProperties: true } },
+    via: { type: "string" },
+  },
+};
+async function runCompetitionJudge(projectDir, spec, label = "judge", phaseNameOpt) {
+  // De-fang backticks so a producer-supplied domain name / path containing ``` can't
+  // break out of the markdown fence in the prompt (Red Team MED-5). The judge only
+  // reads structural fields (id, domains.name, touches[]); a sanitized name is fine.
+  const specJson = JSON.stringify(spec).replace(/`/g, "'");
+  const qDir = _shq(projectDir);
+  const specPath = `${projectDir}/.gsd-t/briefs/_competition-spec.json`;
+  const qSpec = _shq(specPath);
+  const prompt = [
+    `Run the GSD-T Competition Mode judge for the project at \`${projectDir}\` and report its FULL output. Steps:`,
+    `1. Write this EXACT JSON (one line) to \`${specPath}\` (overwrite; create .gsd-t/briefs/ if needed):`,
+    "~~~json",
+    specJson,
+    "~~~",
+    `2. If \`${projectDir}/bin/gsd-t-competition-judge.cjs\` exists, run: \`node ${qDir}/bin/gsd-t-competition-judge.cjs --in ${qSpec} --project-dir ${qDir}\` (set via="local"). Otherwise run: \`gsd-t competition-judge --in ${qSpec} --project-dir ${qDir}\` (set via="global"). cwd \`${projectDir}\`.`,
+    `3. The command prints a JSON object to stdout with fields: ok, exitCode, winner, ranked, n.`,
+    `4. COPY those fields (ok, exitCode, winner, ranked) up to the TOP LEVEL of your reply, plus via. Do NOT nest them under "envelope". If the command failed, set winner=null.`,
+    `Do NOT do any other work.`,
+  ].join("\n");
+  const opts = { label, schema: _JUDGE_ENVELOPE_SCHEMA, model: "haiku" };
+  if (phaseNameOpt) opts.phase = phaseNameOpt;
+  const r = await agent(prompt, opts).catch((e) => ({ ok: false, winner: null, ranked: [], via: "error", err: String(e && e.message) }));
+  // Prefer top-level fields; fall back to a nested envelope if the agent nested anyway.
+  const env = (r && r.winner !== undefined) ? r : (r && r.envelope) || {};
+  return { ok: !!env.ok, winner: env.winner != null ? env.winner : null, ranked: env.ranked || [] };
+}
+
+// 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).
+const COMPETITION_ELIGIBLE = new Set(["partition", "milestone", "discuss", "design-decompose"]);
+
+// Rubric axes for the SUBJECTIVE judge (non-partition eligible phases). Partition
+// uses the objective oracle instead and ignores these.
+const RUBRIC_AXES_BY_PHASE = {
+  milestone: [
+    { key: "coherence", weight: 2 }, { key: "completeness", weight: 1 },
+    { key: "riskCoverage", weight: 1 }, { key: "simplicity", weight: 1 },
+  ],
+  discuss: [
+    { key: "soundness", weight: 2 }, { key: "completeness", weight: 1 },
+    { key: "tradeoffClarity", weight: 1 }, { key: "simplicity", weight: 1 },
+  ],
+  "design-decompose": [
+    { key: "fidelity", weight: 2 }, { key: "completeness", weight: 1 },
+    { key: "reuse", weight: 1 }, { key: "simplicity", weight: 1 },
+  ],
+};
+
 const VALID_PHASES = [
   "partition", "plan", "discuss", "impact",
   "milestone", "prd", "design-decompose", "doc-ripple",
@@ -79,6 +162,15 @@ 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(", ")}.`);
+}
+
 if (!phaseName || !VALID_PHASES.includes(phaseName)) {
   log(`phase: args.phase must be one of: ${VALID_PHASES.join(", ")}`);
   return { status: "failed", reason: "invalid-phase" };
@@ -101,23 +193,245 @@ const promptByPhase = {
   "doc-ripple": `Identify and update all docs affected by recent code changes per the Document Ripple Completion Gate. No code edits.`,
 };
 
-const result = await agent(
-  [
-    `You are the ${phaseName} phase agent.`,
-    milestone ? `Milestone: ${milestone}` : "",
-    `**Brief (REQUIRED):** ${brief.briefPath || "(no brief — re-walk repo)"}`,
-    userInput ? `\nUser input:\n${userInput}` : "",
-    ``,
-    `Objective: ${promptByPhase[phaseName]}`,
-    ``,
-    `Follow the CLAUDE.md Pre-Commit Gate. Commit artifacts with prefix "m61(${phaseName})" or similar.`,
-    `Return JSON per the schema.`,
-  ].filter(Boolean).join("\n"),
-  { label: phaseName, phase: "Phase", schema: PHASE_RESULT_SCHEMA, model: "opus" }
-).catch((e) => ({
-  status: "failed",
-  artifacts: [],
-  summary: `agent error: ${e && e.message}`,
-}));
+const baseObjective = promptByPhase[phaseName];
+const briefLine = `**Brief (REQUIRED):** ${brief.briefPath || "(no brief — re-walk repo)"}`;
+
+let result;
+if (!competitionOn) {
+  // ── Single-producer path (default, unchanged behavior) ──
+  result = await agent(
+    [
+      `You are the ${phaseName} phase agent.`,
+      milestone ? `Milestone: ${milestone}` : "",
+      briefLine,
+      userInput ? `\nUser input:\n${userInput}` : "",
+      ``,
+      `Objective: ${baseObjective}`,
+      ``,
+      `Follow the CLAUDE.md Pre-Commit Gate. Commit artifacts with prefix "${(milestone || "m").toLowerCase()}(${phaseName})".`,
+      `Return JSON per the schema.`,
+    ].filter(Boolean).join("\n"),
+    { 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.",
+  ];
+
+  const PRODUCER_SCHEMA = phaseName === "partition"
+    ? {
+        type: "object", required: ["id", "domains"], additionalProperties: true,
+        properties: {
+          id: { type: "string" },
+          rationale: { type: "string" },
+          domains: {
+            type: "array", items: {
+              type: "object", required: ["name", "touches"], additionalProperties: true,
+              properties: {
+                name: { type: "string" },
+                touches: { type: "array", items: { type: "string" } },
+                summary: { type: "string" },
+              },
+            },
+          },
+        },
+      }
+    : {
+        type: "object", required: ["id", "proposal"], additionalProperties: true,
+        properties: { id: { type: "string" }, proposal: { type: "string" }, rationale: { type: "string" } },
+      };
+
+  phase("Compete");
+  log(`competition: ${competitionN} producers (Self-MoA, model=opus) for ${phaseName}`);
+  const ids = ["A", "B", "C", "D", "E"];
+  const candidates = (await parallel(
+    Array.from({ length: competitionN }, (_, i) => () =>
+      agent(
+        [
+          `You are candidate ${ids[i]} — one of ${competitionN} INDEPENDENT ${phaseName} proposals competing on quality.`,
+          milestone ? `Milestone: ${milestone}` : "",
+          briefLine,
+          userInput ? `\nUser input:\n${userInput}` : "",
+          ``,
+          `Objective: ${baseObjective}`,
+          `Your distinct angle: ${ANGLES[i % ANGLES.length]}`,
+          ``,
+          `DO NOT write or commit any files. PROPOSE ONLY — return your proposal as JSON per the schema.`,
+          phaseName === "partition"
+            ? `For "touches", list the concrete repo file paths each domain will WRITE (its owned files). Be specific and realistic — the judge scores file-disjointness from these.`
+            : `Put the full proposal text in "proposal".`,
+          `Set "id" to "${ids[i]}".`,
+        ].filter(Boolean).join("\n"),
+        { label: `candidate:${ids[i]}`, phase: "Compete", schema: PRODUCER_SCHEMA, model: "opus" }
+      ).then((c) => ({ ...c, id: c.id || ids[i] })).catch(() => null)
+    )
+  )).filter(Boolean);
+
+  if (candidates.length === 0) {
+    return { status: "failed", artifacts: [], summary: "competition: all producers failed" };
+  }
+
+  phase("Judge");
+  let winnerId = null;
+  let ranked = [];
+  if (phaseName === "partition") {
+    // OBJECTIVE oracle judge — calculator, not critic.
+    const env = await runCompetitionJudge(projectDir, { kind: "partition", candidates }, "judge:oracle", "Judge");
+    winnerId = env.winner; ranked = env.ranked || [];
+  } else {
+    // SUBJECTIVE judge: a different-model (sonnet) rubric scorer. Candidates are
+    // blind (author identity stripped) AND shuffled (deterministic permutation) so
+    // judge position no longer correlates with producer index/angle — Red Team
+    // HIGH-3: the shuffle was claimed in a comment but never implemented.
+    const axes = RUBRIC_AXES_BY_PHASE[phaseName] || [{ key: "quality", weight: 1 }];
+    // Deterministic permutation (Math.random is sandbox-banned): rotate by a seed
+    // derived from the milestone+phase string so order is stable per run but
+    // decoupled from producer index. The CLI tiebreak keys off the candidate's own
+    // id (carried through), so final selection stays reproducible regardless.
+    const seedStr = `${milestone || "m"}:${phaseName}`;
+    let seed = 0;
+    for (let k = 0; k < seedStr.length; k++) seed = (seed * 31 + seedStr.charCodeAt(k)) >>> 0;
+    const rot = candidates.length ? (seed % candidates.length) : 0;
+    const shuffled = candidates.map((_, i) => candidates[(i + rot) % candidates.length]);
+    const labeled = shuffled.map((c, i) => ({ id: c.id, label: ids[i], text: c.proposal || c.rationale || "" }));
+    const rubric = await agent(
+      [
+        `You are a BLIND, IMPARTIAL judge scoring ${labeled.length} competing ${phaseName} proposals.`,
+        `Score each on a 1-5 scale per axis: ${axes.map((a) => a.key).join(", ")}. Higher = better.`,
+        `Judge ONLY the content. The labels are arbitrary and the order is randomized — do NOT prefer earlier ones. Be calibrated and critical.`,
+        ``,
+        ...labeled.map((c) => `### Candidate ${c.label}\n${c.text}`),
+        ``,
+        `Return JSON: { "scores": [ { "id": "<candidate label A/B/C...>", "<axis>": <1-5>, ... }, ... ] }`,
+        `IMPORTANT: use the CANDIDATE LABEL (A, B, C…) shown above as the "id" in your scores.`,
+      ].join("\n"),
+      {
+        label: "judge:rubric", phase: "Judge", model: "sonnet",
+        schema: {
+          type: "object", required: ["scores"], additionalProperties: true,
+          properties: { scores: { type: "array", items: { type: "object", additionalProperties: true } } },
+        },
+      }
+    ).catch(() => ({ scores: [] }));
+    // Map the judge's label-keyed scores back to the REAL candidate ids before
+    // deterministic selection (so the winner id matches an actual candidate).
+    const labelToId = new Map(labeled.map((c) => [c.label, c.id]));
+    const judgeCandidates = (rubric.scores || []).map((s) => {
+      const { id, ...rest } = s; return { id: labelToId.get(id) || id, scores: rest };
+    });
+    const env = await runCompetitionJudge(projectDir, { kind: "generic", axes, candidates: judgeCandidates }, "judge:select", "Judge");
+    winnerId = env.winner; ranked = env.ranked || [];
+  }
+
+  // Red Team HIGH-1: NEVER fall back to an arbitrary candidate. For partition the
+  // judge returns winner=null only when EVERY candidate is file-overlapping
+  // (invalid) — committing candidates[0] would ship an invalid partition the
+  // dispatcher then mis-fans-out (contract Invariant 2). Hard-fail instead.
+  let winner = candidates.find((c) => c.id === winnerId);
+  if (!winner) {
+    if (phaseName === "partition") {
+      log(`competition: no VALID partition among ${candidates.length} candidates — failing the phase (Invariant 2: invalid never selected).`);
+      return {
+        status: "failed", artifacts: [],
+        summary: `competition: no valid (file-disjoint) partition among ${candidates.length} candidates`,
+        competition: { n: candidates.length, winner: null, ranked },
+      };
+    }
+    // Subjective phases: fall back to the judge's rank-1, else the first candidate.
+    const rank1 = (ranked[0] && candidates.find((c) => c.id === ranked[0].id)) || candidates[0];
+    winner = rank1;
+    log(`competition: judge returned no winner; falling back to rank-1 (${winner.id}).`);
+  }
+  log(`competition: winner = ${winner.id} (of ${candidates.map((c) => c.id).join(", ")})`);
+
+  // FINALIZE: one agent commits the WINNING approach (pick-one at the thesis level),
+  // then enriches it with non-overlapping good line-items from the losers (safe union
+  // at the separable layer — "winner + salvage orphaned good ideas"; never grafts a
+  // coupled thesis). Per the two-gate rule in competition-mode-contract.md.
+  phase("Finalize");
+  const winnerBlob = phaseName === "partition" ? JSON.stringify(winner.domains) : (winner.proposal || winner.rationale || "");
+  const losersBlob = candidates.filter((c) => c.id !== winner.id)
+    .map((c) => phaseName === "partition" ? JSON.stringify(c.domains) : (c.proposal || c.rationale || ""))
+    .join("\n---\n");
+  // For partition, the finalizer must report the EXACT domains+touches it committed
+  // so we can RE-VALIDATE the graft (Red Team HIGH-2 / contract Invariant 4: a
+  // salvaged "missed file" could silently reintroduce a write-target overlap).
+  const FINALIZE_SCHEMA = phaseName === "partition"
+    ? {
+        // finalizedDomains REQUIRED for partition (Red Team recheck LOW-1): if it's
+        // optional, a finalizer that omits it silently bypasses re-validation.
+        type: "object", required: ["status", "artifacts", "finalizedDomains"], additionalProperties: false,
+        properties: {
+          status: { type: "string", enum: ["complete", "partial", "blocked", "failed"] },
+          artifacts: { type: "array", items: { type: "string" } },
+          summary: { type: "string" },
+          decisions: { type: "array", items: { type: "string" } },
+          finalizedDomains: {
+            type: "array", items: {
+              type: "object", required: ["name", "touches"], additionalProperties: true,
+              properties: { name: { type: "string" }, touches: { type: "array", items: { type: "string" } } },
+            },
+          },
+        },
+      }
+    : PHASE_RESULT_SCHEMA;
+
+  result = await agent(
+    [
+      `You are the ${phaseName} finalizer. A competition selected a WINNING proposal; implement it for real.`,
+      milestone ? `Milestone: ${milestone}` : "",
+      briefLine,
+      ``,
+      `Objective: ${baseObjective}`,
+      ``,
+      `WINNING proposal (implement this whole — it is a coherent thesis, do NOT Frankenstein it):`,
+      winnerBlob,
+      ``,
+      `Other proposals (for SALVAGE ONLY — fold in any non-overlapping, clearly-good line-items, e.g. an extra risk, a missed file, a better domain name — that do NOT conflict with the winning structure. NEVER assign a file to a domain that another domain already owns. If in doubt, leave them out):`,
+      losersBlob || "(none)",
+      ``,
+      `Now WRITE the real artifacts and follow the CLAUDE.md Pre-Commit Gate. Commit with prefix "${(milestone || "m").toLowerCase()}(${phaseName})".`,
+      phaseName === "partition"
+        ? `Return JSON per the schema, INCLUDING "finalizedDomains" — the exact {name, touches[]} of every domain you committed (touches = the repo files each domain OWNS/WRITES). This is re-validated for file-disjointness.`
+        : `Return JSON per the schema.`,
+      `Include the competition outcome in "decisions" (e.g. "competition: winner ${winner.id} of ${candidates.length}").`,
+    ].filter(Boolean).join("\n"),
+    { label: `${phaseName}:finalize`, phase: "Finalize", schema: FINALIZE_SCHEMA, model: "opus" }
+  ).catch((e) => ({ status: "failed", artifacts: [], summary: `finalizer error: ${e && e.message}` }));
+
+  // Re-validate the FINALIZED partition (Invariant 4). If salvage reintroduced an
+  // overlap, the finalized graft is invalid → block completion with a clear reason.
+  if (phaseName === "partition" && result && result.status !== "failed") {
+    const finalized = Array.isArray(result.finalizedDomains) ? result.finalizedDomains : null;
+    if (!finalized || !finalized.length) {
+      // No finalizedDomains to re-check → can't prove disjointness → block rather
+      // than silently accept (Red Team recheck LOW-1: never fail-open on the gate).
+      log(`competition: finalizer returned no finalizedDomains — cannot re-validate disjointness, blocking.`);
+      result.status = "blocked";
+      result.summary = `finalizer did not report finalizedDomains; partition disjointness unverifiable. ${result.summary || ""}`.trim();
+    } else {
+      const reval = await runCompetitionJudge(
+        projectDir,
+        { kind: "partition", candidates: [{ id: "finalized", domains: finalized }] },
+        "judge:revalidate", "Finalize"
+      );
+      if (reval.winner !== "finalized") {
+        log(`competition: FINALIZED partition failed re-validation (salvage reintroduced a file overlap) — blocking (Invariant 4).`);
+        result.status = "blocked";
+        result.summary = `finalized partition is NOT file-disjoint (salvage overlap); re-run finalize dropping the conflicting file. ${result.summary || ""}`.trim();
+      }
+    }
+  }
+
+  // Thread the competition telemetry up so the caller can report measured SC#1.
+  result.competition = { n: candidates.length, winner: winner.id, ranked };
+}
 
 return result;