@codedrifters/configulator 0.0.404 → 0.0.405

package/lib/index.js

@@ -213,6 +213,7 @@ __export(index_exports, {
   CDK_WATCH_DEFAULTS_BY_STAGE: () => CDK_WATCH_DEFAULTS_BY_STAGE,
   CLAUDE_RULE_TARGET: () => CLAUDE_RULE_TARGET,
   COMPLETE_JOB_ID: () => COMPLETE_JOB_ID,
+  CONVENTIONAL_COMMIT_TYPE_LABELS: () => CONVENTIONAL_COMMIT_TYPE_LABELS,
   CdkCli: () => CdkCli,
   DEFAULT_AC_THRESHOLDS: () => DEFAULT_AC_THRESHOLDS,
   DEFAULT_AGENT_PATHS: () => DEFAULT_AGENT_PATHS,
@@ -284,6 +285,7 @@ __export(index_exports, {
   MONOREPO_LAYOUT: () => MONOREPO_LAYOUT,
   MonorepoProject: () => MonorepoProject,
   Nvmrc: () => Nvmrc,
+  PHASE_LABEL_TYPE_MAP: () => PHASE_LABEL_TYPE_MAP,
   PROD_DEPLOY_NAME: () => PROD_DEPLOY_NAME,
   PROGRESS_FILES_FORMAT_VALUES: () => PROGRESS_FILES_FORMAT_VALUES,
   PnpmWorkspace: () => PnpmWorkspace,
@@ -444,6 +446,8 @@ __export(index_exports, {
   renderIssueTemplatesStarterPage: () => renderIssueTemplatesStarterPage,
   renderMeetingTypesSection: () => renderMeetingTypesSection,
   renderNextRequirementIdProcedure: () => renderNextRequirementIdProcedure,
+  renderPhaseTypeInvariantSection: () => renderPhaseTypeInvariantSection,
+  renderPhaseTypeInvariantShellHelpers: () => renderPhaseTypeInvariantShellHelpers,
   renderPriorityRulesSection: () => renderPriorityRulesSection,
   renderProgressFileName: () => renderProgressFileName,
   renderProgressFilePath: () => renderProgressFilePath,
@@ -495,6 +499,7 @@ __export(index_exports, {
   resolveSkillEvals: () => resolveSkillEvals,
   resolveTemplateVariables: () => resolveTemplateVariables,
   resolveTemporalFraming: () => resolveTemporalFraming,
+  resolveTypeLabelForLabels: () => resolveTypeLabelForLabels,
   resolveTypeScriptProjectOutdir: () => resolveTypeScriptProjectOutdir,
   resolveUnblockDependents: () => resolveUnblockDependents,
   runScan: () => runScan,
@@ -504,6 +509,7 @@ __export(index_exports, {
   stripToolArtifactTagsProcedure: () => stripToolArtifactTagsProcedure,
   tsdocRecordToFindings: () => tsdocRecordToFindings,
   turborepoBundle: () => turborepoBundle,
+  typeLabelForPhaseLabel: () => typeLabelForPhaseLabel,
   typescriptBundle: () => typescriptBundle,
   upstreamConfigulatorDocsBundle: () => upstreamConfigulatorDocsBundle,
   validateAgentTierConfig: () => validateAgentTierConfig,
@@ -13646,188 +13652,6 @@ function buildMeetingAnalysisBundle(tier = AGENT_MODEL.BALANCED) {
 }
 var meetingAnalysisBundle = buildMeetingAnalysisBundle();
 
-// src/agent/bundles/run-ratio.ts
-var DEFAULT_DISPATCH_TO_HOUSEKEEPING_RATIO = 4;
-var DEFAULT_STATE_FILE_PATH = ".state/orchestrator-runs.json";
-var DEFAULT_DISPATCH_MODEL = "opus";
-var DEFAULT_HOUSEKEEPING_MODEL = "sonnet";
-function resolveRunRatio(config) {
-  const ratio = config?.ratio ?? DEFAULT_DISPATCH_TO_HOUSEKEEPING_RATIO;
-  assertValidRatio(ratio);
-  const stateFilePath = config?.stateFilePath ?? DEFAULT_STATE_FILE_PATH;
-  assertValidStateFilePath(stateFilePath);
-  return {
-    enabled: config?.enabled ?? true,
-    ratio,
-    stateFilePath,
-    dispatchModel: config?.dispatchModel ?? DEFAULT_DISPATCH_MODEL,
-    housekeepingModel: config?.housekeepingModel ?? DEFAULT_HOUSEKEEPING_MODEL
-  };
-}
-function validateRunRatioConfig(config) {
-  return resolveRunRatio(config);
-}
-function classifyRun(runCounter, ratio) {
-  if (!ratio.enabled) {
-    return "dispatch";
-  }
-  const cycle = ratio.ratio + 1;
-  return runCounter > 0 && runCounter % cycle === 0 ? "housekeeping" : "dispatch";
-}
-function renderRunRatioSection(ratio) {
-  const lines = [
-    "## Run ratio (dispatch vs housekeeping)",
-    "",
-    "The orchestrator keeps a **persistent run counter** and interleaves",
-    "dispatch runs (pick the next ready issue, recommend a worker) with",
-    "**housekeeping runs** (batch PR review + maintenance scan) on a",
-    "configurable ratio. This mirrors openhi's `DISPATCHER.md` contract:",
-    "multiple dispatch runs feed the worker queue, then one batched",
-    "housekeeping run flushes review backlog and runs maintenance",
-    "triage so the pipeline never drifts.",
-    ""
-  ];
-  if (!ratio.enabled) {
-    lines.push(
-      "**The run ratio is disabled for this project.** Every orchestrator",
-      "run executes the full dispatch pipeline; PR review and maintenance",
-      "remain manual invocations. Enable the ratio via",
-      "`AgentConfigOptions.runRatio.enabled = true` once the operator is",
-      "comfortable with the counter-backed cadence.",
-      ""
-    );
-    return lines.join("\n");
-  }
-  const cycle = ratio.ratio + 1;
-  lines.push(
-    "### Cadence",
-    "",
-    `The cycle length is **${cycle}** runs:`,
-    "",
-    `- Runs 1 through ${ratio.ratio} execute the **dispatch** pipeline`,
-    `  (recommended model: \`${ratio.dispatchModel}\`).`,
-    `- Run ${cycle} executes the **housekeeping** pipeline`,
-    `  (recommended model: \`${ratio.housekeepingModel}\`).`,
-    `- The counter wraps \u2014 run ${cycle + 1} is a dispatch run again, run ${cycle * 2} is the next housekeeping run, and so on.`,
-    "",
-    "The orchestrator increments the counter **once per invocation** at",
-    "the top of the run, before any pipeline phase executes. The",
-    "pre-increment value is never observed \u2014 the tick always returns",
-    "the post-increment counter and the classified run type in a single",
-    "atomic update.",
-    "",
-    "### State file",
-    "",
-    `The run counter persists at \`${ratio.stateFilePath}\`. The file is`,
-    "plain JSON with a single `run_counter` integer field:",
-    "",
-    "```json",
-    '{ "run_counter": 42 }',
-    "```",
-    "",
-    "The state file is **gitignored** in consumer repos (it is local to",
-    "each operator's machine). On a first run, or if the file is missing",
-    "or corrupt, the orchestrator recreates it with `run_counter: 1`.",
-    "",
-    "### Dispatch-run pipeline",
-    "",
-    "1. Phase A \u2014 startup (fetch + checkout default branch).",
-    "2. Phase C \u2014 triage unblock (resolve `Depends on:` chains).",
-    "3. Phase E \u2014 queue scan (pick the top `PICK` line, run the scope",
-    "   gate, emit `NEXT_WORK_ITEM`).",
-    "4. Phase F \u2014 cleanup.",
-    "",
-    "### Housekeeping-run pipeline",
-    "",
-    "1. Phase A \u2014 startup.",
-    "2. Phase B \u2014 batch PR review across every eligible open PR.",
-    "3. Phase D \u2014 maintenance scan (stale detection, orphaned branches,",
-    "   needs-attention summary).",
-    "4. Phase F \u2014 cleanup.",
-    "",
-    "### Model recommendations",
-    "",
-    `Dispatch runs should use \`${ratio.dispatchModel}\` \u2014 the routing`,
-    "logic, scope gate, and funnel-tier sort benefit from the stronger",
-    "reasoning model. Housekeeping runs are mechanical (read CI status,",
-    "toggle labels, post canned comments) and should use",
-    `\`${ratio.housekeepingModel}\` so the batched PR review and`,
-    "maintenance scan cost less per invocation.",
-    "",
-    "These strings are **informational** \u2014 they surface in the",
-    "orchestrator's rendered rule content so operators know which model",
-    "to run each session against. Configulator does not inject them as",
-    "`model:` frontmatter on the sub-agent definition; the operator (or",
-    "a scheduled task) picks the model at invocation time."
-  );
-  return lines.join("\n");
-}
-function renderRunRatioShellHelpers(ratio) {
-  const cycle = ratio.ratio + 1;
-  return [
-    "# Increment the orchestrator run counter and classify the run.",
-    "# Reads the state file (creating it on first run or corruption),",
-    "# increments the counter, writes back atomically, and echoes",
-    "# `run=<n> type=<dispatch|housekeeping>` on stdout.",
-    "#",
-    "# Uses the cycle length (ratio + 1) hard-coded from the resolved",
-    "# RunRatioConfig so the shell helper matches the rendered rule",
-    "# content byte-for-byte.",
-    "run_counter_tick() {",
-    '  local state_file="$ORCHESTRATOR_STATE_FILE"',
-    "  local state_dir",
-    '  state_dir=$(dirname "$state_file")',
-    '  mkdir -p "$state_dir" 2>/dev/null || true',
-    "",
-    "  local current=0",
-    '  if [ -f "$state_file" ]; then',
-    "    # jq returns empty string on parse failure; guard against it.",
-    `    current=$(jq -r '.run_counter // 0' "$state_file" 2>/dev/null || echo 0)`,
-    '    case "$current" in',
-    "      ''|*[!0-9]*) current=0 ;;",
-    "    esac",
-    "  fi",
-    "",
-    "  local next=$((current + 1))",
-    "",
-    '  local tmp_file="${state_file}.tmp.$$"',
-    `  printf '{ "run_counter": %d }\\n' "$next" > "$tmp_file"`,
-    '  mv "$tmp_file" "$state_file"',
-    "",
-    "  local run_type=dispatch",
-    `  if [ $((next % ${cycle})) -eq 0 ]; then`,
-    "    run_type=housekeeping",
-    "  fi",
-    `  printf 'run=%d type=%s\\n' "$next" "$run_type"`,
-    "}"
-  ].join("\n");
-}
-function assertValidRatio(ratio) {
-  if (!Number.isInteger(ratio)) {
-    throw new Error(
-      `RunRatioConfig.ratio must be a positive integer; got ${ratio}`
-    );
-  }
-  if (ratio < 1) {
-    throw new Error(
-      `RunRatioConfig.ratio must be a positive integer; got ${ratio}`
-    );
-  }
-}
-function assertValidStateFilePath(stateFilePath) {
-  const trimmed = stateFilePath.trim();
-  if (trimmed.length === 0) {
-    throw new Error(
-      "RunRatioConfig.stateFilePath must be a non-empty string relative to the repo root"
-    );
-  }
-  if (trimmed.startsWith("/")) {
-    throw new Error(
-      `RunRatioConfig.stateFilePath must be relative to the repo root (no leading '/'); got ${stateFilePath}`
-    );
-  }
-}
-
 // src/agent/bundles/bundle-ownership.ts
 var BUNDLE_OWNERSHIP = {
   agenda: {
@@ -13971,6 +13795,255 @@ var BUNDLE_OWNERSHIP = {
     downstreamIssueKinds: true
   }
 };
+var CONVENTIONAL_COMMIT_TYPE_LABELS = [
+  "type:chore",
+  "type:docs",
+  "type:feat",
+  "type:fix",
+  "type:hotfix",
+  "type:refactor",
+  "type:release"
+];
+var PHASE_LABEL_TYPE_MAP = buildPhaseLabelTypeMap();
+function typeLabelForPhaseLabel(phaseLabel) {
+  const exact = PHASE_LABEL_TYPE_MAP[phaseLabel];
+  if (exact !== void 0 && !phaseLabel.endsWith(":")) {
+    return exact;
+  }
+  let bestMatcher;
+  for (const matcher of Object.keys(PHASE_LABEL_TYPE_MAP)) {
+    if (!matcher.endsWith(":")) {
+      continue;
+    }
+    if (!phaseLabel.startsWith(matcher)) {
+      continue;
+    }
+    if (bestMatcher === void 0 || matcher.length > bestMatcher.length) {
+      bestMatcher = matcher;
+    }
+  }
+  return bestMatcher === void 0 ? void 0 : PHASE_LABEL_TYPE_MAP[bestMatcher];
+}
+function resolveTypeLabelForLabels(labels) {
+  const phaseLabels = [];
+  const candidates = /* @__PURE__ */ new Set();
+  for (const label of labels) {
+    const typeLabel = typeLabelForPhaseLabel(label);
+    if (typeLabel === void 0) {
+      continue;
+    }
+    phaseLabels.push(label);
+    candidates.add(typeLabel);
+  }
+  const candidateTypeLabels = Array.from(candidates).sort();
+  if (candidateTypeLabels.length === 0) {
+    return { outcome: "none", candidateTypeLabels: [], phaseLabels: [] };
+  }
+  if (candidateTypeLabels.length === 1) {
+    return {
+      outcome: "match",
+      typeLabel: candidateTypeLabels[0],
+      candidateTypeLabels,
+      phaseLabels
+    };
+  }
+  return { outcome: "ambiguous", candidateTypeLabels, phaseLabels };
+}
+function renderPhaseTypeInvariantSection(excludeBundles = []) {
+  const rows = Object.keys(PHASE_LABEL_TYPE_MAP).filter(
+    (matcher) => !isPhaseLabelMatcherOwnedByExcluded(matcher, excludeBundles)
+  ).sort().map((matcher) => {
+    const display = matcher.endsWith(":") ? `${matcher}*` : matcher;
+    const kind = matcher.endsWith(":") ? "prefix" : "exact";
+    return `| \`${display}\` | ${kind} | \`${PHASE_LABEL_TYPE_MAP[matcher]}\` |`;
+  });
+  return [
+    "## Phase-label \u2192 `type:<bundle>` invariant",
+    "",
+    "Every phased-pipeline bundle pairs its `<bundle>:<phase>` labels",
+    "with exactly one `type:<bundle>` label. That type label is the",
+    "**dedup + dispatch signal**: agents de-duplicate downstream work",
+    'with `gh issue list --label "type:<bundle>"`, and Phase E derives',
+    "its funnel-tier sort key from the issue's `type:*` label. An issue",
+    "that carries the phase label but a conventional-commit `type:*`",
+    "(`type:feat`, `type:docs`, \u2026, stamped from its title prefix by the",
+    "generic create-issue workflow) is invisible to that dedup query and",
+    "mis-tiers in dispatch.",
+    "",
+    "The pairing below is derived from the canonical bundle-ownership",
+    "map \u2014 the same source of truth that generates the label registry.",
+    "Matchers ending in `*` match by prefix; the rest match exactly, and",
+    "an exact match always beats a prefix match.",
+    "",
+    "| Phase label | Match | Required type label |",
+    "|-------------|-------|---------------------|",
+    ...rows,
+    "",
+    "### Enforcement",
+    "",
+    "The Phase D maintenance sweep runs the invariant in auto-correct",
+    "mode and emits one summary line:",
+    "",
+    "```",
+    "LABEL_INVARIANT_DONE mode=fix checked=<N> ok=<O> violations=<V> corrected=<C> flagged=<F>",
+    "```",
+    "",
+    "A **report-only** audit is available for repos that prefer",
+    "report-then-fix over auto-correct \u2014 same sweep, no mutations:",
+    "",
+    "```bash",
+    ".claude/procedures/check-blocked.sh label-invariant        # report only",
+    ".claude/procedures/check-blocked.sh label-invariant --fix  # apply",
+    "```",
+    "",
+    "### Correction policy",
+    "",
+    "An issue must carry **exactly one** `type:*` label. Merely *adding*",
+    "the required type label to an issue that already carries a",
+    "conventional-commit one would leave two, making the funnel-tier sort",
+    "key (which reads the **first** `type:*` label) non-deterministic and",
+    "violating the label conventions. The correction therefore",
+    "**replaces**, in a single atomic `gh issue edit`, so the issue is",
+    "never observable carrying two `type:*` labels:",
+    "",
+    "| Issue state | Action |",
+    "|-------------|--------|",
+    "| Required type label present, nothing else | none \u2014 compliant, left untouched |",
+    "| No `type:*` label at all | **add** the required label |",
+    "| Only conventional-commit `type:*` label(s) | **replace** \u2014 remove them, add the required label |",
+    "| Required label present **plus** a stray conventional-commit one | **remove** the stray, leaving exactly one |",
+    "| A `type:*` label owned by a **different** bundle | **flag** `status:needs-attention` \u2014 never guessed at |",
+    "| Phase labels imply **two or more** type labels | **flag** `status:needs-attention` \u2014 never auto-corrected |",
+    "",
+    "Only a conventional-commit `type:*` label is ever removed. A",
+    "`type:*` label owned by another bundle carries real routing",
+    "information, so the sweep refuses to guess and hands the issue to a",
+    "human instead. Ambiguity is narrower than it looks: all three",
+    "requirements bundles declare `type:requirement`, so every `req:*`",
+    "phase label resolves to the same type label \u2014 genuine ambiguity",
+    "needs phase labels from two bundles with *different* type labels.",
+    "",
+    "`status:needs-attention` is applied **additively** \u2014 the base",
+    "`status:*` label always stays, per the additive-flag rule. Flagging",
+    "is idempotent: an issue already carrying the flag is reported but",
+    "not re-flagged."
+  ].join("\n");
+}
+function isPhaseLabelMatcherOwnedByExcluded(matcher, excludeBundles) {
+  if (excludeBundles.length === 0) {
+    return false;
+  }
+  let owned = false;
+  for (const [bundleName, ownership] of Object.entries(BUNDLE_OWNERSHIP)) {
+    if (!ownership.phaseLabelPrefixes.includes(matcher)) {
+      continue;
+    }
+    owned = true;
+    if (!excludeBundles.includes(bundleName)) {
+      return false;
+    }
+  }
+  return owned;
+}
+function renderPhaseTypeInvariantShellHelpers() {
+  const matchers = Object.keys(PHASE_LABEL_TYPE_MAP);
+  const exactMatchers = matchers.filter((m) => !m.endsWith(":")).sort();
+  const prefixMatchers = matchers.filter((m) => m.endsWith(":")).sort((a, b) => b.length - a.length || a.localeCompare(b));
+  const lines = [
+    "# Resolve ONE phase label to the `type:<bundle>` label its owning",
+    "# bundle declares. Echoes the label (with the `type:` prefix) or",
+    "# nothing when no bundle owns it. Exact-match branches come first,",
+    "# so `req:write` (requirements-writer) beats the `req:` prefix",
+    "# (requirements-analyst). Generated from BUNDLE_OWNERSHIP \u2014 do not",
+    "# hand-edit.",
+    "phase_label_type_of() {",
+    '  case "${1:-}" in'
+  ];
+  for (const matcher of exactMatchers) {
+    lines.push(`    ${matcher}) echo "${PHASE_LABEL_TYPE_MAP[matcher]}" ;;`);
+  }
+  for (const matcher of prefixMatchers) {
+    lines.push(`    ${matcher}*) echo "${PHASE_LABEL_TYPE_MAP[matcher]}" ;;`);
+  }
+  lines.push(
+    "    *) : ;;",
+    "  esac",
+    "}",
+    "",
+    "# Return 0 when the argument is a conventional-commit `type:*`",
+    "# label \u2014 the ONLY type labels the invariant correction may remove.",
+    "# A `type:*` label owned by another bundle is never removed; the",
+    "# issue is flagged for human triage instead.",
+    "is_conventional_type_label() {",
+    `  case "\${1:-}" in`,
+    `    ${CONVENTIONAL_COMMIT_TYPE_LABELS.join("|")}) return 0 ;;`,
+    "    *) return 1 ;;",
+    "  esac",
+    "}",
+    "",
+    "# Resolve an issue's FULL label list (one label per line on stdin)",
+    "# to the type label the phase-label invariant requires. Emits",
+    "# KEY=VALUE assignments the caller parses:",
+    "#   OUTCOME=none      \u2014 no recognised phase label; invariant N/A",
+    "#   OUTCOME=match     \u2014 plus TYPE_LABEL=<type:bundle>",
+    "#   OUTCOME=ambiguous \u2014 plus CANDIDATE_TYPE_LABELS=<space-separated>",
+    "#   PHASE_LABELS=<space-separated recognised phase labels>",
+    "phase_type_of() {",
+    "  local label resolved",
+    '  local matched_types=""',
+    '  local matched_phase=""',
+    "  while IFS= read -r label; do",
+    '    [ -z "$label" ] && continue',
+    '    resolved=$(phase_label_type_of "$label")',
+    '    [ -z "$resolved" ] && continue',
+    '    matched_phase="${matched_phase}${label} "',
+    '    case " ${matched_types} " in',
+    '      *" ${resolved} "*) ;;',
+    '      *) matched_types="${matched_types}${resolved} " ;;',
+    "    esac",
+    "  done",
+    "  local count=0",
+    "  for resolved in $matched_types; do",
+    "    count=$((count + 1))",
+    "  done",
+    '  if [ "$count" -eq 0 ]; then',
+    '    echo "OUTCOME=none"',
+    '  elif [ "$count" -eq 1 ]; then',
+    '    echo "OUTCOME=match"',
+    '    echo "TYPE_LABEL=${matched_types% }"',
+    "  else",
+    '    echo "OUTCOME=ambiguous"',
+    '    echo "CANDIDATE_TYPE_LABELS=${matched_types% }"',
+    "  fi",
+    '  echo "PHASE_LABELS=${matched_phase% }"',
+    "}"
+  );
+  return lines.join("\n");
+}
+function buildPhaseLabelTypeMap() {
+  const map = {};
+  for (const [bundleName, ownership] of Object.entries(BUNDLE_OWNERSHIP)) {
+    if (ownership.phaseLabelPrefixes.length === 0) {
+      continue;
+    }
+    if (ownership.typeLabels.length !== 1) {
+      throw new Error(
+        `BUNDLE_OWNERSHIP["${bundleName}"] declares ${ownership.phaseLabelPrefixes.length} phase-label matcher(s) but ${ownership.typeLabels.length} type label(s); a phase label must pair with exactly one type label`
+      );
+    }
+    const typeLabel = `type:${ownership.typeLabels[0]}`;
+    for (const matcher of ownership.phaseLabelPrefixes) {
+      const existing = map[matcher];
+      if (existing !== void 0 && existing !== typeLabel) {
+        throw new Error(
+          `Phase-label matcher "${matcher}" resolves to both "${existing}" and "${typeLabel}"; a matcher must imply exactly one type label`
+        );
+      }
+      map[matcher] = typeLabel;
+    }
+  }
+  return map;
+}
 function isTypeLabelOwnedByExcluded(typeLabel, excludedBundles) {
   if (excludedBundles.length === 0) {
     return false;
@@ -14060,6 +14133,188 @@ function findOwnersOfTypeLabel(typeLabel) {
   return owners;
 }
 
+// src/agent/bundles/run-ratio.ts
+var DEFAULT_DISPATCH_TO_HOUSEKEEPING_RATIO = 4;
+var DEFAULT_STATE_FILE_PATH = ".state/orchestrator-runs.json";
+var DEFAULT_DISPATCH_MODEL = "opus";
+var DEFAULT_HOUSEKEEPING_MODEL = "sonnet";
+function resolveRunRatio(config) {
+  const ratio = config?.ratio ?? DEFAULT_DISPATCH_TO_HOUSEKEEPING_RATIO;
+  assertValidRatio(ratio);
+  const stateFilePath = config?.stateFilePath ?? DEFAULT_STATE_FILE_PATH;
+  assertValidStateFilePath(stateFilePath);
+  return {
+    enabled: config?.enabled ?? true,
+    ratio,
+    stateFilePath,
+    dispatchModel: config?.dispatchModel ?? DEFAULT_DISPATCH_MODEL,
+    housekeepingModel: config?.housekeepingModel ?? DEFAULT_HOUSEKEEPING_MODEL
+  };
+}
+function validateRunRatioConfig(config) {
+  return resolveRunRatio(config);
+}
+function classifyRun(runCounter, ratio) {
+  if (!ratio.enabled) {
+    return "dispatch";
+  }
+  const cycle = ratio.ratio + 1;
+  return runCounter > 0 && runCounter % cycle === 0 ? "housekeeping" : "dispatch";
+}
+function renderRunRatioSection(ratio) {
+  const lines = [
+    "## Run ratio (dispatch vs housekeeping)",
+    "",
+    "The orchestrator keeps a **persistent run counter** and interleaves",
+    "dispatch runs (pick the next ready issue, recommend a worker) with",
+    "**housekeeping runs** (batch PR review + maintenance scan) on a",
+    "configurable ratio. This mirrors openhi's `DISPATCHER.md` contract:",
+    "multiple dispatch runs feed the worker queue, then one batched",
+    "housekeeping run flushes review backlog and runs maintenance",
+    "triage so the pipeline never drifts.",
+    ""
+  ];
+  if (!ratio.enabled) {
+    lines.push(
+      "**The run ratio is disabled for this project.** Every orchestrator",
+      "run executes the full dispatch pipeline; PR review and maintenance",
+      "remain manual invocations. Enable the ratio via",
+      "`AgentConfigOptions.runRatio.enabled = true` once the operator is",
+      "comfortable with the counter-backed cadence.",
+      ""
+    );
+    return lines.join("\n");
+  }
+  const cycle = ratio.ratio + 1;
+  lines.push(
+    "### Cadence",
+    "",
+    `The cycle length is **${cycle}** runs:`,
+    "",
+    `- Runs 1 through ${ratio.ratio} execute the **dispatch** pipeline`,
+    `  (recommended model: \`${ratio.dispatchModel}\`).`,
+    `- Run ${cycle} executes the **housekeeping** pipeline`,
+    `  (recommended model: \`${ratio.housekeepingModel}\`).`,
+    `- The counter wraps \u2014 run ${cycle + 1} is a dispatch run again, run ${cycle * 2} is the next housekeeping run, and so on.`,
+    "",
+    "The orchestrator increments the counter **once per invocation** at",
+    "the top of the run, before any pipeline phase executes. The",
+    "pre-increment value is never observed \u2014 the tick always returns",
+    "the post-increment counter and the classified run type in a single",
+    "atomic update.",
+    "",
+    "### State file",
+    "",
+    `The run counter persists at \`${ratio.stateFilePath}\`. The file is`,
+    "plain JSON with a single `run_counter` integer field:",
+    "",
+    "```json",
+    '{ "run_counter": 42 }',
+    "```",
+    "",
+    "The state file is **gitignored** in consumer repos (it is local to",
+    "each operator's machine). On a first run, or if the file is missing",
+    "or corrupt, the orchestrator recreates it with `run_counter: 1`.",
+    "",
+    "### Dispatch-run pipeline",
+    "",
+    "1. Phase A \u2014 startup (fetch + checkout default branch).",
+    "2. Phase C \u2014 triage unblock (resolve `Depends on:` chains).",
+    "3. Phase E \u2014 queue scan (pick the top `PICK` line, run the scope",
+    "   gate, emit `NEXT_WORK_ITEM`).",
+    "4. Phase F \u2014 cleanup.",
+    "",
+    "### Housekeeping-run pipeline",
+    "",
+    "1. Phase A \u2014 startup.",
+    "2. Phase B \u2014 batch PR review across every eligible open PR.",
+    "3. Phase D \u2014 maintenance scan (stale detection, orphaned branches,",
+    "   needs-attention summary).",
+    "4. Phase F \u2014 cleanup.",
+    "",
+    "### Model recommendations",
+    "",
+    `Dispatch runs should use \`${ratio.dispatchModel}\` \u2014 the routing`,
+    "logic, scope gate, and funnel-tier sort benefit from the stronger",
+    "reasoning model. Housekeeping runs are mechanical (read CI status,",
+    "toggle labels, post canned comments) and should use",
+    `\`${ratio.housekeepingModel}\` so the batched PR review and`,
+    "maintenance scan cost less per invocation.",
+    "",
+    "These strings are **informational** \u2014 they surface in the",
+    "orchestrator's rendered rule content so operators know which model",
+    "to run each session against. Configulator does not inject them as",
+    "`model:` frontmatter on the sub-agent definition; the operator (or",
+    "a scheduled task) picks the model at invocation time."
+  );
+  return lines.join("\n");
+}
+function renderRunRatioShellHelpers(ratio) {
+  const cycle = ratio.ratio + 1;
+  return [
+    "# Increment the orchestrator run counter and classify the run.",
+    "# Reads the state file (creating it on first run or corruption),",
+    "# increments the counter, writes back atomically, and echoes",
+    "# `run=<n> type=<dispatch|housekeeping>` on stdout.",
+    "#",
+    "# Uses the cycle length (ratio + 1) hard-coded from the resolved",
+    "# RunRatioConfig so the shell helper matches the rendered rule",
+    "# content byte-for-byte.",
+    "run_counter_tick() {",
+    '  local state_file="$ORCHESTRATOR_STATE_FILE"',
+    "  local state_dir",
+    '  state_dir=$(dirname "$state_file")',
+    '  mkdir -p "$state_dir" 2>/dev/null || true',
+    "",
+    "  local current=0",
+    '  if [ -f "$state_file" ]; then',
+    "    # jq returns empty string on parse failure; guard against it.",
+    `    current=$(jq -r '.run_counter // 0' "$state_file" 2>/dev/null || echo 0)`,
+    '    case "$current" in',
+    "      ''|*[!0-9]*) current=0 ;;",
+    "    esac",
+    "  fi",
+    "",
+    "  local next=$((current + 1))",
+    "",
+    '  local tmp_file="${state_file}.tmp.$$"',
+    `  printf '{ "run_counter": %d }\\n' "$next" > "$tmp_file"`,
+    '  mv "$tmp_file" "$state_file"',
+    "",
+    "  local run_type=dispatch",
+    `  if [ $((next % ${cycle})) -eq 0 ]; then`,
+    "    run_type=housekeeping",
+    "  fi",
+    `  printf 'run=%d type=%s\\n' "$next" "$run_type"`,
+    "}"
+  ].join("\n");
+}
+function assertValidRatio(ratio) {
+  if (!Number.isInteger(ratio)) {
+    throw new Error(
+      `RunRatioConfig.ratio must be a positive integer; got ${ratio}`
+    );
+  }
+  if (ratio < 1) {
+    throw new Error(
+      `RunRatioConfig.ratio must be a positive integer; got ${ratio}`
+    );
+  }
+}
+function assertValidStateFilePath(stateFilePath) {
+  const trimmed = stateFilePath.trim();
+  if (trimmed.length === 0) {
+    throw new Error(
+      "RunRatioConfig.stateFilePath must be a non-empty string relative to the repo root"
+    );
+  }
+  if (trimmed.startsWith("/")) {
+    throw new Error(
+      `RunRatioConfig.stateFilePath must be relative to the repo root (no leading '/'); got ${stateFilePath}`
+    );
+  }
+}
+
 // src/agent/bundles/scheduled-tasks.ts
 var SCHEDULED_TASK_MODEL_VALUES = ["opus", "sonnet", "haiku"];
 var SCHEDULED_TASK_KIND_VALUES = ["issue-worker", "pipeline"];
@@ -16015,6 +16270,7 @@ function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
     "#   .claude/procedures/check-blocked.sh maintenance",
     "#   .claude/procedures/check-blocked.sh prs",
     "#   .claude/procedures/check-blocked.sh scope <issue-number>",
+    "#   .claude/procedures/check-blocked.sh label-invariant [--fix]",
     "",
     "set -uo pipefail",
     "",
@@ -16064,6 +16320,8 @@ function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
     "",
     scopeHelperIndented,
     "",
+    renderPhaseTypeInvariantShellHelpers(),
+    "",
     ...renderDelegationActiveSignalsHelper(),
     "",
     "# \u2500\u2500 subcommands \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
@@ -16699,16 +16957,43 @@ function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
     "    esac",
     '  done <<< "$lease_output"',
     "",
+    "  # \u2500\u2500 phase-label \u2192 type:<bundle> invariant (MUTATING) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "  # Run the label-invariant sweep in --fix mode and surface its",
+    "  # per-issue lines for log visibility. cmd_label_invariant applies",
+    "  # the label edits itself (a single atomic remove+add per issue, so",
+    "  # an issue is never observable carrying two type:* labels) and",
+    "  # flags the cases it must not guess at. Its terminal",
+    "  # LABEL_INVARIANT_DONE line is captured and re-emitted alongside",
+    "  # MAINTENANCE_DONE so the orchestrator reads every summary from",
+    "  # one maintenance invocation.",
+    "  local label_output",
+    "  label_output=$(cmd_label_invariant --fix)",
+    '  local label_summary="LABEL_INVARIANT_DONE mode=fix checked=0 ok=0 violations=0 corrected=0 flagged=0"',
+    "",
+    "  while IFS= read -r line; do",
+    '    [[ -z "$line" ]] && continue',
+    '    case "$line" in',
+    "      'LABEL_INVARIANT_DONE '*)",
+    '        label_summary="$line"',
+    "        ;;",
+    "      *)",
+    '        echo "$line"',
+    "        ;;",
+    "    esac",
+    '  done <<< "$label_output"',
+    "",
     "  # \u2500\u2500 needs-attention total \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
     "  local needs_attention_total",
     '  needs_attention_total=$(gh issue list --label "status:needs-attention" --state open \\',
     "    --json number --limit 100 2>/dev/null | jq 'length' 2>/dev/null || echo 0)",
     "  needs_attention_total=${needs_attention_total:-0}",
     "",
-    "  # Two summary lines consumed by the orchestrator: the issue/orphan",
-    "  # MAINTENANCE_DONE line and the PR-lease LEASE_RECONCILE line.",
+    "  # Three summary lines consumed by the orchestrator: the",
+    "  # issue/orphan MAINTENANCE_DONE line, the PR-lease LEASE_RECONCILE",
+    "  # line, and the LABEL_INVARIANT_DONE line.",
     '  echo "MAINTENANCE_DONE flagged_stale=${flagged_stale_count} flagged_blocked=${flagged_blocked_count} orphan_branches=${orphan_branches_count} orphan_prs=${orphan_prs_count} needs_attention_total=${needs_attention_total}"',
     '  echo "$lease_summary"',
+    '  echo "$label_summary"',
     "}",
     "",
     "cmd_prs() {",
@@ -16774,6 +17059,196 @@ function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
     '  done <<< "$eligible"',
     "}",
     "",
+    "cmd_label_invariant() {",
+    "  # Phase-label \u2192 type:<bundle> invariant sweep.",
+    "  #",
+    "  # Every phased-pipeline bundle pairs its <bundle>:<phase> labels",
+    "  # with exactly one type:<bundle> label. An agent that reconstructs",
+    "  # a gh issue create call from prose can stamp a conventional-commit",
+    "  # type label derived from the title prefix instead, producing an",
+    "  # issue that carries the phase label but the WRONG type label \u2014",
+    "  # invisible to the --label type:<bundle> duplicate-check idiom and",
+    "  # mis-tiered by the funnel-tier sort in cmd_eligible.",
+    "  #",
+    "  # Default mode is REPORT-ONLY (the consumer-runnable audit); pass",
+    "  # --fix to apply corrections. cmd_maintenance runs the --fix mode",
+    "  # as part of the Phase D sweep.",
+    "  #",
+    "  # CORRECTION POLICY. An issue must carry EXACTLY ONE type:* label",
+    "  # (cmd_eligible derives its funnel-tier sort key from the FIRST",
+    "  # one, and the label conventions mandate exactly one), so the",
+    "  # correction REPLACES rather than merely adds:",
+    "  #",
+    "  #   no type:* at all              \u2192 add the implied type label",
+    "  #   only conventional-commit      \u2192 remove them, add the implied",
+    "  #     type labels present           label (single atomic edit)",
+    "  #   implied label already there   \u2192 remove the stray conventional",
+    "  #     alongside a conventional one   label, leaving exactly one",
+    "  #   a type:* owned by ANOTHER     \u2192 FLAG status:needs-attention;",
+    "  #     bundle                         never guess which to drop",
+    "  #   phase labels imply 2+ types   \u2192 FLAG status:needs-attention",
+    "  #",
+    "  # Only a conventional-commit type label is ever removed \u2014 the set",
+    "  # is_conventional_type_label() recognises. A type:* label owned by",
+    "  # a different bundle is a genuine conflict a human must resolve.",
+    "  # status:needs-attention is applied ADDITIVELY; the base status:*",
+    "  # label always stays (see the additive-flag rule).",
+    "  local apply=0",
+    '  if [[ "${1:-}" == "--fix" ]]; then',
+    "    apply=1",
+    "  fi",
+    '  local mode="report"',
+    '  [[ "$apply" -eq 1 ]] && mode="fix"',
+    "",
+    "  local issues",
+    "  issues=$(gh issue list --state open --json number,labels \\",
+    '    --limit 1000 2>/dev/null || echo "[]")',
+    "",
+    "  # Filter jq-side and emit a TWO-field record. The label list is",
+    "  # last AND guaranteed non-empty by the select, so no field can",
+    "  # collapse under IFS=tab and shift the record left (#884). The",
+    "  # title is deliberately not threaded through \u2014 every output line",
+    "  # keys off the issue number.",
+    "  local issue_data",
+    `  issue_data=$(echo "$issues" | jq -r '`,
+    "    .[] |",
+    "    (.labels | map(.name)) as $names |",
+    "    select($names | length > 0) |",
+    '    "\\(.number)\\t\\($names | join(","))"',
+    "  ' 2>/dev/null)",
+    "",
+    "  local checked_count=0",
+    "  local ok_count=0",
+    "  local corrected_count=0",
+    "  local flagged_count=0",
+    "",
+    "  while IFS=$'\\t' read -r num labels_csv; do",
+    '    [[ -z "$num" ]] && continue',
+    "",
+    "    local labels_nl",
+    `    labels_nl=$(printf '%s' "$labels_csv" | tr ',' '\\n')`,
+    "",
+    "    local resolution assignment",
+    "    local outcome='' type_label='' phase_labels='' candidates=''",
+    `    resolution=$(printf '%s\\n' "$labels_nl" | phase_type_of)`,
+    "    while IFS= read -r assignment; do",
+    '      case "$assignment" in',
+    "        OUTCOME=*) outcome=${assignment#OUTCOME=} ;;",
+    "        TYPE_LABEL=*) type_label=${assignment#TYPE_LABEL=} ;;",
+    "        CANDIDATE_TYPE_LABELS=*) candidates=${assignment#CANDIDATE_TYPE_LABELS=} ;;",
+    "        PHASE_LABELS=*) phase_labels=${assignment#PHASE_LABELS=} ;;",
+    "      esac",
+    '    done <<< "$resolution"',
+    "",
+    "    # No recognised phase label \u2014 the invariant does not apply.",
+    "    # Consumer-specific `foo:bar` labels are deliberately not policed.",
+    '    [[ "$outcome" == "none" ]] && continue',
+    "    checked_count=$((checked_count + 1))",
+    "",
+    "    # Idempotent flagging: read the existing flag off the labels we",
+    "    # already fetched rather than spending another API call.",
+    "    local already_flagged=0",
+    '    case ",${labels_csv}," in',
+    '      *",status:needs-attention,"*) already_flagged=1 ;;',
+    "    esac",
+    "",
+    '    if [[ "$outcome" == "ambiguous" ]]; then',
+    '      echo "LABEL_AMBIGUOUS #${num} phase=\\"${phase_labels}\\" candidates=\\"${candidates}\\""',
+    "      flagged_count=$((flagged_count + 1))",
+    '      if [[ "$apply" -eq 1 && "$already_flagged" -eq 0 ]]; then',
+    '        if gh issue edit "$num" --add-label "status:needs-attention" >/dev/null 2>&1; then',
+    '          gh issue comment "$num" \\',
+    '            --body "Label invariant: phase label(s) ${phase_labels} imply more than one bundle type label (${candidates}). Flagged for human triage \u2014 an ambiguous pairing is never auto-corrected." >/dev/null 2>&1 || true',
+    '          echo "LABEL_FLAGGED #${num} \u2014 added status:needs-attention (ambiguous)"',
+    "        else",
+    '          echo "LABEL_FLAG_FAILED #${num} \u2014 could not add status:needs-attention (ambiguous)"',
+    "        fi",
+    "      fi",
+    "      continue",
+    "    fi",
+    "",
+    "    # Partition the issue's existing type:* labels against the",
+    "    # implied one.",
+    "    local label",
+    "    local has_expected=0",
+    "    local conv_types=''",
+    "    local foreign_types=''",
+    "    while IFS= read -r label; do",
+    '      [ -z "$label" ] && continue',
+    '      case "$label" in',
+    "        type:*) ;;",
+    "        *) continue ;;",
+    "      esac",
+    '      if [ "$label" = "$type_label" ]; then',
+    "        has_expected=1",
+    "        continue",
+    "      fi",
+    '      if is_conventional_type_label "$label"; then',
+    '        conv_types="${conv_types}${label} "',
+    "      else",
+    '        foreign_types="${foreign_types}${label} "',
+    "      fi",
+    '    done <<< "$labels_nl"',
+    "",
+    '    if [[ "$has_expected" -eq 1 && -z "${conv_types}${foreign_types}" ]]; then',
+    '      echo "LABEL_OK #${num} type=${type_label}"',
+    "      ok_count=$((ok_count + 1))",
+    "      continue",
+    "    fi",
+    "",
+    "    # A type:* label owned by a DIFFERENT bundle is a conflict the",
+    "    # sweep must not guess at: removing it would destroy routing",
+    "    # information, and adding alongside it would leave two bundle",
+    "    # type labels and a non-deterministic funnel tier.",
+    '    if [[ -n "$foreign_types" ]]; then',
+    '      echo "LABEL_CONFLICT #${num} phase=\\"${phase_labels}\\" expected=${type_label} foreign=\\"${foreign_types% }\\""',
+    "      flagged_count=$((flagged_count + 1))",
+    '      if [[ "$apply" -eq 1 && "$already_flagged" -eq 0 ]]; then',
+    '        if gh issue edit "$num" --add-label "status:needs-attention" >/dev/null 2>&1; then',
+    '          gh issue comment "$num" \\',
+    '            --body "Label invariant: phase label(s) ${phase_labels} require ${type_label}, but this issue carries ${foreign_types% }, which is owned by another bundle. Flagged for human triage \u2014 the sweep only removes conventional-commit type labels." >/dev/null 2>&1 || true',
+    '          echo "LABEL_FLAGGED #${num} \u2014 added status:needs-attention (conflicting bundle type)"',
+    "        else",
+    '          echo "LABEL_FLAG_FAILED #${num} \u2014 could not add status:needs-attention (conflict)"',
+    "        fi",
+    "      fi",
+    "      continue",
+    "    fi",
+    "",
+    "    # Correctable: add the implied label and/or drop the",
+    "    # conventional-commit label(s) shadowing it, in ONE edit so the",
+    "    # issue is never observable carrying two type:* labels.",
+    '    local removing="${conv_types% }"',
+    "    local adding=''",
+    '    [[ "$has_expected" -eq 0 ]] && adding="$type_label"',
+    '    echo "LABEL_VIOLATION #${num} phase=\\"${phase_labels}\\" expected=${type_label} add=\\"${adding}\\" remove=\\"${removing}\\""',
+    '    if [[ "$apply" -eq 0 ]]; then',
+    "      continue",
+    "    fi",
+    "",
+    "    local -a edit_args=()",
+    "    local stray",
+    "    for stray in $removing; do",
+    '      edit_args+=(--remove-label "$stray")',
+    "    done",
+    '    [[ -n "$adding" ]] && edit_args+=(--add-label "$adding")',
+    '    if [[ "${#edit_args[@]}" -eq 0 ]]; then',
+    "      continue",
+    "    fi",
+    '    if gh issue edit "$num" "${edit_args[@]}" >/dev/null 2>&1; then',
+    '      gh issue comment "$num" \\',
+    '        --body "Label invariant: phase label(s) ${phase_labels} require ${type_label}. Corrected \u2014 added: ${adding:-(none)}; removed: ${removing:-(none)}." >/dev/null 2>&1 || true',
+    '      echo "LABEL_CORRECTED #${num} added=\\"${adding}\\" removed=\\"${removing}\\""',
+    "      corrected_count=$((corrected_count + 1))",
+    "    else",
+    '      echo "LABEL_CORRECT_FAILED #${num} \u2014 label edit failed"',
+    "    fi",
+    '  done <<< "$issue_data"',
+    "",
+    "  local violations_count=$((checked_count - ok_count))",
+    '  echo "LABEL_INVARIANT_DONE mode=${mode} checked=${checked_count} ok=${ok_count} violations=${violations_count} corrected=${corrected_count} flagged=${flagged_count}"',
+    "}",
+    "",
     "cmd_scope() {",
     '  local issue_num="${1:-}"',
     '  if [[ -z "$issue_num" ]]; then',
@@ -16860,8 +17335,9 @@ function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
     '  maintenance) shift; cmd_maintenance "$@" ;;',
     '  prs)         shift; cmd_prs "$@" ;;',
     '  scope)       shift; cmd_scope "$@" ;;',
+    '  label-invariant) shift; cmd_label_invariant "$@" ;;',
     "  help|*)",
-    '    echo "Usage: check-blocked.sh <unblock|eligible|stale|orphaned|lease-reconcile|maintenance|prs|scope>"',
+    '    echo "Usage: check-blocked.sh <unblock|eligible|stale|orphaned|lease-reconcile|maintenance|prs|scope|label-invariant>"',
     "    exit 1",
     "    ;;",
     "esac"
@@ -16870,7 +17346,7 @@ function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
 function buildCheckBlockedProcedure(tiers, scopeGate = resolveScopeGate(), runRatio = resolveRunRatio()) {
   return {
     name: "check-blocked.sh",
-    description: "Token-efficient issue triage script with subcommands: eligible, unblock, stale, orphaned, lease-reconcile, maintenance, prs, scope. Sorts eligible issues by priority desc \u2192 funnel tier asc \u2192 issue number asc, excluding issues carrying `status:needs-attention` or `status:deferred`; the scope subcommand classifies a single issue against the scope-gate thresholds; the unblock subcommand applies the `status:blocked` \u2192 `status:ready` label flip itself, posts the canned unblock comment, skips human-parked `status:deferred` candidates with a `SKIP_DEFERRED` line, and emits a single `TRIAGE_DONE unblocked=N still_blocked=M deferred_skipped=K` summary line; the lease-reconcile subcommand auto-reconciles stuck `review:fixing` PR leases \u2014 re-applying `review:needs-worker` on an orphaned lease (fix-list stale, no worker report) so the Phase B1 drain retries, and removing `review:needs-worker` on a consumed-but-uncleared wedge (branch HEAD advanced past the fix-list, marker still set, no worker report) so the reviewer confirm pass can merge, always posting an audit-trail note comment and emitting a single `LEASE_RECONCILE orphaned=N consumed_uncleared=M` summary line; the maintenance subcommand flags stale issues with `status:needs-attention` (never auto-resets to `status:ready`), counts orphan branches/PRs, folds in the lease-reconcile sweep, and emits a `MAINTENANCE_DONE flagged_stale=N flagged_blocked=M orphan_branches=A orphan_prs=B needs_attention_total=T` summary line followed by the `LEASE_RECONCILE` line.",
+    description: "Token-efficient issue triage script with subcommands: eligible, unblock, stale, orphaned, lease-reconcile, maintenance, prs, scope, label-invariant. Sorts eligible issues by priority desc \u2192 funnel tier asc \u2192 issue number asc, excluding issues carrying `status:needs-attention` or `status:deferred`; the scope subcommand classifies a single issue against the scope-gate thresholds; the unblock subcommand applies the `status:blocked` \u2192 `status:ready` label flip itself, posts the canned unblock comment, skips human-parked `status:deferred` candidates with a `SKIP_DEFERRED` line, and emits a single `TRIAGE_DONE unblocked=N still_blocked=M deferred_skipped=K` summary line; the lease-reconcile subcommand auto-reconciles stuck `review:fixing` PR leases \u2014 re-applying `review:needs-worker` on an orphaned lease (fix-list stale, no worker report) so the Phase B1 drain retries, and removing `review:needs-worker` on a consumed-but-uncleared wedge (branch HEAD advanced past the fix-list, marker still set, no worker report) so the reviewer confirm pass can merge, always posting an audit-trail note comment and emitting a single `LEASE_RECONCILE orphaned=N consumed_uncleared=M` summary line; the maintenance subcommand flags stale issues with `status:needs-attention` (never auto-resets to `status:ready`), counts orphan branches/PRs, folds in the lease-reconcile sweep and the label-invariant auto-correction, and emits a `MAINTENANCE_DONE flagged_stale=N flagged_blocked=M orphan_branches=A orphan_prs=B needs_attention_total=T` summary line followed by the `LEASE_RECONCILE` and `LABEL_INVARIANT_DONE` lines; the label-invariant subcommand enforces the phase-label \u2192 `type:<bundle>` pairing derived from the canonical `BUNDLE_OWNERSHIP` map \u2014 report-only by default, auto-correcting with `--fix` (replacing a shadowing conventional-commit `type:*` rather than merely adding, so the issue keeps exactly one `type:*`) and flagging `status:needs-attention` when the pairing is ambiguous or collides with another bundle's type label, emitting a single `LABEL_INVARIANT_DONE mode=M checked=N ok=O violations=V corrected=C flagged=F` summary line.",
     content: buildCheckBlockedScript(tiers, scopeGate, runRatio)
   };
 }
@@ -17586,32 +18062,36 @@ var orchestratorSubAgent = {
     "## Phase D: Maintenance",
     "",
     "Run the bundled `check-blocked.sh maintenance` procedure and read",
-    "**only** the two summary lines it emits \u2014 `MAINTENANCE_DONE` and",
-    "`LEASE_RECONCILE`. The procedure folds the stale-detection,",
-    "orphan-detection, needs-attention summary, and PR-lease",
-    "auto-reconcile that earlier revisions split across D1, D2, and D3",
-    "into a single sweep \u2014 applying the `status:needs-attention` label",
-    "and posting the canned flag comment for each stale / stale-blocked",
-    "issue itself, and reconciling stuck `review:fixing` PR leases",
-    "itself, mirroring the discipline of Phase B (`pr-sweep.sh`) and",
-    "Phase C (`check-blocked.sh unblock`).",
+    "**only** the three summary lines it emits \u2014 `MAINTENANCE_DONE`,",
+    "`LEASE_RECONCILE`, and `LABEL_INVARIANT_DONE`. The procedure folds",
+    "the stale-detection, orphan-detection, needs-attention summary,",
+    "PR-lease auto-reconcile, and phase-label invariant sweep that",
+    "earlier revisions split across D1, D2, and D3 into a single sweep \u2014",
+    "applying the `status:needs-attention` label and posting the canned",
+    "flag comment for each stale / stale-blocked issue itself,",
+    "reconciling stuck `review:fixing` PR leases itself, and correcting",
+    "mislabeled pipeline issues itself, mirroring the discipline of",
+    "Phase B (`pr-sweep.sh`) and Phase C (`check-blocked.sh unblock`).",
     "",
     "```bash",
     ".claude/procedures/check-blocked.sh maintenance",
     "```",
     "",
-    "The script emits two summary lines in this shape:",
+    "The script emits three summary lines in this shape:",
     "",
     "```",
     "MAINTENANCE_DONE flagged_stale=<N> flagged_blocked=<M> orphan_branches=<A> orphan_prs=<B> needs_attention_total=<T>",
     "LEASE_RECONCILE orphaned=<N> consumed_uncleared=<M>",
+    "LABEL_INVARIANT_DONE mode=fix checked=<N> ok=<O> violations=<V> corrected=<C> flagged=<F>",
     "```",
     "",
     "Per-issue / per-orphan / per-PR informational lines (`FLAGGED_STALE",
     "#N`, `FLAGGED_BLOCKED #N`, `STALE #N \u2014 \u2026`, `STALE_BLOCKED #N \u2014 \u2026`,",
     "`ORPHAN_BRANCH \u2026`, `ORPHAN_PR #N \u2014 \u2026`, `FLAG_FAILED #N \u2014 \u2026`,",
     "`LEASE_ORPHANED PR #N \u2014 \u2026`, `LEASE_CONSUMED_UNCLEARED PR #N \u2014 \u2026`,",
-    "`LEASE_RECONCILE_FAILED PR #N \u2014 \u2026`) are emitted for log visibility",
+    "`LEASE_RECONCILE_FAILED PR #N \u2014 \u2026`, `LABEL_VIOLATION #N \u2014 \u2026`,",
+    "`LABEL_CORRECTED #N \u2014 \u2026`, `LABEL_AMBIGUOUS #N \u2014 \u2026`,",
+    "`LABEL_CONFLICT #N \u2014 \u2026`) are emitted for log visibility",
     "but are **not** load-bearing for the orchestrator \u2014 partial failures",
     "(one bad `gh` call) do not abort the sweep, they are simply omitted",
     "from the counters.",
@@ -17651,9 +18131,24 @@ var orchestratorSubAgent = {
     "is never silently force-released. The `review:fixing` lease itself",
     "is always left for the reviewer confirm pass to release.",
     "",
-    "Log both summary lines and continue to Phase E regardless of",
-    "outcomes \u2014 a non-zero `flagged_*`, `orphan_*`, `orphaned`, or",
-    "`consumed_uncleared` count is informational, not a failure.",
+    "**Phase-label invariant (`LABEL_INVARIANT_DONE`).** The sweep also",
+    "enforces the phase-label \u2192 `type:<bundle>` pairing on every open",
+    "issue, so a pipeline issue filed with a conventional-commit",
+    "`type:*` (derived from its title prefix) cannot stay invisible to",
+    'the `--label "type:<bundle>"` duplicate-check idiom or mis-tier in',
+    "Phase E's funnel-tier sort. The script mutates the labels itself \u2014",
+    "the orchestrator only reads the summary line. See the **Phase-label",
+    "\u2192 `type:<bundle>` invariant** section in `CLAUDE.md` for the full",
+    "correction policy; in short, a shadowing conventional-commit type",
+    "label is **replaced** (never merely supplemented, so the issue",
+    "keeps exactly one `type:*`), and an ambiguous or cross-bundle",
+    "collision is **flagged** `status:needs-attention` rather than",
+    "guessed at.",
+    "",
+    "Log all three summary lines and continue to Phase E regardless of",
+    "outcomes \u2014 a non-zero `flagged_*`, `orphan_*`, `orphaned`,",
+    "`consumed_uncleared`, `corrected`, or `flagged` count is",
+    "informational, not a failure.",
     "",
     "## Phase E: Queue Scan",
     "",
@@ -18655,6 +19150,7 @@ var ORCHESTRATOR_CONVENTIONS_PREAMBLE = [
   "- Stale thresholds: 72h for in-progress, 168h for blocked",
   "- Flagged issues get `status:needs-attention` \u2014 they are not auto-reset",
   "- **Phase D auto-reconciles stuck PR leases.** The maintenance sweep's `check-blocked.sh maintenance` invocation folds in a PR-lease reconcile that unwedges `review:fixing` PRs the Phase B1 drain and the worker hand-off left stuck, emitting a `LEASE_RECONCILE orphaned=<N> consumed_uncleared=<M>` line alongside `MAINTENANCE_DONE`. An **orphaned lease** (`review:fixing` without `review:needs-worker`, fix-list older than the 72h stale threshold, no worker-report newer than the fix-list) is **re-armed** \u2014 the sweep re-applies `review:needs-worker` so the Phase B1 drain retries the delegation, leaving the lease untouched. A **consumed-but-uncleared wedge** (both labels present, branch HEAD newer than the fix-list, no worker-report \u2014 the worker pushed but skipped the hand-off) is **auto-reconciled** \u2014 the sweep removes `review:needs-worker` so the reviewer confirm pass can merge. Both paths post an audit-trail note comment; a lease is never silently force-released, and the `review:fixing` lease itself is always left for the reviewer confirm pass to release.",
+  "- **Phase D enforces the phase-label \u2192 `type:<bundle>` invariant.** The same maintenance sweep folds in a label-invariant pass that auto-corrects open issues carrying a pipeline phase label without the matching `type:<bundle>` label, emitting a `LABEL_INVARIANT_DONE mode=fix checked=<N> ok=<O> violations=<V> corrected=<C> flagged=<F>` line alongside `MAINTENANCE_DONE`. The correction **replaces** a shadowing conventional-commit `type:*` rather than merely adding the bundle type, so the issue keeps exactly one `type:*` and Phase E's funnel-tier sort key stays deterministic. Ambiguous pairings and collisions with another bundle's `type:*` label are **flagged** `status:needs-attention` (additively) instead of guessed at. See the **Phase-label \u2192 `type:<bundle>` invariant** section below for the matcher table and the full correction policy.",
   "",
   "## Depth-0 invocation requirement",
   "",
@@ -18670,6 +19166,8 @@ function buildOrchestratorConventionsContent(tiers, scopeGate = resolveScopeGate
     "",
     renderScopeGateSection(scopeGate, excludeBundles),
     "",
+    renderPhaseTypeInvariantSection(excludeBundles),
+    "",
     renderScheduledTasksSection(scheduledTasks),
     "",
     renderUnblockDependentsSection(unblockDependents)
@@ -41022,6 +41520,7 @@ export const collections = {
   CDK_WATCH_DEFAULTS_BY_STAGE,
   CLAUDE_RULE_TARGET,
   COMPLETE_JOB_ID,
+  CONVENTIONAL_COMMIT_TYPE_LABELS,
   CdkCli,
   DEFAULT_AC_THRESHOLDS,
   DEFAULT_AGENT_PATHS,
@@ -41093,6 +41592,7 @@ export const collections = {
   MONOREPO_LAYOUT,
   MonorepoProject,
   Nvmrc,
+  PHASE_LABEL_TYPE_MAP,
   PROD_DEPLOY_NAME,
   PROGRESS_FILES_FORMAT_VALUES,
   PnpmWorkspace,
@@ -41253,6 +41753,8 @@ export const collections = {
   renderIssueTemplatesStarterPage,
   renderMeetingTypesSection,
   renderNextRequirementIdProcedure,
+  renderPhaseTypeInvariantSection,
+  renderPhaseTypeInvariantShellHelpers,
   renderPriorityRulesSection,
   renderProgressFileName,
   renderProgressFilePath,
@@ -41304,6 +41806,7 @@ export const collections = {
   resolveSkillEvals,
   resolveTemplateVariables,
   resolveTemporalFraming,
+  resolveTypeLabelForLabels,
   resolveTypeScriptProjectOutdir,
   resolveUnblockDependents,
   runScan,
@@ -41313,6 +41816,7 @@ export const collections = {
   stripToolArtifactTagsProcedure,
   tsdocRecordToFindings,
   turborepoBundle,
+  typeLabelForPhaseLabel,
   typescriptBundle,
   upstreamConfigulatorDocsBundle,
   validateAgentTierConfig,