@coreplane/switchboard 1.252.0 → 1.254.0

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

@@ -14,6 +14,7 @@ import {
   type ReviewVerdict,
 } from "./reviewVerdict.js";
 import { IDEMPOTENCY_KEY_PATTERN, INSTANCE_ID_PATTERN } from "./coordinator/contract.js";
+import { isPipelineSummaryShape, type PipelineSummary } from "./pipelineStanding.js";
 import {
   FRICTION_CATEGORIES,
   type CategoryTotals,
@@ -184,6 +185,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
@@ -208,6 +216,15 @@ export interface RunRecord {
    *  coordinator tag. Present only on a ship run whose hand-off succeeded;
    *  a record written before the event has none. */
   instanceId?: string;
+  /** The pipeline's standing (record 0065): the fold of the run's own
+   *  `ship_round`/`ship_unit` events, summarized at the seal so the stored row
+   *  reads it without the events. Present only on a run that published ship
+   *  facts; a record written before the field carries none and reads as today. */
+  pipeline?: PipelineSummary;
+  /** A ship pipeline's parent run (record 0060; record 0065): `RunMeta.hosted`
+   *  carried onto the record at the seal, so a history reader draws the run as
+   *  a pipeline. Absent on every other run and on older records. */
+  hosted?: true;
   /** Where the run's conversation started (item 52): `channel` — its own
    *  thread's history, as for every run a person, a schedule or a coordinator
    *  started — or `parent` — a spawned child seeded from its parent's text
@@ -404,6 +421,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>;
@@ -939,6 +995,11 @@ export function isRunRecord(v: unknown): v is RunRecord {
   // The instance a ship run's hand-off created (record 0051 R2; item 2).
   if (r.instanceId !== undefined && (typeof r.instanceId !== "string" || !INSTANCE_ID_PATTERN.test(r.instanceId)))
     return false;
+  // The pipeline's standing and the hosted marker (record 0065): the summary
+  // is checked for shape — an older reader accepts a newer record — and the
+  // marker, like `provisional`, is the literal `true` or absent.
+  if (r.pipeline !== undefined && !isPipelineSummaryShape(r.pipeline)) return false;
+  if (r.hosted !== undefined && r.hosted !== true) return false;
   if (typeof r.channelId !== "string" || typeof r.userId !== "string" || typeof r.threadKey !== "string") return false;
   if (r.relayedBy !== undefined && typeof r.relayedBy !== "string") return false;
   if (r.authenticatedAs !== undefined && typeof r.authenticatedAs !== "string") return false;

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

@@ -31,6 +31,11 @@ export interface ModelUsage {
    *  a record whose turns predate the meter row (the price table then prices
    *  the tokens, costs.md item 4b). */
   usd?: number | null;
+  /** The model's BYOK aggregator fees summed from its turns' `feeUsd` attrs —
+   *  the share of `usd` that is the aggregator's own charge, what the biller's
+   *  invoice tie-out compares against its `usage` column (costs.md item 4d).
+   *  Absent when no turn carried one. */
+  feeUsd?: number;
   /** 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[];
@@ -59,12 +64,24 @@ 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> }>();
+  // the token-counting turns that lack a figure are counted directly
+  // (`unpricedTokenTurns`), so a priced zero-token turn can never stand in for
+  // an unpriced 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;
+      feeUsd: number;
+      feeTurns: number;
+      pricedTurns: number;
+      unpricedTokenTurns: 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>;
@@ -87,19 +104,31 @@ export function usageOfEvents(events: readonly RunEvent[]): RunUsage {
     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;
+    const p = priced.get(model) ?? {
+      usd: 0,
+      feeUsd: 0,
+      feeTurns: 0,
+      pricedTurns: 0,
+      unpricedTokenTurns: 0,
+      sources: new Set<string>(),
+    };
+    if (counted > 0 && !hasUsd) p.unpricedTokenTurns += 1;
     if (hasUsd) {
       p.usd += attrs.usd as number;
       p.pricedTurns += 1;
     }
+    if (typeof attrs.feeUsd === "number" && Number.isFinite(attrs.feeUsd)) {
+      p.feeUsd += attrs.feeUsd;
+      p.feeTurns += 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;
+    m.usd = p.unpricedTokenTurns > 0 ? null : p.usd;
+    if (p.feeTurns > 0) m.feeUsd = p.feeUsd;
     if (p.sources.size > 0) m.priceSources = [...p.sources].sort();
   }
   return usage;
@@ -128,6 +157,8 @@ export function addUsage(a: RunUsage, b: RunUsage): RunUsage {
       const usd = foldUsd(acc.usd, m.usd);
       if (usd === undefined) delete acc.usd;
       else acc.usd = usd;
+      // A side without a fee spent none — a fee of nothing, never an unknown.
+      if (acc.feeUsd !== undefined || m.feeUsd !== undefined) acc.feeUsd = (acc.feeUsd ?? 0) + (m.feeUsd ?? 0);
       const sources = new Set([...(acc.priceSources ?? []), ...(m.priceSources ?? [])]);
       if (sources.size > 0) acc.priceSources = [...sources].sort();
     }
@@ -145,6 +176,7 @@ const isModelUsage = (v: unknown): v is ModelUsage => {
   )
     return false;
   if (m.usd !== undefined && m.usd !== null && typeof m.usd !== "number") return false;
+  if (m.feeUsd !== undefined && typeof m.feeUsd !== "number") return false;
   return (
     m.priceSources === undefined ||
     (Array.isArray(m.priceSources) && m.priceSources.every((s) => typeof s === "string"))

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

@@ -451,16 +451,16 @@ export const TIMEOUT_ON_LONG_COMMANDS =
  *  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>`";
+ *  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 — each scoped to the changed set, never the whole project: " +
-  `${CHANGED_SET_TEST_PLACEHOLDER} (the pull request's base; or the touched test files), ` +
+  `${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 " +
@@ -474,14 +474,7 @@ export const FAST_GATES_BEFORE_PUSH =
 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;
+  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. ` +

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

@@ -461,6 +461,12 @@ export type CoordinatorAction =
   | {
       type: "pr-check";
       step: string;
+      /** The unit-start's pre-check (issue 1689): the bot reads the entry facts
+       *  beside the listing — the branch's own tip, whether its approval
+       *  stands at the head, and the checks there — so a re-issued plan's
+       *  unit resumes at review, or at the merge decision, never at coding
+       *  over an already-shipped pull request. */
+      entry?: true;
       /** Set after a coding child died: the bot opens the pull request from the
        *  pushed branch itself (title from the unit, body from this run's
        *  submitted description when the record holds one) instead of answering
@@ -545,6 +551,15 @@ export type PrCheck =
       prNumber: number;
       url: string;
       headSha?: string;
+      /** The unit branch's own tip, read beside the listing on the entry check
+       *  (issue 1689): the listing's `headSha` can lag a force-push, so the
+       *  machine resumes at review only when the pull request heads the
+       *  branch's actual tip — a head behind the branch is round 0's. */
+      branchHead?: string;
+      /** Whether an approving review by the bot stands at the head (the entry
+       *  check, issue 1689): with green checks the attempt resumes straight at
+       *  the merge decision instead of a review round. */
+      approved?: boolean;
       autoMergeEnabled?: boolean;
       /** The check runs at the head, when the read asked for them (the ending's facts). */
       checks?: CommitChecksFacts;
@@ -696,7 +711,46 @@ export type UnitEnding =
     }
   | { kind: "no_verdict"; round: RoundRef; reviewRounds: number; finalReply?: string }
   | { kind: "interrupted"; round: RoundRef; runId: string; reviewRounds: number }
-  | { kind: "refused"; refusal: string; message?: string; round: RoundRef; reviewRounds: number };
+  | { kind: "refused"; refusal: string; message?: string; round: RoundRef; reviewRounds: number }
+  /** The unit idles instead of ending (record 0051): with the resolved
+   *  `ship.idleDays` above zero, `end()` wraps an idling kind — every kind but
+   *  the four ended ones (`merged`, `already_landed`, `merge_ready`,
+   *  `refused`) — in this ending: the old kind as `why`, the old kind's
+   *  report unchanged, and what a continuation needs (the renewals the grant
+   *  still holds — unspent: the wake spends one, this plan's fifth unit — the
+   *  head to continue from, the last coding child's run, the spend and its
+   *  handoff). `runId` is absent when the pipeline capped before any coding
+   *  child ran. */
+  | {
+      kind: "idle";
+      why: IdleWhy;
+      /** The ending the idle stands in for, whole: its report is rendered per
+       *  copy at that copy's level — the row's and the board's in full, the
+       *  thread's at the request's verbosity — never once at mapping time. */
+      idled: Exclude<UnitEnding, { kind: "idle" }>;
+      renewalsLeft: number;
+      from?: string;
+      runId?: string;
+      spendUsd: number | null;
+      handoff?: Handoff;
+      round?: RoundRef;
+      reviewRounds: number;
+    };
+
+/** The kinds that idle: every ending but the four ended ones — the unit is
+ *  unfinished (a cap, a stop, an abort, a refused merge, a segment's end) and
+ *  a reply could continue it. `merged`, `already_landed`, `merge_ready` and
+ *  `refused` never idle: the first two are done, merge-ready waits only for a
+ *  person's merge, and a refused child would be refused again. */
+export type IdleWhy = Exclude<UnitEnding["kind"], "idle" | "merged" | "already_landed" | "merge_ready" | "refused">;
+
+const NEVER_IDLES: ReadonlySet<UnitEnding["kind"]> = new Set([
+  "idle",
+  "merged",
+  "already_landed",
+  "merge_ready",
+  "refused",
+]);
 
 /** What a transition tells the driver beyond the next action: a round boundary
  *  the card draws (`shipRoundHeader`) and the run stream records, and the end. */
@@ -783,6 +837,11 @@ export interface UnitPipelineInput {
    *  `plan` with an id and no `path` — whose unit runs in the requesting
    *  thread and is re-issued with the request's own text, never a plan path. */
   generated: boolean;
+  /** The idle flag (record 0051; agent-ship item 8): `ship.idleDays` as the
+   *  ship fork resolved it onto the instance — above zero, an idling kind ends
+   *  `idle` instead; zero or absent is today's behavior byte for byte. The
+   *  wait itself lands with this plan's fifth unit. */
+  idleDays?: number;
   /** Resume at review: an open pull request of ship's own the requester named. */
   resume?: { pr: number; headSha?: string; url?: string };
   /** The head the previous attempt's coding child last pushed (a
@@ -876,6 +935,10 @@ export interface UnitPipelineState {
   readonly findingsRunByRound: Readonly<Record<number, string>>;
   /** The last coding run (round 0's child or a findings step's): its record carries the unit's handoff. */
   readonly lastCodingRunId?: string;
+  /** The head the last coding child left the branch at, and its handoff — the
+   *  continuation facts an `idle` ending carries (record 0051). */
+  readonly lastChildHead?: string;
+  readonly lastCodingHandoff?: Handoff;
   /** How the budget went so far, accrued as each answer moves the clock. */
   readonly spentMs: ShipBudgetSpent;
   /** The session's dollars so far: the input's from earlier segments plus each
@@ -1033,7 +1096,7 @@ export function nextAction(s: UnitPipelineState): CoordinatorAction {
   const p = s.phase;
   switch (p.at) {
     case "pre-check":
-      return { type: "pr-check", step: `${unit}/pr-check` };
+      return { type: "pr-check", step: `${unit}/pr-check`, entry: true };
     case "branch":
       return { type: "branch", step: `${unit}/branch`, branch: s.input.unit.branch, from: s.input.base };
     case "spawn": {
@@ -1117,7 +1180,55 @@ function addSpend(sum: number | null, cost: number | null | undefined): number |
 }
 
 function end(s: UnitPipelineState, ending: UnitEnding, notes: CoordinatorNote[] = []): Transition {
-  return { state: { ...s, phase: ENDED, ending }, notes: [...notes, { type: "ended", ending }] };
+  const idled = idleEnding(s, ending);
+  const final = idled ?? ending;
+  return { state: { ...s, phase: ENDED, ending: final }, notes: [...notes, { type: "ended", ending: final }] };
+}
+
+/** The idle mapping (record 0051; agent-ship item 8): with the input's
+ *  `idleDays` above zero an idling kind ends `idle` — the old kind as `why`,
+ *  the old ending itself for the report, and the continuation facts off the state
+ *  (a `continued` ending's own where it carries them). At zero, undefined:
+ *  every ending is byte for byte today's. The round notes keep the old kind's
+ *  outcome — the row and the card say what happened. */
+function idleEnding(s: UnitPipelineState, ending: UnitEnding): Extract<UnitEnding, { kind: "idle" }> | undefined {
+  if ((s.input.idleDays ?? 0) <= 0) return undefined;
+  if (NEVER_IDLES.has(ending.kind)) return undefined;
+  const old = ending as Exclude<UnitEnding, { kind: "idle" | "merged" | "already_landed" | "merge_ready" | "refused" }>;
+  const grant = s.input.grant ?? DEFAULT_GRANT;
+  // Unspent: an idle spends no renewal — the wake's segment does (this plan's
+  // fifth unit) — so the row says what the grant still holds.
+  const renewalsLeft = Math.max(0, grant.renewals - (s.input.session?.renewalsSpent ?? 0));
+  // The head to continue from: a segment's own; a review_pending's reviewed
+  // head — the pull request's, known even when the coding record carried none,
+  // so the re-issue's resume-at-review fact survives the idle; else the last
+  // coding child's recorded head.
+  const from =
+    old.kind === "continued"
+      ? old.from
+      : old.kind === "review_pending"
+        ? (old.headSha ?? s.lastChildHead)
+        : s.lastChildHead;
+  // The last coding child's run: a segment's own, a dead coding child's own —
+  // a review child that died names nothing here, the coding run before it does.
+  const runId =
+    old.kind === "continued" || (old.kind === "interrupted" && old.round.kind !== "review")
+      ? old.runId
+      : s.lastCodingRunId;
+  const handoff = old.kind === "continued" ? old.handoff : s.lastCodingHandoff;
+  const round = "round" in old ? old.round : undefined;
+  return {
+    kind: "idle",
+    why: old.kind,
+    idled: old,
+    renewalsLeft,
+    ...(from !== undefined ? { from } : {}),
+    ...(runId !== undefined ? { runId } : {}),
+    spendUsd: s.spendUsd,
+    ...(handoff !== undefined ? { handoff } : {}),
+    ...(round !== undefined ? { round } : {}),
+    reviewRounds: s.reviewRounds,
+  };
 }
 
 /** A gated finding as the gate note names it: `F1 (minor)`. */
@@ -1190,6 +1301,9 @@ function settleCoding(
   let next: UnitPipelineState = {
     ...s,
     spendUsd: addSpend(s.spendUsd, facts.costUsd),
+    // The continuation facts an idle ending reads off the state (record 0051).
+    ...(facts.headSha !== undefined ? { lastChildHead: facts.headSha } : {}),
+    ...(facts.handoffLists !== undefined ? { lastCodingHandoff: facts.handoffLists } : {}),
     ...(facts.pr !== undefined ? { pr: { number: facts.pr.number, url: facts.pr.url } } : {}),
     ...(round.kind === "findings" && facts.dispositions !== undefined
       ? {
@@ -1760,19 +1874,40 @@ export function applyReturn(s: UnitPipelineState, ret: StepReturn): Transition {
       // by the coding child and adopted at the round's own pr-check.
       const r = ret as Extract<StepReturn, { type: "pr-check" }>;
       if (r.pr.state === "merged") return foundMerged(clocked, r.pr);
-      // The open pull request still heads at the child's own last push (the
-      // previous attempt ended `review_pending`): nothing to code, so the
-      // attempt adopts it and starts at the review round — never a fresh
-      // coding round on an already-shipped pull request.
+      // The open pull request still heads the branch — its head is the
+      // branch's own tip (the entry facts, issue 1689) or the child's own last
+      // push (the previous attempt ended `review_pending`, the row's
+      // `lastPush`): nothing to code, so the attempt adopts it and starts at
+      // the review round — never a fresh coding round on an already-shipped
+      // pull request. Approved at that very head with green checks, there is
+      // nothing to review either: the attempt resumes straight at the merge
+      // decision — `merge_ready` for a person, the merge door under
+      // `merge: runner`, which re-verifies the approval and the checks itself.
       if (r.pr.state === "open") {
         const head = normalizeHead(r.pr.headSha);
+        const branchHead = normalizeHead(r.pr.branchHead);
         const lastPush = normalizeHead(s.input.lastPush);
-        if (head !== undefined && lastPush !== undefined && sameCommit(head, lastPush))
-          return nextReview({
+        const atBranchHead = head !== undefined && branchHead !== undefined && sameCommit(head, branchHead);
+        const atLastPush = head !== undefined && lastPush !== undefined && sameCommit(head, lastPush);
+        if (atBranchHead || atLastPush) {
+          // The entry facts — the approval and the checks — were read at the
+          // branch's own tip when GitHub answered it (`branchHead`, the
+          // fresher read of the same head ref), else at the listing's sha.
+          // The resume pins the review — and the merge decision — at that
+          // same head, so the approved+green shortcut never fires at a stale
+          // listing sha the facts do not describe.
+          const entryHead = branchHead ?? head;
+          const adopted: UnitPipelineState = {
             ...clocked,
             pr: { number: r.pr.prNumber, url: r.pr.url },
-            lastReviewHead: head,
-          });
+            lastReviewHead: entryHead,
+          };
+          const checks = r.pr.checks;
+          const green =
+            checks !== undefined && checks.total > 0 && checks.failed.length === 0 && checks.pending.length === 0;
+          if (r.pr.approved === true && green) return approveOutcome(adopted, []);
+          return nextReview(adopted);
+        }
       }
       return { state: { ...clocked, phase: { at: "branch" } }, notes: [] };
     }
@@ -2242,5 +2377,9 @@ export function renderUnitReport(
         `🚫 The ${presetOf(e.round.kind)} child of round ${e.round.index} was refused by the authorize stage (${e.refusal})${e.message ? `: ${e.message}` : ""} — every child is authorized as the requesting user, so the pipeline ends here.`,
         reissue,
       ]);
+    case "idle":
+      // The old kind's sentence at this copy's level — the report is unchanged
+      // by the idle at every verbosity (record 0051).
+      return renderUnitReport({ ...s, ending: e.idled }, facts, verbosity);
   }
 }

package/dist/assets/src/deploy/profile.ts

@@ -100,6 +100,22 @@ export const profileSchema = z.object({
         .regex(/^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/, "an R2 bucket name: 3–63 lowercase letters, digits and hyphens"),
     })
     .optional(),
+  /** The run-metrics dataset (docs/reference/specs/run-metrics.md item 6), when the installation
+   *  writes points: the state Worker's template binds it as `RUN_METRICS` with the name beside it
+   *  in `RUN_METRICS_DATASET`, and `deploy plan` names the binding on the memory step. Nothing is
+   *  created ahead of the deploy — the platform creates a dataset on first write. The bot's runtime
+   *  config (`metrics.dataset`) must name the same dataset; the two are held together by the bot's
+   *  boot warning, not by the profile. Analytics Engine's own dataset-name rules. */
+  metrics: z
+    .object({
+      dataset: z
+        .string()
+        .regex(
+          /^[A-Za-z_][A-Za-z0-9_]{0,63}$/,
+          "an Analytics Engine dataset name: 1–64 letters, digits and underscores, not starting with a digit",
+        ),
+    })
+    .optional(),
 });
 
 export type DeploymentProfile = z.infer<typeof profileSchema>;