@tekyzinc/gsd-t 4.7.11 → 4.9.11

package/templates/prompts/qa-subagent.md

@@ -1,5 +1,9 @@
 # QA Subagent Prompt — Per-Task Validation
 
+<!-- reader-contract -->
+**Report concisely:** verdict/answer first, no preamble. Gloss every code/jargon term (e.g. `M93-D2` = milestone 93, domain 2) in plain words on first use. Bullets over paragraphs. Expand only if asked.
+<!-- /reader-contract -->
+
 You are the QA agent. Your sole job is test generation, execution, and gap reporting. You write ZERO feature code. You never modify implementation files — only test files and reports.
 
 <!-- M61 D7-T3: Workflow-stage invocation -->
@@ -8,6 +12,16 @@ You are the QA agent. Your sole job is test generation, execution, and gap repor
 <!-- M55-D5: brief-first rule -->
 **Brief first.** If you're about to grep, read, or run a test, check the brief first at `$BRIEF_PATH` (a ≤2,500-token JSON snapshot of CLAUDE.md + contracts + scope + constraints, generated by `bin/gsd-t-context-brief.cjs`). The brief replaces the 30–60k context re-read every parallel worker would otherwise perform — it's the dominant ITPM-relief lever in M55. If `$BRIEF_PATH` is unset or the file is missing, fall back to the legacy read-everything pattern, but log a note so the orchestrator can see the gap.
 
+<!-- guard-map-ingest -->
+**Guard-map rule ingest (A5 — contract-compliance frame).** When a guard-map is
+present, the surfaced RULE-ID set reaches you via
+`gsd-t rule-consume --map <guard-map.json> --json` → the `qa` array. INGEST that
+set: treat **every RULE-ID as a required compliance assertion**. For each id, the
+build/tests MUST demonstrate the rule's invariant holds — an unverified or
+unasserted rule is a contract-compliance FAILURE, not a pass. Do NOT drop, skip,
+or sample rules: every id in the `qa` frame is a mandatory check.
+<!-- /guard-map-ingest -->
+
 ## What to Do
 
 1. **Detect every configured test suite** in this project — vitest/jest/mocha config, `playwright.config.*`, `cypress.config.*`. Run EVERY suite that exists.

package/templates/prompts/red-team-subagent.md

@@ -1,5 +1,9 @@
 # Red Team Subagent Prompt — Adversarial QA (per-domain)
 
+<!-- reader-contract -->
+**Report concisely:** verdict/answer first, no preamble. Gloss every code/jargon term (e.g. `M93-D2` = milestone 93, domain 2) in plain words on first use. Bullets over paragraphs. Expand only if asked.
+<!-- /reader-contract -->
+
 You are a Red Team QA adversary. Your job is to BREAK the code that was just written for this domain. You operate with inverted incentives — your value is measured by REAL bugs found, not tests passed.
 
 <!-- M61 D7-T3: Workflow-stage invocation -->
@@ -8,6 +12,18 @@ You are a Red Team QA adversary. Your job is to BREAK the code that was just wri
 <!-- M55-D5: brief-first rule -->
 **Brief first.** If you're about to grep, read, or run a test, check the brief first at `$BRIEF_PATH` (a ≤2,500-token JSON snapshot of CLAUDE.md + contracts + scope + constraints + recent commits, generated by `bin/gsd-t-context-brief.cjs --kind red-team`). The brief identifies high-risk surfaces, recent diffs, and contract status — your starting attack surface. The brief replaces the 30–60k context re-read every parallel worker would otherwise perform. If `$BRIEF_PATH` is unset or the file is missing, fall back to the legacy read-everything pattern, but log a note so the orchestrator can see the gap.
 
+<!-- guard-map-ingest -->
+**Guard-map rule ingest (A5 — attack-surface frame).** When a guard-map is
+present, the surfaced RULE-ID set reaches you via
+`gsd-t rule-consume --map <guard-map.json> --json` → the `redTeam` array. INGEST
+that set: treat **every RULE-ID as an invariant to ATTACK**. For each id, mount a
+concrete attack that tries to make the rule's invariant FALSE (boundary inputs,
+race/double-submit, out-of-order state, error paths). A rule you cannot break
+after an exhaustive attempt is a defended invariant; a rule you DROP from your
+attack plan is a seam breach. Do NOT sample — every id in the `redTeam` frame
+must be attacked.
+<!-- /guard-map-ingest -->
+
 ## Hard Rules
 
 - **Bugs found = value.** A short attack list is failure.

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

