@juzser/blacksmith 0.4.0 → 0.5.0

package/factory/policies/budgets.yml

@@ -6,23 +6,24 @@
 # What is mechanical, and what is a request (P9-18, 2026-08-08; `failed_rounds`
 # added P9-32 and `alarm_ratio` P9-33, both 2026-08-10; `max_in_flight_tasks`
 # added 2026-08-26, the same day `epic.cap_tokens` grew a reader that actually
-# blocks). Exactly six numbers here reach a runtime host:
+# blocks). Exactly six kinds of number here reach a runtime host — each one
+# sized per effort tier, see "Effort tiers" below:
 #
 #   * `epic.cap_tokens` — three readers now, and only the newest of them
 #     blocks. planQuorum's budget trigger sums *declared* task budgets against
 #     it before any dispatch and only ever surfaces the finding for a human to
-#     act on; `smith budget alarm` compares it against spend counted from the
-#     event log, after wave merge, and also stops nothing itself. `smith wave
+#     act on; `bs budget alarm` compares it against spend counted from the
+#     event log, after wave merge, and also stops nothing itself. `bs wave
 #     check` (src/waveBudget.ts) is the reader that blocks: at wave admission —
 #     before any task in the wave has been dispatched — it sums the wave's
 #     declared task budgets against headroom under the cap (measured spend plus
 #     a declared price for every dispatch nothing has measured yet, the same
-#     projection `smith budget alarm` computes) and refuses to admit a wave
+#     projection `bs budget alarm` computes) and refuses to admit a wave
 #     that would cross it. It is not a stricter version of the other two
 #     readers' advice; it is the only one of the three standing upstream of the
 #     spend it is judging, so it is the only one that can refuse the spend
 #     instead of merely describing it afterward.
-#   * `epic.alarm_ratio` — `smith budget alarm` (src/budgetAlarm.ts), which
+#   * `epic.alarm_ratio` — `bs budget alarm` (src/budgetAlarm.ts), which
 #     reports each epic's measured and projected spend against
 #     `alarm_ratio * cap_tokens` and exits 1 on a crossing. Measured spend is a
 #     floor, not a total: a judge returns findings rather than a Result, so its
@@ -32,14 +33,17 @@
 #     `task:` block's coverage of the roles the factory actually dispatches is
 #     load-bearing and not merely documentary.
 #   * a task's `tokens` — compared at the gate against the result's
-#     `token_usage.total_tokens`.
+#     `token_usage.total_tokens`. The per-role caps under `task:` are what
+#     `bs budget alarm` and `bs wave check` charge a dispatch nothing has
+#     measured yet, and what the dispatch harness hands a CLI turn as its
+#     `cap_tokens`.
 #   * a task's `diff_lines` — compared at the gate against a real
 #     `git diff --numstat` (src/diffstat.ts), lockfiles and generated output
 #     excluded.
 #   * `escalation_ladder.rungs[].failed_rounds` — counted from `gate-outcome`
-#     events by `smith escalation check` (src/escalation.ts), which asserts the
+#     events by `bs escalation check` (src/escalation.ts), which asserts the
 #     rung's `enforce` obligation against what the log shows happened next.
-#   * `epic.max_in_flight_tasks` — `smith wave check`, which refuses to admit a
+#   * `epic.max_in_flight_tasks` — `bs wave check`, which refuses to admit a
 #     wave that would put more of the epic's tasks in flight at once (admitted,
 #     not yet merged) than this. Null by default; see the field's own comment
 #     below for why it is not the mechanism that bounds cost.
@@ -51,7 +55,7 @@
 # measuring (D-29: a coder spent its tail shaving lines to land exactly on
 # `diff_lines`, stopping mid-procedure to do it).
 #
-# The epic cap no longer works that way: `smith wave check` blocks on one.
+# The epic cap no longer works that way: `bs wave check` blocks on one.
 # The difference is not that an epic overrun matters more than a task overrun
 # — it is *when* each is checked. The task gate polices work already
 # underway, so refusing there distorts the work it is judging. Wave admission
@@ -68,13 +72,48 @@
 # agent-interviews.md M-4 had called it inert), and a plan cannot raise or
 # lower a role's ceiling. So plan validation rejects it as a task budget
 # field, and the dispatch prompt restates the template's number verbatim.
