@coreplane/switchboard 1.251.0 → 1.253.0

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

@@ -0,0 +1,237 @@
+import { FRICTION_CATEGORIES, type CategoryTotals, type FrictionCategory } from "./runFriction.js";
+import { llmUsdOfUsage, type ModelPriceTable } from "./modelPricing.js";
+import { emptyUsage, UNKNOWN_AGENT } from "./runUsage.js";
+import { utf8ByteLength, type RunRecord } from "./runRecord.js";
+
+// Run metrics (docs/reference/specs/run-metrics.md; docs/decisions/0063-every-finished-run-writes-one-metrics-point-and-a-metrics-page-reads-the-trend.md):
+// one flat point per finished run, written to a Workers Analytics Engine
+// dataset beside the record's commit. This file is the point's contract, shared
+// by both sides of the wire — the bot's store/ledger clients compute the point
+// (`pointOf`), the state Worker validates it (`isRunMetricsPoint`) and decides
+// whether the row turned final (`pointTurnsFinal`) — so it is node-free like
+// `runRecord.ts`: no Node built-ins, no I/O, no clock.
+
+/** A point as the platform's `writeDataPoint` takes it: one index (the
+ *  sampling key), positional string blobs and positional doubles. */
+export interface RunMetricsPoint {
+  indexes: [string];
+  blobs: string[];
+  doubles: number[];
+}
+
+/** The platform's byte cap per blob (and per index); `pointOf` truncates. */
+export const MAX_POINT_BLOB_BYTES = 96;
+
+/** The point's schema word, `blob1` — bump it when a position changes meaning. */
+export const POINT_SCHEMA = "1";
+
+const BLOB_NAMES = [
+  "schema",
+  "agent",
+  "preset",
+  "model",
+  "status",
+  "failure kind",
+  "dominant friction",
+  "channel",
+  "repository",
+  "machine class",
+  "route class",
+  "reply",
+  "lineage",
+  "requester",
+  "identity",
+  "run id",
+] as const;
+
+const DOUBLE_NAMES = [
+  "wall",
+  "getting ready",
+  "thinking",
+  "tools",
+  "finishing up",
+  "overhead",
+  "not recorded",
+  "not loaded",
+  "turns",
+  "input tokens",
+  "output tokens",
+  "cache read tokens",
+  "cache write tokens",
+  "dollars",
+  "steps",
+  "tool calls",
+  "events",
+  "unpriced tokens",
+  "minutes",
+  "finished at",
+] as const;
+
+export type PointBlobName = (typeof BLOB_NAMES)[number];
+export type PointDoubleName = (typeof DOUBLE_NAMES)[number];
+
+/** The ONE ordered table naming every position once: `blobs[i]` is the meaning
+ *  of `blob<i+1>`, `doubles[i]` of `double<i+1>`, `index[0]` of `index1`. The
+ *  writer builds from it (`pointOf` fills a `Record<name, value>` and maps it
+ *  through this order, so a position added here without a value fails to
+ *  compile) and the reader's SQL aliases from it — a query names a column
+ *  through its name here, never a magic number. */
+export const POINT_COLUMNS = {
+  index: ["agent"] as const,
+  blobs: BLOB_NAMES,
+  doubles: DOUBLE_NAMES,
+};
+
+/** The 1-based platform column of a named blob: `"status"` → `"blob5"`. */
+export function blobColumn(name: PointBlobName): string {
+  return `blob${POINT_COLUMNS.blobs.indexOf(name) + 1}`;
+}
+
+/** The 1-based platform column of a named double: `"dollars"` → `"double14"`. */
+export function doubleColumn(name: PointDoubleName): string {
+  return `double${POINT_COLUMNS.doubles.indexOf(name) + 1}`;
+}
+
+/** A point's blob by its `POINT_COLUMNS` name — the tests' and readers' accessor. */
+export function blobOf(point: RunMetricsPoint, name: PointBlobName): string {
+  return point.blobs[POINT_COLUMNS.blobs.indexOf(name)];
+}
+
+/** A point's double by its `POINT_COLUMNS` name. */
+export function doubleOf(point: RunMetricsPoint, name: PointDoubleName): number {
+  return point.doubles[POINT_COLUMNS.doubles.indexOf(name)];
+}
+
+/** Truncate to the platform's per-blob byte cap (multi-byte safe: cut by
+ *  characters until the UTF-8 size fits — blob values are ids and enum words,
+ *  so the loop is theoretical). */
+function capBlob(s: string): string {
+  let out = s;
+  while (utf8ByteLength(out) > MAX_POINT_BLOB_BYTES) out = out.slice(0, -1);
+  return out;
+}
+
+const isFinite_ = (v: unknown): v is number => typeof v === "number" && Number.isFinite(v);
+
+/** The dominant friction category of a stored diagnosis: the `FrictionCategory`
+ *  with the largest `durationMs` among those with a count (first in
+ *  `FRICTION_CATEGORIES` order on a tie); empty when no category has a count. */
+export function dominantFriction(byCategory: Partial<Record<FrictionCategory, CategoryTotals>>): FrictionCategory | "" {
+  let best: FrictionCategory | "" = "";
+  let bestMs = -1;
+  for (const c of FRICTION_CATEGORIES) {
+    const t = byCategory[c];
+    if (!t || t.count <= 0) continue;
+    if (t.durationMs > bestMs) {
+      best = c;
+      bestMs = t.durationMs;
+    }
+  }
+  return best;
+}
+
+/**
+ * The record's metrics point, or `undefined` for a record still in its
+ * provisional window (`provisional: true`) — and for nothing else: a final
+ * record whose `finishedAt` equals its `startedAt` is counted with a zero
+ * wall. Reads ONLY the record's typed dimensions and counters — never
+ * `activity`, `label`, `events`, `verdict`, `handoff`, `dispositions` or
+ * `diagnosis.verdict` — so no free text reaches the dataset. Dollars are
+ * priced at finish through the same table `RunsService` prices reads with
+ * (`llmUsdOfUsage`); an unpriced model's tokens land in `unpriced tokens`,
+ * never in `dollars` as $0.
+ */
+export function pointOf(record: RunRecord, prices?: ModelPriceTable): RunMetricsPoint | undefined {
+  if (record.provisional === true) return undefined;
+  const usage = record.usage ?? emptyUsage();
+  const priced = llmUsdOfUsage(usage, prices);
+  let inputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadTokens = 0;
+  let cacheWriteTokens = 0;
+  for (const m of Object.values(usage.byModel)) {
+    inputTokens += m.inputTokens;
+    outputTokens += m.outputTokens;
+    cacheReadTokens += m.cacheReadTokens;
+    cacheWriteTokens += m.cacheWriteTokens;
+  }
+  const shape = record.diagnosis.shape;
+  const blobs: Record<PointBlobName, string> = {
+    schema: POINT_SCHEMA,
+    agent: record.agent ?? "",
+    preset: record.profile?.preset ?? "",
+    model: record.model ?? "",
+    status: record.status,
+    "failure kind": record.failure?.kind ?? "",
+    "dominant friction": dominantFriction(record.diagnosis.byCategory),
+    channel: record.channelId,
+    repository: record.repo ?? "",
+    "machine class": record.profile?.machine ?? "",
+    "route class": record.route !== undefined ? "routed" : "chosen",
+    reply: record.replyOk === true ? "ok" : record.replyOk === false ? "failed" : "none",
+    lineage: record.parentRunId !== undefined ? "child" : "root",
+    requester: record.userId,
+    identity: record.profile?.identity ?? "",
+    "run id": record.id,
+  };
+  const doubles: Record<PointDoubleName, number> = {
+    wall: record.finishedAt - (record.receivedAt ?? record.startedAt),
+    "getting ready": shape?.gettingReadyMs ?? 0,
+    thinking: shape?.thinkingMs ?? 0,
+    tools: shape?.toolsMs ?? 0,
+    "finishing up": shape?.finishingUpMs ?? 0,
+    overhead: shape?.overheadMs ?? 0,
+    "not recorded": shape?.notRecordedMs ?? 0,
+    "not loaded": shape?.notLoadedMs ?? 0,
+    turns: usage.turns,
+    "input tokens": inputTokens,
+    "output tokens": outputTokens,
+    "cache read tokens": cacheReadTokens,
+    "cache write tokens": cacheWriteTokens,
+    dollars: priced.usd,
+    steps: record.stepCount ?? 0,
+    "tool calls": isFinite_(record.diagnosis.toolCalls) ? record.diagnosis.toolCalls : 0,
+    events: record.eventCount,
+    "unpriced tokens": priced.unpricedTokens,
+    minutes: record.profile?.minutes ?? 0,
+    "finished at": record.finishedAt,
+  };
+  return {
+    indexes: [capBlob(record.agent ?? UNKNOWN_AGENT)],
+    blobs: POINT_COLUMNS.blobs.map((n) => capBlob(blobs[n])),
+    doubles: POINT_COLUMNS.doubles.map((n) => doubles[n]),
+  };
+}
+
+/** Structural check on a point from outside the process (the `/runs/put` and
+ *  `/runs/finish` bodies): exactly one index, exactly `POINT_COLUMNS.blobs.length`
+ *  strings each at most `MAX_POINT_BLOB_BYTES` bytes, exactly
+ *  `POINT_COLUMNS.doubles.length` finite numbers — and nothing else. */
+export function isRunMetricsPoint(v: unknown): v is RunMetricsPoint {
+  if (typeof v !== "object" || v === null) return false;
+  const p = v as Record<string, unknown>;
+  if (!Array.isArray(p.indexes) || p.indexes.length !== 1) return false;
+  const index = p.indexes[0];
+  if (typeof index !== "string" || utf8ByteLength(index) > MAX_POINT_BLOB_BYTES) return false;
+  if (!Array.isArray(p.blobs) || p.blobs.length !== POINT_COLUMNS.blobs.length) return false;
+  if (!p.blobs.every((b) => typeof b === "string" && utf8ByteLength(b) <= MAX_POINT_BLOB_BYTES)) return false;
+  if (!Array.isArray(p.doubles) || p.doubles.length !== POINT_COLUMNS.doubles.length) return false;
+  return p.doubles.every(isFinite_);
+}
+
+/**
+ * The emission rule's one question, answered inside the store's transaction:
+ * did this write turn the run's row final? True exactly when the stored record
+ * is final (`provisional` absent) and the existing row was absent or itself
+ * provisional. There is deliberately no `finishedAt > startedAt` term: a plain
+ * `put` of an `interrupted` record over no row is a run counted once, and a
+ * final rewrite over a final row (the review artifact, an identical retry) is
+ * false however its stamps compare.
+ */
+export function pointTurnsFinal(
+  existing: { provisional?: boolean } | undefined,
+  stored: Pick<RunRecord, "provisional">,
+): boolean {
+  if (stored.provisional === true) return false;
+  return existing === undefined || existing.provisional === true;
+}

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

