@dev-loops/core 1.0.4-pre.0 → 1.0.4-pre.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-loops/core",
-  "version": "1.0.4-pre.0",
+  "version": "1.0.4-pre.1",
   "type": "module",
   "engines": {
     "node": ">=24"

package/src/analysis/change-classifier.mjs

@@ -99,7 +99,7 @@ export const ALWAYS_INCLUDE = new Set(["gate-evidence", "renderer-security", "pr
  *   merges addedAngles on top to form the full effective run set
  * @property {string[]} skippedAngles — angles skipped with reasons
  * @property {Record<string, string>} reasons — why each angle was skipped
- * @property {boolean} fallbackToAll — true when ambiguous → all angles recommended
+ * @property {boolean} fallbackToAll — retained for compatibility; always false
  * @property {string[]} addedAngles — catalog angles added (additive mode only, see #1048)
  * @property {Record<string, string>} addedReasons — why each added angle was added
  */
@@ -108,8 +108,14 @@ export const ALWAYS_INCLUDE = new Set(["gate-evidence", "renderer-security", "pr
  * Resolve which gate angles to run based on detected change categories.
  *
  * When the diff is ambiguous (no detected categories / analysis failure),
- * all configured angles are recommended (fallback-to-all). A LOGIC_CHANGE
- * diff resolves to its core review subset, not fallback-to-all.
+ * uncertainty still resolves through the same best-effort selection as a
+ * classified diff; it never expands to every configured angle. A LOGIC_CHANGE
+ * diff likewise resolves to its core review subset.
+ *
+ * `configuredAngles` is the caller's candidate pool (mandatory angles have
+ * already been removed), so an uncertain diff may legitimately resolve to an
+ * empty candidate set. The caller combines this with its mandatory floor and
+ * falls back to the static pool if that combined selection would be empty.
  *
  * When `anglePool` is provided (additive mode, see #1048), catalog angles in
  * the pool that the change categories recommend but that are not already in
@@ -121,8 +127,8 @@ export const ALWAYS_INCLUDE = new Set(["gate-evidence", "renderer-security", "pr
  * angle) can still be recommended BY change category or file kind when it
  * declares `categories`/`kinds` via `angleDeclarations`. This is purely
  * additive: it can only SELECT such an angle when the diff intersects its
- * declaration; it never drops any angle the catalog map, ALWAYS_INCLUDE, or the
- * fallback-to-all path would otherwise recommend.
+ * declaration; it never drops any angle the catalog map or ALWAYS_INCLUDE
+ * would otherwise recommend.
  *
  * @param {object} options
  * @param {string[]} options.configuredAngles — all angles configured for this gate
@@ -146,30 +152,6 @@ export function resolveDynamicAngles({
   angleDeclarations = {},
   fileKinds = [],
 }) {
-  // Fallback: ambiguous diff → all angles
-  if (ambiguous) {
-    return {
-      recommendedAngles: [...configuredAngles],
-      skippedAngles: [],
-      reasons: {},
-      fallbackToAll: true,
-      addedAngles: [],
-      addedReasons: {},
-    };
-  }
-
-  // No change categories → all angles (defensive)
-  if (changeCategories.length === 0) {
-    return {
-      recommendedAngles: [...configuredAngles],
-      skippedAngles: [],
-      reasons: {},
-      fallbackToAll: true,
-      addedAngles: [],
-      addedReasons: {},
-    };
-  }
-
   // Build recommended set from category union, tracking the first trigger per angle
   const recommended = new Set();
   const triggers = new Map();
@@ -219,7 +201,11 @@ export function resolveDynamicAngles({
   // Build reasons
   const reasons = {};
   for (const angle of skippedAngles) {
-    reasons[angle] = `Skipped: detected categories (${changeCategories.join(", ") || "none"}) do not trigger this angle`;
+    reasons[angle] = changeCategories.length === 0
+      ? "Skipped: no change category could be established (uncertain classification)"
+      : ambiguous
+        ? `Skipped: analysis remained ambiguous despite detected categories (${changeCategories.join(", ")})`
+        : `Skipped: detected categories (${changeCategories.join(", ")}) do not trigger this angle`;
   }
 
   // Additive: pull in recommended catalog angles not already configured (#1048)

package/src/analysis/diff-analyzer.mjs

@@ -443,6 +443,8 @@ export function analyzeT1(diffOutput, t0) {
  * @property {T0Result} t0
  * @property {T1Result | null} t1
  * @property {boolean} ambiguous — true when heuristics cannot confidently classify
+ * @property {boolean} fullDiffMissing — true when a mixed diff needed hunk-level
+ *   analysis but the full-diff capture was absent/empty (see analyzeDiff)
  */
 
 /**
@@ -496,9 +498,8 @@ function t0PresentSurfaceCategories(t0) {
 function inferCategoriesFromT0(t0) {
   const categories = t0FileCategories(t0);
   // Pure code-only change (all files classify as code, not a rename) is a
-  // LOGIC_CHANGE. Without this an all-code diff yields no category, which
-  // resolveDynamicAngles treats as unclassifiable → fallback-to-all, regressing
-  // the primary case: a code-only PR must resolve to the LOGIC_CHANGE subset.
+  // LOGIC_CHANGE. Without this an all-code diff yields no category and loses
+  // the justified code-review core from best-effort selection.
   if (!t0.renameOnly && t0.files.length > 0 && t0.files.every((f) => classifyFile(f) === "code")) {
     categories.push("LOGIC_CHANGE");
   }
@@ -523,19 +524,31 @@ export function analyzeDiff({ nameStatusOutput, diffOutput }) {
   const t0Ambiguous = !t0.renameOnly && !t0.allDocs && t0.files.length > 1 &&
     new Set(t0.files.map(classifyFile)).size > 1;
 
-  if (t0Ambiguous && diffOutput) {
+  // A full-diff capture is usable evidence only when it carries non-whitespace
+  // content. A whitespace-only capture (e.g. "   \n") must take the SAME
+  // fail-closed path as an absent/empty one: T1 must not run and
+  // `fullDiffMissing` must fire, so a gate needing the full diff cannot read a
+  // hunk-less whitespace capture as complete evidence.
+  const hasDiffText = typeof diffOutput === "string" && diffOutput.trim().length > 0;
+
+  if (t0Ambiguous && hasDiffText) {
     t1 = analyzeT1(diffOutput, t0);
   }
 
   // When t1 is null (unambiguous diff), infer categories from t0
   // so dynamic angle resolution can narrow for config-only / test-only etc.
   if (!t1) {
-    // A genuinely MIXED diff whose T1 never ran (no diffOutput) must NOT get a
-    // T0-only category: non-empty categories set ambiguous=false, so it would
-    // under-select and drop the code-review core. T0-only inference is safe only
-    // for unambiguous diffs; a mixed diff without hunk content is unclassifiable,
-    // so return empty categories and fall back to the full angle set (fail closed).
-    const changeCategories = t0Ambiguous ? [] : inferCategoriesFromT0(t0);
+    // A genuinely MIXED diff whose T1 never ran (no diffOutput) still has
+    // honest T0 surface evidence. Reuse the same surface-presence categories
+    // as the hunk path, and add LOGIC_CHANGE when code is present, so
+    // best-effort selection retains the code-review core without widening to
+    // the full pool.
+    const changeCategories = t0Ambiguous
+      ? [
+          ...t0PresentSurfaceCategories(t0),
+          ...(t0.files.some((f) => classifyFile(f) === "code") ? ["LOGIC_CHANGE"] : []),
+        ]
+      : inferCategoriesFromT0(t0);
     t1 = {
       changeCategories,
       hunkCount: 0,
@@ -551,11 +564,21 @@ export function analyzeDiff({ nameStatusOutput, diffOutput }) {
   }
 
   // `ambiguous` flags one case: a diff T0 could not classify (mixed categories)
-  // AND whose hunk analysis produced no category. It is NOT the only fallback
-  // trigger — resolveDynamicAngles also falls back whenever changeCategories is
-  // empty. A mixed diff that yields a category (e.g. LOGIC_CHANGE) is classified
-  // and not ambiguous, so LOGIC_CHANGE never forces fallback-to-all via this flag.
+  // AND its available analysis produced no category. Empty categories resolve
+  // through mandatory-floor best-effort selection, while a hunk-less mixed diff
+  // with T0 surface evidence stays classified and keeps its justified core.
   const ambiguous = t0Ambiguous && t1.changeCategories.length === 0;
 
-  return { t0, t1, ambiguous };
+  // Evidence-availability signal, SEPARATE from `ambiguous` on purpose. A mixed
+  // diff whose hunk-level analysis never ran (no full-diff capture) legitimately
+  // classifies through its honest T0 surfaces for ANGLE SELECTION — that is what
+  // keeps the code-review core in the best-effort subset without widening to the
+  // whole pool. But a fail-closed gate that needs the FULL diff (the size
+  // budget's unwaivable block) must not read that angle-selection fallback as
+  // complete evidence: `ambiguous` is now false for this case, so such a gate
+  // would silently downgrade. Consumers that need the diff itself key off THIS
+  // flag instead of piggybacking on the angle classifier's ambiguity flag.
+  const fullDiffMissing = t0Ambiguous && !hasDiffText;
+
+  return { t0, t1, ambiguous, fullDiffMissing };
 }

package/src/claude/asset-generation.mjs

@@ -21,7 +21,10 @@
  *   async-dispatch concerns. The user entrypoint under Claude is the dev-loop *skill*.)
  * - Skills keep name/description/allowed-tools (space-separated) and preserve `user-invocable`
  *   (Claude honors it 1:1 — `user-invocable: false` hides the skill from the `/` menu). The
- *   Pi-specific `compatibility` text is dropped (no Claude field).
+ *   Pi-specific `compatibility` text is dropped (no Claude field). Whole-file skill exclusion is
+ *   applied by `collectGeneratedAssets` in scripts/claude/generate-claude-assets.mjs before these
+ *   transforms run; this is distinct from `<!-- pi-only -->` blocks, which remove only marked body
+ *   sections.
  */
 
 import { parse as parseYaml } from "yaml";
@@ -295,6 +298,38 @@ export function transformCommand({ source, raw, version = "latest" }) {
   return `${lines.join("\n")}\n${body}`;
 }
 
+/**
+ * Check whether a skill should be excluded from Claude asset generation.
+ * Supports:
+ * - `claude-sync: false`
+ * - `harness: pi` (or `harness: ["pi"]`)
+ * - `pi-only: true`
+ *
+ * @param {Record<string, unknown> | undefined} frontmatter
+ * @returns {boolean}
+ */
+export function isSkillExcludedFromClaude(frontmatter) {
+  if (!frontmatter || typeof frontmatter !== "object") {
+    return false;
+  }
+  const claudeSync = frontmatter["claude-sync"];
+  if (claudeSync === false || (typeof claudeSync === "string" && claudeSync.trim().toLowerCase() === "false")) {
+    return true;
+  }
+  const piOnly = frontmatter["pi-only"];
+  if (piOnly === true || (typeof piOnly === "string" && piOnly.trim().toLowerCase() === "true")) {
+    return true;
+  }
+  const harness = frontmatter.harness;
+  if (typeof harness === "string" && harness.trim().toLowerCase() === "pi") {
+    return true;
+  }
+  if (Array.isArray(harness) && harness.length === 1 && String(harness[0]).trim().toLowerCase() === "pi") {
+    return true;
+  }
+  return false;
+}
+
 /**
  * Transform a canonical `skills/<name>/SKILL.md` into a Claude `.claude/skills/<name>/SKILL.md`.
  * @param {{ source: string, raw: string, version?: string }} input

package/src/config/config.mjs

@@ -6,7 +6,7 @@ import { parse as parseYaml } from "yaml";
 import { fileURLToPath } from "node:url";
 import { z } from "zod";
 import { classifyFile } from "../analysis/diff-analyzer.mjs";
-import { ChangeCategory } from "../analysis/change-classifier.mjs";
+import { ChangeCategory, resolveDynamicAngles } from "../analysis/change-classifier.mjs";
 import { isDevLoopConfigSourcePath } from "../loop/gate-carry-forward.mjs";
 import { isClaudeHarness } from "../loop/run-context.mjs";
 import { trimmedOrNull } from "../loop/normalize.mjs";
@@ -184,9 +184,9 @@ const GateTier = z.strictObject({
 });
 
 const GateDynamicConfig = z.strictObject({
-  // Diff-driven dynamic angle PRUNING, ON by default. mandatory:true
-  // angles stay a hard always-run floor; fallbackToAll degrades to the full
-  // static pool when classification is ambiguous.
+  // Diff-driven dynamic angle PRUNING, ON by default. mandatory:true angles
+  // stay a hard always-run floor. fallbackToAll is retained in resolver output
+  // for compatibility but is always false; uncertainty never widens the set.
   subtractive: z.boolean().default(true).describe("Enable diff-driven dynamic angle PRUNING for this gate (ON by default; set false to restore the full static angle pool). Was gates.<gate>.dynamicAngles."),
   // Additive counterpart to the subtractive path: when true, the
   // context-builder may also ADD catalog angles (from resolveAnglePool) that
@@ -2205,12 +2205,15 @@ export function resolveFanoutSequential(config) {
 
 /**
  * Claude-harness-scoped cap on effective fan-out concurrency (per ADR
- * docs/decisions/0069-claude-harness-fanout-concurrency-clamp.md). The
- * shipped cross-harness `gates.fanout.maxConcurrent` default (4) plus the
- * driver's own call still 429s a single-driver Claude session; other
- * harnesses (pi, unknown) are unaffected — see `resolveFanoutEffectiveConcurrency`.
+ * docs/decisions/0069-claude-harness-fanout-concurrency-clamp.md, amended by
+ * docs/decisions/0083-raise-claude-fanout-concurrency-cap-to-4.md). The
+ * `GATE-EXEC-DISPATCH-RETRY-BACKOFF` retry/backoff policy turns a single 429
+ * into latency instead of a failed drive, so this cap only bounds the
+ * steady-state per-wave burst (driver + dispatch units) for a single-driver
+ * Claude session; other harnesses (pi, unknown) are unaffected — see
+ * `resolveFanoutEffectiveConcurrency`.
  */
-export const CLAUDE_MAX_EFFECTIVE_CONCURRENT = 2;
+export const CLAUDE_MAX_EFFECTIVE_CONCURRENT = 4;
 
 /**
  * Resolve the effective fan-out concurrency (dispatch units per wave): 1 when
@@ -2482,6 +2485,51 @@ export function resolveGateTier(config, gate, { changedFiles, filesChanged, line
   return { tier: matched.name, angles: [...new Set([...mandatoryAngles, ...matched.angles])], reason: "tier_match" };
 }
 
+/**
+ * Best-effort angle selection for a diff no diff-class tier matched (an
+ * unclassifiable file, a dev-loop config-source delta, or no tier configured).
+ * Uncertainty selects the mandatory floor plus the lenses the diff still
+ * justifies — the always-include lens and any consumer angle whose declared
+ * category/kind binding intersects the diff. It is never the whole pool,
+ * except for the degenerate gate whose pool holds neither a mandatory nor an
+ * always-include angle: an empty best-effort selection falls back to the static
+ * pool (fail-closed — more angles, not fewer) rather than returning nothing.
+ *
+ * `dynamic.subtractive: false` is the documented opt-out ("restore the full
+ * static angle pool"); this returns the static pool unchanged, mirroring
+ * resolveGateAnglesDynamic's `!gateConfig.dynamicAngles` branch so the composer
+ * and the resolver agree for the same diff.
+ *
+ * This composer has no diff TEXT (only the changed-file list), so it can bind
+ * on file kinds but not on hunk-derived change categories. Except for the
+ * `gate:full` path, it is therefore a lower bound: the round's authoritative
+ * angle set is resolved by resolveGateAnglesDynamic, which can add lenses bound
+ * to real change categories. On `gate:full`, the composer deliberately returns
+ * the full static pool and is instead a superset of the dynamic resolver.
+ */
+function selectFloorPlusJustifiedAngles(config, gate, changedFiles) {
+  const gateConfig = resolveGateConfig(config, gate);
+  // Documented opt-out: `dynamic.subtractive: false` restores the full static
+  // pool. Mirror resolveGateAnglesDynamic's `!gateConfig.dynamicAngles` branch
+  // so the composer and the resolver never disagree under an explicit operator
+  // config (both are callers of the same selection contract).
+  if (!gateConfig.dynamicAngles) return resolveGateAngles(config, gate) ?? [];
+  const { mandatoryAngles } = resolveGateAngleContract(config, gate);
+  const pool = resolveGateAngles(config, gate) ?? [];
+  const candidatePool = pool.filter((a) => !mandatoryAngles.includes(a));
+  const validChangedFiles = (Array.isArray(changedFiles) ? changedFiles : [])
+    .filter((f) => typeof f === "string" && f.trim().length > 0);
+  const fileKinds = [...new Set(validChangedFiles.map((f) => classifyFile(f)))];
+  const { recommendedAngles } = resolveDynamicAngles({
+    configuredAngles: candidatePool,
+    changeCategories: [],
+    fileKinds,
+    angleDeclarations: gateConfig.angleCategoryBindings,
+  });
+  const selected = [...new Set([...mandatoryAngles, ...recommendedAngles])];
+  return selected.length > 0 ? selected : pool;
+}
+
 /**
  * The primer-owned deterministic review-proportionality plan
  * (GATE-EXEC-PROPORTIONALITY, gate-review-sub-loop-contract.md): a single,
@@ -2489,25 +2537,25 @@ export function resolveGateTier(config, gate, { changedFiles, filesChanged, line
  * set + execution mode + grouping) is one testable, persistable object.
  * Delegates entirely to {@link resolveGateDispatchMode} (mode, including the
  * non-overridable size-cap/risk-path/size-outcome/ambiguity floors),
- * {@link resolveGateTier} (angle set AND diff-classification), and
- * {@link resolveFanoutGroups} (dispatch-unit grouping). No git I/O, no logic
+ * {@link resolveGateTier} (angle set AND diff-classification),
+ * {@link resolveDynamicAngles} (no-tier best-effort selection), and {@link
+ * resolveFanoutGroups} (dispatch-unit grouping). No git I/O, no logic
  * of its own beyond the floor-vs-tier precedence below: this is the ONE place
  * the primer (emit) and the merge gate (re-verify) compose mode + angles +
  * grouping, so they can never drift onto two different floor implementations.
  *
- * Floor-vs-tier precedence: a fired RISK-signal floor — the risk-path
- * denylist (`risk_path_touch`), a non-clean/ambiguous size-budget outcome
- * (`size_outcome_*`, `size_outcome_unavailable`), missing changed-file
- * evidence (`changed_files_unavailable`), or an unclassifiable diff
- * (`resolveGateTier`'s `unclassifiable_file`) — ALWAYS forces `full_fanout`
- * with the FULL untriered angle pool, never a matched tier's reduced set. The
- * hard size cap (`over_threshold`) differs: it ALWAYS forces `full_fanout`
- * MODE (distinct-reviewer-per-angle, never the light single-combined path)
- * but does NOT force the full untriered pool — a merely-over-cap-but-tier-
- * classifiable diff keeps its diff-class-tier-reduced angle set (the
- * pre-existing, orthogonal mechanism), untouched for a `gate:full`-labelled
- * PR (resolveGateTier self-bypasses) or a repo with light mode disabled
- * (`light_mode_disabled` is not a floor).
+ * Floor-vs-tier precedence: every fired floor affects DISPATCH only. A
+ * RISK-signal floor — the risk-path denylist (`risk_path_touch`), a non-clean/
+ * ambiguous size-budget outcome (`size_outcome_*`,
+ * `size_outcome_unavailable`), missing changed-file evidence
+ * (`changed_files_unavailable`), or an unclassifiable diff
+ * (`resolveGateTier`'s `unclassifiable_file`) — ALWAYS forces `full_fanout`,
+ * as does the hard size cap (`over_threshold`). The angle SET remains the
+ * matched tier or, when no tier matched, the mandatory floor plus the lenses
+ * justified by the changed-file kinds. It never widens to the full untriered
+ * pool merely because a floor fired. A `gate:full` label (which self-bypasses
+ * tier matching) and disabled light mode continue to govern dispatch mode
+ * independently; `light_mode_disabled` is not a floor.
  *
  * @param {DevLoopConfig} config
  * @param {"draft"|"preApproval"} gate
@@ -2544,23 +2592,24 @@ export function resolveReviewProportionality(config, gate, {
     // dispatch-mode facts alone looked trivial.
     unclassifiable: tier.reason === "unclassifiable_file",
   });
-  // sizeCap (over_threshold) is deliberately EXCLUDED from the forced-full-
-  // pool set: it predates this change's risk/ambiguity floors and pre-existing
-  // behavior (the diff-class-tier mechanism) keeps a merely-over-the-tiny-
-  // inline-cap-but-still-tier-classifiable diff on its reduced tier set — see
-  // resolveGateTier's "small non-risky diff outside the inline cap but
-  // matching a tier" contract. Only a genuine RISK signal (a risk-path touch,
-  // a non-clean/ambiguous size-budget outcome, or an unclassifiable diff)
-  // forces the full untriered pool.
+  // sizeCap (over_threshold) is deliberately EXCLUDED from the risk-signal
+  // floor set: it predates the risk/ambiguity floors. Every floor affects the
+  // dispatch mode only; angle selection remains tiered or best-effort.
   const dispatchFloorFired = floors.riskPath || floors.sizeOutcome || floors.ambiguity;
   const floored = dispatchFloorFired || floors.unclassifiable;
   const mode = floored ? "full_fanout" : dispatch.mode;
   const reason = floored && !dispatchFloorFired ? "unclassifiable_diff" : dispatch.reason;
   // The mandatory-angle floor is present either way: a tier match already
-  // unions mandatoryAngles in (resolveGateTier), and the no-tier fallback
-  // (resolveGateAngles) does the same union — see AC-4 "mandatory angles
-  // combined, never dropped".
-  const angles = floored ? resolveGateAngles(config, gate) : (tier.angles ?? resolveGateAngles(config, gate));
+  // unions mandatoryAngles in (resolveGateTier), and the no-tier best-effort
+  // selection does the same union — see AC-4 "mandatory angles combined,
+  // never dropped". A `gate:full` label is the explicit "run everything"
+  // escape hatch (ADR 0048): it keeps forcing the full configured pool, which
+  // is also what resolveGateTier's gate_full_label bypass left in place before
+  // best-effort selection existed.
+  const staticAngles = resolveGateAngles(config, gate);
+  const angles = hasFullLabel
+    ? staticAngles
+    : (tier.angles ?? (staticAngles === null ? null : selectFloorPlusJustifiedAngles(config, gate, changedFiles)));
   const groups = resolveFanoutGroups(config, gate, angles ?? [], { fullLabel: hasFullLabel });
   return Object.freeze({
     mode,
@@ -2575,9 +2624,10 @@ export function resolveReviewProportionality(config, gate, {
  * Resolve gate angles dynamically when `dynamicAngles` is enabled.
  *
  * Diff analysis (../analysis/*) filters the configured angle list to angles
- * relevant to the change set. When `dynamic.subtractive: false` or no
- * diff is given, returns the full configured list. When `additiveAngles` is on,
- * catalog angles from resolveAnglePool may also be added, with
+ * relevant to the change set. When `dynamic.subtractive: false`, returns the
+ * full configured list. Without a diff, ordinary callers keep that static pool
+ * while floor-aware callers use mandatory-floor best-effort selection. When
+ * `additiveAngles` is on, catalog angles from resolveAnglePool may also be added, with
  * `excludeAngles` a hard ceiling.
  *
  * Diff-class tiers (resolveGateTier) are consulted FIRST: a tier match returns
@@ -2586,15 +2636,14 @@ export function resolveReviewProportionality(config, gate, {
  *
  * GATE-EXEC-PROPORTIONALITY floor-awareness (opt-in via `checkFloors`): when
  * the caller supplies `checkFloors: true` (and, when available, `sizeOutcome`
- * from check-size-budget.mjs), this delegates to {@link
+ * from check-size-budget.mjs), this delegates floor determination to {@link
  * resolveReviewProportionality} — the SAME composer resolve-gate-dispatch.mjs
- * uses — over the SAME diff-derived changed-file/scope facts, so a diff whose
- * dispatch decision is floored (risk-path touch, a non-clean/ambiguous
- * size-budget outcome, or an unclassifiable diff) NEVER keeps a tier's
- * reduced (or dynamically-pruned) angle set here: it gets the full untriered
- * pool, exactly like the primer's own dispatch-decision step. Omitted
- * (default), this resolves exactly as before — a caller that does not have
- * size-budget evidence to hand is unaffected.
+ * uses — over the SAME diff-derived changed-file/scope facts. A fired floor
+ * forces `full_fanout` DISPATCH and refuses an explicit override, but the angle
+ * SET is always the tier-or-dynamic best-effort selection below; uncertainty
+ * never widens it to the full untriered pool. Omitted (default), this resolves
+ * exactly as before — a caller that does not have size-budget evidence to hand
+ * is unaffected.
  *
  * @param {import("./types.js").DevLoopConfig} config
  * @param {"draft"|"preApproval"} gate
@@ -2603,7 +2652,7 @@ export function resolveReviewProportionality(config, gate, {
  * @param {boolean} [options.hasFullLabel] — `gate:full` label present on the PR (bypasses tier resolution)
  * @param {boolean} [options.checkFloors] — opt into the GATE-EXEC-PROPORTIONALITY floor check above
  * @param {{ outcome?: "pass"|"escalate"|"block", tierLogicLoc?: { t1?: number } }|null} [options.sizeOutcome] — only consulted when `checkFloors` is true
- * @param {string[]} [options.explicitAngles] — caller-supplied verbatim override (e.g. CLI `--angles`); wins over tier/dynamic resolution but NEVER over a fired floor above (a fired floor's full pool, mandatory angles included via resolveGateAngles, is returned instead)
+ * @param {string[]} [options.explicitAngles] — caller-supplied verbatim override (e.g. CLI `--angles`); wins over tier/dynamic resolution but NEVER over a fired floor above (a fired floor refuses the override and continues to tier/dynamic best-effort selection)
  * @returns {{ recommendedAngles: string[] | null, skippedAngles: string[], reasons: Record<string,string>, fallbackToAll: boolean, dynamicAnglesActive: boolean, addedAngles: string[], addedReasons: Record<string,string> }}
  */
 export async function resolveGateAnglesDynamic(config, gate, { diff, hasFullLabel = false, checkFloors = false, sizeOutcome, explicitAngles } = {}) {
@@ -2625,30 +2674,20 @@ export async function resolveGateAnglesDynamic(config, gate, { diff, hasFullLabe
       linesChanged = lineStats.added + lineStats.deleted;
     }
   }
-  if (checkFloors) {
-    const plan = resolveReviewProportionality(config, gate, {
-      scope: { filesChanged, linesChanged },
-      changedFiles,
-      sizeOutcome,
-      hasFullLabel,
-    });
-    if (plan.floors.riskPath || plan.floors.sizeOutcome || plan.floors.ambiguity || plan.floors.unclassifiable) {
-      return {
-        recommendedAngles: plan.angles ?? [],
-        skippedAngles: [],
-        reasons: {},
-        fallbackToAll: false,
-        dynamicAnglesActive: false,
-        addedAngles: [],
-        addedReasons: {},
-      };
-    }
-  }
-  // A fired floor above always wins (its full pool already includes the
-  // mandatory floor via resolveGateAngles) — an explicit --angles override is
-  // only honored once no floor fired, matching its documented "verbatim,
-  // dynamic resolution bypassed" contract.
-  if (Array.isArray(explicitAngles)) {
+  const plan = checkFloors
+    ? resolveReviewProportionality(config, gate, {
+        scope: { filesChanged, linesChanged },
+        changedFiles,
+        sizeOutcome,
+        hasFullLabel,
+      })
+    : null;
+  const floorFired = plan !== null && (
+    plan.floors.riskPath || plan.floors.sizeOutcome || plan.floors.ambiguity || plan.floors.unclassifiable
+  );
+  // A fired floor refuses an explicit --angles override. Selection falls
+  // through to the same tier/dynamic best-effort path as every other diff.
+  if (Array.isArray(explicitAngles) && !floorFired) {
     return {
       recommendedAngles: explicitAngles,
       skippedAngles: [],
@@ -2688,12 +2727,24 @@ export async function resolveGateAnglesDynamic(config, gate, { diff, hasFullLabe
   }
 
   if (!gateConfig.dynamicAngles || !diff) {
+    // No diff to select on (a thin briefing) or dynamic resolution explicitly
+    // disabled by config. An explicitly disabled resolver keeps its static pool
+    // — that is the config asking for every angle. When dynamic resolution is
+    // enabled, a floor-aware caller that simply has no diff still gets the
+    // composer's mandatory-floor-plus-justified set rather than the whole pool,
+    // so absence of evidence never widens the angle set either.
+    const bestEffortWithoutDiff = Boolean(!diff && plan && gateConfig.dynamicAngles);
+    const recommendedAngles = bestEffortWithoutDiff ? (plan.angles ?? staticAngles) : staticAngles;
+    const recommended = new Set(recommendedAngles);
+    const skippedAngles = staticAngles.filter((a) => !recommended.has(a));
     return {
-      recommendedAngles: staticAngles,
-      skippedAngles: [],
-      reasons: {},
+      recommendedAngles,
+      skippedAngles,
+      reasons: Object.fromEntries(
+        skippedAngles.map((a) => [a, "Skipped: no diff is available to select on; the mandatory floor plus justified lenses were selected instead"]),
+      ),
       fallbackToAll: false,
-      dynamicAnglesActive: false,
+      dynamicAnglesActive: bestEffortWithoutDiff,
       addedAngles: [],
       addedReasons: {},
     };
@@ -2724,8 +2775,7 @@ export async function resolveGateAnglesDynamic(config, gate, { diff, hasFullLabe
     ? resolveAnglePool(config).filter(a => !excluded.has(a))
     : undefined;
 
-  const { resolveDynamicAngles: resolve } = await import("../analysis/change-classifier.mjs");
-  const dynamicResult = resolve({
+  const dynamicResult = resolveDynamicAngles({
     configuredAngles: candidatePool,
     changeCategories: categories,
     ambiguous: analysis.ambiguous,
@@ -2746,12 +2796,24 @@ export async function resolveGateAnglesDynamic(config, gate, { diff, hasFullLabe
     Object.entries(dynamicResult.addedReasons ?? {}).filter(([a]) => !mandatory.has(a))
   );
 
-  const recommendedAngles = [...new Set([...filteredMandatory, ...dynamicResult.recommendedAngles, ...addedAngles])];
+  const mergedAngles = [...new Set([...filteredMandatory, ...dynamicResult.recommendedAngles, ...addedAngles])];
+
+  // Degenerate-pool fail-closed: a gate whose configured pool holds neither a
+  // mandatory nor an always-include angle (e.g. `angles: ["kiss"]`) can legally
+  // resolve to zero angles for an unclassifiable diff. Never resolve zero
+  // angles — fall back to the static pool (already excludeAngles-filtered),
+  // mirroring selectFloorPlusJustifiedAngles and the composer, so the resolver
+  // and the composer agree for the identical input. The whole pool is selected,
+  // so nothing is skipped and no angle carries a skip reason.
+  const degenerateFallback = mergedAngles.length === 0;
+  const recommendedAngles = degenerateFallback ? [...staticAngles] : mergedAngles;
+  const skippedAngles = degenerateFallback ? [] : dynamicResult.skippedAngles;
+  const reasons = degenerateFallback ? {} : dynamicResult.reasons;
 
   return {
     recommendedAngles,
-    skippedAngles: dynamicResult.skippedAngles,
-    reasons: dynamicResult.reasons,
+    skippedAngles,
+    reasons,
     fallbackToAll: dynamicResult.fallbackToAll,
     dynamicAnglesActive: true,
     addedAngles,

package/src/config/extension-defaults.yaml

@@ -126,9 +126,15 @@ gates:
             implementation bugs, logic errors, contract violations, or security
             issues
           - Unresolved review threads that raise implementation concerns Flag any unresolved comment that identifies a concrete implementation problem as a blocking finding (severity: high or medium). Do not flag: - Resolved threads - Style nits, formatting suggestions, or cosmetic feedback - Comments from non-collaborators or bots - Outdated comments that were already addressed in a later commit If no unresolved implementation concerns exist, return clean.
-      - contradiction-lens
-      - code-conformance
-      - semantic-drift
+      - name: contradiction-lens
+        persona: review
+        prompt: "Apply STYLE-CONTRADICTION-LENS when the repo defines it (dev-loops: skills/docs/contract-style-guide.md): check every added or changed normative rule (MUST/SHOULD/MAY) against the repo's rule registry for opposing modality or a weaker restatement. Also flag statements in the diff, the PR body, touched contracts, or accepted decision records (for example docs/decisions/) that contradict each other. Cite both sides of each contradiction with file:line."
+      - name: code-conformance
+        persona: review
+        prompt: Review this change for conformance to existing repo code conventions and patterns. Compare naming, module layout, and helper reuse against neighboring code in the same package. Flag ad hoc patterns that diverge from an established convention without a stated reason.
+      - name: semantic-drift
+        persona: review
+        prompt: Review this change for semantic drift between code and its documented behavior. Compare the diff's actual logic against the intent stated in touched docs, contracts, and comments. Flag a documented behavior that no longer matches what the code does, or code whose behavior no longer matches what a touched doc or contract claims.
       - name: pr-description
         mandatory: true
         persona: review
@@ -342,9 +348,15 @@ gates:
           give a minimal fix. Respect declared non-goals — do not manufacture
           scope. If the change is coherent and complete against the spec, return
           clean.
-      - contradiction-lens
-      - correctness-final
-      - ui-validation
+      - name: contradiction-lens
+        persona: review
+        prompt: "Apply STYLE-CONTRADICTION-LENS when the repo defines it (dev-loops: skills/docs/contract-style-guide.md): check every added or changed normative rule (MUST/SHOULD/MAY) against the repo's rule registry for opposing modality or a weaker restatement. Also flag statements in the diff, the PR body, touched contracts, or accepted decision records (for example docs/decisions/) that contradict each other. Cite both sides of each contradiction with file:line."
+      - name: correctness-final
+        persona: review
+        prompt: Perform a final correctness pass on the current head. Flag residual logic errors, contract violations, and behavior mismatches introduced or left unfixed since the draft gate.
+      - name: ui-validation
+        persona: review
+        prompt: "Review this change against the repo's UI validation contract when it defines one (dev-loops: skills/docs/ui-validation-contract.md and skills/docs/ui-e2e-scoping-step.md). When the changed-file set matches the UI e2e scoping globs, verify passing UI e2e coverage exists and that each touched rendered artifact is registered; an unregistered new artifact is a blocking finding. Return clean when no changed path matches or the repo defines no UI validation contract."
     required: true
   # Relaxed spike gate profile (#965). A spike's deliverable is a findings doc,
   # not production code, so it is intentionally lighter than the production