@coreplane/switchboard 1.260.1 → 1.260.3

package/dist/assets/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "switchboard",
-  "version": "1.260.1",
+  "version": "1.260.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "switchboard",
-      "version": "1.260.1",
+      "version": "1.260.3",
       "license": "Apache-2.0",
       "workspaces": [
         "web",
@@ -20445,7 +20445,7 @@
     },
     "packages/switchboard": {
       "name": "@coreplane/switchboard",
-      "version": "1.260.1",
+      "version": "1.260.3",
       "license": "Apache-2.0",
       "dependencies": {
         "@earendil-works/pi-ai": "0.85.1",

package/dist/assets/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchboard",
-  "version": "1.260.1",
+  "version": "1.260.3",
   "private": true,
   "description": "Mention it in Slack and an agent reviews the PR, ships the fix, or answers the question — on the model you choose, with its tools running where you decide.",
   "license": "Apache-2.0",

package/dist/assets/source.json

@@ -1,5 +1,5 @@
 {
-  "version": "1.260.1",
-  "commit": "c57cb7b614e8916b3fd0ab86c848a8398d8dc781",
-  "builtAt": "2026-09-21T18:18:08.788Z"
+  "version": "1.260.3",
+  "commit": "9f64917c9c2520b2797f3d5e6a73494879408e26",
+  "builtAt": "2026-09-22T05:04:08.797Z"
 }

package/dist/assets/src/agents/registry.ts

@@ -191,7 +191,7 @@ const CONTRACT_HEADINGS_LIST = Object.values(CONTRACT_SECTION_HEADINGS)
 // assembled by the child, which would choose what to leave out. Both coding
 // prompts carry this verbatim so the resident and sandbox children read the
 // same rule; the review prompts name the same block and the same severity.
-const UNIT_CONTRACT = `UNIT CONTRACT: when your first user turn carries a \`${CONTRACT_HEADING}\` block — its sub-headings, in this order: ${CONTRACT_HEADINGS_LIST} — it is the contract for one plan unit, rendered by Switchboard from the plan itself, and it outranks any free-text task beside it. Do its first instruction first: the rebase of the unit's branch onto the merged parent (a conflict ends the unit — report it and stop; never resolve it by force). Then implement the unit's section as written: every test scenario it lists is added as a test, every spec row it names is updated so its proof binding resolves, the agent rules are followed, and no guard it names is weakened. The review is handed the same block and checks the diff against it: a test scenario the unit listed and the diff did not add is a finding at minor severity — the same severity as a spec contradiction. Never edit the plan record itself; where the unit is wrong or a criterion could not be proven, say so in the handoff and in your final message.`;
+const UNIT_CONTRACT = `UNIT CONTRACT: when your first user turn carries a \`${CONTRACT_HEADING}\` block — its sub-headings, in this order: ${CONTRACT_HEADINGS_LIST} — it is the contract for one plan unit, rendered by Switchboard from the plan itself, and it outranks any free-text task beside it. Do its first instruction first: the rebase of the unit's branch onto the merged parent. Then implement the unit's section as written: every test scenario it lists is added as a test, every spec row it names is updated so its proof binding resolves, the agent rules are followed, and no guard it names is weakened. The review is handed the same block and checks the diff against it: a test scenario the unit listed and the diff did not add is a finding at minor severity — the same severity as a spec contradiction. Never edit the plan record itself; where the unit is wrong or a criterion could not be proven, say so in the handoff and in your final message.`;
 
 // The unit handoff (docs/reference/specs/agent-coding.md item 9; agent-ship.md
 // item 14): the contract's return edge, as data. A child that ran for a plan
@@ -289,10 +289,11 @@ export const FAST_GATES_BEFORE_PUSH =
 // (src/core/ship/contract.ts).
 export const REBASE_BEFORE_PUSH =
   "REBASE BEFORE EVERY PUSH — always, not configurable. Immediately before each push: fetch your base branch, " +
-  "rebase your branch onto it, resolve any conflict with the context you already have (the repository's " +
-  "AGENTS.md says how a generated file is regenerated — regenerate it, never hand-merge it), re-run THE FAST " +
-  "GATES on the rebased tree, and only then push. Every head that reaches review is then current with its " +
-  "base when it lands, and no unit ends merge-ready behind a sibling that merged first.";
+  "rebase your branch onto it, and resolve any conflict with the context you already have in one bounded model " +
+  "round — the thread's context and the repository's AGENTS.md (which says how a generated file is regenerated: " +
+  "regenerate it, never hand-merge it). If you cannot resolve it inside that bound, end the round; otherwise " +
+  "re-run THE FAST GATES on the rebased tree, and only then push. Every head that reaches review is then current " +
+  "with its base when it lands, and no unit ends merge-ready behind a sibling that merged first.";
 
 const CODING_SYSTEM = `You are Switchboard's coding agent, operating from a Slack request.
 
@@ -447,7 +448,7 @@ Your final message is posted to Slack — keep it readable, lead with the outcom
 // whole reply — so the prose never repeats them and never pads around them.
 const REVIEW_FINAL_MESSAGE = `YOUR FINAL MESSAGE IS THE REVIEW'S TEXT, NOTHING ELSE. Switchboard renders the verdict line and the findings list from your submit_verdict call — on GitHub as the head of the comment, in Slack as the whole reply — and folds your final message under them on GitHub as the full review. So write only what the list cannot carry: one short paragraph per finding, keyed by its id (what is wrong, the concrete failure, the fix). Do not restate the verdict or the findings, do not summarize what you read, do not list what you verified clean, do not describe your method — what you checked belongs in your notes, which the run page shows. A change with no findings needs one sentence, not a tour.`;
 
-const REVIEW_VERDICT_INSTRUCTION = `VERDICT: before your final message, call the submit_verdict tool exactly once with \`approve\` (no finding at or above the severity to address remains — the level in force for this run, \`minor\` by default: a major or a minor finding means \`request_changes\`; nits alone never block) or \`request_changes\`, a one-line summary, \`head\` = the output of \`git rev-parse HEAD\` in the checkout you reviewed, and \`findings\` — every issue you report as a structured entry with a stable id you assign in order (F1, F2, …), a severity of exactly blocking|major|minor|nit, the file (plus line when it points at one), and a one-line title. The findings array is the index of your review: the full explanation of each finding stays in your prose, keyed by the same ids. Switchboard writes the verdict as the first line of the GitHub comment itself, lists the findings under it and folds your text below them as the full review; a review with no submitted verdict is posted as not approving, so never skip it. An \`approve\` carrying a finding at or above the severity to address is downgraded to \`request_changes\` and the tool's ack says so — approve only when every finding sits below the level. Do not write "LGTM" in your own text — the verdict line carries it.`;
+const REVIEW_VERDICT_INSTRUCTION = `VERDICT: before your final message, call the submit_verdict tool exactly once with \`approve\` (no finding at or above the severity to address remains — the level in force for this run, \`minor\` by default: a major or a minor finding means \`request_changes\`; nits alone never block) or \`request_changes\`, a one-line summary, \`head\` = the output of \`git rev-parse HEAD\` in the checkout you reviewed, and \`findings\` — every issue you report as a structured entry with a stable id you assign in order (F1, F2, …), a severity of exactly blocking|major|minor|nit, the file (plus line when it points at one), and a one-line title. The findings array is the index of your review: the full explanation of each finding stays in your prose, keyed by the same ids. Switchboard writes the verdict as the first line of the GitHub comment itself, lists the findings under it and folds your text below them as the full review; a review with no submitted verdict is posted as not approving, so never skip it. The only exception is a preflight infrastructure failure from the REVIEW TARGET block's first-command HEAD check: stop, submit no finding or verdict, and let Switchboard report it without a GitHub post. An \`approve\` carrying a finding at or above the severity to address is downgraded to \`request_changes\` and the tool's ack says so — approve only when every finding sits below the level. Do not write "LGTM" in your own text — the verdict line carries it.`;
 
 // The diff-gated spec review (docs/reference/specs/agent-review.md item 14) and
 // the test guard under it (item 16; specs-coverage.md item 6), one text for
@@ -485,7 +486,7 @@ Strategy — GATHER ONCE, THEN ANALYZE ONCE. Do not explore file-by-file; your c
 
 1. GATHER, in 2-4 batched tool calls total:
    - \`gh pr view <ref> --json title,body,url,baseRefName\` and \`gh pr diff <ref>\` (the complete diff) in one command
-   - clone the repo and check out the PR branch, then call the \`diff_digest\` tool to orient: per-file churn, totals, and risky-file flags (migrations/schema, auth/permission, whole-file deletions, lockfiles, very large files) so you know where to look hardest before you read a line
+   - for a PR review, use the checkout Switchboard provisioned at the head named in the REVIEW TARGET block — do not clone or check out another ref — then call the \`diff_digest\` tool to orient: per-file churn, totals, and risky-file flags (migrations/schema, auth/permission, whole-file deletions, lockfiles, very large files) so you know where to look hardest before you read a line
 ${REVIEW_WHOLE_CHANGE}
    - in ONE command, print the full current contents of every changed source file, e.g.: \`gh pr diff <ref> --name-only | grep -v -E "lock|generated|snap" | while read f; do echo "=== $f ==="; cat "$f"; done\`
    - if the PR is enormous (>~6k changed lines), print the riskiest files in full (state mutation, auth, concurrency, data deletion, public APIs) and only the diff hunks for the rest — and say which files you skimmed

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

@@ -231,6 +231,13 @@ export const PULL_SWEEP = { leaseMinutes: 15, spendCapUsd: 5 } as const;
  *  budget. */
 export const PROVIDER_RETRY_BACKOFFS_MS = [5_000, 15_000, 45_000] as const;
 
+/** How often the model proxy writes an SSE comment while the provider is
+ *  reasoning silently. The public container hop has cut an otherwise healthy
+ *  stream at about thirty seconds of silence; a comment inside half that
+ *  window keeps the transport alive without becoming a model event. The
+ *  model call itself remains bounded by the run's lease. */
+export const MODEL_STREAM_HEARTBEAT_MS = 15_000;
+
 /** A hosted ship parent's deadline margin past the pipeline's wall clock
  *  (record 0060): the row's `state.hosting.until` is the hand-off time plus
  *  the instance's `caps.maxMinutes` plus this hour, absorbing the runner's own

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

@@ -10,7 +10,13 @@
 //
 import { IDLE_DAYS_MAX, type Grant, type GrantSource } from "../budgets.js";
 import { isVerbosity, type Verbosity } from "../verbosity.js";
-import { isAddressSeverity, type AddressSeverity, type AddressSeveritySource } from "../ship/coordinator.js";
+import { isFindingShape } from "../reviewVerdict.js";
+import {
+  isAddressSeverity,
+  type AddressSeverity,
+  type AddressSeveritySource,
+  type HumanGatePending,
+} from "../ship/coordinator.js";
 import { isHandoffShape, type Handoff } from "../ship/handoff.js";
 
 // A coordinator is a Workflow instance in the shim Worker whose children are
@@ -421,6 +427,8 @@ export interface UnitIdle {
   runId?: string;
   spendUsd: number | null;
   handoff?: Handoff;
+  /** The human-gated question this idle is waiting on. */
+  humanGate?: HumanGatePending;
   wakes: number;
 }
 
@@ -439,6 +447,7 @@ export type UnitWakeAnswer =
       texts: string[];
       senders: string[];
       leaseMs?: number;
+      humanGate?: HumanGatePending;
     }
   | { kind: "answered"; reply: string }
   | { kind: "stopped" }
@@ -579,6 +588,23 @@ const isRoundGate = (v: unknown): boolean =>
   Array.isArray(v.findings) &&
   v.findings.every((f) => typeof f === "string");
 
+export const isHumanGatePending = (v: unknown): v is HumanGatePending =>
+  isObject(v) &&
+  isObject(v.pr) &&
+  typeof v.pr.number === "number" &&
+  Number.isInteger(v.pr.number) &&
+  v.pr.number > 0 &&
+  isText(v.pr.url) &&
+  typeof v.round === "number" &&
+  Number.isInteger(v.round) &&
+  v.round >= 1 &&
+  Array.isArray(v.findings) &&
+  v.findings.every((finding: unknown) => isFindingShape(finding)) &&
+  (v.verdict === "approve" || v.verdict === "request_changes") &&
+  (v.reviewRunId === undefined || isText(v.reviewRunId)) &&
+  (v.headSha === undefined || isText(v.headSha)) &&
+  (v.askedAt === undefined || isFinite(v.askedAt));
+
 const isUnitIdle = (v: unknown): boolean =>
   isObject(v) &&
   isText(v.why, IDLE_WHY_MAX) &&
@@ -588,6 +614,7 @@ const isUnitIdle = (v: unknown): boolean =>
   (v.runId === undefined || isText(v.runId)) &&
   (v.spendUsd === null || isFinite(v.spendUsd)) &&
   (v.handoff === undefined || isHandoffShape(v.handoff)) &&
+  (v.humanGate === undefined || isHumanGatePending(v.humanGate)) &&
   isCount(v.wakes);
 
 const isSegment = (v: unknown): boolean =>
@@ -616,7 +643,8 @@ export const isUnitWakeAnswer = (v: unknown): v is UnitWakeAnswer => {
     v.texts.every((text) => typeof text === "string") &&
     Array.isArray(v.senders) &&
     v.senders.every((sender) => isText(sender)) &&
-    (v.leaseMs === undefined || (isFinite(v.leaseMs) && v.leaseMs > 0))
+    (v.leaseMs === undefined || (isFinite(v.leaseMs) && v.leaseMs > 0)) &&
+    (v.humanGate === undefined || isHumanGatePending(v.humanGate))
   );
 };
 
@@ -693,6 +721,24 @@ export type RunFinishedSend =
   | { kind: "no-binding"; instance: string }
   | { kind: "failed"; instance: string; type: string; reason: string };
 
+/** Wake one unit after durable outside input was appended. The payload is
+ * deliberately empty: the unit re-reads its own event list before acting. */
+export async function sendUnitNudge(
+  workflow: WorkflowSender | undefined,
+  key: { instanceId: string; unit: string },
+): Promise<RunFinishedSend> {
+  const instance = key.instanceId;
+  if (!workflow) return { kind: "no-binding", instance };
+  const type = unitNudgeEventType(key);
+  try {
+    const handle = await workflow.get(instance);
+    await handle.sendEvent({ type, payload: {} });
+    return { kind: "sent", instance, type };
+  } catch (err) {
+    return { kind: "failed", instance, type, reason: err instanceof Error ? err.message : String(err) };
+  }
+}
+
 /** The one send per settled head (http-ingress.md item 12): best effort like
  *  `sendRunFinished` — a refusal is answered, never thrown, and the parent's
  *  bounded merge wait times out on its own. */

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

@@ -40,6 +40,7 @@
 // the shim Worker imports this by relative path.
 
 import { DAY_MS, DEFAULT_GRANT, GRANT_RENEWALS_MAX, IDLE_DAYS_MAX, type Grant, type GrantSource } from "../budgets.js";
+import { isFindingShape, type Finding } from "../reviewVerdict.js";
 import { DEFAULT_VERBOSITY, isVerbosity, type Verbosity } from "../verbosity.js";
 import {
   applyReturn,
@@ -51,6 +52,7 @@ import {
   type PlanCursor,
   type UnitStatus,
   renderUnitReport,
+  reenterApprovedRebase,
   settleUnit,
   startUnit,
   type ChildFacts,
@@ -114,6 +116,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
@@ -341,6 +344,8 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
   // they were written (the run record's validator), read here as they are.
   const facts = run as unknown as Omit<Extract<ChildFacts, { finished: true }>, "finished" | "status">;
   const {
+    finishedAt,
+    reviewAskedAt,
     finalReply,
     pr,
     headSha,
@@ -365,6 +370,8 @@ function readRecordReturn(step: string, a: BotAnswer): StepReturn {
     run: {
       finished: true,
       status: run.status as Extract<ChildFacts, { finished: true }>["status"],
+      ...(typeof finishedAt === "number" ? { finishedAt } : {}),
+      ...(typeof reviewAskedAt === "number" ? { reviewAskedAt } : {}),
       ...(finalReply !== undefined ? { finalReply } : {}),
       ...(pr !== undefined ? { pr } : {}),
       ...(headSha !== undefined ? { headSha } : {}),
@@ -401,6 +408,33 @@ function isCommitChecks(v: unknown): v is { total: number; pending: string[]; fa
   return typeof c.total === "number" && names(c.pending) && names(c.failed);
 }
 
+function entryHumanGate(v: unknown):
+  | {
+      round: number;
+      findings: Finding[];
+      verdict: "approve" | "request_changes";
+      answer: string;
+      author: string;
+      commentId: string;
+    }
+  | undefined {
+  if (typeof v !== "object" || v === null) return undefined;
+  const row = v as Record<string, unknown>;
+  if (typeof row.round !== "number" || !Number.isInteger(row.round) || row.round < 1) return undefined;
+  if (!Array.isArray(row.findings) || !row.findings.every(isFindingShape)) return undefined;
+  if (row.verdict !== "approve" && row.verdict !== "request_changes") return undefined;
+  if (typeof row.answer !== "string" || typeof row.author !== "string" || typeof row.commentId !== "string")
+    return undefined;
+  return {
+    round: row.round,
+    findings: row.findings,
+    verdict: row.verdict,
+    answer: row.answer,
+    author: row.author,
+    commentId: row.commentId,
+  };
+}
+
 function prCheckReturn(step: string, a: BotAnswer): StepReturn {
   const { ok, state, prNumber, url, headSha, sha, mergedAt, at } = a.body;
   if (ok === true && state === "none") {
@@ -446,6 +480,7 @@ function prCheckReturn(step: string, a: BotAnswer): StepReturn {
         // The base's merge-queue rule beside the checks (issue 2011): the
         // merge:person report says the person's merge is queued.
         ...(typeof a.body.baseHasMergeQueue === "boolean" ? { baseHasMergeQueue: a.body.baseHasMergeQueue } : {}),
+        ...(entryHumanGate(a.body.humanGate) !== undefined ? { humanGate: entryHumanGate(a.body.humanGate)! } : {}),
       },
       at,
     };
@@ -505,13 +540,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
@@ -706,6 +754,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 }),
+          ),
+        ),
+      );
   }
 }
 
@@ -838,7 +896,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)
@@ -892,9 +950,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
@@ -907,6 +965,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).
@@ -928,6 +994,7 @@ async function runUnit(
                     ...(note.ending.from !== undefined ? { from: note.ending.from } : {}),
                     spendUsd: note.ending.spendUsd,
                     ...(note.ending.handoff !== undefined ? { handoff: note.ending.handoff } : {}),
+                    ...(note.ending.humanGate !== undefined ? { humanGate: note.ending.humanGate } : {}),
                   }
                 : {}),
             },
@@ -1138,6 +1205,7 @@ async function waitOnIdle(
         ...(answer.runId !== undefined ? { previousRunId: answer.runId } : {}),
         ...(answer.handoff !== undefined ? { previousHandoff: answer.handoff } : {}),
         ...(answer.texts.length > 0 ? { texts: answer.texts } : {}),
+        ...(answer.humanGate !== undefined ? { humanGate: answer.humanGate } : {}),
         ...(answer.leaseMs !== undefined
           ? { resume: { leaseMs: answer.leaseMs, attempt: (currentSession?.resume?.attempt ?? 0) + 1 } }
           : {}),
@@ -1207,7 +1275,7 @@ async function walk(step: StepRunner, bot: CoordinatorBot, instanceId: string):
           next,
           stepPrefixOf(next, session),
           ending,
-          plan.idleDays,
+          ending.parkDays ?? plan.idleDays,
           session,
         );
         if (parked.kind === "ending") {

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

@@ -328,8 +328,14 @@ function findingCounts(findings: readonly Finding[] | undefined): string {
   return `${findings.length} finding${findings.length === 1 ? "" : "s"}: ${by}`;
 }
 
-/** A table cell: pipes escaped so the row holds, already one line. */
-const cell = (text: string): string => oneLine(text).replace(/\|/g, "\\|");
+/** A one-line Markdown table cell. Backslashes are escaped before pipes so
+ * input cannot consume the pipe escape and split the row. */
+export const escapeMarkdownTableCell = (text: string): string =>
+  oneLine(text).replace(/\\/g, "\\\\").replace(/\|/g, "\\|");
+
+/** Decode the two escapes emitted by `escapeMarkdownTableCell`. This also
+ * accepts the legacy form that escaped pipes without first escaping slashes. */
+export const unescapeMarkdownTableCell = (text: string): string => text.replace(/\\([\\|])/g, "$1");
 
 /** Whether a finding's `file` is a path a blob URL can point at: no
  *  whitespace, no backtick, not a URL. */
@@ -339,7 +345,7 @@ const isRepoPath = (file: string): boolean => /^[^\s`]+$/.test(file) && !/^[a-z]
  *  file is a path and a target is known. */
 function whereCell(f: Finding, target: ReviewBodyTarget | undefined): string {
   const location = f.line !== undefined ? `${f.file}:${f.line}` : f.file;
-  const label = `\`${cell(location)}\``;
+  const label = `\`${escapeMarkdownTableCell(location)}\``;
   if (!target || !isRepoPath(f.file)) return label;
   const path = encodeURI(f.file).replace(/#/g, "%23").replace(/\?/g, "%3F");
   const url = `https://github.com/${target.repo}/blob/${target.head}/${path}${f.line !== undefined ? `#L${f.line}` : ""}`;
@@ -360,6 +366,7 @@ function verdictMarker(verdict: ReviewVerdict | undefined, target: ReviewBodyTar
             id: f.id,
             severity: f.severity,
             file: f.file,
+            title: f.title,
             ...(f.line !== undefined ? { line: f.line } : {}),
             ...(f.humanGated ? { humanGated: true } : {}),
           })),
@@ -395,7 +402,10 @@ export function buildReviewPostBody(
       [
         "| Severity | Finding | Where |",
         "| --- | --- | --- |",
-        ...findings.map((f) => `| ${f.severity} | **${cell(f.id)}** ${cell(f.title)} | ${whereCell(f, target)} |`),
+        ...findings.map(
+          (f) =>
+            `| ${f.severity} | **${escapeMarkdownTableCell(f.id)}** ${escapeMarkdownTableCell(f.title)} | ${whereCell(f, target)} |`,
+        ),
       ].join("\n"),
     );
   }
@@ -517,7 +527,7 @@ const DISPOSITION_KINDS: readonly string[] = ["fixed", "declined"];
 
 const isRecordLike = (v: unknown): v is Record<string, unknown> => typeof v === "object" && v !== null;
 
-function isFindingShape(v: unknown): v is Finding {
+export function isFindingShape(v: unknown): v is Finding {
   if (!isRecordLike(v)) return false;
   return (
     typeof v.id === "string" &&

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/ship/contract.ts

@@ -480,7 +480,7 @@ function renderFirstInstruction(rebase: ChildContract["rebase"]): string {
   const gates = `${FAST_GATES_POINTER} ${GATE_RECEIPTS}`;
   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. ` +
+    `the only writes are your own on that branch. ` +
     `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} ${REBASE_POINTER} At the wind-down note, ` +