@@ -548,9 +548,15 @@ for (const dr of domainResults.filter(Boolean)) {
     reason: triggerEnv.reason || null,
     provenByAdversaryOnly: triggerEnv.provenByAdversaryOnly || false,
     stopDirective: triggerEnv.stopDirective || false,
+    // M92 — surface the cheaper-first response rung + its directive (look→smallest→spike→defer)
+    // so the "look at what exists / smallest change" guidance reaches the worker.
+    mode: triggerEnv.mode || null,
+    responseDirective: triggerEnv.lookDirective || triggerEnv.smallestDirective || triggerEnv.deferDirective || null,
   });
 }
-log(`M90 arch-trigger: ${domainArchTriggerResults.length} domain(s) fired extend-existing-code signal`);
+log(`M90 arch-trigger: ${domainArchTriggerResults.length} domain(s) fired extend-existing-code signal` +
+  (domainArchTriggerResults.some((r) => r.mode === "look")
+    ? ` — M92 default response: LOOK (grep/read existing before scoping)` : ""));
 
 phase("Integrate");
 const integratePrompt = [

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

@@ -555,9 +555,19 @@ const _PROBE_SCHEMA = {
     approaches: { type: "array", items: { type: "string" } },
   },
 };
-async function runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPath, userInput, phaseNameOpt } = {}) {
+async function runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPath, userInput, phaseNameOpt, altitude } = {}) {
+  // M87 altitude shift: when behavior is SPEC'D (the milestone is authored at the
+  // intention-first high-level-approach altitude), the milestone solution-space
+  // probe shifts UP — it competes over high-level APPROACHES (what/why/when, actors,
+  // one-breath thesis), NOT lower-altitude implementation detail. This changes WHAT
+  // the producers compete on, never WHO competes (producers stay opus, judge differs —
+  // M82 blindness invariant preserved) nor the probe's model (stays fable).
+  const atApproachAltitude = altitude === "high-level-approach";
   const prompt = [
     `You are the Solution-Space Probe for the ${phaseName} phase${milestone ? ` of ${milestone}` : ""}. Decide ONE thing: should this phase generate MULTIPLE competing candidates (then a judge picks the best), or is a single draft sufficient?`,
+    atApproachAltitude
+      ? `ALTITUDE: HIGH-LEVEL APPROACH (M87 — behavior is spec'd intention-first). Compete over distinct high-level APPROACHES — what/why/when, the actors, the one-breath thesis — NOT over field-level implementation detail. The competition is about WHICH approach best serves the intention, decided before the detailed PseudoCode-[Title].md is authored.`
+      : "",
     `**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".`,
@@ -690,9 +700,13 @@ if (_competitionEligible) {
     // Automatic decision — the workflow probes and decides. Opus probe (or the
     // partition-specific probe); biased toward competing.
     phase("Probe");
+    // M87: the milestone phase is authored intention-first — behavior is spec'd at the
+    // high-level-approach altitude, so its solution-space probe shifts UP to compete over
+    // high-level approaches (not implementation detail). Other phases keep their altitude.
+    const _probeAltitude = phaseName === "milestone" ? "high-level-approach" : undefined;
     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" });
+      : await runSolutionSpaceProbe(projectDir, phaseName, { milestone, briefPath: brief.briefPath, userInput, phaseNameOpt: "Probe", altitude: _probeAltitude });
     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("; ")}]` : ""}`);
