@coreplane/switchboard 1.241.0 → 1.243.0

package/dist/assets/src/core/budgets.ts

@@ -0,0 +1,313 @@
+// Every wall clock in Switchboard as one table (docs/decisions/0046; docs/reference/specs/harness-pi.md
+// item 15; docs/reference/specs/agent-ship.md item 8). A budget is a LEASE a
+// parent carves from its own remainder, never a constant a file holds on its
+// own: a preset ASKS for a lease and does useful work above a FLOOR; a parent
+// that runs a loop holds back a RESERVE, derived from the floors and the
+// provisioning of every round that must still follow, plus the merge wait's
+// floor; and the lease covers everything the run does, the loop, the write-up
+// and the post-step, each an ALLOWANCE named here. The registry reads its
+// `maxMinutes` and `maxTurns` from this module and `budgets.check.test.ts`
+// asserts the fits, so a number that breaks another's assumption is a red
+// build. `carve` is called by the ship coordinator for every round (agent-ship
+// item 8), `fit` by the config validator at load and by the fork over a clipped
+// request, and `carveChildOfParent` by the conductor's spawn.
+//
+// Deliberately free of node: imports and of the agent registry, so the
+// Workflow-driven coordinator and the deploy Workers can bundle it — the
+// dependency runs registry → budgets, never the reverse.
+
+export const MINUTE_MS = 60_000;
+
+/** The presets that run the tool loop, and the one pipeline preset. */
+export const LOOP_PRESETS = ["general", "coding", "review", "research", "explore", "conductor"] as const;
+export type LoopPreset = (typeof LOOP_PRESETS)[number];
+export type Preset = LoopPreset | "ship";
+
+/** What each preset asks for when nothing above it is tighter, in minutes. The
+ *  pipeline's (`ship`) is the wall clock one segment of its loop runs under;
+ *  a deployment's `ship.maxMinutes` replaces it, held to `fit` below. */
+export const ASKS: Readonly<Record<Preset, number>> = {
+  general: 5,
+  coding: 45,
+  review: 25,
+  ship: 120,
+  research: 8,
+  explore: 120,
+  conductor: 120,
+};
+
+/** The rounds a ship loop is made of. `fix` is a coding child handed the
+ *  review's findings; `merge` is the runner's wait on the guards. */
+export type RoundKind = "coding" | "review" | "fix" | "merge";
+
+/** The least lease in which a round does useful work, in minutes. A carve that
+ *  falls under the floor is refused rather than dispatched: a two-minute
+ *  review or fix costs an attach and a model turn and finishes nothing.
+ *  Review's is the ledger's 90th percentile of completed reviews (5.1 min over
+ *  181); coding's and the merge wait's are guesses until the ledger says. */
+export const PRESET_FLOORS: Readonly<Record<LoopPreset, number>> = {
+  general: 2,
+  coding: 10,
+  review: 5,
+  research: 3,
+  explore: 15,
+  conductor: 15,
+};
+export const FLOORS: Readonly<Record<RoundKind, number>> = {
+  coding: PRESET_FLOORS.coding,
+  fix: PRESET_FLOORS.coding,
+  review: PRESET_FLOORS.review,
+  merge: 10,
+};
+
+/** The merge wait's own ask: how long the runner waits on the guards at most
+ *  when the remainder allows it. */
+export const MERGE_WAIT_ASK_MINUTES = 60;
+
+/** The ship runner's waits, in minutes: the margin a child's wait allows past
+ *  its budget, the slice a wait is asked in, the merge door's re-ask cadence,
+ *  and the pause before a busy spawn is asked again. */
+export const SHIP_WAIT = { marginMinutes: 5, chunkMinutes: 5, mergeChunkMinutes: 5, busyRetryMinutes: 2 } as const;
+
+/** The named amounts a lease holds back, in minutes. Each stands for a step
+ *  every run or round pays: `provision` is attach and restore before the
+ *  harness's clock starts; `writeUp` is the final answer after the loop ends;
+ *  `commandWriteUp` is what the last command leaves for that answer; `execCall`
+ *  is the exec client's wait past a command's own budget; `bearerGrace` is how
+ *  far past the lease the model bearer stays valid for the last call's tail. */
+export const ALLOWANCES = {
+  provision: 3,
+  writeUp: 3,
+  commandWriteUp: 1,
+  execCall: 0.5,
+  bearerGrace: 1,
+} as const;
+
+/** The post-step turn a preset runs after its loop, in minutes: the coding
+ *  run's description turn, the review's verdict turn, none for the rest. */
+export const POST_STEP_MINUTES: Readonly<Record<Preset, number>> = {
+  coding: 5,
+  review: 3,
+  general: 0,
+  research: 0,
+  explore: 0,
+  conductor: 0,
+  ship: 0,
+};
+
+/** The post-step allowance of a preset named by its def's `name`: a name
+ *  outside the table (a test's, a command run's) runs no post-step. */
+export function postStepMinutes(preset: string): number {
+  return (POST_STEP_MINUTES as Readonly<Record<string, number>>)[preset] ?? 0;
+}
+
+/** The post-step turn's lease, in minutes (fractional when the remainder is:
+ *  the harness turns it back into ms): the preset's allowance, or the lease's
+ *  remainder when that is less — never under a minute, so a turn the loop's
+ *  write-up crowded still gets its one chance. The bearer's grace covers that
+ *  floor for a turn that starts at or before the lease's end; a turn that
+ *  starts later runs on a bearer that may expire under it, and its refused
+ *  call fails soft — the run's answer already stands. Without a remainder
+ *  (no harness session says) the allowance stands. */
+export function postStepLease(preset: string, remainingMs: number | undefined): number {
+  const allowance = postStepMinutes(preset);
+  if (remainingMs === undefined) return allowance;
+  return Math.min(allowance, Math.max(1, remainingMs / MINUTE_MS));
+}
+
+/** A follow-up turn's lease, in ms: the lesser of what it asks and what the
+ *  run's lease still holds, never under a minute — the grace covers that floor
+ *  when the turn starts by the lease's end; later, the bearer may expire under
+ *  the turn and its call is refused, failing soft. */
+export function turnLeaseMs(askMinutes: number, remainingMs: number): number {
+  return Math.min(askMinutes * MINUTE_MS, Math.max(MINUTE_MS, remainingMs));
+}
+
+/** The wrap-up warning's place before the loop's end: three minutes, or a
+ *  quarter of the loop when the loop is shorter than twelve. */
+export const WRAP_UP_WARNING = { minutes: 3, fraction: 0.25 } as const;
+
+/** The clocks a harness keeps for one lease (docs/reference/specs/harness-pi.md
+ *  items 6 and 15). The lease ENDS at `deadline`; the LOOP ENDS at `loopEnd`,
+ *  the write-up allowance and the preset's post-step earlier, so both run
+ *  inside the lease; the WARNING is steered at `warnAt`; the write-up is
+ *  BOUNDED by `finaleMs`. A follow-up turn on the session (`kind: "turn"`)
+ *  holds nothing back — its deliverable is a tool call, not a write-up — and
+ *  its loop ends at its deadline. A lease shorter than its hold-back has no
+ *  loop time: the loop ends at its start, never before it. */
+export interface LoopClock {
+  startedAt: number;
+  deadline: number;
+  loopEnd: number;
+  warnAt: number;
+  finaleMs: number;
+}
+
+export function loopClock(
+  startedAt: number,
+  remainingMs: number,
+  preset: string,
+  kind: "loop" | "turn" = "loop",
+): LoopClock {
+  const deadline = startedAt + remainingMs;
+  const holdBackMs = kind === "loop" ? (ALLOWANCES.writeUp + postStepMinutes(preset)) * MINUTE_MS : 0;
+  const loopEnd = Math.max(startedAt, deadline - holdBackMs);
+  const warnAt =
+    loopEnd - Math.min(WRAP_UP_WARNING.minutes * MINUTE_MS, (loopEnd - startedAt) * WRAP_UP_WARNING.fraction);
+  return { startedAt, deadline, loopEnd, warnAt, finaleMs: ALLOWANCES.writeUp * MINUTE_MS };
+}
+
+/** When a run's model-proxy bearer expires: the lease's end plus the grace
+ *  (docs/reference/specs/model-proxy.md item 2). */
+export function bearerExpiresAt(leaseEndsAt: number): number {
+  return leaseEndsAt + ALLOWANCES.bearerGrace * MINUTE_MS;
+}
+
+/** The bearer's expiry as the mint at provisioning sets it, before the lease
+ *  has started: the provisioning allowance, the lease and the grace — replaced
+ *  by `bearerExpiresAt` the moment the harness starts the lease. */
+export function provisionalBearerExpiresAt(now: number, leaseMinutes: number): number {
+  return now + (ALLOWANCES.provision + leaseMinutes + ALLOWANCES.bearerGrace) * MINUTE_MS;
+}
+
+/** The per-command bash budget's rows: the default when a call names none, the
+ *  ceiling a call may raise it to, and the floor under which a number is a
+ *  typo (docs/reference/specs/execution.md item 11). */
+export const BASH_COMMAND = { defaultMinutes: 5, maxMinutes: 20, minMs: 1_000 } as const;
+
+/** The pace that marks a run as looping rather than working: a model turn
+ *  every ten seconds, sustained for the whole wall clock. A busy run takes
+ *  20–40 s a turn (a model think plus a tool call), so a run that averages six
+ *  a minute from start to end is re-issuing calls, not making progress — and
+ *  its turn cap ends it before the wall clock would, with a write-up that
+ *  says so (docs/reference/specs/harness-pi.md item 15). */
+export const RUNAWAY_TURNS_PER_MINUTE = 6;
+
+/** The turn cap a wall clock implies: `maxMinutes × RUNAWAY_TURNS_PER_MINUTE`.
+ *  Every preset that runs the loop derives its `maxTurns` from this, so the
+ *  cap is never a number a good run reaches — the minutes are the budget. */
+export function runawayTurnCap(maxMinutes: number): number {
+  return maxMinutes * RUNAWAY_TURNS_PER_MINUTE;
+}
+
+/** A pipeline's loop as the config allows it: `maxRounds` counts review rounds. */
+export interface Loop {
+  maxRounds: number;
+}
+
+/** A round's position in its loop: its kind and its index, so the reserve is
+ *  the rounds after that index, never a table keyed by kind alone. */
+export interface RoundPosition {
+  kind: RoundKind;
+  index: number;
+}
+
+/** The rounds of a loop in order: the coding round, then a review and, after
+ *  every review but the last, a fix, then the merge wait. */
+export function loopRounds(loop: Loop): RoundKind[] {
+  const rounds: RoundKind[] = ["coding"];
+  for (let i = 0; i < loop.maxRounds; i++) {
+    rounds.push("review");
+    if (i < loop.maxRounds - 1) rounds.push("fix");
+  }
+  rounds.push("merge");
+  return rounds;
+}
+
+/** Where a round sits in `loopRounds`: the coding round first; review round
+ *  `n` (counted from 1) and the fix that follows it at `2n − 1` and `2n`; the
+ *  merge wait last. The ship coordinator numbers its rounds this way, so the
+ *  reserve it carves with is the one the fit assumed. */
+export function loopPosition(loop: Loop, kind: RoundKind, n = 0): number {
+  switch (kind) {
+    case "coding":
+      return 0;
+    case "review":
+      return 2 * n - 1;
+    case "fix":
+      return 2 * n;
+    case "merge":
+      return 2 * loop.maxRounds;
+  }
+}
+
+/** A child spawned outside any loop (a conductor's): the parent's whole
+ *  remainder in whole minutes, refused under the child preset's floor — a
+ *  child under its floor costs a thread and a model turn and finishes nothing. */
+export function carveChildOfParent(
+  remainingMs: number,
+  preset: LoopPreset,
+): { kind: "carved"; minutes: number } | { kind: "refused"; reason: "under floor"; minutes: number; floor: number } {
+  const minutes = Math.max(0, Math.floor(remainingMs / MINUTE_MS));
+  const floor = PRESET_FLOORS[preset];
+  if (minutes < floor) return { kind: "refused", reason: "under floor", minutes, floor };
+  return { kind: "carved", minutes };
+}
+
+/** The minutes a round holds back for what must follow it in the loop: the
+ *  floor plus provisioning of every later review and fix, and the merge
+ *  wait's floor. A merge holds nothing back; a round with no loop (a
+ *  conductor's child) holds nothing back either. */
+export function reserveMinutes(
+  round: RoundPosition,
+  loop: Loop | undefined,
+  floors: Readonly<Record<RoundKind, number>> = FLOORS,
+): number {
+  if (!loop) return 0;
+  let reserve = 0;
+  for (const kind of loopRounds(loop).slice(round.index + 1)) {
+    reserve += kind === "merge" ? floors.merge : floors[kind] + ALLOWANCES.provision;
+  }
+  return reserve;
+}
+
+/** What a round asks for: the preset's ask for a coding or fix round, the
+ *  review's for a review, the merge wait's own for the merge. */
+export function roundAskMinutes(kind: RoundKind): number {
+  switch (kind) {
+    case "coding":
+    case "fix":
+      return ASKS.coding;
+    case "review":
+      return ASKS.review;
+    case "merge":
+      return MERGE_WAIT_ASK_MINUTES;
+  }
+}
+
+/** A carve's result: the minutes with what bounded them (`ask` when the round
+ *  got its whole ask, `parent` when the remainder minus the reserve was
+ *  tighter) and what the parent holds back, or a refusal when the minutes the
+ *  remainder leaves fall under the round's floor. */
+export type Carve =
+  | { kind: "carved"; minutes: number; boundedBy: "ask" | "parent"; holds: number }
+  | { kind: "refused"; reason: "under floor"; minutes: number; floor: number; holds: number };
+
+/** The only place a round's minutes are computed: the parent's remainder in
+ *  whole minutes minus the round's reserve, capped at the round's ask, refused
+ *  under the round's floor. `loop` is undefined for a child outside any loop. */
+export function carve(remainingMs: number, round: RoundPosition, loop: Loop | undefined): Carve {
+  const holds = reserveMinutes(round, loop);
+  const ask = roundAskMinutes(round.kind);
+  const headroom = Math.floor(remainingMs / MINUTE_MS) - holds;
+  const minutes = Math.min(ask, headroom);
+  const floor = FLOORS[round.kind];
+  // A refusal reports what the remainder left, never a negative number.
+  if (minutes < floor) return { kind: "refused", reason: "under floor", minutes: Math.max(0, minutes), floor, holds };
+  return { kind: "carved", minutes, boundedBy: minutes === ask ? "ask" : "parent", holds };
+}
+
+/** A pipeline's wall clock and its loop: what `fit` judges. */
+export interface Pipeline extends Loop {
+  maxMinutes: number;
+}
+
+/** The fit: a pipeline holds its first child at its ask and every later round
+ *  at its floor — `provision + ask(coding) + reserve(coding, loop) ≤
+ *  maxMinutes`. Asserted at verify over the registry, at config load over the
+ *  deployment's `ship` block (`validateShip`), and at the fork over a request a
+ *  boundary or a `budget:` directive clipped. `need` is the sum a refusal names. */
+export function fit(pipeline: Pipeline): { ok: boolean; need: number; have: number } {
+  const need = ALLOWANCES.provision + ASKS.coding + reserveMinutes({ kind: "coding", index: 0 }, pipeline);
+  return { ok: pipeline.maxMinutes >= need, need, have: pipeline.maxMinutes };
+}

