@coreplane/switchboard 1.252.0 → 1.253.0

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/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

@@ -696,7 +696,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 +822,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 +920,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
@@ -1117,7 +1165,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 +1286,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
       ? {
@@ -2242,5 +2341,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>;