@@ -720,6 +734,12 @@ ${STATED_CLAIMS_INSTRUCTION}`,
 ${STATED_CLAIMS_INSTRUCTION}`,
   milestone: `Define a new milestone — origin, goal, success criteria, falsifiable acceptance. Append to .gsd-t/progress.md. Defer partition/plan.
 
+TWO-ALTITUDE INTENTION-FIRST FLOW (M87, default-ON — contract pseudocode-source-of-truth-contract.md §1). Author the milestone at two altitudes, IN ORDER:
+  ALTITUDE 1 — HIGH-LEVEL APPROACH (signed off FIRST): emit the high-level approach pseudocode — what/why/when (the user's intention, never agent reasoning), the actors, and a one-breath summary ("one call in one breath"). PRESENT this approach to the user for SIGN-OFF. The detailed doc is authored ONLY AFTER the approach is approved — the sign-off is the checkpoint between the two altitudes. (This is a PROSE flow: describe the checkpoint; do NOT assert a machine-checkable DEFINED-state predicate — that is M88.)
+  ALTITUDE 2 — DETAILED doc: only after the approach is signed off, author .gsd-t/pseudocode/PseudoCode-[Title].md at exemplar granularity (the §1 section set: Intention, Mechanism, one-breath table, Guard map, Divergence flags, Appendix). [Title] = the SUBJECT (e.g. PseudoCode-PayPal.md), never a milestone id; a milestone may produce several.
+DEFAULT-ON; skip is a LOGGED decision in progress.md naming WHY — NEVER a silent default-off (feedback_no_silent_degradation).
+KEEP-OR-SUPERSEDE: before encoding any model inherited from shipped code, run the keep-or-supersede protocol (templates/prompts/keep-or-supersede-subagent.md) — per inherited model ASK keep or supersede; each supersede WRITES a ⚠ Divergence flag (§4 grammar) into the doc. Keep = no flag.
+
 ${STATED_CLAIMS_INSTRUCTION}`,
   prd: `Generate a product requirements doc at docs/prd.md. Functional + non-functional requirements traceable to acceptance criteria.`,
   "design-decompose": `Decompose a design reference (Figma URL / images) into hierarchical contracts: elements -> widgets -> pages, each at .gsd-t/contracts/design/.`,

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

@@ -182,8 +182,17 @@ const result = await agent(
     `Quick task: ${task}`,
     `**Brief:** ${brief.briefPath || "(no brief)"}`,
     ``,
+    `**CRUX-FIRST — START HERE (smallest change is the default, ceremony is opt-in):**`,
+    `1. CRUX: state the crux of this ask in ONE line — the single thing that must become true.`,
+    `2. WHAT EXISTS: grep/read what ALREADY exists for this before choosing any scope.`,
+    `   Do not build outward until you know what is already here to edit.`,
+    `3. SMALLEST CHANGE: propose the SMALLEST change that hits the crux — edit INWARD at the`,
+    `   source (the one place the behavior is defined), not OUTWARD at the N consumers.`,
+    `   The recommendation is "do it directly / one-file change," not a partition or plan.`,
+    `4. ESCALATE ONLY IF NEEDED: reach for ceremony (plan→execute, partition, competition) ONLY`,
+    `   when the crux genuinely needs cross-domain coordination or real uncertainty — and say WHY.`,
+    ``,
     `Constraints from CLAUDE.md:`,
-    `- SIMPLICITY ABOVE ALL — minimal change`,
     `- Check downstream effects before changing existing code`,
     `- Run affected tests before reporting done`,
     `- Update relevant docs in the same commit`,
@@ -372,13 +381,18 @@ if (Array.isArray(result.filesEdited) && result.filesEdited.length > 0) {
       "Research"
     );
     const triggerEnv = triggerResult.envelope || {};
-    log(`M90 arch-trigger quick: fired=${triggerEnv.fired} reason=${triggerEnv.reason || "?"} provenByAdversaryOnly=${triggerEnv.provenByAdversaryOnly || false}`);
+    const m92Directive = triggerEnv.lookDirective || triggerEnv.smallestDirective || triggerEnv.deferDirective || null;
+    log(`M90 arch-trigger quick: fired=${triggerEnv.fired} reason=${triggerEnv.reason || "?"} provenByAdversaryOnly=${triggerEnv.provenByAdversaryOnly || false}` +
+      (triggerEnv.mode ? ` — M92 response: ${triggerEnv.mode}${triggerEnv.mode === "look" ? " (grep/read existing before scoping)" : ""}` : ""));
     quickArchTriggerResult = {
       existingFiles,
       fired: triggerEnv.fired || false,
       reason: triggerEnv.reason || null,
       provenByAdversaryOnly: triggerEnv.provenByAdversaryOnly || false,
       stopDirective: triggerEnv.stopDirective || false,
+      // M92 — cheaper-first response rung + its directive surfaced to the quick worker.
+      mode: triggerEnv.mode || null,
+      responseDirective: m92Directive,
     };
   }
 }

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