package/dist/assets/src/core/coordinator/contract.ts

@@ -150,6 +150,8 @@ export interface CoordinatorInstance {
   /** The bound credential behind the person (authorization.md item 15), when
    *  there was one: every child is authorized under ITS grants, as the request was. */
   authenticatedAs?: string;
+  /** The app that relayed the request for the person (authorization.md item 14), when one did: every child is authorized under app ∩ person, as the request was. */
+  postedBy?: string;
   channelId: string;
   channelName?: string;
   /** The requesting thread: where the card lives and where a generated plan's
@@ -260,7 +262,7 @@ export function isCoordinatorInstance(v: unknown): v is CoordinatorInstance {
   if (r.kind !== "ship") return false;
   if (!isText(r.userId) || !isText(r.channelId) || !isText(r.threadKey)) return false;
   if (!isOptionalText(r.userName) || !isOptionalText(r.channelName) || !isOptionalText(r.sourceUrl)) return false;
-  if (!isOptionalText(r.authenticatedAs)) return false;
+  if (!isOptionalText(r.authenticatedAs) || !isOptionalText(r.postedBy)) return false;
   if (typeof r.repo !== "string" || !REPO_SLUG.test(r.repo)) return false;
   if (!isText(r.branch) || !isOptionalText(r.base)) return false;
   if (!isFinite(r.createdAt)) return false;

package/dist/assets/src/core/coordinator/driver.ts

@@ -54,7 +54,6 @@ import {
   type ShipCaps,
   type StepReturn,
   type UnitEnding,
-  type UnitPipelineInput,
   type UnitPipelineState,
 } from "../ship/coordinator.js";
 import { checksSettledEventType, isCoordinatorUnit, runFinishedEventType, type CoordinatorUnit } from "./contract.js";
@@ -170,7 +169,6 @@ interface PlanFacts {
   repo: string;
   base: string;
   caps: ShipCaps;
-  childMinutes: UnitPipelineInput["childMinutes"];
   units: CoordinatorUnit[];
 }
 
@@ -184,12 +182,6 @@ function readPlan(a: BotAnswer): PlanFacts {
   if (typeof b.repo !== "string" || typeof b.base !== "string") throw new UnreadableAnswer("plan", a, "repo and base");
   if (!isMinutes(b.caps) || typeof b.caps.maxRounds !== "number" || typeof b.caps.maxMinutes !== "number")
     throw new UnreadableAnswer("plan", a, "caps");
-  if (
-    !isMinutes(b.childMinutes) ||
-    typeof b.childMinutes.coding !== "number" ||
-    typeof b.childMinutes.review !== "number"
-  )
-    throw new UnreadableAnswer("plan", a, "childMinutes");
   const units: unknown = b.units;
   if (!Array.isArray(units) || !units.every(isCoordinatorUnit)) throw new UnreadableAnswer("plan", a, "units");
   return {
@@ -204,7 +196,6 @@ function readPlan(a: BotAnswer): PlanFacts {
     repo: b.repo,
     base: b.base,
     caps: { maxRounds: b.caps.maxRounds, maxMinutes: b.caps.maxMinutes },
-    childMinutes: { coding: b.childMinutes.coding, review: b.childMinutes.review },
     units,
   };
 }
@@ -486,7 +477,6 @@ async function runUnit(
       repo: plan.repo,
       base: plan.base,
       caps: plan.caps,
-      childMinutes: plan.childMinutes,
       // The instance's field decides who merges (record 0031's merge grant),
       // carried here by the plan route: the hand-off wrote `runner` on a
       // seeded plan and `person` on a task, and the door re-checks it — the

package/dist/assets/src/core/costs.ts

@@ -1,3 +1,9 @@
+import {
+  anthropicTokensCostUsd,
+  parseModelPrices,
+  type AnthropicTokens,
+  type ModelPriceTable,
+} from "./modelPricing.js";
 import { systemClock } from "./trace/clock.js";
 // Spend report: what a group of deployed pieces ("switchboard" = the bot
 // Worker + its containers, the resident/sandbox/memory Workers) costs per day,
@@ -68,10 +74,15 @@ export interface CostsConfig {
   /** Env var holding an Anthropic Admin API key (sk-ant-admin…). Optional feature. */
   anthropicAdminKeyEnv: string;
   groups: Record<string, CostGroupConfig>;
+  /** `costs.prices`: the operator's per-million rates by `<provider>/<model>`, over the Anthropic list (item 4b). */
+  prices: ModelPriceTable;
   /** The snapshot the page and the twins serve (src/core/costsSnapshot.ts). */
   snapshot: {
     /** Hours between two reads of the billing sources. */
     everyHours: number;
+    /** The platform-namespaced channel (`slack:C…`) told when takes keep failing and when they
+     *  land again (`ALERT_AFTER_FAILURES` in a row); absent → the status alone says so. */
+    alertChannel?: string;
   };
 }
 