+# It is one number per template, not per tier: a template cannot know the
+# epic it will be dispatched into, so each `maxTurns` is sized as the ceiling
+# for the huge tier (raised 2026-09-29, measured on eight medium-tier dogfood
+# epics, 2026-09-14..29). The token caps below are what scale down for a
+# smaller epic; the turn ceiling does not.
+#
+# Effort tiers (2026-09-29). Every token and diff number in this file is sized
+# per effort tier — effort.yml's small / medium / huge: the tier the epic
+# runs at, i.e. its plan's `effort` raised by effort.yml's `security_floor`
+# when a live task trips a security trigger, and effort.yml's `default_tier`
+# (medium) when there is no plan in hand or it names none. One source of
+# truth, one scale:
+#
+#   * `epic.cap_tokens` is an explicit triplet, because an epic's size is not
+#     a straight multiple of its tasks'.
+#   * every `task:` number is declared once, at medium, and multiplied by
+#     `task_tier_scale` for the tier: small 0.5x, huge 2x.
+#   * `epic.alarm_ratio` is a ratio and is the same at every tier.
+#
+# Per-box env overrides (`.env`, or an exported value, which beats it). Each
+# number that a box may want to move has an env name — BS_EPIC_CAP_TOKENS,
+# BS_TASK_<ROLE>_CAP_TOKENS, … listed in .env.example (the deprecated
+# SMITH_* spellings still work as a fallback) — and each name has a
+# `_SMALL`, `_MEDIUM` and `_HUGE` variant. For an epic of a given tier the
+# precedence is, highest first:
+#
+#   1. the variant for that tier, e.g. BS_EPIC_CAP_TOKENS_HUGE;
+#   2. the bare name, e.g. BS_EPIC_CAP_TOKENS, which applies to every tier
+#      that has no variant of its own set;
+#   3. the number in this file for that tier.
+#
+# An env value beats the tier: a bare name pins one number for every tier. A
+# malformed value in any variant — even one for a tier not in play — is
+# refused with `budgets.invalid-env`. `bs wave check` and `bs budget
+# alarm` name the variables that moved a number, never their values.
 #
 # No concurrency cap on cost grounds, by design (removed 2026-08-05). Workers
 # run in isolated worktrees on disjoint path claims, so parallelism is bounded
 # by the claim graph, not by a worker count — and fan-out buys wall-clock
 # without buying extra tokens (architecture §15.3). Hundreds of concurrent
 # subagents is a supported shape. That reasoning holds only as long as the
-# token cap it leans on actually binds, which — before `smith wave check` —
+# token cap it leans on actually binds, which — before `bs wave check` —
 # `epic.cap_tokens` did not. `epic.max_in_flight_tasks` below is not that
 # removed cap come back: it defaults to null, and cost stays bounded by
 # `cap_tokens`, not by a worker count. It exists for an operator who wants a
@@ -83,7 +122,22 @@
 # nothing about what bounds spend.
 
 epic:
-  cap_tokens: 4000000        # planner + all workers + judges, one epic.
+  cap_tokens:                # planner + all workers + judges, one epic.
+    small: 4000000
+    medium: 16000000
+    huge: 32000000
+                              # 2026-09-29: per tier. Medium is 16M, the cap
+                              # the operator's own box had already been
+                              # running by env override; the largest measured
+                              # medium epic (eight medium-tier dogfood epics,
+                              # 2026-09-14..29) spent about 7.3M, so 16M
+                              # carries it with the alarm at 11.2M. Small
+                              # keeps the old single number, 4M; huge is 32M.
+                              # This is also the per-epic override follow-up
+                              # (1) below asked for, in the only form a
+                              # policy file can give it: an epic's `effort`
+                              # picks its cap.
+                              # Earlier history:
                               # Raised from 2,000,000 by operator decision on
                               # 2026-08-11 (dogfood-mcp-1), which is the
                               # operator answer the `alarm_ratio` note below
@@ -99,31 +153,32 @@ epic:
                               # so a number raised for one epic is raised for
                               # every epic black-smith will ever run. What
                               # exists is a per-BOX override, a different
-                              # thing: SMITH_EPIC_CAP_TOKENS in the env (or
+                              # thing: BS_EPIC_CAP_TOKENS in the env (or
                               # `.env`) replaces this number for every epic
                               # run on that box while it is set — the