@@ -39,6 +39,7 @@ export const meta = {
     { title: "Auto-Research Gate", detail: "M89 §7 ENFORCE: scan for status=uncited markers (A4 — no silent guess)" },
     { title: "CI-Parity",          detail: "M57 build-coverage + ci-parity (FAIL-blocking)" },
     { title: "Test-Data Purge",    detail: "M58 test-data --purge (FAIL-blocking)" },
+    { title: "Guard-Map Gate",     detail: "M87 [RULE] guard-map gate (FAIL-blocking, §7 discovery)" },
     { title: "Orthogonal Triad",   detail: "code-review ultra ∥ Red Team ∥ QA" },
     { title: "Synthesis",          detail: "merge without collapsing categories" },
   ],
@@ -77,6 +78,13 @@ async function runCli(projectDir, subcmd, argv, localBin, label, parseJson = tru
 }
 async function runPreflight(projectDir, label = "preflight", phaseName) { return runCli(projectDir, "preflight", ["--json"], "cli-preflight.cjs", label, true, phaseName); }
 async function runVerifyGate(projectDir, label = "verify-gate", phaseName) { return runCli(projectDir, "verify-gate", ["--json"], "gsd-t-verify-gate.cjs", label, true, phaseName); }
+// M92 D2 (keystone) — the deterministic shrink-metric. Computes the milestone diff's
+// net size from `git diff --numstat <range>` via the shared runCli helper (M71-clean:
+// the git call runs in the agent's Bash, NOT via require/fs/child_process here). model:
+// "haiku" (mechanical), like the other deterministic-gate CLI calls.
+async function runShrinkMetric(projectDir, range, label = "m92:shrink-metric", phaseName) {
+  return runCli(projectDir, "shrink-metric", ["--range", range, "--project-dir", projectDir, "--json"], "gsd-t-shrink-metric.cjs", label, true, phaseName);
+}
 async function generateBrief(projectDir, { kind = "verify", milestone, domain, id, label = "brief", phaseName } = {}) {
   const argv = ["--kind", kind, "--spawn-id", id, "--out", `${projectDir}/.gsd-t/briefs/${id}.json`];
   if (milestone) argv.push("--milestone", milestone);
@@ -205,6 +213,20 @@ const VERDICT_SCHEMA = {
     overallVerdict: { type: "string", enum: ["VERIFIED", "VERIFIED-WITH-WARNINGS", "VERIFY-FAILED"] },
     summary:        { type: "string" },
     blockingFindings: { type: "array", items: { type: "string" } },
+    // M92 D2 (keystone) — ADDITIVE, ORTHOGONAL "did it get leaner" readout. The
+    // 3-enum stays the pure correctness gate (AND-of-gates); `shrink` is a SEPARATE
+    // success dimension surfaced ALONGSIDE it (never folded into pass/fail). MEASURED
+    // by bin/gsd-t-shrink-metric.cjs from `git diff --numstat`, never LLM-attested.
+    // Optional: omitted when the diff base is unavailable (logged skip-with-reason).
+    shrink: {
+      type: "object",
+      required: ["netLoc", "leaner"],
+      additionalProperties: true,
+      properties: {
+        netLoc: { type: "number" },
+        leaner: { type: "boolean" },
+      },
+    },
   },
 };
 
@@ -517,7 +539,105 @@ if (!td.ok) {
   log(`M58 test-data purge FAIL exitCode=${td.exitCode} — halting (FAIL-blocking)`);
   return { status: "test-data-purge-failed", overallVerdict: "VERIFY-FAILED", testDataPurge: td.envelope };
 }