@@ -82,13 +93,15 @@ const DEFAULT_ANTHROPIC_ADMIN_ENV = "ANTHROPIC_ADMIN_KEY";
  *  default — both sources bucket by UTC day, and the page is read about as often. */
 export const COSTS_SNAPSHOT_EVERY_HOURS = Object.freeze({ default: 24, min: 1, max: 168 });
 
-/** `costs.snapshot`: absent → the default interval; a value outside the bounds or not a whole number throws by name. */
+/** `costs.snapshot`: absent → the default interval and no alert channel; a value outside the
+ *  bounds or not a whole number throws by name; `alertChannel`, when given, is a platform-namespaced id. */
 function snapshotConfig(raw: unknown): CostsConfig["snapshot"] {
   if (raw === undefined) return { everyHours: COSTS_SNAPSHOT_EVERY_HOURS.default };
   if (typeof raw !== "object" || raw === null || Array.isArray(raw))
     throw new Error("costs.snapshot must be a mapping");
-  const every = (raw as Record<string, unknown>).everyHours;
-  if (every === undefined) return { everyHours: COSTS_SNAPSHOT_EVERY_HOURS.default };
+  const r = raw as Record<string, unknown>;
+  // `undefined` alone defaults: a bare `everyHours:` key (null) is a malformed value, refused below by name.
+  const every = r.everyHours === undefined ? COSTS_SNAPSHOT_EVERY_HOURS.default : r.everyHours;
   if (
     typeof every !== "number" ||
     !Number.isInteger(every) ||
@@ -98,7 +111,10 @@ function snapshotConfig(raw: unknown): CostsConfig["snapshot"] {
     throw new Error(
       `costs.snapshot.everyHours must be a whole number of hours between ${COSTS_SNAPSHOT_EVERY_HOURS.min} and ${COSTS_SNAPSHOT_EVERY_HOURS.max}`,
     );
-  return { everyHours: every };
+  if (r.alertChannel === undefined) return { everyHours: every };
+  if (typeof r.alertChannel !== "string" || !/^[a-z]+:.+$/.test(r.alertChannel))
+    throw new Error("costs.snapshot.alertChannel must be a platform-namespaced channel id (`slack:C…`)");
+  return { everyHours: every, alertChannel: r.alertChannel };
 }
 
 function labelMap(raw: unknown, what: string): Record<string, string> {
@@ -147,6 +163,7 @@ export function parseCostsConfig(raw: unknown): CostsConfig | undefined {
     anthropicAdminKeyEnv:
       typeof r.anthropicAdminKeyEnv === "string" ? r.anthropicAdminKeyEnv : DEFAULT_ANTHROPIC_ADMIN_ENV,
     groups,
+    prices: parseModelPrices(r.prices),
     snapshot: snapshotConfig(r.snapshot),
   };
 }
@@ -683,82 +700,6 @@ export function buildCostReport(
   };
 }
 
-// ---- Anthropic list prices ----------------------------------------------------------------
-
-/** USD per million tokens of one kind, one model family. */
-export interface AnthropicModelPrice {
-  input: number;
-  output: number;
-  cacheWrite5m: number;
-  cacheWrite1h: number;
-  cacheRead: number;
-}
-
-/** Anthropic list prices per model family (platform.claude.com/docs/en/about-claude/pricing;
- *  re-check when it moves). Keyed by the family id the usage report spells — a dated
- *  release (`claude-haiku-4-5-20251001`) resolves to its family through
- *  `anthropicPriceOf`. Only what the estimate needs: the open day priced at
- *  the rate it will bill at; the cost report remains the invoice. */
-export const ANTHROPIC_PRICES: Record<string, AnthropicModelPrice> = {
-  "claude-fable-5-1": { input: 10, output: 50, cacheWrite5m: 12.5, cacheWrite1h: 20, cacheRead: 0.25 },
-  "claude-mythos-5-1": { input: 10, output: 50, cacheWrite5m: 12.5, cacheWrite1h: 20, cacheRead: 0.25 },
-  "claude-fable-5": { input: 10, output: 50, cacheWrite5m: 12.5, cacheWrite1h: 20, cacheRead: 1 },
-  "claude-mythos-5": { input: 10, output: 50, cacheWrite5m: 12.5, cacheWrite1h: 20, cacheRead: 1 },
-  "claude-opus-5": { input: 5, output: 25, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
-  "claude-opus-4-8": { input: 5, output: 25, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
-  "claude-opus-4-7": { input: 5, output: 25, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
-  "claude-opus-4-6": { input: 5, output: 25, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
-  "claude-opus-4-5": { input: 5, output: 25, cacheWrite5m: 6.25, cacheWrite1h: 10, cacheRead: 0.5 },
-  "claude-opus-4-1": { input: 15, output: 75, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5 },
-  "claude-opus-4": { input: 15, output: 75, cacheWrite5m: 18.75, cacheWrite1h: 30, cacheRead: 1.5 },
-  "claude-sonnet-5": { input: 2, output: 10, cacheWrite5m: 2.5, cacheWrite1h: 4, cacheRead: 0.2 },
-  "claude-sonnet-4-6": { input: 3, output: 15, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3 },
-  "claude-sonnet-4-5": { input: 3, output: 15, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3 },
-  "claude-sonnet-4": { input: 3, output: 15, cacheWrite5m: 3.75, cacheWrite1h: 6, cacheRead: 0.3 },
-  "claude-haiku-4-5": { input: 1, output: 5, cacheWrite5m: 1.25, cacheWrite1h: 2, cacheRead: 0.1 },
-  "claude-haiku-3-5": { input: 0.8, output: 4, cacheWrite5m: 1, cacheWrite1h: 1.6, cacheRead: 0.08 },
-};
-
-const DATED_RELEASE_SUFFIX = /^-\d{8}$/;
-
-/** The family prices of a model id: the id itself, or the id less a dated
- *  release suffix (`-YYYYMMDD`). Nothing else counts as "the same family" —
- *  `claude-fable-5-1` is not `claude-fable-5` with a suffix, and its cache
- *  reads bill differently. Unknown → undefined, never a guess. */
-export function anthropicPriceOf(modelId: string): AnthropicModelPrice | undefined {
-  const exact = ANTHROPIC_PRICES[modelId];
-  if (exact) return exact;
-  for (const family of Object.keys(ANTHROPIC_PRICES)) {
-    if (modelId.startsWith(family) && DATED_RELEASE_SUFFIX.test(modelId.slice(family.length)))
-      return ANTHROPIC_PRICES[family];
-  }
-  return undefined;
-}
-
-/** Token counts of one usage-report row, in the report's own kinds. */
-export interface AnthropicTokens {
-  uncachedInput: number;
-  output: number;
-  cacheRead: number;
-  cacheWrite5m: number;
-  cacheWrite1h: number;
-}
-
-/** What those tokens cost at the family's list prices; undefined for a model
- *  the table does not know (the caller reports the tokens, never $0). */
-export function anthropicTokensCostUsd(modelId: string, t: AnthropicTokens): number | undefined {
-  const p = anthropicPriceOf(modelId);
-  if (!p) return undefined;
-  return (
-    (t.uncachedInput * p.input +
-      t.output * p.output +
-      t.cacheRead * p.cacheRead +
-      t.cacheWrite5m * p.cacheWrite5m +
-      t.cacheWrite1h * p.cacheWrite1h) /
-    1_000_000
-  );
-}
-
 // ---- range ----------------------------------------------------------------------------
 
 const DEFAULT_DAYS = 30;

package/dist/assets/src/core/harness/scope.ts

@@ -0,0 +1,21 @@
+// Where a preset's harness word is set (docs/reference/specs/harness.md item
+// 8), in a module with no imports of its own: the run record (`run_meta.harnessScope`)
+// and the timeline fold read it, and both are compiled into the Workers' and
+// the dashboard's programs, where the roster's neighbours — the harness
+// objects, their Node-only process code — must not follow. The roster
+// re-exports these names, so every reader inside the bot can still take them
+// from there.
+
+/** The scopes a word is set at, most specific first — the order the resolution
+ *  walks the layers: the requester's own scope, the channel's, then the
+ *  deployment's top-level `harness` block, which is the defaults layer under
+ *  its one spelling. What `run_meta.harnessScope` and the config block name, so
+ *  a reader of a run on OpenCode never guesses whose word put it there. */
+export const HARNESS_SCOPES = ["user", "channel", "defaults"] as const;
+export type HarnessScope = (typeof HARNESS_SCOPES)[number];
+
+/** Whether a value is one of the scopes a word is set at: the timeline's test
+ *  for the field a record carries. */
+export function isHarnessScope(value: unknown): value is HarnessScope {
+  return typeof value === "string" && (HARNESS_SCOPES as readonly string[]).includes(value);
+}