-                              # SMITH_EPIC_* / SMITH_TASK_* names in
+                              # BS_EPIC_* / BS_TASK_* names in
                               # .env.example cover each number in this file
                               # that a box may want to move; (2) a
                               # large share of that 1.5M was rework — stopped
-                              # dispatches and re-dispatches that `smith
+                              # dispatches and re-dispatches that `bs
                               # escalation check` recorded as ladder
                               # violations — so this cap now accommodates
                               # waste as well as work. A cap sized from a
                               # badly-run epic is a ceiling measured at the
                               # wrong place.
-  alarm_ratio: 0.7           # at 2.8M tokens: planner must re-plan remaining
+  alarm_ratio: 0.7           # same at every tier (small: 2.8M, medium:
+                              # 11.2M, huge: 22.4M). At that point: planner must re-plan remaining
                               # work to fit, or ask the operator. Epics that
                               # cannot fit are split at spec time, never
                               # silently extended (extension is always an
-                              # operator question). Checked by `smith budget
+                              # operator question). Checked by `bs budget
                               # alarm <session>`, which the /bs run loop runs at
                               # each wave merge — before P9-33 this number's
                               # only reader was a human remembering to look.
   max_in_flight_tasks: null  # Off by default. "Fan-out buys wall-clock
                               # without buying extra tokens" above is the
                               # standing decision, and it only holds while the
-                              # token cap actually binds — which `smith wave
+                              # token cap actually binds — which `bs wave
                               # check` now makes true. So this is NOT the
                               # mechanism that bounds cost; `cap_tokens` is,
                               # and it is checked regardless of how this field
@@ -131,17 +186,32 @@ epic:
                               # wants a wall-clock or rate-limit bound for a
                               # reason of their own — a provider's
                               # concurrent-request limit, a laptop's CPU count
-                              # — and setting it makes `smith wave check`
+                              # — and setting it makes `bs wave check`
                               # refuse to admit a wave that would put more of
                               # the epic's tasks in flight (admitted, not yet
                               # merged) than this number at once.
 
+task_tier_scale:
+  # Multiplies every `task:` number below for an epic of that tier. Not the
+  # epic cap, which is declared per tier above.
+  small: 0.5
+  medium: 1
+  huge: 2
+
 task:
+  # Medium-tier numbers; `task_tier_scale` gives the small and huge ones.
   # Defaults a planner sizes a task's own `budget` block against. The task's
   # declared numbers are what the gate checks; these are the shape of a
   # reasonable declaration, not a second cap applied on top.
+  #
+  # Sized 2026-09-29 from the p90 tokens per dispatch measured on eight
+  # medium-tier dogfood epics, 2026-09-14..29, rounded up. Before that the
+  # coder cap was 150k (10 of 36 measured coder dispatches over it), the four
+  # judges shared one 40k bucket (31 of 32 spec-reviewer dispatches over it),
+  # researcher was 60k, and planner, tester, security-reviewer and auditor had
+  # no cap at all, which left every epic that used one unverifiable.
   coder:
-    cap_tokens: 150000       # Second reader, added 2026-08-26: `smith wave
+    cap_tokens: 220000       # Second reader, added 2026-08-26: `bs wave
                              # check` prices a task that exists only in the
                              # event log at this number. A follow-up minted by
                              # `findings raise` has claims but no declared
@@ -158,18 +228,38 @@ task:
                              # `budget.tokens` is a different silence and is
                              # still refused — the schema requires that field,
                              # so its absence is a plan that never passed
-                             # `smith plan validate`.
-    cap_diff_lines: 400      # excludes lockfiles/generated files
+                             # `bs plan validate`.
+    cap_diff_lines: 700      # excludes lockfiles/generated files. Measured
+                             # p50 316 / p90 727 lines (was 400); small 350,
+                             # huge 1400.
+  tester:
+    cap_tokens: 60000        # p90 55k
+  planner:
+    cap_tokens: 110000       # p90 103k
   researcher:
-    cap_tokens: 60000
-  judges:                    # spec-reviewer, reviewer, verifier, grader
-    cap_tokens: 40000
-  # Not priced here, and dispatched anyway: security-reviewer, merger, tester,
-  # uiux, planner, scribe. `smith budget alarm` cannot put a number on those
-  # dispatches, so an epic that used one is reported unverifiable rather than
-  # under — the omission is visible instead of free. Left unpriced on purpose
-  # until there is real spend data to size them from; inventing a cap would
-  # make the projection look complete without making it true.
+    cap_tokens: 80000        # p90 74k (was 60k)
+  spec-reviewer:
+    cap_tokens: 170000       # p90 168k (was the shared 40k judges bucket)
+  grader:
+    cap_tokens: 110000       # p90 105k (was 40k)
+  reviewer:
+    cap_tokens: 60000        # p90 56k (was 40k)
+  verifier:
+    cap_tokens: 40000        # p90 25k (unchanged)
+  security-reviewer:
+    cap_tokens: 80000        # p90 77k
+  auditor:
+    cap_tokens: 90000        # p90 89k
+  # The old shared `judges:` bucket is gone. A policy file that still carries
+  # `judges: {cap_tokens: N}` has N read for spec-reviewer, reviewer, verifier
+  # and grader wherever it does not name that role itself.
+  #
+  # Not priced here, and dispatched anyway: merger, uiux, scribe, wave-runner.
+  # `bs budget alarm` cannot put a number on those dispatches, so an epic
+  # that used one is reported unverifiable rather than under — the omission is
+  # visible instead of free. Left unpriced on purpose until there is real spend
+  # data to size them from; inventing a cap would make the projection look
+  # complete without making it true.
 
 pre_code_budget:
   # researcher + uiux together, before any code is written for the epic
@@ -193,7 +283,7 @@ context_window:
                                # quietly loses the contract it was given.
   counts_against_budget: true  # tokens spent before a compaction still count
                                # against the caps above — compacting is not a
-                               # way around the 150k coder cap.
+                               # way around the coder cap.
   compacting_roles: [planner, coder, tester, researcher, uiux, scribe]
   narrowing_roles: [reviewer, verifier, grader, spec-reviewer, security-reviewer, merger, auditor]
   # narrowing_roles hold evidence rather than build on it: a judge that compacts
@@ -219,7 +309,7 @@ escalation_ladder:
   # architecture §12, agent-constraints.md "budgets (factory-wide)"
   #
   # `failed_rounds` and `enforce` are the machine-readable half, added P9-32.
-  # src/escalation.ts reads them and `smith escalation check` asserts them
+  # src/escalation.ts reads them and `bs escalation check` asserts them
   # against the log; `trigger`/`action` stay as the human contract and must say
   # the same thing. A failed round is one `gate-outcome` with outcome
   # `blocked` for the task.
@@ -260,7 +350,7 @@ effort_scaling:
   # and it lives in `factory/policies/effort.yml`: a per-epic tier
   # (small/medium/huge) that scales the deliberation steps — pre-code briefs,
   # spec-review rounds, the plan quorum, grader rounds, verifier severities,
-  # the closing spec review — and nothing else. Ask `smith effort show`; the
+  # the closing spec review — and nothing else. Ask `bs effort show`; the
   # two files do not overlap, and neither may touch a mechanical gate.
   - rule: small fixes get a single coder, not a fan-out.
   - rule: >

package/factory/policies/crosscheck.yml

@@ -14,11 +14,11 @@
 # provider does not fail loudly; it spends a doomed call on every quorum
 # trigger, has it caught, and leaves a failure row that reads like an outage.
 # So turn on the one you actually have — a one-line edit, runbook §2, and
-# `smith judge preflight` says beforehand whether it will work.
+# `bs judge preflight` says beforehand whether it will work.
 # Full setup/calibration/promotion procedure: docs/runbooks/providers.md.
 #
 # Shadow mode (Phase 8 design decision): `mode: shadow` means a provider's
-# verdicts are RECORDED (judge-verdict events, `smith stats providers`) but
+# verdicts are RECORDED (judge-verdict events, `bs stats providers`) but
 # have ZERO gating power — quorum.ts falls back to the native verdict alone
 # whenever no provider in a case is `mode: active`. Flipping a provider to
 # `mode: active` in this file (an operator edit, never a runtime write) is
@@ -48,13 +48,21 @@ providers:
     # extractor generations diverge exactly as D-118 claimed: first-parseable
     # returns `[]`, first-validating returns the verdict. If you change these
     # args, re-run that comparison rather than reasoning about it.