-log(`M58 test-data purge green — proceeding to orthogonal triad`);
+log(`M58 test-data purge green — proceeding to guard-map gate`);
+
+// ─── M87 D1 Guard-Map Gate (FAIL-blocking — A1 / SC1) ─────────────────────
+// Turns each PseudoCode-[Title].md prose `[RULE]` guard map into a
+// machine-checkable gate: a divergent (UNBACKED or CONTRADICTED) rule HALTS
+// verify BEFORE the triad, at contract-breach severity, naming the RULE-ID —
+// zero LLM judgment in the pass/fail decision (deterministic, like verify-gate /
+// CI-parity / test-data).
+//
+// Discovery per contract §7 (deterministic, path-as-path):
+//   1. glob `.gsd-t/pseudocode/PseudoCode-*.md` (multi-doc — a milestone may
+//      produce several subjects).
+//   2. each doc's map = same basename with `.md` → `.map.json`, co-located.
+//   3. pairing outcomes (each OBSERVABLE, never a silent pass):
+//        - doc + co-located map  → FIRE the gate on that pair.
+//        - doc with no map       → logged skip-with-reason `no-build-map`.
+//        - zero docs             → logged skip-with-reason `no-pseudocode-docs`.
+//   4. the fire path passes `--doc <doc> --map <map>` to gsd-t-guard-map.cjs; any
+//      FAIL-blocking non-zero HALTS verify before the triad.
+// M81: no fs — a haiku discovery agent globs + pairs and returns the set; each
+// fire-able pair is gated via the runCli helper (model: haiku, like the other gates).
+// Contract: pseudocode-source-of-truth-contract.md §2 + §7.
+phase("Guard-Map Gate");
+const GUARD_MAP_DISCOVERY_SCHEMA = {
+  type: "object",
+  required: ["docsFound", "firePairs", "skips"],
+  additionalProperties: true,
+  properties: {
+    docsFound: { type: "integer" },
+    firePairs: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["doc", "map"],
+        properties: { doc: { type: "string" }, map: { type: "string" } },
+      },
+    },
+    skips: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["reason"],
+        properties: { reason: { type: "string" }, doc: { type: "string" } },
+      },
+    },
+    notes: { type: "string" },
+  },
+};
+const guardMapDiscovery = await agent(
+  [
+    `You are the M87 guard-map discovery scanner for the project at "${projectDir}". Discover the PseudoCode doc + build-map pairs per contract §7 (deterministic, path-as-path) and return JSON. Do NOT gate anything — only enumerate.`,
+    ``,
+    `Steps:`,
+    `1. Glob the docs: \`ls ${projectDir}/.gsd-t/pseudocode/PseudoCode-*.md 2>/dev/null || true\`. These are the candidate docs (a milestone may produce SEVERAL — handle the multi-doc set).`,
+    `2. docsFound = the number of PseudoCode-*.md docs found.`,
+    `3. For EACH doc, the build-map is the SAME basename with \`.md\` replaced by \`.map.json\`, co-located in \`.gsd-t/pseudocode/\` (e.g. PseudoCode-Foo.md → PseudoCode-Foo.map.json). Check it exists: \`test -f <map> && echo EXISTS || echo ABSENT\`.`,
+    `   - doc + co-located map EXISTS → add { "doc": "<abs-or-project-rel doc path>", "map": "<map path>" } to firePairs.`,
+    `   - doc with map ABSENT → add { "reason": "no-build-map", "doc": "<doc path>" } to skips (a logged skip WITH A REASON, never a silent pass).`,
+    `4. If docsFound === 0 → firePairs is empty and skips = [ { "reason": "no-pseudocode-docs" } ] (the gate legitimately has nothing to gate, but the skip is SURFACED, not silent).`,
+    ``,
+    `Return JSON per the schema: { "docsFound": N, "firePairs": [ { "doc", "map" } ], "skips": [ { "reason", "doc"? } ], "notes": "..." }. Discovery is path-as-path (glob + basename derivation), never substring.`,
+  ].join("\n"),
+  { label: "guard-map-discovery", phase: "Guard-Map Gate", schema: GUARD_MAP_DISCOVERY_SCHEMA, model: "haiku" }
+).catch((e) => ({ docsFound: 0, firePairs: [], skips: [{ reason: "discovery-error" }], notes: `guard-map discovery agent error: ${e && e.message}` }));
+
+const guardMapResults = [];
+if (guardMapDiscovery.docsFound === 0 || (guardMapDiscovery.firePairs || []).length === 0) {
+  // No fire-able pair — surface the DISTINCT skip reason(s), never a silent pass.
+  const reasons = (guardMapDiscovery.skips || []).map((s) => s.reason).join(", ") || "no-pseudocode-docs";
+  log(`M87 guard-map gate: SKIP (no fire-able doc+map pair) — reason(s): ${reasons}`);
+} else {
+  for (const pair of guardMapDiscovery.firePairs) {
+    const gmr = await runCli(
+      projectDir,
+      "guard-map",
+      ["--doc", pair.doc, "--map", pair.map, "--json"],
+      "gsd-t-guard-map.cjs",
+      `m87:guard-map:${pair.doc.split("/").pop()}`,
+      true,
+      "Guard-Map Gate"
+    );
+    guardMapResults.push({ pair, envelope: gmr.envelope, ok: gmr.ok, exitCode: gmr.exitCode });
+    if (!gmr.ok) {
+      const env = gmr.envelope || {};
+      const named = (env.violations || []).map((v) => v.id).join(", ") || env.reason || "(rule id unavailable)";
+      log(`M87 guard-map gate FAIL exitCode=${gmr.exitCode} on ${pair.doc} — divergent RULE(s): ${named} — halting before triad`);
+      return {
+        status: "guard-map-gate-failed",
+        overallVerdict: "VERIFY-FAILED",
+        reason: `M87 guard-map divergence on ${pair.doc}: ${named} (unbacked or contradicted [RULE]) — back/cite the rule, then re-verify`,
+        guardMap: { discovery: guardMapDiscovery, results: guardMapResults },
+        verifyGate: vg.envelope,
+        autoResearchGate: arGate,
+      };
+    }
+    log(`M87 guard-map gate: PASS on ${pair.doc} — all ${(gmr.envelope && gmr.envelope.ruleCount) || "?"} [RULE]s backed, none contradicted`);
+  }
+  log(`M87 guard-map gate green (${guardMapResults.length} doc+map pair(s) fired) — proceeding to orthogonal triad`);
+}
 
 phase("Orthogonal Triad");
 