@@ -184,6 +184,13 @@ export interface RunRecord {
    *  reading the events. Absent for a preset a person, a scope or the default
    *  chose, and on records written before it existed. */
   route?: RunRouteDecision;
+  /** The operator's shadow decision beside the routed request (record 0057;
+   *  the one-door plan's operator unit; run-history item 60): what the operator
+   *  bound for the same event, redacted like the receipt — never the message
+   *  text — with the intake gate's verdict when the gate was present. The
+   *  agreement row reads it from here; it follows the record's retention.
+   *  Absent under `routing.operator: off` and on records written before it. */
+  operator?: RunOperatorDecision;
   /** The effective profile the run was admitted with (docs/decisions/0026-capability-profiles-and-request-routing.md):
    *  the preset, its machine class and identity, the minutes it ran on and —
    *  when a boundary clipped the budget — the scope that did, so a reader can
@@ -404,6 +411,45 @@ export function routeOfEvents(events: readonly RunEvent[]): RunRouteDecision | u
   };
 }
 
+/** The operator's decision as a record carries it — the `operator` event's
+ *  fields less the stream bookkeeping (record 0057; run-history item 60). */
+export interface RunOperatorDecision {
+  mode: "shadow" | "on";
+  outcome: "binds" | "question" | "refusal";
+  reason: string;
+  binds?: { line: string; reason: string }[];
+  question?: string;
+  /** A question's proposed line — what the next turn's "yes" binds. */
+  proposal?: string;
+  refusalCause?: string;
+  refusalText?: string;
+  intake?: { verdict: string; reason: string };
+  latencyMs?: number;
+  outputTokens?: number;
+}
+
+/** The operator's decision the run's events carry: the one `operator` event
+ *  (record 0057), whatever the run's own agent source — the shadow decision
+ *  rides routed and unrouted runs alike, or there would be no disagreement to
+ *  count. Undefined on a run the operator never saw. */
+export function operatorOfEvents(events: readonly RunEvent[]): RunOperatorDecision | undefined {
+  const e = events.find((e) => e.type === "operator");
+  if (e?.type !== "operator") return undefined;
+  return {
+    mode: e.mode,
+    outcome: e.outcome,
+    reason: e.reason,
+    ...(e.binds ? { binds: e.binds.map((b) => ({ line: b.line, reason: b.reason })) } : {}),
+    ...(e.question !== undefined ? { question: e.question } : {}),
+    ...(e.proposal !== undefined ? { proposal: e.proposal } : {}),
+    ...(e.refusalCause !== undefined ? { refusalCause: e.refusalCause } : {}),
+    ...(e.refusalText !== undefined ? { refusalText: e.refusalText } : {}),
+    ...(e.intake ? { intake: { verdict: e.intake.verdict, reason: e.intake.reason } } : {}),
+    ...(e.latencyMs !== undefined ? { latencyMs: e.latencyMs } : {}),
+    ...(e.outputTokens !== undefined ? { outputTokens: e.outputTokens } : {}),
+  };
+}
+
 function isRunRouteShape(v: unknown): v is RunRouteDecision {
   if (typeof v !== "object" || v === null) return false;
   const r = v as Record<string, unknown>;

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,28 +439,48 @@ 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
- *  (agent-ship item 13; agent-coding item 9). "Its cheapest proving checks"
- *  left the choice to the child, and children chose wrong: prettier was
- *  reported clean while `format:check` was red, and hygiene imprints reached
- *  CI that `hygiene:check` would have caught locally. Naming the commands
- *  makes each gate a receipt — the exit line goes into the handoff's verified
- *  list, and a gate the child could not run is unproven, never claimed clean. */
+/** 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 test gate is the touched
+ *  files by name, never a changed-set or directory run. */
+/** The test command the contract hands a child: the touched files by name, once.
+ *  Never `--changed`: against a base that moves, it selects most of the suite, and on the
+ *  shared resident that is the memory incident the coding contract exists to prevent. */
+export const TOUCHED_TESTS_COMMAND = "`npx vitest run` on the test files you touched, by name,";
+
 export const FAST_GATES_BEFORE_PUSH =
-  "The fast gates, before every push: `npx prettier --check` on the changed files, `npm run hygiene:check`, " +
-  "`npm run specs:check`, and `tsc --noEmit` on the touched project under `NODE_OPTIONS=--max-old-space-size=6144`. " +
-  "Paste each command's exit line into the handoff's verified list; a gate you could not run goes under unproven " +
-  "and is never claimed clean.";
+  "The fast gates, before every push — each scoped to the changed set, never the whole project: " +
+  `${TOUCHED_TESTS_COMMAND} once (never \`--changed\`, never a directory: on a moving base that is most of the suite), ` +
+  "`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";
+  const gates = 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 the fast gates 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. ${FAST_GATES_BEFORE_PUSH} Right before each push, fetch ${onto} again and rebase ` +
+    `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}`
   );