-    args: ["exec", "--color", "never"]
-    model_tier: mid          # taxonomy.yml model_tier — judge tier, architecture §4
+    #
+    # Model and effort are pinned here, not inherited. Without `-m` the judge
+    # runs whatever `~/.codex/config.toml` defaults to — an interactive-use
+    # choice, often the frontier model at high effort — so a confirm/refute
+    # call billed at `model_tier: mid` spent frontier quota. `model` below must
+    # name the same id as `-m`: it is what the event log records (without it a
+    # cli judge is logged as `codex:default`), and nothing checks the two agree.
+    args: ["exec", "--color", "never", "-m", "gpt-6-sol", "-c", "model_reasoning_effort=\"medium\""]
+    model: gpt-6-sol
+    model_tier: mid         # taxonomy.yml model_tier — judge tier, architecture §4
     # PRECONDITION: `codex` on PATH, and `codex login` run on every machine
     # that dispatches a quorum trigger. Without either the CLI transport still
     # spawns, fails, and quorum.ts records a provider error per trigger —
     # caught, so nothing gates on it, but it is latency and noise.
-    # `smith judge preflight` checks the first half locally; only a real call
+    # `bs judge preflight` checks the first half locally; only a real call
     # can check the second.
     # `auto`, not `true`. This is the one field in the file that describes a
     # MACHINE, and the file is checked in, so `true` here would be a claim
@@ -69,7 +77,7 @@ providers:
     # session still spends a call per trigger and records the failure.
     #
     # Turned on for THIS box, 2026-09-02, by the operator who owns it: `codex`
-    # resolves on PATH and `codex login` is done, both checked by `smith judge
+    # resolves on PATH and `codex login` is done, both checked by `bs judge
     # preflight` and by a real `codex exec` call. Rollback for one box is
     # `enabled: false` here, which `auto` never overrides.
     enabled: auto
@@ -89,11 +97,30 @@ providers:
     # is make this box gate the moment one is enabled, with no second edit
     # and no second decision to remember. Rollback is `mode: shadow` here.
     mode: active
+    # OpenRouter substitution (operator decision 1a, docs/runbooks/providers.md
+    # §9): when `codex` is missing from PATH or not logged in, and
+    # OPENROUTER_API_KEY is set, this provider runs through OpenRouter
+    # instead — same name, same mode, same gating power, only the transport
+    # and model underneath change. `openai/gpt-6-sol` is an EXACT catalog
+    # match (`curl -s https://openrouter.ai/api/v1/models`, checked
+    # 2026-09-30) for the id `-m gpt-6-sol` pins above: codex substitutes as
+    # literally the same model, not an approximation. No
+    # response_format_json_object override: the catalog entry lists
+    # `response_format` among its supported parameters, so the default
+    # (true) applies.
+    openrouter_fallback:
+      model: openai/gpt-6-sol
   deepseek:
     kind: api
     transport: api
     base_url: https://api.deepseek.com
-    model: deepseek-reasoner
+    # `deepseek-reasoner` retired from DeepSeek's own `/models` listing
+    # (live check of `/models`, 2026-09-30): a call naming it is now silently
+    # answered by `deepseek-flash` instead of erroring, so the pin below
+    # matters -- a stale model id here fails open, not closed.
+    # `deepseek-v4-pro` is DeepSeek's current reasoning-tier model, the
+    # direct-API successor to the retired `deepseek-reasoner`.
+    model: deepseek-v4-pro
     response_format_json_object: true
     api_key_env: DEEPSEEK_API_KEY
     model_tier: mid
@@ -103,7 +130,7 @@ providers:
     # Without it api-transport.ts throws `Environment variable "DEEPSEEK_API_KEY"
     # is not set` on every quorum trigger; quorum.ts catches it, so the gate
     # holds on the native verdict alone, but each trigger records a provider
-    # error. `smith judge preflight` reports the name it looked for and never
+    # error. `bs judge preflight` reports the name it looked for and never
     # the value it found, so it is safe to run anywhere.
     #
     # `auto`, not `true`, for the same reason codex is: this file is checked in
@@ -123,6 +150,17 @@ providers:
     # two dogfooded product epics (docs/runbooks/providers.md §3).
     # Rollback is `mode: shadow` here; nothing else remembers the promotion.
     mode: active
