Story 1566: Who governs the agent when nobody is watching

Why this exists (the catastrophe it prevents). The rails (Story-1562) gave every agent a leash. But a leash has to be set by someone — and in an Auto run there is no human in the room to set it. Auto is the extraction worker: a document lands, an event fires, the agent processes a batch overnight, and counsel reads the summary in the morning. Three doors swing open if a firm can't configure that headless run. First, no default: the agent has no Thinking level or review posture to use, so it either fails or falls back to something arbitrary. Second, no spend cap: counsel says "process everything" and wakes to a 500-file batch that silently ran every step at Extra-High and blew the firm's budget — or, worse, a tight budget quietly drops a privilege-detection step below its safety floor to fit, and a privileged document leaks. Third, no firm posture: an enterprise client wants "delegate routine work in trusted matters" expressed once, firm-wide, not re-picked per run. This Story builds the admin/firm configuration that governs all three — and wires it so that the budget governs cost, the floor governs safety, and safety always wins.

The one analogy: a thermostat with a hard-wired frost guard

Think of the firm config as a building thermostat the office manager sets. The Auto defaults are the schedule it runs on when nobody's touching it — "overnight, run at this setting." The budget ceiling is a cap on the energy bill: spend no more than this. But the thermostat has a frost guard wired behind the panel — a minimum the heat will hold no matter how low you set the budget, because frozen pipes cost more than electricity. If your budget is so tight it can't even afford the frost guard, the thermostat doesn't quietly let the pipes freeze — it flashes a warning and waits for you. The authority profiles are named presets ("Eco", "Comfort") the manager defines once and selects. And the floor list is a label on the panel telling you the frost guard exists and at what temperature — readable, never a dial you can turn off.

🛰️ Satellite: what shipped

Two firm-scoped tables, one alembic migration (0122), a firm-config domain with a router under /app/agent-runtime, and two new pure rails the broker consumes. No model name, price, or token figure crosses any surface — the budget is in abstract cost units.

• Auto-mode defaults (D3) — per-firm default thinking_level + authority_mode for headless runs. The new auto_posture rail resolves requested_level by precedence (user > matter > firm > agent default) and then floors it: effective_level = max(requested, step_floor). A cost-cutting firm default of low still runs privilege detection at high.
• Budget ceiling, floor-protected (D11) — the new budget rail. Floors drive a non-negotiable min_batch_cost the budget can never cap below. A batch over the ceiling chunks + checkpoints + alerts; a batch whose floor alone exceeds the ceiling is held and surfaced (never run below a floor). Never a silent overrun, never a floor violation.
• Firm-policy authority profiles (D4) — business.firm_agent_authority_profiles: named profiles each declaring a concrete base posture. When a run's mode is firm_policy, the broker resolves through the selected profile. The non-delegable list is not stored here — it is doctrine enforced per-effect, regardless of profile.
• Floor list config (D3) — GET /app/agent-runtime/floors renders the declared global floors. Read-only by construction: there is no write endpoint, because floors are additive and can never be removed or lowered by config.
• Posture provenance (D8) — a monotonic policy_version on the firm policy row, bumped on every material edit, stamped into each applied effect so an effect is auditable months later to whose config authorized it.

✈️ Airplane: how the budget governor decides (D11)

estimate = { item_count, total_cost_units, min_batch_cost_units }   <- min is floor-driven
ceiling  = firm.budget_ceiling_units    (None = unbounded)

resolve_budget(ceiling, estimate):
  ceiling is None                      -> WITHIN_BUDGET        (nothing to cap)
  min_batch_cost  >  ceiling           -> FLOOR_EXCEEDS_BUDGET (HELD + alert; floor NOT lowered)
  total_cost      <= ceiling           -> WITHIN_BUDGET        (run whole, silent)
  else (total > ceiling >= min)        -> CHUNK_AND_CHECKPOINT (ceil(total/ceiling) chunks + alert)

cost units are ABSTRACT: low=1, medium=2, high=4, extra_high=8   (no $/token/model)
a higher level costs strictly more, so a floor that RAISES a level RAISES its cost too

Four turns make this correct:

• The floor is checked before the budget can chunk. If the floored minimum alone is over the ceiling, the budget is unsatisfiable without lowering a floor — which is forbidden — so the governor returns FLOOR_EXCEEDS_BUDGET and the batch is held for counsel, never trimmed below the floor to fit. Safety beats cost, structurally.
• Over-budget never means silent overrun. A batch above the ceiling is split into ceiling-sized, checkpointed chunks (reusing document_status_events, D6) with a counsel-facing alert at the review point. The cap throttles throughput, never safety — each chunk still runs its floored steps at floor.
• Cost is abstract, so no model or price leaks. The weights are relative units with one required property: strict monotonicity. The admin sees "units", never tokens or rupees (D2), and the broker never has to expose a model name to compute a budget.
• The floor default beats the Auto default. The auto_posture rail floors the resolved level after precedence, so the firm's headless default can be cheap for ordinary steps yet never for a floored one.

✈️ Airplane: how a firm config row becomes a governed run

admin PUTs /app/agent-runtime/policy   -> firm_agent_runtime_policies (1 row/firm, RLS)
                                          { auto_thinking_level, auto_authority_mode,
                                            active_authority_profile_id, budget_ceiling_units,
                                            budget_default_level, policy_version++ }

# later, a headless Auto run (broker-side, Story-1562 rails):
posture = resolve_auto_posture(                       <- this Story's rail
            firm_level   = policy.auto_thinking_level, <- config, never content
            firm_authority = policy.auto_authority_mode,
            firm_policy_profile_mode = profile.base_authority_mode,
            step = "privilege_detection")
          requested=low? -> effective = max(low, HIGH) = HIGH   (floor wins)
          firm_policy    -> authority resolves through the selected profile
          stamps { config_source: firm, policy_version, floor_applied } (D8)

🔬 Microscopic: the boundary lines that matter

One-sentence recall

When no human is watching, the firm config sets the agent's Auto defaults and a spend ceiling — but the safety floor is wired behind the panel: the budget can throttle the work into chunks, never below the floor, and if the floor alone costs more than the budget, the batch waits for counsel rather than running cheap.