@coreplane/switchboard 1.250.0 → 1.252.0

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

@@ -23,6 +23,17 @@ export interface ModelUsage {
   outputTokens: number;
   cacheReadTokens: number;
   cacheWriteTokens: number;
+  /** The model's dollars summed from its turns' own `usd` attrs (the proxy's
+   *  meter row, model-proxy item 6): a number when every turn that counted
+   *  tokens carried one, null when such a turn lacked it (unpriced — a sum
+   *  that left counted tokens out would understate the model; a turn that
+   *  counted none, an errored call or a retry, leaves nothing out), absent on
+   *  a record whose turns predate the meter row (the price table then prices
+   *  the tokens, costs.md item 4b). */
+  usd?: number | null;
+  /** The distinct `priceSource` words the turns carried, sorted — what the
+   *  by-model view names as the source. Absent when no turn carried one. */
+  priceSources?: string[];
 }
 
 export interface RunUsage {
@@ -46,6 +57,14 @@ export const emptyUsage = (): RunUsage => ({ turns: 0, byModel: {} });
 /** The run's usage from its events: one `model.turn` span end per provider call. */
 export function usageOfEvents(events: readonly RunEvent[]): RunUsage {
   const usage = emptyUsage();
+  // The meter row per model (model-proxy item 6): the turns' own dollars and
+  // sources. `usd` sums only when every turn that counted tokens carried one —
+  // a turn that counted none (an upstream error, a retry the harness's SDK
+  // spent, a stream broken before its usage) has nothing a sum could leave
+  // out, so it never turns the model unpriced; a model none of whose turns
+  // carried price attrs stays without the fields (a record from before the
+  // meter row — the table prices it, costs.md item 4b).
+  const priced = new Map<string, { usd: number; pricedTurns: number; tokenTurns: number; sources: Set<string> }>();
   for (const e of events) {
     if (e.type !== "span_end" || e.name !== MODEL_TURN) continue;
     const attrs = (e.attrs ?? {}) as Record<string, unknown>;
@@ -57,6 +76,8 @@ export function usageOfEvents(events: readonly RunEvent[]): RunUsage {
       cacheReadTokens: 0,
       cacheWriteTokens: 0,
     };
+    const counted =
+      num(attrs.inputTokens) + num(attrs.outputTokens) + num(attrs.cacheReadTokens) + num(attrs.cacheWriteTokens);
     m.turns += 1;
     m.inputTokens += num(attrs.inputTokens);
     m.outputTokens += num(attrs.outputTokens);
@@ -64,38 +85,71 @@ export function usageOfEvents(events: readonly RunEvent[]): RunUsage {
     m.cacheWriteTokens += num(attrs.cacheWriteTokens);
     usage.byModel[model] = m;
     usage.turns += 1;
+    const hasUsd = typeof attrs.usd === "number" && Number.isFinite(attrs.usd);
+    const hasSource = typeof attrs.priceSource === "string" && attrs.priceSource !== "";
+    const p = priced.get(model) ?? { usd: 0, pricedTurns: 0, tokenTurns: 0, sources: new Set<string>() };
+    if (counted > 0) p.tokenTurns += 1;
+    if (hasUsd) {
+      p.usd += attrs.usd as number;
+      p.pricedTurns += 1;
+    }
+    if (hasSource) p.sources.add(attrs.priceSource as string);
+    priced.set(model, p);
+  }
+  for (const [model, p] of priced) {
+    if (p.pricedTurns === 0 && p.sources.size === 0) continue;
+    const m = usage.byModel[model]!;
+    m.usd = p.pricedTurns >= p.tokenTurns ? p.usd : null;
+    if (p.sources.size > 0) m.priceSources = [...p.sources].sort();
   }
   return usage;
 }
 
+/** The two sides' `usd` folded: a sum when both carry one, null when either
+ *  has an unpriced turn, absent when either predates the meter row (the whole
+ *  cell then prices from the table, never half a figure). */
+const foldUsd = (a: ModelUsage["usd"], b: ModelUsage["usd"]): ModelUsage["usd"] =>
+  a === undefined || b === undefined ? undefined : a === null || b === null ? null : a + b;
+
 export function addUsage(a: RunUsage, b: RunUsage): RunUsage {
   const out: RunUsage = { turns: a.turns + b.turns, byModel: {} };
   for (const src of [a.byModel, b.byModel]) {
     for (const [model, m] of Object.entries(src)) {
-      const acc = out.byModel[model] ?? {
-        turns: 0,
-        inputTokens: 0,
-        outputTokens: 0,
-        cacheReadTokens: 0,
-        cacheWriteTokens: 0,
-      };
+      const acc = out.byModel[model];
+      if (!acc) {
+        out.byModel[model] = { ...m, ...(m.priceSources ? { priceSources: [...m.priceSources] } : {}) };
+        continue;
+      }
       acc.turns += m.turns;
       acc.inputTokens += m.inputTokens;
       acc.outputTokens += m.outputTokens;
       acc.cacheReadTokens += m.cacheReadTokens;
       acc.cacheWriteTokens += m.cacheWriteTokens;
-      out.byModel[model] = acc;
+      const usd = foldUsd(acc.usd, m.usd);
+      if (usd === undefined) delete acc.usd;
+      else acc.usd = usd;
+      const sources = new Set([...(acc.priceSources ?? []), ...(m.priceSources ?? [])]);
+      if (sources.size > 0) acc.priceSources = [...sources].sort();
     }
   }
   return out;
 }
 
-const isModelUsage = (v: unknown): v is ModelUsage =>
-  typeof v === "object" &&
-  v !== null &&
-  (["turns", "inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"] as const).every(
-    (k) => typeof (v as Record<string, unknown>)[k] === "number",
+const isModelUsage = (v: unknown): v is ModelUsage => {
+  if (typeof v !== "object" || v === null) return false;
+  const m = v as Record<string, unknown>;
+  if (
+    !["turns", "inputTokens", "outputTokens", "cacheReadTokens", "cacheWriteTokens"].every(
+      (k) => typeof m[k] === "number",
+    )
+  )
+    return false;
+  if (m.usd !== undefined && m.usd !== null && typeof m.usd !== "number") return false;
+  return (
+    m.priceSources === undefined ||
+    (Array.isArray(m.priceSources) && m.priceSources.every((s) => typeof s === "string"))
   );
+};
 
 export function isRunUsage(v: unknown): v is RunUsage {
   if (typeof v !== "object" || v === null) return false;

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

@@ -379,6 +379,9 @@ export interface WatchdogSummary {
     action?: unknown;
     error?: string;
     disk?: unknown;
+    /** The resident's last memory reading (`{usedBytes, capBytes, percent, …}`,
+     *  resident-repos.md item 70) when it has one. */
+    memory?: unknown;
     /** What the pass did about the resident's refresh Workflow instance: `{id, action, why}`. */
     instance?: unknown;
   }>;

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

@@ -439,17 +439,57 @@ export const TIMEOUT_ON_LONG_COMMANDS =
   "State a timeout on any command you expect to run longer than a minute: a timeout that reaches past the loop's " +
   "end is refused before the command runs, never cut midway.";
 
+/** The fast gates a plan child runs before every push, named one by one and
+ *  each scoped to the changed set (agent-ship item 13; agent-coding item 9).
+ *  "Its cheapest proving checks" left the choice to the child, and children
+ *  chose wrong in both directions: prettier was reported clean while
+ *  `format:check` was red, hygiene imprints reached CI that `hygiene:check`
+ *  would have caught locally — and children ran the whole suite and the whole
+ *  typecheck on the shared resident, minutes each call, time-sliced against
+ *  every other run. So the gates are the changed-set forms, the full runs are
+ *  said to be CI's alone in the same breath, and each gate is a receipt — the
+ *  exit line goes into the PR description's validation table as the row's proof
+ *  (the handoff has no verified list; parseHandoff carries deviations, followUps,
+ *  unproven and landed), and a gate the child could not run goes under the
+ *  handoff's unproven list, never claimed clean. The tests compare against the
+ *  pull request's own base — `origin/<base>` — which the render substitutes
+ *  from the rebase's `onto` when the contract knows it. */
+/** The changed-set test command as the contract renders it before the base is
+ *  known; the render substitutes the unit's base for `<base>` (`renderFirstInstruction`). */
+export const CHANGED_SET_TEST_PLACEHOLDER = "`npx vitest run --changed origin/<base>`";
+
+export const FAST_GATES_BEFORE_PUSH =
+  "The fast gates, before every push — each scoped to the changed set, never the whole project: " +
+  `${CHANGED_SET_TEST_PLACEHOLDER} (the pull request's base; or the touched test files), ` +
+  "`tsc --noEmit -p` the touched tsconfig under `NODE_OPTIONS=--max-old-space-size=6144`, " +
+  "`npx prettier --check` on the changed files, `npm run hygiene:check` and `npm run specs:check` — " +
+  "then your judgement on what else this change needs, not a longer checklist. Every CI pipeline runs the " +
+  "tests, the types, the formatting and the full verification on your push, so you never run them again: " +
+  "you validate and fix your own change before pushing, at the changed-set scope. Passing the full test suite " +
+  "and the full typecheck is NOT part of your criteria: CI is that gate and the only place they run — on a " +
+  "shared resident they cost minutes that every other run pays for. " +
+  "Paste each command's exit line into the PR description's validation table as the row's proof; a gate you " +
+  "could not run goes under the handoff's unproven list and is never claimed clean.";
+
 function renderFirstInstruction(rebase: ChildContract["rebase"]): string {
   const branch = rebase.branch ? `\`${rebase.branch}\`` : "the unit's branch";
   const onto = rebase.onto ? `\`${rebase.onto}\`` : "the merged parent";
+  // the changed-set test run compares against the unit's own base, which the
+  // contract knows as the rebase target; unknown, the placeholder stands
+  // split/join, never String.replace: a `$` in a branch name is literal text here
+  const gates = rebase.onto
+    ? FAST_GATES_BEFORE_PUSH.split(`${CHANGED_SET_TEST_PLACEHOLDER} (the pull request's base; or`).join(
+        `\`npx vitest run --changed origin/${rebase.onto}\` (or`,
+      )
+    : FAST_GATES_BEFORE_PUSH;
   return (
     `Rebase ${branch} onto ${onto} before any other work — the parent unit has merged and the base has moved; ` +
     `the only writes are your own on that branch. A conflict ends the unit: report it as the handoff and stop. ` +
-    `Push the branch as soon as the change exists and its cheapest proving checks pass — before the project's ` +
-    `full verification, which runs after that push with any fix as a further commit; an unpushed tree does not ` +
-    `survive the run's end. Right before each push, fetch ${onto} again and rebase once more if it moved while ` +
-    `you worked, so the pull request is not born conflicting. At the wind-down note, commit and push what compiles, ` +
-    `say what does not, then answer. ${TIMEOUT_ON_LONG_COMMANDS}`
+    `Push the branch as soon as the change exists and the fast gates pass — the project's full verification ` +
+    `is CI's gate, run there after the push with any fix as a further commit; an unpushed tree does not ` +
+    `survive the run's end. ${gates} Right before each push, fetch ${onto} again and rebase ` +
+    `once more if it moved while you worked, so the pull request is not born conflicting. At the wind-down note, ` +
+    `commit and push what compiles, say what does not, then answer. ${TIMEOUT_ON_LONG_COMMANDS}`
   );
 }