+    # OpenRouter substitution (operator decision 1a): when DEEPSEEK_API_KEY
+    # is missing and OPENROUTER_API_KEY is set, this provider runs through
+    # OpenRouter instead. `deepseek/deepseek-v4-pro` is an EXACT catalog
+    # match (`curl -s https://openrouter.ai/api/v1/models`, checked
+    # 2026-09-30) for the id pinned above: the fallback substitutes as
+    # literally the same model, not an approximation, same as the codex
+    # substitution above. No response_format_json_object override: the
+    # catalog entry lists `response_format` among its supported parameters,
+    # same as the direct-API entry above, so the default (true) applies.
+    openrouter_fallback:
+      model: deepseek/deepseek-v4-pro
 
 quorum_triggers:
   # architecture §6, agent-constraints.md "cross-check (phase 8)" — all four,
@@ -195,7 +233,7 @@ quorum_rule:
   # deciding with two opinions in front of them rather than one — which is the
   # whole point of the file — not an automatic override.
   #
-  # It silences one advisory in `smith judge preflight` and nothing else. A
+  # It silences one advisory in `bs judge preflight` and nothing else. A
   # provider enabled where it cannot be called is still a problem, and
   # `gating.canDecide` still reports false, because it is false.
   accept_non_gating_actives: true
@@ -204,7 +242,7 @@ asymmetric_roles:
   finder_ne_critic: true
   critic_mandate: refute, not confirm
   # The machine-readable form of finder_ne_critic (P9-23). Each pair says
-  # "this critic must not run on that finder's own model"; `smith dispatch
+  # "this critic must not run on that finder's own model"; `bs dispatch
   # check <session>` asserts it against the event log after the fact, using
   # the `model` field every dispatch_decision now carries. Without this list
   # the rule was unenforceable prose: it named no roles.
@@ -229,13 +267,13 @@ role_isolation:
   #
   # The only evidence of a separate turn the event log can hold is a separate
   # `dispatch_decision`, written by the node that dispatched, never by an agent
-  # about itself. `smith tester check <session>` asserts that against the log
+  # about itself. `bs tester check <session>` asserts that against the log
   # after the fact, per `testgate-result`.
   #
   # That reading survives delegation.yml granting `Agent` because of what the
   # grant costs: a grantee must open its own session first, so its dispatches
   # are its own log's, and no grant may hand a role its own auditor from the
-  # `pairs` below. `smith delegation check` enforces both, which is what keeps
+  # `pairs` below. `bs delegation check` enforces both, which is what keeps
   # a widened grant from quietly disarming this file.
   #
   # One entry, and it is meant to stay one until a second role starts grading
@@ -289,7 +327,7 @@ independent_finder:
   # summary and the failure scenario and never the source. A finder cannot: it
   # has nothing to read but the diff. Shipping worktree source to a third-party
   # API is a decision no code in this repo has standing to make quietly, so it
-  # is a switch, it ships false, and `smith crossfind run` REFUSES rather than
+  # is a switch, it ships false, and `bs crossfind run` REFUSES rather than
   # falling back to a diffless "find bugs" prompt that would invent findings.
   send_diff: false
   max_diff_bytes: 120000 # refuse rather than truncate: half a diff produces confident findings about code that is not there

package/factory/policies/delegation.yml

@@ -9,15 +9,15 @@
 # event log for what it dispatches" (docs/standards/agent-constraints.md).
 # Until D13 step 3 that was enforced by granting `Agent` to nobody, which also
 # capped an epic at one operator session. A grantee that opens its own session
-# with `smith session start <id> --continues <dispatch-event-id>` is a real
+# with `bs session start <id> --continues <dispatch-event-id>` is a real
 # dispatching node with a real log, so the cap can lift without the rule
 # bending.
 #
-# What a grant may not do — asserted by `smith delegation check` and by
+# What a grant may not do — asserted by `bs delegation check` and by
 # delegation.test.ts against the shipped files, so a widened grant fails CI:
 #
 #   - dispatch itself (a role that dispatches itself writes dispatches about
-#     itself, and `smith tester check` reads a second dispatch as proof of a
+#     itself, and `bs tester check` reads a second dispatch as proof of a
 #     second turn),
 #   - dispatch its own auditor from crosscheck.yml `role_isolation.pairs`
 #     (a coder that picks and prompts its own tester grades itself), or