@@ -594,6 +714,55 @@ const stages = [
 
 const triadResults = await parallel(stages);
 
+// ─── M92 D2 Shrink-Metric (keystone — ADDITIVE leanness dimension) ─────────
+// Before synthesis, MEASURE the milestone diff's net size so the verdict can SAY
+// "we made it smaller" — a first-class, ORTHOGONAL success dimension surfaced
+// ALONGSIDE the overallVerdict enum (never folded into pass/fail). MEASURED, never
+// LLM-attested ([[feedback_measure_dont_claim]]): the metric is computed by
+// bin/gsd-t-shrink-metric.cjs from `git diff --numstat <base>..HEAD`.
+//
+// The diff base = the milestone branch-point (merge-base of HEAD against the default
+// branch). M71-clean: BOTH the merge-base resolution AND the numstat run go through an
+// agent's Bash, never require/fs/child_process in this orchestrator. If the base can't
+// be resolved (detached HEAD, shallow clone, no default branch), the metric is SKIPPED
+// with a logged reason — NEVER fabricated ([[feedback_no_silent_degradation]]).
+const SHRINK_BASE_SCHEMA = {
+  type: "object",
+  required: ["resolved"],
+  additionalProperties: true,
+  properties: { resolved: { type: "boolean" }, base: { type: "string" }, reason: { type: "string" } },
+};
+const shrinkBase = await agent(
+  [
+    `Resolve the milestone diff BASE for the git repo at "${projectDir}" (the branch-point of the current work). Run ONLY git, report JSON. Steps:`,
+    `1. Find the default branch tip. Try in order, using the first that resolves to a commit (cwd "${projectDir}"):`,
+    `   a. \`git -C "${projectDir}" rev-parse --verify --quiet origin/HEAD\` (then its symbolic target), else`,
+    `   b. \`git -C "${projectDir}" rev-parse --verify --quiet main\`, else`,
+    `   c. \`git -C "${projectDir}" rev-parse --verify --quiet master\`.`,
+    `2. Compute the merge-base of HEAD and that default tip: \`git -C "${projectDir}" merge-base HEAD <defaultTip>\`.`,
+    `3. If a merge-base commit is produced AND it differs from HEAD's own sha (there IS a diff to measure), return { "resolved": true, "base": "<merge-base-sha>" }.`,
+    `4. If NO default branch resolves, OR merge-base fails, OR merge-base === HEAD (nothing to measure), return { "resolved": false, "reason": "<short reason, e.g. no default branch / detached / merge-base===HEAD>" }.`,
+    `Do NOT do any other work. ONLY run git and report.`,
+  ].join("\n"),
+  { label: "m92:shrink-base", phase: "Synthesis", schema: SHRINK_BASE_SCHEMA, model: "haiku" }
+).catch((e) => ({ resolved: false, reason: `shrink-base agent error: ${e && e.message}` }));
+
+let shrink = null;
+let shrinkSkipReason = null;
+if (shrinkBase && shrinkBase.resolved && shrinkBase.base) {
+  const sm = await runShrinkMetric(projectDir, `${shrinkBase.base}..HEAD`, "m92:shrink-metric", "Synthesis");
+  if (sm.ok && sm.envelope && typeof sm.envelope.netLoc === "number" && typeof sm.envelope.leaner === "boolean") {
+    shrink = { netLoc: sm.envelope.netLoc, leaner: sm.envelope.leaner, insertions: sm.envelope.insertions, deletions: sm.envelope.deletions, filesAdded: sm.envelope.filesAdded, filesRemoved: sm.envelope.filesRemoved, filesModified: sm.envelope.filesModified };
+    log(`M92 shrink-metric: netLoc=${shrink.netLoc} leaner=${shrink.leaner} (+${shrink.insertions}/-${shrink.deletions}) — surfacing as the orthogonal leanness dimension`);
+  } else {
+    shrinkSkipReason = `shrink-metric CLI did not return a usable metric (exitCode=${sm.exitCode}) — SKIPPED, not fabricated`;
+    log(`M92 shrink-metric: SKIP — ${shrinkSkipReason}`);
+  }
+} else {
+  shrinkSkipReason = `diff base unavailable (${(shrinkBase && shrinkBase.reason) || "unknown"}) — shrink-metric SKIPPED, never fabricated`;
+  log(`M92 shrink-metric: SKIP — ${shrinkSkipReason}`);
+}
+
 phase("Synthesis");
 const synthesisPrompt = [
   `You are the synthesis agent. Three orthogonal validators have run.`,
@@ -611,7 +780,15 @@ const synthesisPrompt = [
   `- VERIFIED-WITH-WARNINGS if: Red Team GRUDGING-PASS, QA suite green, contracts compliant, AND any of: code-review ultra has "important" findings, OR skipUltra=true (reason: ${skipUltraReason || "(none — would have failed above)"}), OR QA shallowTests.length === 1 (single non-core).`,
   `- VERIFY-FAILED otherwise (Red Team FAIL, QA fail>0, contract violations>0, shallowTests ≥ 2 or in core paths).`,
   ``,
-  `Return JSON per VERDICT_SCHEMA with blockingFindings listing concrete things that must fix.`,
+  `**M92 SHRINK DIMENSION (ORTHOGONAL — do NOT fold into pass/fail):** a deterministic shrink-metric measured the milestone diff:`,
+  shrink
+    ? `    shrink = ${JSON.stringify({ netLoc: shrink.netLoc, leaner: shrink.leaner })}  (full: +${shrink.insertions}/-${shrink.deletions}, files +${shrink.filesAdded}/-${shrink.filesRemoved}/~${shrink.filesModified})`
+    : `    shrink = (SKIPPED — ${shrinkSkipReason}; report it as not-measured, NEVER fabricate a value)`,
+  shrink
+    ? `  Copy this measured shrink object VERBATIM into the "shrink" field of your output ({ "netLoc": ${shrink.netLoc}, "leaner": ${shrink.leaner} }). It is MEASURED — do not recompute or alter it. If leaner=true, explicitly ACKNOWLEDGE in the summary that the milestone made the codebase smaller (net-negative LOC) as a SUCCESS dimension, ORTHOGONAL to the correctness verdict — a VERIFIED-or-not correctness result and a leaner:true result are independent and BOTH reported.`
+    : `  OMIT the "shrink" field (the metric was skipped — say so in the summary; do NOT invent a netLoc/leaner).`,
+  ``,
+  `Return JSON per VERDICT_SCHEMA. Include blockingFindings listing concrete things that must fix${shrink ? ", and the measured shrink object" : ""}.`,
 ].join("\n");
 
 const verdict = await agent(synthesisPrompt, {
@@ -629,6 +806,10 @@ return {
   buildCoverage: bc.envelope,
   ciParity: cip.envelope,
   testDataPurge: td.envelope,
+  guardMap: { discovery: guardMapDiscovery, results: guardMapResults },
   triad: triadResults,
+  // M92 D2 (keystone) — the measured leanness dimension, surfaced ALONGSIDE the
+  // overallVerdict enum (orthogonal; null + a reason when the diff base was unavailable).
+  shrink: shrink || { skipped: true, reason: shrinkSkipReason },
   verdict,
 };