@coreplane/switchboard 1.260.0 → 1.260.2

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

@@ -51,6 +51,7 @@ import {
   type PlanCursor,
   type UnitStatus,
   renderUnitReport,
+  reenterApprovedRebase,
   settleUnit,
   startUnit,
   type ChildFacts,
@@ -114,6 +115,7 @@ export type CoordinatorStepRoute =
   | "unit-wake"
   | "checks"
   | "merge"
+  | "rebase"
   | "finish";
 
 /** What a step stores: the bot's reply as the wire carried it — its status and
@@ -469,7 +471,7 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
  *  ask's answer carries `retried` instead: whether the re-run was dispatched,
  *  so the machine never waits on a head an undispatched re-run left unchanged. */
 function checksReturn(step: string, a: BotAnswer): StepReturn {
-  const { ok, checks, draft, retried, at } = a.body;
+  const { ok, checks, draft, retried, refired, at } = a.body;
   if (ok !== true) throw new UnreadableAnswer("checks", a, "ok");
   return {
     type: "checks",
@@ -479,6 +481,7 @@ function checksReturn(step: string, a: BotAnswer): StepReturn {
     // unit for the ready event instead of merging or ending without a cause.
     ...(draft === true ? { draft: true } : {}),
     ...(typeof retried === "boolean" ? { retried } : {}),
+    ...(typeof refired === "boolean" ? { refired } : {}),
     at,
   };
 }
@@ -489,7 +492,10 @@ const isRoundChecks = (v: unknown): v is RoundChecks =>
   Array.isArray(v.pending) &&
   v.pending.every((n: unknown) => typeof n === "string") &&
   Array.isArray(v.failed) &&
-  v.failed.every((f: unknown) => isRecord(f) && typeof f.name === "string" && typeof f.conclusion === "string");
+  v.failed.every((f: unknown) => isRecord(f) && typeof f.name === "string" && typeof f.conclusion === "string") &&
+  (v.required === undefined ||
+    (Array.isArray(v.required) && v.required.every((n: unknown) => typeof n === "string"))) &&
+  (v.expected === undefined || (Array.isArray(v.expected) && v.expected.every((n: unknown) => typeof n === "string")));
 
 function mergeReturn(step: string, a: BotAnswer): StepReturn {
   const { ok, outcome, by, sha, mergedAt, reason, at } = a.body;
@@ -501,13 +507,26 @@ function mergeReturn(step: string, a: BotAnswer): StepReturn {
     return { type: "merge", step, outcome: "merged", sha, at };
   if (
     ok === true &&
-    (outcome === "pending" || outcome === "refused" || outcome === "enqueued" || outcome === "removed") &&
+    (outcome === "pending" ||
+      outcome === "refused" ||
+      outcome === "conflict" ||
+      outcome === "enqueued" ||
+      outcome === "removed") &&
     typeof reason === "string"
   )
     return { type: "merge", step, outcome, reason, at };
   throw new UnreadableAnswer("merge", a, "outcome");
 }
 
+function rebaseReturn(step: string, a: BotAnswer): StepReturn {
+  const { ok, outcome, headSha, reason, at } = a.body;
+  if (ok === true && (outcome === "carried" || outcome === "changed") && typeof headSha === "string")
+    return { type: "rebase", step, outcome, headSha, at };
+  if (ok === true && (outcome === "conflict" || outcome === "refused") && typeof reason === "string")
+    return { type: "rebase", step, outcome, reason, at };
+  throw new UnreadableAnswer("rebase", a, "outcome");
+}
+
 // ---- the steps ----------------------------------------------------------------------------------------
 
 /** One bot call inside a step: a reply that is not the bot's answer and a
@@ -670,8 +689,8 @@ async function perform(
     }
     case "checks":
       // The round's checks step (record 0055): the bot reads the check runs at
-      // the reviewed head with the merge door's own reading — or, on a retry
-      // ask, re-runs the named failed checks' jobs first.
+      // the reviewed head with the merge door's own reading — or performs one
+      // of the step's bounded recovery effects first.
       return checksReturn(
         action.step,
         answerOf(
@@ -682,6 +701,7 @@ async function perform(
               prNumber: action.prNumber,
               headSha: action.headSha,
               ...(action.retry !== undefined ? { retry: action.retry } : {}),
+              ...(action.refire === true ? { refire: true } : {}),
             }),
           ),
         ),
@@ -701,6 +721,16 @@ async function perform(
           ),
         ),
       );
+    case "rebase":
+      return rebaseReturn(
+        action.step,
+        answerOf(
+          "rebase",
+          await step.do(action.step, STEP_CONFIG, () =>
+            call(bot, "rebase", { ...tag, prNumber: action.prNumber, headSha: action.headSha }),
+          ),
+        ),
+      );
   }
 }
 
@@ -833,7 +863,7 @@ async function runUnit(
   let notes = 0;
   let endedAt: number | undefined;
   try {
-    for (;;) {
+    pipeline: for (;;) {
       const action = nextAction(state);
       if (action.type === "end") return { ...action.ending, ...(endedAt !== undefined ? { endedAt } : {}) };
       // Keep the current round across its non-round phases (for example merge)
@@ -887,9 +917,9 @@ async function runUnit(
                   // The checks at the approved head (record 0055): the report's
                   // headline is a claim about them, never "merge-ready" over a red one.
                   ...(check.pr.checks !== undefined ? { checks: check.pr.checks } : {}),
-                  // The ready state beside them (agent-ship item 9): a conflicting
-                  // head, or one carrying an unsquashed fix-up commit, is reported
-                  // approved-but-not-merge-ready, never "merge-ready".
+                  // The ready state beside them (agent-ship item 9): a conflict
+                  // feeds the runner re-entry below, while an unsquashed fix-up
+                  // commit remains an approved-but-not-merge-ready report.
                   ...(check.pr.mergeableState !== undefined ? { mergeableState: check.pr.mergeableState } : {}),
                   ...(check.pr.fixupCommits !== undefined ? { fixupCommits: check.pr.fixupCommits } : {}),
                   // The base's merge-queue rule (issue 2011): the merge:person
@@ -902,6 +932,14 @@ async function runUnit(
               // the report simply omits the fact
             }
           }
+          // A person-merge pipeline used to publish this dirty state as its
+          // ending and hand the pull request to the sweep. It remains the
+          // owner instead: rung one runs now, and only a conflict buys a coding
+          // child under this run's remaining lease.
+          if (note.ending.kind === "merge_ready" && endFacts?.mergeableState === "dirty") {
+            state = reenterApprovedRebase(state);
+            continue pipeline;
+          }
           // The last coding child's run is named so the bot can put its handoff
           // — the deviations it recorded — on the unit's board issue beside the
           // ending (agent-ship item 14).

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

@@ -94,6 +94,7 @@ export const ROUND_STAGE = {
   request_changes: "fix",
   no_verdict: "hold",
   checks_failed: "fix",
+  checks_restarted: "approved",
   transient: "hold",
   enqueued: "approved",
   dequeued: "fix",
@@ -174,6 +175,7 @@ export const ROUND_OUTCOME_WORDS = {
   request_changes: "changes requested",
   no_verdict: "no verdict",
   checks_failed: "checks failed",
+  checks_restarted: "checks restarted",
   transient: "retried",
   enqueued: "queued to merge",
   dequeued: "removed from the merge queue",

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

@@ -51,6 +51,20 @@ export function sameCommit(a: string, b: string): boolean {
   return n >= 7 && a.slice(0, n) === b.slice(0, n);
 }
 
+/** A mismatch sentence that cannot print two identical accepted-looking
+ * prefixes: it names the authoritative source, both values and their first
+ * differing hex position. */
+function mismatchReason(source: "workspace-observed" | "model-reported", reviewed: string, expected: string): string {
+  const compared = Math.min(reviewed.length, expected.length);
+  let at = 0;
+  while (at < compared && reviewed[at] === expected[at]) at += 1;
+  const divergence =
+    at < compared
+      ? `they first differ at hex ${at + 1} (${reviewed[at]} ≠ ${expected[at]})`
+      : `the ${reviewed.length}-hex reviewed value ends before the ${expected.length}-hex PR head`;
+  return `${source} reviewed head ${reviewed} is not the PR head ${expected}; ${divergence}`;
+}
+
 /**
  * Decide whether the reviewed head is the PR head. `expected` is the PR head
  * from repo resolution; `observed` the dispatcher's own `git rev-parse HEAD`
@@ -63,7 +77,7 @@ export function checkReviewedHead(input: { expected?: string; observed?: string;
   if (observed) {
     return sameCommit(observed, expected)
       ? { ok: true, head: observed, source: "observed" }
-      : { ok: false, reason: `reviewed head ${observed.slice(0, 7)} is not the PR head ${expected.slice(0, 7)}` };
+      : { ok: false, reason: mismatchReason("workspace-observed", observed, expected) };
   }
   const reported = normalizeHead(input.reported);
   if (!reported)
@@ -73,5 +87,5 @@ export function checkReviewedHead(input: { expected?: string; observed?: string;
     };
   return sameCommit(reported, expected)
     ? { ok: true, head: reported, source: "reported" }
-    : { ok: false, reason: `reviewed head ${reported.slice(0, 7)} is not the PR head ${expected.slice(0, 7)}` };
+    : { ok: false, reason: mismatchReason("model-reported", reported, expected) };
 }

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

@@ -294,6 +294,10 @@ export type RunNoteKind =
    *  there was nothing to push), so a re-issue starts from the partial work
    *  (docs/reference/specs/agent-ship.md item 8). */
   | "budget_salvage"
+  /** A coordinator's coding child ended failed, stopped or interrupted with
+   *  work in its tree: before teardown the run loop made a WIP commit and
+   *  pushed the unit branch, or recorded why no push was possible. */
+  | "work_salvage"
   /** A pi run's compaction failed for good — the provider refused the summary
    *  (harness-pi.md item 7) — and the run loop treated it as a checkpoint
    *  signal: the tracked changes were committed and pushed to the run's own
@@ -363,6 +367,7 @@ export const RUN_NOTE_KINDS = [
   "tool_unnamed",
   "directory_reached",
   "budget_salvage",
+  "work_salvage",
   "compaction_salvage",
   "stuck_loop",
   "decline_cascade",
@@ -432,6 +437,9 @@ export type ShipRoundOutcome =
    *  0055): the failures become check findings and the findings step runs as
    *  for any changes-requested round. */
   | "checks_failed"
+  /** No required check appeared during the checks step's grace chunk, so the
+   *  runner re-fired the pull_request event once by closing and reopening it. */
+  | "checks_restarted"
   /** The round's coding child died on a provider transient with nothing
    *  pushed (issue 1932): the first such boundary marks the round's one
    *  re-run, a second the `transient` ending. */
@@ -1096,7 +1104,7 @@ export type RunEvent =
        *  `model` is the ref the run uses, resolved from a model the person
        *  named in plain words (the plain-words model unit) — applied at
        *  directive precedence. Additive: unknown → no model. */
-      binds?: ReadonlyArray<{ line: string; reason: string; model?: string; confirmed?: true }>;
+      binds?: ReadonlyArray<{ line: string; reason: string; model?: string; repo?: string; confirmed?: true }>;
       question?: string;
       /** A question's proposed line, redacted and cut like the receipt — what
        *  the next turn's "yes" binds (`bindFromAnswer`). */

package/dist/assets/src/core/runLedger/types.ts

@@ -128,9 +128,9 @@ export interface LiveRunMeta {
 export type RunState = Record<string, unknown>;
 
 /** A hosted ship parent's hosting fact on the row's state (record 0060): the
- *  runner instance the run hosts and the deadline past which a reclaim closes
- *  the row `interrupted` instead of re-hosting it. Set by the ship branch once
- *  the instance exists; read by the boot reclaim. */
+ *  runner instance the run hosts and its original wall-clock estimate. Reclaim
+ *  may outlive that estimate while the Workflow or one of its child rows is
+ *  live; only no durable owner beyond it closes the row. */
 export interface HostingState {
   instanceId: string;
   /** Epoch ms: the hand-off time plus the instance's `caps.maxMinutes` plus

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

@@ -289,19 +289,23 @@ export interface RunLease {
   loopEndsAt: number;
 }
 
-/** A head a run pushed, as the record names it (item 2): the branch and the sha. */
+/** A head a run pushed, as the record names it (item 2): the branch, sha,
+ *  and whether the agent pushed it or the run's mechanical WIP salvage did.
+ *  `by` is optional for records written before that distinction survived the
+ *  event fold. */
 export interface PushedHead {
   ref: string;
   sha: string;
+  by?: "push" | "salvage";
 }
 
 /** The heads a run's events say it pushed — one per branch, the last event's
  *  sha winning, in first-seen order — or nothing when it pushed none. */
 export function pushedHeadsOf(events: readonly RunEvent[]): PushedHead[] | undefined {
-  const byRef = new Map<string, string>();
-  for (const e of events) if (e.type === "pushed_head") byRef.set(e.ref, e.sha);
+  const byRef = new Map<string, { sha: string; by: "push" | "salvage" }>();
+  for (const e of events) if (e.type === "pushed_head") byRef.set(e.ref, { sha: e.sha, by: e.by });
   if (byRef.size === 0) return undefined;
-  return [...byRef].map(([ref, sha]) => ({ ref, sha }));
+  return [...byRef].map(([ref, pushed]) => ({ ref, ...pushed }));
 }
 
 /** The lease a run's events say its harness started — the first `lease`
@@ -440,7 +444,7 @@ export interface RunOperatorDecision {
   mode: "shadow" | "on";
   outcome: "binds" | "question" | "refusal" | "non_decision";
   reason: string;
-  binds?: { line: string; reason: string }[];
+  binds?: { line: string; reason: string; model?: string; repo?: string; confirmed?: true }[];
   question?: string;
   /** A question's proposed line — what the next turn's "yes" binds. */
   proposal?: string;
@@ -468,7 +472,17 @@ export function operatorOfEvents(events: readonly RunEvent[]): RunOperatorDecisi
     mode: e.mode,
     outcome: e.outcome,
     reason: e.reason,
-    ...(e.binds ? { binds: e.binds.map((b) => ({ line: b.line, reason: b.reason })) } : {}),
+    ...(e.binds
+      ? {
+          binds: e.binds.map((b) => ({
+            line: b.line,
+            reason: b.reason,
+            ...(b.model !== undefined ? { model: b.model } : {}),
+            ...(b.repo !== undefined ? { repo: b.repo } : {}),
+            ...(b.confirmed ? { confirmed: true as const } : {}),
+          })),
+        }
+      : {}),
     ...(e.question !== undefined ? { question: e.question } : {}),
     ...(e.proposal !== undefined ? { proposal: e.proposal } : {}),
     ...(e.request !== undefined ? { request: e.request } : {}),
@@ -1019,8 +1033,14 @@ export function isRunRecord(v: unknown): v is RunRecord {
       Array.isArray(r.pushed) &&
       r.pushed.every((h) => {
         if (typeof h !== "object" || h === null) return false;
-        const { ref, sha } = h as Record<string, unknown>;
-        return typeof ref === "string" && ref.length > 0 && typeof sha === "string" && /^[0-9a-f]{7,40}$/.test(sha);
+        const { ref, sha, by } = h as Record<string, unknown>;
+        return (
+          typeof ref === "string" &&
+          ref.length > 0 &&
+          typeof sha === "string" &&
+          /^[0-9a-f]{7,40}$/.test(sha) &&
+          (by === undefined || by === "push" || by === "salvage")
+        );
       })
     )
   )