package/factory/policies/effort.yml

@@ -7,7 +7,7 @@
 # written for: a decision made fresh every time is a decision made differently
 # every time. So the tiers are declared here and asked for, never recalled.
 #
-# HOST: `smith effort show --plan <plan.json>` reads this file plus the plan's
+# HOST: `bs effort show --plan <plan.json>` reads this file plus the plan's
 # own `effort` field and returns the profile for that epic
 # (factory/orchestrator/src/effort.ts). `.claude/skills/bs/plan.md` and
 # `run.md` run that verb at the top of `/bs plan` and `/bs run` and obey the
@@ -19,6 +19,14 @@
 # `effort_scaling:` block is the prose sibling of this file — it says fan-out
 # is a wall-clock optimisation; this says how much judgment each epic buys.
 #
+# Budgets follow the same tier (2026-09-29): `budgets.yml` sizes the epic cap
+# and every per-task cap for small / medium / huge, and each budget reader
+# takes the tier the epic runs at — the plan's `effort`, else `default_tier`
+# below, raised to `security_floor` when the floor applies. That is
+# a size, not a skipped step — the budgets still report and alarm at every
+# tier. Agent `maxTurns` is not tiered: one ceiling per template, sized for
+# `huge`.
+#
 # THE INVARIANT THAT MAKES THIS SAFE: a tier scales judgment steps only. It
 # never touches a mechanical oracle or a guardrail — see `invariants:` at the
 # bottom, which the host returns alongside every profile so the list cannot be
@@ -61,7 +69,7 @@ tiers:
     pre_code_uiux: when-ui-criterion
     # /bs plan steps 3-4 — planner <-> spec-reviewer until nothing S1/S2 is left.
     spec_review_rounds: until-clean
-    # /bs plan step 4 — `smith plan quorum` before operator sign-off.
+    # /bs plan step 4 — `bs plan quorum` before operator sign-off.
     plan_quorum: always
     # /bs run step 6 — the grader's bounded rubric loop (agent-constraints.md
     # caps it at 2; a tier may lower that number, never raise it).
@@ -120,22 +128,22 @@ tiers:
 
 # ── What no tier may touch ──────────────────────────────────────────
 #
-# Returned verbatim by `smith effort show` next to every profile. These are
+# Returned verbatim by `bs effort show` next to every profile. These are
 # mechanical oracles and guardrails, not judgments: their cost is a command
 # exiting, not an agent thinking, so scaling them saves nothing and buys
 # nothing but a weaker claim about the result.
 invariants:
   - the gate pipeline — schema check, grader verdict, tests, coverage
-    evidence, findings intake, severity decision (`smith gate run`)
+    evidence, findings intake, severity decision (`bs gate run`)
   - the root-level integration check on the assembled branch
-    (`smith integration check`)
-  - claim disjointness and worktree isolation (`smith wave check`,
-    `smith worktree create/fingerprint/verify`)
+    (`bs integration check`)
+  - claim disjointness and worktree isolation (`bs wave check`,
+    `bs worktree create/fingerprint/verify`)
   - the security-reviewer's conditional dispatch
-    (`smith security triggers`) — sensitive-paths.yml decides it, not a tier
+    (`bs security triggers`) — sensitive-paths.yml decides it, not a tier
   - the operator's plan sign-off, which no tier may skip or infer
