@codedrifters/configulator 0.0.298 → 0.0.299

package/lib/index.mjs

@@ -1080,6 +1080,47 @@ var awsCdkBundle = {
         "- When adding a `NodejsFunction` with a bundled handler, ensure the `entry` path is explicitly configured",
         "- Verify the entry is included in the build tool config (e.g., tsup entry list) so the runtime can find the handler",
         "",
+        "## Lambda Construct Encapsulation",
+        "",
+        "When a Lambda construct is event-driven, it should own:",
+        "",
+        "- The EventBridge Rule (or other trigger) that routes events to itself.",
+        "- The IAM permissions it needs on resources passed in via props.",
+        "",
+        "Pass the resources (event bus, table, queue, etc.) into the Lambda",
+        "construct's props rather than defining triggers and grants in the",
+        "enclosing workflow or service. The Lambda construct then becomes",
+        'self-describing \u2014 "what triggers me, what I write to" lives in one',
+        "file \u2014 and reverting or refactoring a single Lambda doesn't ripple",
+        "through unrelated constructs.",
+        "",
+        "```typescript",
+        "export interface MyLambdaProps {",
+        "  readonly eventBus: IEventBus;",
+        "  readonly dataStoreTable: ITable;",
+        "}",
+        "",
+        "export class MyLambda extends Construct {",
+        "  public readonly lambda: NodejsFunction;",
+        "  public readonly rule: Rule;",
+        "",
+        "  constructor(scope: Construct, props: MyLambdaProps) {",
+        '    super(scope, "my-lambda");',
+        "",
+        '    this.lambda = new NodejsFunction(this, "handler", { /* ... */ });',
+        "    props.dataStoreTable.grantReadWriteData(this.lambda);",
+        '    this.rule = new Rule(this, "rule", {',
+        "      eventBus: props.eventBus,",
+        "      eventPattern: { /* ... */ },",
+        "      targets: [new LambdaFunction(this.lambda)],",
+        "    });",
+        "  }",
+        "}",
+        "```",
+        "",
+        "A workflow or service construct then composes these Lambda constructs",
+        "without owning their triggers or grants directly.",
+        "",
         "## CDK Testing",
         "",
         "- Mock `Code.fromAsset` in any test file that synthesizes CDK stacks",
@@ -13193,11 +13234,10 @@ function shellSingleQuote(value) {
 }
 
 // src/agent/bundles/orchestrator.ts
-function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
+function buildCheckBlockedScript(tiers, scopeGate, _runRatio) {
   const tierCase = renderAgentTierCaseStatement(tiers);
   const scopeHelper = renderScopeGateShellHelpers(scopeGate);
   const scopeHelperIndented = scopeHelper.split("\n").map((line) => line.length > 0 ? line : "").join("\n");
-  const runRatioHelper = renderRunRatioShellHelpers(runRatio);
   return [
     "#!/usr/bin/env bash",
     "# check-blocked.sh \u2014 Token-efficient issue triage for agent loops.",
@@ -13209,9 +13249,9 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     "#   .claude/procedures/check-blocked.sh eligible",
     "#   .claude/procedures/check-blocked.sh stale",
     "#   .claude/procedures/check-blocked.sh orphaned",
+    "#   .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 tick",
     "",
     "set -uo pipefail",
     "",
@@ -13225,9 +13265,6 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     `SCOPE_AC_MEDIUM_MAX=${scopeGate.acceptanceCriteria.mediumMax}`,
     `SCOPE_SOURCES_SMALL_MAX=${scopeGate.sources.smallMax}`,
     `SCOPE_SOURCES_MEDIUM_MAX=${scopeGate.sources.mediumMax}`,
-    `RUN_RATIO_ENABLED=${runRatio.enabled ? "1" : "0"}`,
-    `RUN_RATIO_DISPATCH_PER_HOUSEKEEPING=${runRatio.ratio}`,
-    `ORCHESTRATOR_STATE_FILE="${runRatio.stateFilePath}"`,
     "",
     "# \u2500\u2500 helpers \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\u2500\u2500\u2500\u2500",
     "",
@@ -13258,8 +13295,6 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     "",
     scopeHelperIndented,
     "",
-    runRatioHelper,
-    "",
     "# \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",
     "",
     "cmd_unblock() {",
@@ -13270,7 +13305,7 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     "  local count",
     `  count=$(echo "$issues" | jq 'length')`,
     '  if [[ "$count" -eq 0 ]]; then',
-    '    echo "NO_BLOCKED_ISSUES"',
+    '    echo "TRIAGE_DONE unblocked=0 still_blocked=0"',
     "    return 0",
     "  fi",
     "",
@@ -13281,18 +13316,36 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     '    "\\(.number)\\t\\($dep_line)"',
     "  ')",
     "",
+    "  # Counters for the summary line. The orchestrator reads only",
+    "  # TRIAGE_DONE; the per-issue lines below are for log visibility,",
+    "  # mirroring unblock-dependents.sh.",
+    "  local unblocked_count=0",
+    "  local still_blocked_count=0",
+    "",
     "  while IFS=$'\\t' read -r num dep_line; do",
     '    [[ -z "$num" ]] && continue',
     "",
     '    if [[ -z "$dep_line" ]]; then',
     '      echo "BLOCKED #${num} \u2014 no Depends on field found"',
+    "      still_blocked_count=$((still_blocked_count + 1))",
     "      continue",
     "    fi",
     "",
     "    local deps",
     '    deps=$(parse_deps "$dep_line")',
     '    if [[ -z "${deps// /}" ]]; then',
-    '      echo "UNBLOCK #${num} \u2014 no dependencies"',
+    "      # Empty dependency list \u2014 treat as eligible for unblocking.",
+    '      if gh issue edit "$num" \\',
+    '          --remove-label "status:blocked" \\',
+    '          --add-label "status:ready" >/dev/null 2>&1; then',
+    '        gh issue comment "$num" \\',
+    '          --body "Dependencies resolved \u2014 unblocking." >/dev/null 2>&1 || true',
+    '        echo "UNBLOCKED #${num} \u2014 no dependencies"',
+    "        unblocked_count=$((unblocked_count + 1))",
+    "      else",
+    '        echo "UNBLOCK_FAILED #${num} \u2014 label flip failed (no dependencies)"',
+    "        still_blocked_count=$((still_blocked_count + 1))",
+    "      fi",
     "      continue",
     "    fi",
     "",
@@ -13309,11 +13362,30 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     "    done",
     "",
     "    if $all_closed; then",
-    '      echo "UNBLOCK #${num} \u2014 all deps closed (${closed_deps% })"',
+    "      # The label flip is the load-bearing edit; if it fails we must",
+    "      # report the failure so the orchestrator does not double-count.",
+    "      # The comment is best-effort (its absence is recoverable on the",
+    "      # next sweep), so a failed `gh issue comment` does not block the",
+    "      # unblock from being recorded as successful.",
+    '      if gh issue edit "$num" \\',
+    '          --remove-label "status:blocked" \\',
+    '          --add-label "status:ready" >/dev/null 2>&1; then',
+    '        gh issue comment "$num" \\',
+    '          --body "Dependencies resolved \u2014 unblocking." >/dev/null 2>&1 || true',
+    '        echo "UNBLOCKED #${num} \u2014 all deps closed (${closed_deps% })"',
+    "        unblocked_count=$((unblocked_count + 1))",
+    "      else",
+    '        echo "UNBLOCK_FAILED #${num} \u2014 label flip failed (all deps closed: ${closed_deps% })"',
+    "        still_blocked_count=$((still_blocked_count + 1))",
+    "      fi",
     "    else",
-    '      echo "BLOCKED #${num} \u2014 waiting on ${open_deps% }"',
+    '      echo "STILL_BLOCKED #${num} \u2014 waiting on ${open_deps% }"',
+    "      still_blocked_count=$((still_blocked_count + 1))",
     "    fi",
     '  done <<< "$issue_data"',
+    "",
+    "  # Single summary line consumed by the orchestrator.",
+    '  echo "TRIAGE_DONE unblocked=${unblocked_count} still_blocked=${still_blocked_count}"',
     "}",
     "",
     "cmd_eligible() {",
@@ -13505,6 +13577,101 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     "  fi",
     "}",
     "",
+    "cmd_maintenance() {",
+    "  # Phase D maintenance sweep: flag stale issues with",
+    "  # `status:needs-attention`, count orphan branches/PRs (no",
+    "  # auto-deletion), and emit a single MAINTENANCE_DONE summary",
+    "  # line so the orchestrator never iterates raw stale/orphan",
+    "  # output. Mirrors the discipline of cmd_unblock \u2014 per-issue",
+    "  # informational lines (FLAGGED #N, ORPHAN_BRANCH \u2026) survive",
+    "  # for log visibility but are not load-bearing for the",
+    "  # orchestrator.",
+    "  #",
+    "  # SAFETY: this subcommand NEVER auto-resets stale issues to",
+    "  # `status:ready`. It only adds `status:needs-attention`; the",
+    "  # existing `status:in-progress` or `status:blocked` label",
+    "  # stays in place so partial implementation work on a branch",
+    "  # remains visible to humans.",
+    "",
+    "  local flagged_stale_count=0",
+    "  local flagged_blocked_count=0",
+    "  local orphan_branches_count=0",
+    "  local orphan_prs_count=0",
+    "",
+    "  # \u2500\u2500 stale detection + flagging \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 stale_output",
+    "  stale_output=$(cmd_stale)",
+    "",
+    "  while IFS= read -r line; do",
+    '    [[ -z "$line" ]] && continue',
+    '    case "$line" in',
+    "      'STALE #'*)",
+    "        # Extract the issue number after the '#' and before the ' '.",
+    "        local num=${line#STALE #}",
+    "        num=${num%% *}",
+    '        if gh issue edit "$num" --add-label "status:needs-attention" >/dev/null 2>&1; then',
+    '          gh issue comment "$num" \\',
+    '            --body "Flagged: in-progress for >3 days with no activity." >/dev/null 2>&1 || true',
+    '          echo "FLAGGED_STALE #${num} \u2014 added status:needs-attention"',
+    "          flagged_stale_count=$((flagged_stale_count + 1))",
+    "        else",
+    '          echo "FLAG_FAILED #${num} \u2014 could not add status:needs-attention (stale)"',
+    "        fi",
+    "        # Surface the original informational line for log visibility.",
+    '        echo "$line"',
+    "        ;;",
+    "      'STALE_BLOCKED #'*)",
+    "        local num=${line#STALE_BLOCKED #}",
+    "        num=${num%% *}",
+    '        if gh issue edit "$num" --add-label "status:needs-attention" >/dev/null 2>&1; then',
+    '          gh issue comment "$num" \\',
+    '            --body "Flagged: blocked for >7 days \u2014 may need human intervention." >/dev/null 2>&1 || true',
+    '          echo "FLAGGED_BLOCKED #${num} \u2014 added status:needs-attention"',
+    "          flagged_blocked_count=$((flagged_blocked_count + 1))",
+    "        else",
+    '          echo "FLAG_FAILED #${num} \u2014 could not add status:needs-attention (blocked)"',
+    "        fi",
+    '        echo "$line"',
+    "        ;;",
+    "      'NO_STALE_ISSUES')",
+    "        # Surface the no-op marker for log visibility; counters",
+    "        # stay at zero.",
+    '        echo "$line"',
+    "        ;;",
+    "    esac",
+    '  done <<< "$stale_output"',
+    "",
+    "  # \u2500\u2500 orphan detection (count only \u2014 no auto-deletion) \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
+    "  local orphan_output",
+    "  orphan_output=$(cmd_orphaned)",
+    "",
+    "  while IFS= read -r line; do",
+    '    [[ -z "$line" ]] && continue',
+    '    case "$line" in',
+    "      'ORPHAN_BRANCH '*)",
+    "        orphan_branches_count=$((orphan_branches_count + 1))",
+    '        echo "$line"',
+    "        ;;",
+    "      'ORPHAN_PR '*)",
+    "        orphan_prs_count=$((orphan_prs_count + 1))",
+    '        echo "$line"',
+    "        ;;",
+    "      'NO_ORPHANED_RESOURCES')",
+    '        echo "$line"',
+    "        ;;",
+    "    esac",
+    '  done <<< "$orphan_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}",
+    "",
+    "  # Single summary line consumed by the orchestrator.",
+    '  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}"',
+    "}",
+    "",
     "cmd_prs() {",
     "  local prs",
     "  prs=$(gh pr list --state open --json number,title,isDraft,headRefName,labels,body \\",
@@ -13643,31 +13810,18 @@ function buildCheckBlockedScript(tiers, scopeGate, runRatio) {
     "  fi",
     "}",
     "",
-    "cmd_tick() {",
-    "  # DEPRECATED: the orchestrator no longer maintains a dispatch /",
-    "  # housekeeping run-counter \u2014 every invocation runs the full",
-    "  # end-to-end cycle. This subcommand is retained as a no-op for one",
-    "  # release so any consumer mid-flight does not error out, then will",
-    "  # be removed entirely. Existing state files at",
-    '  # "$ORCHESTRATOR_STATE_FILE" can be left alone (they will become',
-    "  # orphaned).",
-    '  echo "tick: deprecated no-op (orchestrator runs a single linear cycle every invocation)" >&2',
-    '  echo "run=0 type=dispatch (deprecated)"',
-    "  return 0",
-    "}",
-    "",
     "# \u2500\u2500 main \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\u2500\u2500\u2500\u2500\u2500\u2500\u2500",
     "",
     'case "${1:-help}" in',
-    '  unblock)   shift; cmd_unblock "$@" ;;',
-    '  eligible)  shift; cmd_eligible "$@" ;;',
-    '  stale)     shift; cmd_stale "$@" ;;',
-    '  orphaned)  shift; cmd_orphaned "$@" ;;',
-    '  prs)       shift; cmd_prs "$@" ;;',
-    '  scope)     shift; cmd_scope "$@" ;;',
-    '  tick)      shift; cmd_tick "$@" ;;',
+    '  unblock)     shift; cmd_unblock "$@" ;;',
+    '  eligible)    shift; cmd_eligible "$@" ;;',
+    '  stale)       shift; cmd_stale "$@" ;;',
+    '  orphaned)    shift; cmd_orphaned "$@" ;;',
+    '  maintenance) shift; cmd_maintenance "$@" ;;',
+    '  prs)         shift; cmd_prs "$@" ;;',
+    '  scope)       shift; cmd_scope "$@" ;;',
     "  help|*)",
-    '    echo "Usage: check-blocked.sh <unblock|eligible|stale|orphaned|prs|scope|tick>"',
+    '    echo "Usage: check-blocked.sh <unblock|eligible|stale|orphaned|maintenance|prs|scope>"',
     "    exit 1",
     "    ;;",
     "esac"
@@ -13676,7 +13830,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, prs, scope, and (deprecated) tick. Sorts eligible issues by priority desc \u2192 funnel tier asc \u2192 issue number asc; the scope subcommand classifies a single issue against the scope-gate thresholds. The tick subcommand is a deprecation no-op retained for one release (the orchestrator no longer maintains a dispatch/housekeeping run counter).",
+    description: "Token-efficient issue triage script with subcommands: eligible, unblock, stale, orphaned, maintenance, prs, scope. Sorts eligible issues by priority desc \u2192 funnel tier asc \u2192 issue number asc; 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, and emits a single `TRIAGE_DONE unblocked=N still_blocked=M` summary line; the maintenance subcommand flags stale issues with `status:needs-attention` (never auto-resets to `status:ready`), counts orphan branches/PRs, and emits a single `MAINTENANCE_DONE flagged_stale=N flagged_blocked=M orphan_branches=A orphan_prs=B needs_attention_total=T` summary line.",
     content: buildCheckBlockedScript(tiers, scopeGate, runRatio)
   };
 }
@@ -13695,6 +13849,59 @@ function buildUnblockDependentsProcedure(unblockDependents = resolveUnblockDepen
 var unblockDependentsProcedure = buildUnblockDependentsProcedure(
   resolveUnblockDependents()
 );
+function buildPrSweepScript() {
+  return [
+    "#!/usr/bin/env bash",
+    "# pr-sweep.sh \u2014 Token-efficient PR-eligibility filter for the",
+    "# orchestrator's Phase B PR review sweep. Emits one summary line",
+    "# per open PR; the orchestrator reads only the PR numbers and",
+    "# dispatches `pr-reviewer` per eligible PR.",
+    "#",
+    "# Skip rules:",
+    "#   - isDraft = true                          \u2192 reason=draft",
+    "#   - review:human-required label             \u2192 reason=human-required",
+    "#   - review:awaiting-human label             \u2192 reason=awaiting-human",
+    "#",
+    "# Usage:",
+    "#   .claude/procedures/pr-sweep.sh",
+    "",
+    "set -uo pipefail",
+    "",
+    "prs=$(gh pr list --state open --json number,isDraft,labels \\",
+    '  --limit 50 2>/dev/null || echo "[]")',
+    "",
+    `count=$(echo "$prs" | jq 'length')`,
+    'if [[ "$count" -eq 0 ]]; then',
+    '  echo "NO_OPEN_PRS"',
+    "  exit 0",
+    "fi",
+    "",
+    "# Emit one PR_ELIGIBLE / PR_SKIP line per open PR, sorted by PR",
+    "# number ascending so the order is deterministic across runs.",
+    `echo "$prs" | jq -r '`,
+    "  sort_by(.number) |",
+    "  .[] |",
+    "  (.labels | map(.name)) as $labels |",
+    "  if .isDraft then",
+    '    "PR_SKIP #\\(.number) reason=draft"',
+    '  elif ($labels | index("review:human-required")) then',
+    '    "PR_SKIP #\\(.number) reason=human-required"',
+    '  elif ($labels | index("review:awaiting-human")) then',
+    '    "PR_SKIP #\\(.number) reason=awaiting-human"',
+    "  else",
+    '    "PR_ELIGIBLE #\\(.number)"',
+    "  end",
+    "'"
+  ].join("\n");
+}
+function buildPrSweepProcedure() {
+  return {
+    name: "pr-sweep.sh",
+    description: "Token-efficient PR-eligibility filter for the orchestrator's Phase B PR review sweep. Emits one `PR_ELIGIBLE #<n>` or `PR_SKIP #<n> reason=<draft|human-required|awaiting-human>` line per open PR; the orchestrator reads only the eligible numbers and dispatches `pr-reviewer` per eligible PR.",
+    content: buildPrSweepScript()
+  };
+}
+var prSweepProcedure = buildPrSweepProcedure();
 var orchestratorSubAgent = {
   name: "orchestrator",
   description: "End-to-end pipeline manager that runs one full cycle every invocation: triage \u2192 maintenance \u2192 queue scan \u2192 delegate the picked issue to the issue-worker \u2192 cleanup",
@@ -13705,13 +13912,16 @@ var orchestratorSubAgent = {
     "# Orchestrator Agent",
     "",
     "You are the pipeline orchestrator for the **{{repository.owner}}/{{repository.name}}** repository.",
-    "Each invocation runs **one full end-to-end cycle**. The cycle triages",
-    "blocked issues, runs maintenance scans, picks the next ready issue, and",
-    "**delegates implementation to the `issue-worker`** sub-agent in scheduled",
-    "mode. The orchestrator itself never implements code, creates branches, or",
-    "pushes commits \u2014 it routes work to other agents. Approved-PR merging is",
-    "owned by the `pr-reviewer` sub-agent (invoked via `/review-pr` /",
-    "`/review-prs`); the orchestrator does not run a merge sweep.",
+    "Each invocation runs **one full end-to-end cycle**. The cycle pulls",
+    "the default branch, sweeps eligible open PRs through the `pr-reviewer`",
+    "sub-agent, triages blocked issues, runs maintenance scans, picks the",
+    "next ready issue, and **delegates implementation to the `issue-worker`**",
+    "sub-agent in scheduled mode. The orchestrator itself never implements",
+    "code, creates branches, pushes commits, or merges PRs \u2014 it routes",
+    "work to other agents. The merge decision is still owned by the",
+    "`pr-reviewer` sub-agent; the orchestrator only chooses which PRs the",
+    "reviewer should look at and dispatches one reviewer session per",
+    "eligible PR.",
     "",
     "Run the phases below in order on every invocation. There is no",
     "dispatch/housekeeping fork \u2014 every phase runs every time.",
@@ -13719,16 +13929,20 @@ var orchestratorSubAgent = {
     "Phase ordering (each runs exactly once per invocation):",
     "",
     "1. **Phase A \u2014 Startup.** Pull the default branch.",
-    "2. **Phase C \u2014 Triage / Unblock.** Flip dependents that have all",
+    "2. **Phase B \u2014 PR Review Sweep.** Read the procedure-script's",
+    "   eligibility summary and dispatch the `pr-reviewer` sub-agent",
+    "   in scheduled mode against each eligible open PR. Failures on",
+    "   one PR never stop the sweep.",
+    "3. **Phase C \u2014 Triage / Unblock.** Flip dependents that have all",
     "   their dependencies closed back to `status:ready`.",
-    "3. **Phase D \u2014 Maintenance.** Stale-issue and orphaned-resource scan",
+    "4. **Phase D \u2014 Maintenance.** Stale-issue and orphaned-resource scan",
     "   plus a needs-attention summary.",
-    "4. **Phase E \u2014 Queue Scan.** Pick the highest-priority `PICK` line",
+    "5. **Phase E \u2014 Queue Scan.** Pick the highest-priority `PICK` line",
     "   and run the scope gate. If the result is `large`, flag and stop.",
-    "5. **Phase G \u2014 Delegate Implementation.** Hand the picked issue off",
+    "6. **Phase G \u2014 Delegate Implementation.** Hand the picked issue off",
     "   to the `issue-worker` sub-agent in scheduled mode. The worker",
     "   handles claim \u2192 branch \u2192 implement \u2192 commit \u2192 PR autonomously.",
-    "6. **Phase F \u2014 Cleanup.** Return to the default branch and log the",
+    "7. **Phase F \u2014 Cleanup.** Return to the default branch and log the",
     "   run summary.",
     "",
     "Phase letters are stable identifiers \u2014 letters skipped in the list",
@@ -13747,76 +13961,160 @@ var orchestratorSubAgent = {
     "git checkout main && git pull origin main",
     "```",
     "",
-    "## Phase C: Triage \u2014 Unblock",
+    "## Phase B: PR Review Sweep",
+    "",
+    "Sweep every open PR through the `pr-reviewer` sub-agent before the",
+    "queue scan so a single `/orchestrate` invocation merges ready PRs",
+    "and dispatches new issue work in one pass.",
+    "",
+    "### Step 1 \u2014 read the eligibility summary",
     "",
-    "Check for blocked issues whose dependencies have resolved:",
+    "Run the bundled `pr-sweep.sh` procedure and read **only** the",
+    "summary lines it emits. Do **not** iterate raw `gh pr list` JSON",
+    "yourself \u2014 the procedure is the single source of PR-eligibility",
+    "metadata, mirroring the discipline of Phase E's bucketed queue scan.",
     "",
     "```bash",
-    ".claude/procedures/check-blocked.sh unblock",
+    ".claude/procedures/pr-sweep.sh",
     "```",
     "",
-    "This phase is the **fallback safety net** for agent-driven",
-    "unblocking. Every agent that applies `status:done` already runs",
-    "`.claude/procedures/unblock-dependents.sh <n>` as part of that",
-    "transition, so in steady state Phase C should usually report",
-    "`NO_BLOCKED_ISSUES` or leave dependents untouched. Phase C still",
-    "runs on every cycle so issues that slipped through \u2014 human",
-    "closures, manual `status:done` edits, or crashes mid-sweep \u2014 get",
-    "picked up within one cycle. See the **Agent-driven",
-    "unblocking** section in `CLAUDE.md` for the per-agent contract.",
+    "Each line follows one of these shapes:",
     "",
-    "For each `UNBLOCK #N` line:",
-    "```bash",
-    'gh issue edit N --remove-label "status:blocked" --add-label "status:ready"',
-    'gh issue comment N --body "Dependencies resolved \u2014 unblocking."',
+    "```",
+    "PR_ELIGIBLE #<n>",
+    "PR_SKIP #<n> reason=draft",
+    "PR_SKIP #<n> reason=human-required",
+    "PR_SKIP #<n> reason=awaiting-human",
     "```",
     "",
-    "For `BLOCKED #N \u2014 no Depends on field found`: leave as-is (Phase D will",
-    "catch it if it's been blocked too long).",
+    "Skip rules (PRs that never reach the reviewer in this sweep):",
     "",
-    "If output is `NO_BLOCKED_ISSUES`, continue to Phase D.",
+    "- `isDraft: true` \u2192 `reason=draft` (the author has not yet asked for review)",
+    "- Carries the `review:human-required` label \u2192 `reason=human-required`",
+    "  (operator override \u2014 the reviewer's auto-merge path is forbidden)",
+    "- Carries the `review:awaiting-human` label \u2192 `reason=awaiting-human`",
+    "  (the reviewer already handed off; a human is the next actor)",
     "",
-    "## Phase D: Maintenance",
+    "If the script emits `NO_OPEN_PRS`, log the empty result and skip",
+    "directly to Phase C.",
     "",
-    "### D1: Stale Detection",
+    "### Step 2 \u2014 dispatch the reviewer per eligible PR",
     "",
-    "```bash",
-    ".claude/procedures/check-blocked.sh stale",
-    "```",
+    "For each `PR_ELIGIBLE #<n>` line in the order the procedure",
+    "emitted them, invoke the `pr-reviewer` sub-agent **in scheduled",
+    "mode** with the brief below. Substitute `<n>` with the PR number",
+    "from the line.",
+    "",
+    "> `scheduled mode`: review PR #<n>. Run the full review pipeline",
+    "> (eligibility, AC checklist, CI status, policy decision, sticky",
+    "> reviewer-notes update) and either enable squash auto-merge or",
+    "> apply `review:awaiting-human`. Do not pause for approval.",
+    "> Return a one-line summary as the final line of your response in",
+    "> the form `REVIEWER_DONE pr:#<n> outcome:<merged|awaiting-human|commented>`",
+    "> on success or `REVIEWER_FAILED pr:#<n> reason:<short>` on failure.",
+    "",
+    "The orchestrator does **not** call `gh pr merge`, apply review",
+    "labels, or post review comments directly \u2014 the reviewer's existing",
+    "logic owns merge dispatch, AC verification, and the sticky",
+    "`## Reviewer notes` comment. Phase B is a thin invoker, not an",
+    "absorber.",
+    "",
+    "### Step 3 \u2014 failure semantics",
+    "",
+    "A single PR's reviewer failure (missing or malformed",
+    "`REVIEWER_*` final line, sub-agent error, CI flake) **never stops",
+    "the sweep**. Log the failure as",
+    "`REVIEWER_FAILED pr:#<n> reason:<observed>` and continue to the",
+    "next eligible PR. The next orchestrator invocation re-scans the",
+    "PR list and re-dispatches the reviewer if the PR is still",
+    "eligible.",
+    "",
+    "After every eligible PR has been processed (or zero eligible PRs",
+    "were emitted), continue to Phase C regardless of outcomes.",
+    "",
+    "## Phase C: Triage \u2014 Unblock",
+    "",
+    "Run the bundled `check-blocked.sh unblock` procedure and read",
+    "**only** the final `TRIAGE_DONE` summary line it emits. The",
+    "procedure applies the label flips (`status:blocked` \u2192",
+    "`status:ready`) and posts the canned",
+    "`Dependencies resolved \u2014 unblocking.` comment itself, mirroring",
+    "the discipline of Phase B (`pr-sweep.sh`) and Phase E",
+    "(`check-blocked.sh eligible`) \u2014 the orchestrator never iterates",
+    "raw `gh` responses, only the procedure's summary lines.",
     "",
-    "For each `STALE #N` line (in-progress >72h without activity):",
     "```bash",
-    'gh issue edit N --add-label "status:needs-attention"',
-    'gh issue comment N --body "Flagged: in-progress for >3 days with no activity."',
+    ".claude/procedures/check-blocked.sh unblock",
     "```",
     "",
-    "For each `STALE_BLOCKED #N` line (blocked >168h):",
-    "```bash",
-    'gh issue edit N --add-label "status:needs-attention"',
-    'gh issue comment N --body "Flagged: blocked for >7 days \u2014 may need human intervention."',
+    "The script emits one summary line in this shape:",
+    "",
     "```",
+    "TRIAGE_DONE unblocked=<N> still_blocked=<M>",
+    "```",
+    "",
+    "Per-issue informational lines (`UNBLOCKED #N`, `UNBLOCK_FAILED #N`,",
+    "`STILL_BLOCKED #N`, `BLOCKED #N \u2014 no Depends on field found`) 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 counted toward `still_blocked`.",
+    "",
+    "This phase is the **fallback safety net** for agent-driven",
+    "unblocking. Every agent that applies `status:done` already runs",
+    "`.claude/procedures/unblock-dependents.sh <n>` as part of that",
+    "transition, so in steady state Phase C should usually report",
+    "`TRIAGE_DONE unblocked=0 still_blocked=0` or leave dependents",
+    "untouched. Phase C still runs on every cycle so issues that",
+    "slipped through \u2014 human closures, manual `status:done` edits, or",
+    "crashes mid-sweep \u2014 get picked up within one cycle. See the",
+    "**Agent-driven unblocking** section in `CLAUDE.md` for the",
+    "per-agent contract.",
+    "",
+    "Log the summary line and continue to Phase D regardless of",
+    "outcomes \u2014 a non-zero `still_blocked` count is normal (issues",
+    "with open dependencies stay blocked) and Phase D will surface",
+    "any that have been blocked too long.",
     "",
-    "**Important:** Do NOT auto-reset stale issues to `status:ready` \u2014 partial",
-    "implementation work may exist on a branch.",
+    "## Phase D: Maintenance",
     "",
-    "### D2: Orphaned Detection",
+    "Run the bundled `check-blocked.sh maintenance` procedure and read",
+    "**only** the final `MAINTENANCE_DONE` summary line it emits. The",
+    "procedure folds the stale-detection, orphan-detection, and",
+    "needs-attention summary 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, mirroring the",
+    "discipline of Phase B (`pr-sweep.sh`) and Phase C",
+    "(`check-blocked.sh unblock`).",
     "",
     "```bash",
-    ".claude/procedures/check-blocked.sh orphaned",
+    ".claude/procedures/check-blocked.sh maintenance",
     "```",
     "",
-    "Report any `ORPHAN_BRANCH` or `ORPHAN_PR` lines. These indicate branches",
-    "or PRs whose linked issues are closed or missing. Log them for visibility",
-    "but do not delete branches automatically.",
-    "",
-    "### D3: Needs-Attention Summary",
+    "The script emits one summary line in this shape:",
     "",
-    "List all issues currently flagged:",
-    "```bash",
-    'gh issue list --label "status:needs-attention" --state open --json number,title',
+    "```",
+    "MAINTENANCE_DONE flagged_stale=<N> flagged_blocked=<M> orphan_branches=<A> orphan_prs=<B> needs_attention_total=<T>",
     "```",
     "",
-    "Log the count and titles for operator visibility.",
+    "Per-issue / per-orphan 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`) 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 `flagged_*` counters.",
+    "",
+    "**Important:** the script never auto-resets stale issues to",
+    "`status:ready`. It only adds `status:needs-attention`; the",
+    "existing `status:in-progress` or `status:blocked` label stays in",
+    "place so partial implementation work on a branch remains visible",
+    "to humans. Orphan branches and PRs are surfaced in the counters",
+    "but are never deleted by the orchestrator \u2014 a human reviews the",
+    "log lines and prunes orphans manually.",
+    "",
+    "Log the summary line and continue to Phase E regardless of",
+    "outcomes \u2014 a non-zero `flagged_*` or `orphan_*` count is",
+    "informational, not a failure.",
     "",
     "## Phase E: Queue Scan",
     "",
@@ -13976,27 +14274,30 @@ var orchestratorSubAgent = {
     "",
     "1. **Never implement code.** You triage, scan, and delegate \u2014 you do not code.",
     "2. **Never claim issues.** Do not add `status:in-progress` or create branches for issues. Phase G's `issue-worker` delegation is the only path that flips an issue's claim labels.",
-    "3. **Never merge PRs.** Approved-PR merging is owned by the `pr-reviewer` sub-agent (invoked via `/review-pr` / `/review-prs`). The orchestrator does not run a merge sweep, does not call `gh pr merge`, and does not enable auto-merge.",
-    "4. **Always use check-blocked.sh.** All triage queries go through the shell script for token efficiency.",
-    "5. **Follow CLAUDE.md conventions** for all git and gh operations.",
-    "6. **Priority order:** critical > high > medium > low > trivial, then **funnel tier asc** (lower tier wins ties), then FIFO by issue number.",
-    "7. **Never dispatch a `large` issue.** Always run the scope check",
+    "3. **Always use procedure scripts.** Issue triage queries go through `.claude/procedures/check-blocked.sh`; PR-eligibility filtering goes through `.claude/procedures/pr-sweep.sh`. Never iterate raw `gh issue list` / `gh pr list` JSON in-context.",
+    "4. **Follow CLAUDE.md conventions** for all git and gh operations.",
+    "5. **Priority order:** critical > high > medium > low > trivial, then **funnel tier asc** (lower tier wins ties), then FIFO by issue number.",
+    "6. **Never dispatch a `large` issue.** Always run the scope check",
     "   on the top `PICK` line before reporting `NEXT_WORK_ITEM`. A",
     "   `large` issue must be flagged with `status:needs-attention` and",
     "   handed a decomposition proposal \u2014 never claimed, never branched,",
     "   never delegated to the `issue-worker`.",
-    "8. **Sweep dependents whenever you apply `status:done`.** Every",
+    "7. **Sweep dependents whenever you apply `status:done`.** Every",
     "   `status:done` transition must be immediately followed by",
     "   `.claude/procedures/unblock-dependents.sh <n>` so downstream",
     "   `Depends on: #<n>` issues flip to `status:ready` without",
     "   waiting for the next cycle. See the **Agent-driven unblocking**",
     "   section in `CLAUDE.md` for the contract.",
-    "9. **Always invoke `issue-worker` in scheduled mode.** Phase G's",
-    "   delegation prompt must contain the literal phrase",
-    "   `scheduled mode` so the worker skips its interactive approval",
-    "   pause and runs the implementation cycle autonomously. Without",
-    "   the phrase the worker pauses for human approval and the",
-    "   delegation stalls."
+    "8. **Always invoke child sub-agents in scheduled mode.** Phase B's",
+    "   `pr-reviewer` dispatch and Phase G's `issue-worker` delegation",
+    "   prompts must each contain the literal phrase `scheduled mode`",
+    "   so the child sub-agent skips its interactive approval pause and",
+    "   runs autonomously. Without the phrase the child pauses for",
+    "   human approval and the delegation stalls.",
+    "9. **A failed reviewer never stops the sweep.** Phase B continues",
+    "   to the next eligible PR after a `REVIEWER_FAILED` line and",
+    "   proceeds to Phase C regardless of how many PRs failed. Do not",
+    "   abort the cycle on a single PR's reviewer failure."
   ].join("\n")
 };
 var issueWorkerSubAgent = {
@@ -14471,9 +14772,9 @@ var ORCHESTRATOR_CONVENTIONS_PREAMBLE = [
   "",
   "When running the orchestrator agent (`.claude/agents/orchestrator.md`):",
   "",
-  "- The orchestrator runs **one full end-to-end cycle every invocation**: triage / unblock \u2192 maintenance \u2192 queue scan \u2192 delegate to `issue-worker` \u2192 cleanup",
-  "- The orchestrator **never** implements code, creates branches, pushes commits, **or merges PRs** \u2014 it triages issues, picks the next work item, and delegates implementation to other sub-agents. Approved-PR merging is owned by the `pr-reviewer` sub-agent (invoked via `/review-pr` / `/review-prs`).",
-  "- All triage queries use `.claude/procedures/check-blocked.sh` for token efficiency",
+  "- The orchestrator runs **one full end-to-end cycle every invocation**: startup \u2192 PR review sweep \u2192 triage / unblock \u2192 maintenance \u2192 queue scan \u2192 delegate to `issue-worker` \u2192 cleanup",
+  "- The orchestrator **never** implements code, creates branches, or pushes commits \u2014 it routes work to other sub-agents. The merge decision is still owned by the `pr-reviewer` sub-agent; Phase B only chooses which open PRs the reviewer should look at and dispatches one reviewer session per eligible PR (skipping drafts and any PR carrying `review:human-required` or `review:awaiting-human`).",
+  "- All triage queries use `.claude/procedures/check-blocked.sh` for token efficiency. PR-eligibility filtering for Phase B uses `.claude/procedures/pr-sweep.sh`, which emits `PR_ELIGIBLE` / `PR_SKIP` lines so the orchestrator never iterates raw `gh pr list` JSON.",
   "- The queue scan reads only `priority:*` and `status:*` labels \u2014 type-routing (which typed agent handles a given `type:*` label) is the `issue-worker`'s concern, not the orchestrator's. The orchestrator's funnel-tier sort is a tie-breaker on `priority:*`, not a routing decision.",
   "- Priority order: critical > high > medium > low > trivial, then **funnel tier asc** (lower tier wins ties), then FIFO by issue number. Phase E's queue scan walks each priority bucket in turn (one `gh issue list` call per bucket, **capped at 50 issues per bucket**) and short-circuits on the first bucket whose survivors clear the `Depends on:` filter, so every higher-priority issue is visible even when the global ready backlog is much larger than 50.",
   "- Stale thresholds: 72h for in-progress, 168h for blocked",
@@ -14481,11 +14782,11 @@ var ORCHESTRATOR_CONVENTIONS_PREAMBLE = [
   "",
   "## Depth-0 invocation requirement",
   "",
-  'The orchestrator agent **must run as the top-level (depth-0) session** when its Phase G needs to delegate work to the `issue-worker` sub-agent. The Claude Code harness forbids nested sub-agent spawning \u2014 *"Subagents cannot spawn other subagents. If your workflow requires nested delegation, use Skills or chain subagents from the main conversation."* (see <https://code.claude.com/docs/en/sub-agents>). If the orchestrator itself were spawned as a depth-1 sub-agent (e.g. via `Agent(subagent_type: "orchestrator")` from another session), the `Agent` tool needed to reach the `issue-worker` at depth-2 would not be available and Phase G would silently abort.',
+  'The orchestrator agent **must run as the top-level (depth-0) session** because both Phase B (PR review sweep) and Phase G (issue delegation) need to spawn child sub-agents. Phase B dispatches the `pr-reviewer` sub-agent once per eligible open PR; Phase G dispatches the `issue-worker` sub-agent against the picked issue. The Claude Code harness forbids nested sub-agent spawning \u2014 *"Subagents cannot spawn other subagents. If your workflow requires nested delegation, use Skills or chain subagents from the main conversation."* (see <https://code.claude.com/docs/en/sub-agents>). If the orchestrator itself were spawned as a depth-1 sub-agent (e.g. via `Agent(subagent_type: "orchestrator")` from another session), the `Agent` tool needed to reach `pr-reviewer` and `issue-worker` at depth-2 would not be available and both Phase B and Phase G would silently abort.',
   "",
-  'Practical implication for scheduled-task wiring: the `worker-orchestrator` scheduled task\'s `SKILL.md` instructs the **scheduled-task session itself** to read `.claude/agents/orchestrator.md` and execute its phase pipeline in-session, then use the `Agent` tool to delegate the picked work item to `issue-worker` (depth-1). The scheduled task does **not** call `Agent(subagent_type: "orchestrator")` \u2014 that would put the orchestrator at depth-1 and break the chain.'
+  'Practical implication for scheduled-task wiring: the `worker-orchestrator` scheduled task\'s `SKILL.md` instructs the **scheduled-task session itself** to read `.claude/agents/orchestrator.md` and execute its phase pipeline in-session, then use the `Agent` tool to delegate to `pr-reviewer` (Phase B) and `issue-worker` (Phase G) at depth-1. The scheduled task does **not** call `Agent(subagent_type: "orchestrator")` \u2014 that would put the orchestrator at depth-1 and break both delegation chains.'
 ].join("\n");
-function buildOrchestratorConventionsContent(tiers, scopeGate = resolveScopeGate(), runRatio = resolveRunRatio(), scheduledTasks = resolveScheduledTasks(), unblockDependents = resolveUnblockDependents(), excludeBundles = []) {
+function buildOrchestratorConventionsContent(tiers, scopeGate = resolveScopeGate(), _runRatio = resolveRunRatio(), scheduledTasks = resolveScheduledTasks(), unblockDependents = resolveUnblockDependents(), excludeBundles = []) {
   return [
     ORCHESTRATOR_CONVENTIONS_PREAMBLE,
     "",
@@ -14493,8 +14794,6 @@ function buildOrchestratorConventionsContent(tiers, scopeGate = resolveScopeGate
     "",
     renderScopeGateSection(scopeGate, excludeBundles),
     "",
-    renderRunRatioSection(runRatio),
-    "",
     renderScheduledTasksSection(scheduledTasks),
     "",
     renderUnblockDependentsSection(unblockDependents)
@@ -14563,13 +14862,18 @@ var checkBlockedCommand = {
     'bash .claude/procedures/check-blocked.sh "$@"',
     "```",
     "",
-    "Pass any extra arguments through verbatim. The script walks every",
-    "`status:blocked` issue, re-checks each `Depends on:` reference, and",
-    "prints `UNBLOCKED` / `STILL_BLOCKED` lines for issues that should",
-    "transition to `status:ready`.",
-    "",
-    "Summarise the output (counts, the first few candidates) \u2014 do **not**",
-    "transition labels yourself; that is the orchestrator's responsibility.",
+    "Pass any extra arguments through verbatim. The `unblock` subcommand",
+    "walks every `status:blocked` issue, re-checks each `Depends on:`",
+    "reference, applies the `status:blocked` \u2192 `status:ready` label flip",
+    "itself, posts the canned `Dependencies resolved \u2014 unblocking.`",
+    "comment, and emits a single",
+    "`TRIAGE_DONE unblocked=<N> still_blocked=<M>` summary line. Per-issue",
+    "informational lines (`UNBLOCKED`, `UNBLOCK_FAILED`, `STILL_BLOCKED`)",
+    "are also emitted for log visibility.",
+    "",
+    "Summarise the output (the `TRIAGE_DONE` counts and the first few",
+    "per-issue lines) \u2014 do **not** apply additional label flips yourself;",
+    "the script already transitioned every eligible issue.",
     ""
   ].join("\n")
 };
@@ -14619,7 +14923,11 @@ var orchestratorBundle = {
     }
   ],
   subAgents: [orchestratorSubAgent, issueWorkerSubAgent],
-  procedures: [checkBlockedProcedure, unblockDependentsProcedure],
+  procedures: [
+    checkBlockedProcedure,
+    unblockDependentsProcedure,
+    prSweepProcedure
+  ],
   commands: [orchestrateCommand, checkBlockedCommand, scanCommand],
   claudePermissions: {
     allow: [
@@ -27687,7 +27995,8 @@ function renderPriorityRulesSection(rules) {
 }
 
 // src/agent/bundles/index.ts
-function buildBuiltInBundles(paths = DEFAULT_AGENT_PATHS, issueDefaults = DEFAULT_RESOLVED_ISSUE_DEFAULTS, defaultAgentTier = AGENT_MODEL.BALANCED) {
+function buildBuiltInBundles(paths = DEFAULT_AGENT_PATHS, issueDefaults = DEFAULT_RESOLVED_ISSUE_DEFAULTS, defaultAgentTier = AGENT_MODEL.BALANCED, bundleAgentTiers = /* @__PURE__ */ new Map()) {
+  const tierFor = (bundle) => bundleAgentTiers.get(bundle) ?? defaultAgentTier;
   return [
     buildBaseBundle(paths),
     upstreamConfigulatorDocsBundle,
@@ -27700,7 +28009,7 @@ function buildBuiltInBundles(paths = DEFAULT_AGENT_PATHS, issueDefaults = DEFAUL
     projenBundle,
     githubWorkflowBundle,
     slackBundle,
-    buildMeetingAnalysisBundle(defaultAgentTier),
+    buildMeetingAnalysisBundle(tierFor("meeting-analysis")),
     agendaBundle,
     orchestratorBundle,
     prReviewBundle,
@@ -27708,16 +28017,28 @@ function buildBuiltInBundles(paths = DEFAULT_AGENT_PATHS, issueDefaults = DEFAUL
     buildRequirementsWriterBundle(paths, issueDefaults),
     buildRequirementsReviewerBundle(paths, issueDefaults),
     buildResearchPipelineBundle(paths, issueDefaults),
-    buildCompanyProfileBundle(paths, issueDefaults, defaultAgentTier),
-    buildCustomerProfileBundle(paths, issueDefaults, defaultAgentTier),
-    buildPeopleProfileBundle(paths, issueDefaults, defaultAgentTier),
-    buildSoftwareProfileBundle(paths, issueDefaults, defaultAgentTier),
+    buildCompanyProfileBundle(paths, issueDefaults, tierFor("company-profile")),
+    buildCustomerProfileBundle(
+      paths,
+      issueDefaults,
+      tierFor("customer-profile")
+    ),
+    buildPeopleProfileBundle(paths, issueDefaults, tierFor("people-profile")),
+    buildSoftwareProfileBundle(
+      paths,
+      issueDefaults,
+      tierFor("software-profile")
+    ),
     buildIndustryDiscoveryBundle(paths, issueDefaults),
     buildBusinessModelsBundle(paths, issueDefaults),
     buildBcmWriterBundle(paths, issueDefaults),
     buildStandardsResearchBundle(paths, issueDefaults),
     buildRegulatoryResearchBundle(paths, issueDefaults),
-    buildMaintenanceAuditBundle(paths, issueDefaults, defaultAgentTier),
+    buildMaintenanceAuditBundle(
+      paths,
+      issueDefaults,
+      tierFor("maintenance-audit")
+    ),
     buildDocsSyncBundle(paths)
   ];
 }
@@ -28352,8 +28673,8 @@ var CopilotRenderer = class {
 };
 
 // src/agent/agent-config.ts
-function resolveDefaultAgentTier(options) {
-  switch (options?.defaultAgentTier) {
+function mapAgentTier(value) {
+  switch (value) {
     case "powerful":
       return AGENT_MODEL.POWERFUL;
     case "fast":
@@ -28363,6 +28684,34 @@ function resolveDefaultAgentTier(options) {
       return AGENT_MODEL.BALANCED;
   }
 }
+function resolveDefaultAgentTier(options) {
+  return mapAgentTier(options?.defaultAgentTier);
+}
+var TIER_AWARE_BUNDLE_NAMES = [
+  "company-profile",
+  "customer-profile",
+  "maintenance-audit",
+  "meeting-analysis",
+  "people-profile",
+  "software-profile"
+];
+function resolveBundleAgentTiers(options) {
+  const overrides = options?.bundleAgentTiers;
+  if (!overrides) {
+    return /* @__PURE__ */ new Map();
+  }
+  const validNames = new Set(TIER_AWARE_BUNDLE_NAMES);
+  const out = /* @__PURE__ */ new Map();
+  for (const [name, value] of Object.entries(overrides)) {
+    if (!validNames.has(name)) {
+      throw new Error(
+        `bundleAgentTiers contains unknown bundle name "${name}". Valid names are: ${TIER_AWARE_BUNDLE_NAMES.join(", ")}.`
+      );
+    }
+    out.set(name, mapAgentTier(value));
+  }
+  return out;
+}
 var DEFAULT_CLAUDE_ALLOW = [
   // ── Git ──────────────────────────────────────────────────────────────
   "Bash(git add *)",
@@ -28715,7 +29064,8 @@ var AgentConfig = class _AgentConfig extends Component8 {
       this.cachedBundles = buildBuiltInBundles(
         this.resolvedPaths,
         resolveIssueDefaults(this.options.issueDefaults),
-        resolveDefaultAgentTier(this.options)
+        resolveDefaultAgentTier(this.options),
+        resolveBundleAgentTiers(this.options)
       );
     }
     return this.cachedBundles;
@@ -33981,6 +34331,7 @@ export {
   SUPPRESSED_WORKFLOW_RULE_NAMES,
   SampleLang,
   StarlightProject,
+  TIER_AWARE_BUNDLE_NAMES,
   TestRunner,
   TsDocCoverageKind,
   TurboRepo,
@@ -34113,6 +34464,7 @@ export {
   resolveAgentTiers,
   resolveAstroProjectOutdir,
   resolveAwsCdkProjectOutdir,
+  resolveBundleAgentTiers,
   resolveDefaultAgentTier,
   resolveIssueDefaults,
   resolveIssueTemplates,