-  - the epic-final verdict and its mechanical holds (`smith epic verdict`,
-    `smith epic close`)
+  - the epic-final verdict and its mechanical holds (`bs epic verdict`,
+    `bs epic close`)
   - the event log — every dispatch is still a `dispatch_decision` with a
     causal parent, at every tier
   - the escalation ladder after a blocked round (budgets.yml

package/factory/policies/guardrails.yml

@@ -1,7 +1,7 @@
 # Blacksmith — guardrail enforcement policy
 #
 # docs/standards/guardrails.md is the contract; this file is the data half of
-# what enforces it. HOST: `smith policy check`/`smith policy hook`
+# what enforces it. HOST: `bs policy check`/`bs policy hook`
 # (factory/orchestrator/src/policy.ts), and — via `dist/policyHook.js` —
 # `.claude/hooks/guard.sh`, the PreToolUse gate on every guarded tool call
 # an agent session makes.
@@ -36,9 +36,11 @@ protected_branches:
   # history-rewrite rule only (rule 5) — worktree.yml's
   # `integration_branch.pattern`: a leaf ref "smith/<epic>" cannot coexist
   # with "smith/<epic>/<task-id>" refs in real git (D/F ref conflict), so the
-  # shape is "smith/<epic>/integration", never a bare "smith/<epic>".
+  # shape is "smith/<epic>/integration", never a bare "smith/<epic>". Both
+  # prefixes are listed (bs-rename, operator decision 2/3): new epics
+  # integrate on bs/, but one already under way on smith/ stays there.
   names: [main, master]
-  patterns: ["smith/*/integration"]
+  patterns: ["bs/*/integration", "smith/*/integration"]
 
 catch_up_remotes:
   # rule 3's one exception: the remotes a protected branch is allowed to
@@ -123,7 +125,7 @@ rules:
 # ---------------------------------------------------------------------------
 #
 # Everything above applies to every agent session. This block applies to one
-# additional condition: a `smith sandbox open` lease is active over the
+# additional condition: a `bs sandbox open` lease is active over the
 # directory the command will run in (factory/orchestrator/src/sandbox.ts).
 # The orchestrator opens a lease before handing a worktree to one of the six
 # read-only judge roles and closes it after.
@@ -141,7 +143,7 @@ rules:
 #
 # What it is not: a container, a seccomp profile, or a read-only mount. A
 # command that writes through an interpreter (`python3 -c "open(...,'w')"`)
-# is invisible to a matcher, and always will be. `smith worktree verify`
+# is invisible to a matcher, and always will be. `bs worktree verify`
 # stays in the pipeline behind this for exactly that reason. Both halves are
 # stated in docs/standards/guardrails.md; neither is sold as the other.
 #
@@ -157,7 +159,7 @@ judge_sandbox:
   # `Edit`/`Write` (.claude/agents/*.md). `researcher` is deliberately absent
   # — fetching is its job, and it is never leased. A lease is matched to a
   # rule set by role, and a role named in neither list falls back to *this*
-  # one, so the list is the vocabulary `smith sandbox open --role` validates
+  # one, so the list is the vocabulary `bs sandbox open --role` validates
   # against rather than a gate of its own.
   roles: [reviewer, verifier, spec-reviewer, security-reviewer, grader, uiux]
 

package/factory/policies/harness.yml

@@ -3,14 +3,14 @@
 # architecture §19 "Worker harness port". A *provider* is the model vendor a
 # judge's verdict comes from (crosscheck.yml); a *harness* is the program
 # that holds a worker turn — gives the agent its tools, its working directory,
-# its turn limit. HOST: `smith harness list` / `smith harness plan`
+# its turn limit. HOST: `bs harness list` / `bs harness plan`
 # (factory/orchestrator/src/harness.ts), which read this file when `--policy`
-# names no other. `smith` renders an invocation from it and never starts one
-# (§18 rule 3); `smith-run` (src/run-cli.ts) is the separate binary that does.
+# names no other. `bs` renders an invocation from it and never starts one
+# (§18 rule 3); `bs-run` (src/run-cli.ts) is the separate binary that does.
 #
 # Shape, per harness:
 #   kind          `in-process` — the Claude Code Agent tool, no program started
-#                 (`command`/`args` unused); `cli` — a program `smith-run` spawns
+#                 (`command`/`args` unused); `cli` — a program `bs-run` spawns
 #                 with the rendered prompt on stdin.
 #   roles         taxonomy roles this harness serves; empty = every role that
 #                 ships a `.claude/agents/<role>.md`.
@@ -25,7 +25,7 @@
 #                 when this is empty). Rule 6's fingerprint runs regardless.
 #   schema_args   appended only when the turn names a schema (`--schema`), so a
 #                 turn that validates nothing renders without one.
-#   output        how smith-run reads the program's output: `text` (default),
+#   output        how bs-run reads the program's output: `text` (default),
 #                 `codex-json` (the `codex exec --json` JSONL stream),
 #                 `claude-json` (the `claude -p --output-format json` object).
 #   models        tier → model id for `{model}`; tiers are taxonomy.yml