@quickchatai/quickreview 1.1.0 → 1.3.1

package/src/tui/app.ts

@@ -841,6 +841,13 @@ export class App {
     if (pr !== this.selectedPr) this.msgDraft = ""; // a cancelled draft belongs to the PR it was typed for
     this.selectedPr = pr;
     if (this.view.progress?.pr !== pr) this.view.progress = undefined;
+    // An offered row (not tracked yet) has no detail, round or session to
+    // read: its pane is the PR list's own fields and the way to review it.
+    if (pr !== undefined && this.offeredSelected()) {
+      this.syncPiPane();
+      if (!this.view.piFocus) this.selectPane(undefined);
+      return;
+    }
     void this.refreshDetail();
     void this.refreshProgress();
     this.followSelection();
@@ -967,6 +974,38 @@ export class App {
     return sorted[this.view.selected]?.number;
   }
 
+  /** Is the selected row an offered one (open on GitHub, not tracked yet)? */
+  private offeredSelected(): boolean {
+    return visiblePrs(this.view)[this.view.selected]?.offered === true;
+  }
+
+  /** A PR verb on an offered row: there is no session or round to act on. */
+  private refuseOffered(): boolean {
+    if (!this.offeredSelected()) return false;
+    this.notice(`#${this.selectedPrNumber()} is not reviewed yet — R reviews it now`);
+    return true;
+  }
+
+  /** `R`: ask the daemon to review the selected PR now — the operator's
+   * `review-now` command over the sealed channel, the same as
+   * `qcr review-now <n>`. Any open PR of the repo, tracked or not. */
+  private reviewNow(): void {
+    const pr = this.selectedPrNumber();
+    if (pr === undefined) {
+      this.notice("select a pull request first (j/k), then R reviews it");
+      return;
+    }
+    if (!this.hooks.operatorCommand) {
+      this.notice("review now: not wired (no remote runner)");
+      return;
+    }
+    this.notice(`asking the daemon to review #${pr} now…`);
+    void this.hooks
+      .operatorCommand({ command: "review-now", pr }, this)
+      .then(() => this.poller.tick())
+      .catch(() => {});
+  }
+
   /** Synthesize a keypress through the normal input path — the command bar's
    * buttons and any tab code that wants "exactly what the key would do". */
   pressKey(key: string): void {
@@ -1432,6 +1471,7 @@ export class App {
         // the whole TUI (AGENTS.md invariant 10, the fixed layout). With no PR
         // selected there is nothing to focus, and nothing else to open.
         if (this.selectedPr !== undefined) {
+          if (this.refuseOffered()) break;
           this.focusPiPane();
           this.repaint();
         }
@@ -1443,6 +1483,7 @@ export class App {
       case "message": {
         const session = this.selectedSession();
         if (!session) break;
+        if (this.refuseOffered()) break;
         if (this.hooks.message) this.hooks.message(session, this);
         else this.openMessageBox(session);
         break;
@@ -1457,6 +1498,7 @@ export class App {
         // overseer command, where the extra deliberation is the point.
         const pr = this.selectedPrNumber();
         if (pr === undefined) break;
+        if (this.refuseOffered()) break;
         if (this.hooks.unwedge) this.hooks.unwedge(pr, this);
         else this.notice("unwedge: not wired (no remote runner)");
         break;
@@ -1482,6 +1524,11 @@ export class App {
           this.setBoardFilter(null);
           break;
         }
+        // R reviews the selected PR now — tracked or offered.
+        if (key.ch === "R" && this.tab === "board") {
+          this.reviewNow();
+          break;
+        }
         // I starts setup — the companion takes it from there.
         if (key.ch === "I" && this.tab === "board") {
           if (this.hooks.setup) this.hooks.setup(this);

package/src/tui/board.ts

@@ -11,7 +11,7 @@ import { cancelCauseLabel, isLoudCancelCause, type StatusSnapshot } from "../sta
 import type { AlertBadge } from "./alerts.js";
 import { barHeight, paintCmdBar, type BarButton, type LiveKeys } from "./cmdbar.js";
 import { filterLabel, visiblePrs, type BoardFilter } from "./filters.js";
-import { glyphFor, type EventLine, type SnapshotPr } from "./model.js";
+import { glyphFor, OFFERED_GLYPH, type EventLine, type SnapshotPr } from "./model.js";
 import { windowStart } from "./panes.js";
 import {
   ACCENT,
@@ -47,7 +47,8 @@ import {
   type LiveAgentProgress,
   type RoundProgressSnapshot,
 } from "@quickchatai/pi-quickreview/src/round-progress.js";
-import type { ConnectionDiagnosis } from "./sshtriage.js";
+import { isLocalDiagnosis, type ConnectionDiagnosis } from "./sshtriage.js";
+import { setupLine, type SetupState } from "./setupstate.js";
 import { FG, RESET, fmtAge, legendLine, osc8, prUrl, stateColor, verdictChip } from "./theme.js";
 
 /** Every clickable thing the board declares. */
@@ -109,6 +110,9 @@ export interface BoardView {
   /** Active board filter (companion `board_filter` verb; F clears).
    * Consumed through `visiblePrs` — never filter a sortPrs call directly. */
   boardFilter?: BoardFilter | null;
+  /** Set while onboarding's checklist exists and is not complete
+   * (src/tui/setupstate.ts): the board says so before anything else. */
+  setup?: SetupState;
 }
 
 // ---- layout ----------------------------------------------------------------
@@ -197,22 +201,26 @@ export function listWidth(prs: SnapshotPr[], cols: number, now: Date = new Date(
 export function boardKeys(
   view: Pick<BoardView, "snapshot" | "boardFilter" | "selected" | "repo">,
 ): LiveKeys {
-  const selected = visiblePrs(view)[view.selected] !== undefined;
+  const row = visiblePrs(view)[view.selected];
+  const selected = row !== undefined;
+  // An offered row (open on GitHub, not tracked yet) has no session, round or
+  // pane: `R` reviews it and `g` opens it, and nothing else addresses it.
+  const tracked = selected && row.offered !== true;
   const bar: BarButton[] = [];
-  if (selected) bar.push({ key: "\r", label: "⏎ pi pane" }, { key: "m", label: "m message" });
+  if (selected) bar.push({ key: "R", label: "R review now" });
+  if (tracked) bar.push({ key: "\r", label: "⏎ pi pane" }, { key: "m", label: "m message" });
   if (selected && view.repo) bar.push({ key: "g", label: "g github" });
   bar.push({ key: "e", label: "e events" });
-  if (selected) bar.push({ key: "u", label: "u unwedge" });
+  if (tracked) bar.push({ key: "u", label: "u unwedge" });
   // Setup is about the repo, not a PR — offered whatever is selected.
   bar.push({ key: "I", label: "I setup" });
   const inline: string[] = [];
-  if (selected) inline.push("a");
+  if (tracked) inline.push("a");
   if (view.boardFilter != null) inline.push("F");
   // A worker-hosted PR's pane is the transcript viewer: `[ ]` step its streams
   // and `< >` its rounds. They are the pane header's keys (painted there), so
   // they exist only while the selected PR's pane is the viewer.
-  const pr = visiblePrs(view)[view.selected];
-  if (pr !== undefined && paneSurface(pr.runtime, pr.number).kind === "viewer")
+  if (tracked && paneSurface(row.runtime, row.number).kind === "viewer")
     inline.push("[", "]", "<", ">");
   return { bar, inline };
 }
@@ -287,6 +295,9 @@ const CONNECTION_LABEL: Record<ConnectionDiagnosis["kind"], string> = {
   "wedged-master": "ssh master wedged",
   "host-unreachable": "host down",
   unknown: "cause unknown",
+  "local-down": "daemon container not running",
+  "local-docker": "local docker not answering",
+  unconfigured: "no ssh_host",
 };
 
 /**
@@ -297,12 +308,30 @@ const CONNECTION_LABEL: Record<ConnectionDiagnosis["kind"], string> = {
  * the truth is "I could not ask"), the reason is named, and the remedy is a
  * command the operator can paste into their own shell.
  */
-export function unknownSourceLines(conn: ConnectionDiagnosis | undefined, width: number): string[] {
+export function unknownSourceLines(
+  conn: ConnectionDiagnosis | undefined,
+  width: number,
+  setup?: SetupState,
+): string[] {
   const lines = [
     `${FG.anomaly}the daemon has not answered yet${RESET}`,
     `${FG.dim}nothing below is a measurement — it is not known${RESET}`,
     "",
   ];
+  if (setup) {
+    // A half-finished onboarding is the whole explanation: the stack is
+    // started by one of its later steps, so daemon or ssh troubleshooting
+    // here would send the operator after a fault that is not one.
+    for (const l of wrap(setupLine(setup), width)) lines.push(`${WARN}${l}${DRESET}`);
+    for (const l of wrap(
+      "the daemon, its memory and this board's connection are set up by the wizard's remaining steps",
+      width,
+    ))
+      lines.push(`${FG.dim}${l}${RESET}`);
+    lines.push("");
+    lines.push(`${FG.dim}r refreshes${RESET}`);
+    return lines.map((l) => truncate(l, width));
+  }
   if (conn && conn.kind !== "ok" && conn.kind !== "local") {
     for (const l of wrap(stripAnsi(conn.cause), width)) lines.push(`${FG.dim}${l}${RESET}`);
     if (conn.remedy !== "") {
@@ -337,7 +366,8 @@ export function unknownDetailLines(conn: ConnectionDiagnosis | undefined, width:
   ];
   if (conn?.detail) {
     lines.push("");
-    for (const l of wrap(`ssh said: ${stripAnsi(conn.detail)}`, width))
+    const who = isLocalDiagnosis(conn) ? "docker" : "ssh";
+    for (const l of wrap(`${who} said: ${stripAnsi(conn.detail)}`, width))
       lines.push(`${FG.dim}${l}${RESET}`);
   }
   return lines.map((l) => truncate(l, width));
@@ -482,9 +512,17 @@ function barSegments(view: BoardView, alerts: boolean): string[] {
       health = `${WARN}▲ DATA STALE (${view.health.dataAgeS}s)${DRESET}`;
       break;
     case "unreachable":
-      health = `${FG.anomaly}✖ unreachable${view.connection ? ` · ${CONNECTION_LABEL[view.connection.kind]}` : ""}${RESET}`;
+      // Under an unfinished setup the setup segment that replaces this is the
+      // cause; a transport label would only point at a fault that is not one
+      // (the list still says, in full, that the daemon has not answered).
+      health = view.setup
+        ? ""
+        : `${FG.anomaly}✖ unreachable${view.connection ? ` · ${CONNECTION_LABEL[view.connection.kind]}` : ""}${RESET}`;
       break;
   }
+  // Short on the bar, where every segment competes for the width; the list
+  // carries the full sentence with the next step.
+  const setupSeg = view.setup ? `${WARN}▲ setup not finished${DRESET}` : "";
   const s = view.snapshot;
   const rounds = s ? `rounds ${s.running_rounds}/${s.max_concurrent_rounds ?? "?"}` : "";
   const spend = s?.today_spend_usd !== undefined ? `today $${s.today_spend_usd.toFixed(2)}` : "";
@@ -512,6 +550,7 @@ function barSegments(view: BoardView, alerts: boolean): string[] {
     `${HEADING}quickreview${DRESET}`,
     mode,
     health,
+    setupSeg,
     mem?.loud ? mem.text : "",
     loop?.loud ? loop.text : "",
     curation,
@@ -549,6 +588,51 @@ export function alertZone(view: BoardView, cols: number): { x1: number; x2: numb
   return { x1, x2: Math.min(cols - 1, x1 + width - 1) };
 }
 
+/**
+ * The board's own guide to the first review, under the PRS header. With open
+ * PRs offered and none tracked it says what to do; with no open PR at all it
+ * says that, naming the repo; once a PR is tracked it is silent. Absent
+ * `open_prs` (a daemon that has not listed yet, or an older one) is unknown,
+ * so the guide says nothing rather than "no open PRs".
+ */
+export function reviewGuideLines(
+  view: Pick<BoardView, "snapshot" | "boardFilter" | "repo">,
+  tracked: number,
+  offered: number,
+  width: number,
+): string[] {
+  if (view.boardFilter != null || tracked > 0 || view.snapshot?.open_prs === undefined) return [];
+  if (offered === 0)
+    return [
+      truncate(
+        `${FG.dim}no open pull requests in ${view.repo ?? "the repository"} — open one, and it is listed here within a few minutes${RESET}`,
+        width,
+      ),
+    ];
+  return [
+    truncate(`${FG.accent}select a pull request (j/k), then R reviews it now${RESET}`, width),
+  ];
+}
+
+/** The detail pane of an offered row: what is known (the PR list's own
+ * fields) and the one thing to do with it. */
+function offeredDetailLines(pr: SnapshotPr, width: number, now: Date): string[] {
+  return [
+    `${FG.dim}${OFFERED_GLYPH}${RESET} ${STRONG}#${pr.number}${RESET} ${STRONG}${truncate(sanitizeText(pr.title), width - 8 - String(pr.number).length)}${RESET}`,
+    truncate(
+      `${FG.author}${pr.author ?? ""}${RESET} ${FG.dim}· updated ${fmtAge(pr.updated_at, now)}${RESET}`,
+      width,
+    ),
+    "",
+    "not reviewed yet",
+    "",
+    truncate(`${STRONG}R${RESET} reviews it now: the reviewer runs one full round`, width),
+    truncate("on this pull request, and its progress shows here.", width),
+    truncate(`${FG.dim}In dry-run (the top bar says so) the review is recorded,${RESET}`, width),
+    truncate(`${FG.dim}never posted to GitHub.${RESET}`, width),
+  ];
+}
+
 function styledRow(
   pr: SnapshotPr,
   selected: boolean,
@@ -811,6 +895,7 @@ export function detailLines(
 ): string[] {
   const lines: string[] = [];
   if (!pr) return ["no PR selected"];
+  if (pr.offered) return offeredDetailLines(pr, width, now);
   lines.push(
     `${stateColor(pr.state)}${STRONG}#${pr.number}${RESET} ${STRONG}${truncate(sanitizeText(pr.title), width - 8 - String(pr.number).length)}${RESET}`,
   );
@@ -1010,7 +1095,7 @@ export function detailLines(
 export const HELP_LINES = [
   "1…8            the eight surfaces: board · memory · digest · tickets · deploy · metrics · feedback · scan",
   "               the bar at the foot shows what THIS frame answers to; a button that is not there is a key that would do nothing",
-  "r / s / ? / q  refresh · reconnect VM ssh (the one ssh key-passphrase prompt) · this overlay · quit (asks first)",
+  "r / s / ? / q  refresh · re-check the connection (VM route: ssh, the one key-passphrase prompt; local route: the daemon container) · this overlay · quit (asks first)",
   "Ctrl-c ×3      kill the TUI from anywhere (terminal restored) — the un-stuck hatch",
   "               an alert in the top bar: click it or ⏎ to open the companion",
   "the companion column down the right edge is on every tab:",
@@ -1025,6 +1110,7 @@ export const HELP_LINES = [
   "< / >          past / later round in the viewer; PgUp / wheel parks it, End follows the tail again",
   "               its input line (focused pane): ⏎ steers the running round, or sends a message to an idle PR; Alt-⏎ queues a follow-up",
   "               Alt-p marks the next message may-post (shown, reset after send); Ctrl-c asks to abort the round (y confirms); [ ] < > are keys only while the line is empty",
+  "R              review the selected PR now — any open PR, tracked or not (○ not reviewed): one round, nothing posted in dry-run",
   "m              quick-message the selected PR's session",
   "u              unwedge: cancel the running round and re-queue it (nothing posted, no GitHub write)",
   "e              events overlay (j/k scroll, e/Esc close; click an event → its PR)",
@@ -1296,11 +1382,22 @@ export function renderBoard(view: BoardView, cols: number, rows: number): Frame
   // detail pane says "no data" rather than "no PR selected".
   const known = view.snapshot !== undefined;
   const flabel = filterLabel(view.boardFilter);
+  const offered = sorted.filter((p) => p.offered === true).length;
   const listLines: string[] = known
-    ? [section(`PRS (${sorted.length})`, flabel !== "" ? flabel : "the daemon's live set")]
+    ? [
+        section(
+          `PRS (${sorted.length})`,
+          flabel !== ""
+            ? flabel
+            : offered > 0
+              ? `${sorted.length - offered} tracked · ${offered} open, not reviewed`
+              : "the daemon's live set",
+        ),
+        ...reviewGuideLines(view, sorted.length - offered, offered, listW - 1),
+      ]
     : [
         section("PRS (?)", "unknown — the daemon has not answered"),
-        ...unknownSourceLines(view.connection, listW - 1),
+        ...unknownSourceLines(view.connection, listW - 1, view.setup),
       ];
   // The list scrolls with the selection: the verbs act on the selected PR, so
   // it must never sit off-screen (`windowStart`, the tabs' shared rule). The

package/src/tui/cmdbar.ts

@@ -51,7 +51,9 @@ const NAV: ReadonlyArray<BarButton & { tab: Tab }> = TABS.map((tab) => ({
 /** Row A right: always the same four, always in the same place. */
 const GLOBALS: readonly BarButton[] = [
   { key: "r", label: "r refresh" },
-  { key: "s", label: "s ssh" },
+  // Transport-neutral: on the VM route `s` re-checks ssh (and offers the one
+  // key-passphrase prompt), on the local route the daemon container.
+  { key: "s", label: "s check" },
   { key: "?", label: "? help" },
   { key: "q", label: "q quit" },
 ];
@@ -73,6 +75,7 @@ export const GLOBAL_KEYS: readonly string[] = [
  */
 export const TAB_VOCABULARY: Readonly<Record<Tab, readonly BarButton[]>> = {
   board: [
+    { key: "R", label: "R review now" },
     { key: "\r", label: "⏎ pi pane" },
     { key: "m", label: "m message" },
     { key: "g", label: "g github" },

package/src/tui/companion.ts

@@ -41,10 +41,11 @@ import {
   stateHome,
   type InstallEnv,
 } from "../install.js";
-import type { CompanionConfig } from "../config.js";
+import { COMPANION_IMAGE, type CompanionConfig } from "../config.js";
 import { writeAtomic } from "../channelfs.js";
 import { appStamp } from "../appstamp.js";
 import { TOKEN_FILE } from "./ghread.js";
+import { MEMORY_PORT } from "./memoryurl.js";
 
 export interface DockerResult {
   ok: boolean;
@@ -274,7 +275,7 @@ export const MEMORY = {
   subnet: "198.51.100.0/24",
   gateway: "198.51.100.1",
   /** Same port the server listens on in the VM container ([openviking] port). */
-  port: 1933,
+  port: MEMORY_PORT,
   /** The OpenViking user whose memory the companion owns — becomes the
    * `X-OpenViking-User` header on every request it makes. */
   user: "companion",
@@ -453,6 +454,15 @@ export function companionInjectDir(cfg: Pick<CompanionConfig, "repo_dir" | "sess
  * `qcr scan` the companion runs) knows it is inside the companion container. */
 export const IN_COMPANION_ENV = "QCR_IN_COMPANION";
 
+/** The published release image's repository (src/onboard/steps/compose.ts
+ * RELEASE_IMAGE_REPO): a tag under it is pulled, never built locally. */
+const RELEASE_IMAGE_PREFIX = "ghcr.io/quickchatai/quickreview:";
+
+/** Is `image` a published release tag (pulled, never built over)? */
+export function isReleaseImage(image: string): boolean {
+  return image.startsWith(RELEASE_IMAGE_PREFIX);
+}
+
 /** The release image's mode word for the companion container
  * (docker/entrypoint.sh): provision pi, start the tmux server, stay alive. */
 export const COMPANION_MODE = "companion";
@@ -560,6 +570,23 @@ export class CompanionLifecycle {
    * companion's tmux server. A field so tests need not wait it out. */
   wrapperStartWaitMs = WRAPPER_START_WAIT_MS;
 
+  /** An image already on this machine to run instead of BUILDING the default
+   * one: the release image a compose box pulled (`ghcr.io/…:<QCR_VERSION>`,
+   * the same docker/Dockerfile CI built). Consulted only on a cold create,
+   * only while `[companion] image` is the shipped default, and only when no
+   * local build of that default exists — so an explicit image and a
+   * contributor's `qcr companion rebuild` both keep winning. */
+  preferredImage: string | undefined;
+
+  /** The image this instance runs: `[companion] image`, until a cold create
+   * adopts `preferredImage`. */
+  private imageInUse: string | undefined;
+
+  /** The image a create runs (and a build tags). */
+  get image(): string {
+    return this.imageInUse ?? this.cfg.image;
+  }
+
   /** The shared socket in `tmux-socket` mode, else undefined. */
   get socketPath(): string | undefined {
     return this.mode === "tmux-socket" ? tmuxSocketPath(this.cfg) : undefined;
@@ -620,7 +647,7 @@ export class CompanionLifecycle {
     // The agent is reached by its mounted socket; no key is in the container.
     if (this.sshSources().agent !== undefined) argv.push("--env", `SSH_AUTH_SOCK=${SSH.agent}`);
     // The release image, in its companion mode (docker/entrypoint.sh).
-    argv.push(this.cfg.image, COMPANION_MODE);
+    argv.push(this.image, COMPANION_MODE);
     return argv;
   }
 
@@ -672,6 +699,13 @@ export class CompanionLifecycle {
       "--theme",
       `${ext}/muted-theme.json`,
       "--extension",
+      // The login route (extensions/login-route.ts), before the inject bridge so
+      // the day-open delivery meets a routed model: a companion whose model's
+      // provider has no login runs the same model on the other OpenAI login
+      // when that one exists, and a companion with no usable login at all says
+      // which logins work and leaves `/login` on its input line.
+      `${ext}/cli/login-route.ts`,
+      "--extension",
       // Day-open channel: the daemon's inject bridge, unmodified. It
       // drains its directory on session_start before it starts watching, so
       // the rollover can queue the opening message before pi is spawned and
@@ -926,10 +960,27 @@ export class CompanionLifecycle {
 
   /** True when the companion image exists locally. */
   async imageExists(): Promise<boolean> {
-    const res = await this.docker(["image", "inspect", this.cfg.image]);
+    const res = await this.docker(["image", "inspect", this.image]);
     return res.ok;
   }
 
+  /**
+   * Before a cold create builds the default image: adopt the preferred
+   * (already-pulled release) image when the default is not built here and the
+   * preferred one is. True when the image to run now exists.
+   */
+  private async adoptPreferredImage(onProgress?: (line: string) => void): Promise<boolean> {
+    if (await this.imageExists()) return true;
+    const preferred = this.preferredImage;
+    if (preferred === undefined || preferred === "" || this.cfg.image !== COMPANION_IMAGE)
+      return false;
+    const res = await this.docker(["image", "inspect", preferred]);
+    if (!res.ok) return false;
+    this.imageInUse = preferred;
+    onProgress?.(`using the release image ${preferred}, already pulled — no local build`);
+    return true;
+  }
+
   /** Remove the container, running or not. Volumes (pihome: OAuth, the
    * conversation) survive — this replaces the container, never its memory. */
   async removeContainer(): Promise<void> {
@@ -945,9 +996,22 @@ export class CompanionLifecycle {
     if (!res.ok) throw new Error(`docker rm ${this.cfg.container_name} failed: ${errText(res)}`);
   }
 
+  /** `docker pull` of a configured release image the machine does not have. */
+  private async pullImage(onProgress?: (line: string) => void): Promise<void> {
+    onProgress?.(`pulling ${this.image} (first run — a few minutes)…`);
+    const res = await this.docker(["pull", this.image], { timeoutMs: 1_800_000 });
+    if (!res.ok) throw new Error(`docker pull ${this.image} failed: ${errText(res)}`);
+    onProgress?.(`${this.image} pulled`);
+  }
+
   /** Throws when the image cannot be built (`imageBuildProblem`) — asked
    * before anything is removed for a rebuild. */
   checkBuildable(): void {
+    if (isReleaseImage(this.image))
+      throw new Error(
+        `${this.image} is a published release image — it is pulled (docker pull ${this.image}), never built over; ` +
+          `set [companion] image = "${COMPANION_IMAGE}" to build one from this checkout`,
+      );
     const problem = imageBuildProblem(this.cfg.build_context, (p) => this.fs.exists(p));
     if (problem !== null) throw new Error(problem);
   }
@@ -960,21 +1024,21 @@ export class CompanionLifecycle {
   async buildImage(onProgress?: (line: string) => void): Promise<void> {
     this.checkBuildable();
     const ctx = this.cfg.build_context;
-    onProgress?.(`building ${this.cfg.image} image (first run — takes a few minutes)…`);
+    onProgress?.(`building ${this.image} image (first run — takes a few minutes)…`);
     // The stamp is the checkout's; the build reads an assembled copy of the
     // release context, so it works on the legacy builder too.
     const stamp = this.stampOf(ctx);
     const built = this.assembleContext(ctx);
     let res;
     try {
-      res = await this.docker(appImageBuildArgv(this.cfg.image, built, stamp), {
+      res = await this.docker(appImageBuildArgv(this.image, built, stamp), {
         timeoutMs: 1_800_000,
       });
     } finally {
       if (built !== ctx) rmSync(built, { recursive: true, force: true });
     }
-    if (!res.ok) throw new Error(`docker build ${this.cfg.image} failed: ${errText(res)}`);
-    onProgress?.(`${this.cfg.image} image built`);
+    if (!res.ok) throw new Error(`docker build ${this.image} failed: ${errText(res)}`);
+    onProgress?.(`${this.image} image built`);
   }
 
   // ---- memory wiring --------------------------------------------------------
@@ -1266,8 +1330,13 @@ export class CompanionLifecycle {
       onProgress?.(`companion container unstartable (${firstLine(errText(started))}) — recreating`);
       await this.forceRemove();
     }
-    // Self-healing first run: build the image rather than failing on its absence.
-    if (!(await this.imageExists())) await this.buildImage(onProgress);
+    // Self-healing first run: the pulled release image when there is one,
+    // else build the image rather than failing on its absence — or, for a
+    // configured release image, pull it (a release tag is never built over).
+    if (!(await this.adoptPreferredImage(onProgress))) {
+      if (isReleaseImage(this.image)) await this.pullImage(onProgress);
+      else await this.buildImage(onProgress);
+    }
     const homes = this.hostHomes();
     this.ensureDirs([
       this.cfg.feed_dir,
@@ -1280,7 +1349,7 @@ export class CompanionLifecycle {
       homes.github,
     ]);
     const created = await this.docker(this.runArgv(), { timeoutMs: 120_000 });
-    if (!created.ok) throw new Error(`docker run ${this.cfg.image} failed: ${errText(created)}`);
+    if (!created.ok) throw new Error(`docker run ${this.image} failed: ${errText(created)}`);
     return st.exists || recreating ? "recreated" : "created";
   }
 

package/src/tui/connect.ts

@@ -11,7 +11,7 @@
 // the exact remedy; pressing `s` is the operator asking for this prompt.
 import { spawnSync } from "node:child_process";
 import type { TuiConfig } from "../config.js";
-import { transportOf } from "./remote.js";
+import { NO_SSH_HOST_STDERR, transportOf } from "./remote.js";
 
 export function masterCheckArgv(cfg: TuiConfig): string[] {
   return ["-O", "check", cfg.ssh_host];
@@ -51,6 +51,12 @@ export function ensureSshMaster(
   // at the call sites) so the board's `s` reconnect hook and any future caller
   // inherit the guarantee: in local mode this function spawns nothing.
   if (transportOf(cfg) === "local") return { kind: "local" };
+  // No host, nothing to connect to: `ssh "" true` only ever fails on name
+  // resolution, and the passphrase prompt it promises would never come.
+  if (cfg.ssh_host.trim() === "") {
+    say(NO_SSH_HOST_STDERR);
+    return { kind: "failed", detail: NO_SSH_HOST_STDERR };
+  }
   if (ssh(masterCheckArgv(cfg), false).status === 0) return { kind: "alive" };
   say(
     `connecting to ${cfg.ssh_host} — enter the GCP key passphrase if asked (once; the connection is shared for 4h)`,

package/src/tui/deploytab.ts

@@ -1,6 +1,6 @@
 // `[5] deploy` — "what would a deploy ship?" plus the deploy button.
-// Every deploy is a RELEASE: the tag, the two-arch build, the paid e2e and the
-// owner's approval already happened in CI, so the tab only chooses a version.
+// Every deploy is a RELEASE: the tag and the two-arch build with its smoke
+// already happened in CI, so the tab only chooses a version.
 // It shows the version and revision the VM runs (`qcr-update status --json`,
 // read over ssh) against the chosen version, the commits between the two
 // revisions (from the local checkout), and deploy.sh's own

package/src/tui/filters.ts

@@ -5,7 +5,8 @@
 // they never touch the poller's snapshot or the memory store.
 import { normalizeTag } from "../memory/store.js";
 import type { MemoryEntry } from "./memory.js";
-import { sortPrs, type SnapshotPr } from "./model.js";
+import type { StatusSnapshot } from "../state.js";
+import { offeredPrs, sortPrs, type SnapshotPr } from "./model.js";
 
 export interface BoardFilter {
   /** Case-insensitive substring match against the PR author login. */
@@ -76,10 +77,13 @@ export function applyMemoryFilter<T extends Pick<MemoryEntry, "tags">>(
  * companion driver all derive rows from here, so a verb can never address a
  * row the filter hid. */
 export function visiblePrs(view: {
-  snapshot?: { prs: SnapshotPr[] };
+  snapshot?: { prs: SnapshotPr[]; open_prs?: StatusSnapshot["open_prs"] };
   boardFilter?: BoardFilter | null;
 }): SnapshotPr[] {
-  return applyBoardFilter(sortPrs(view.snapshot?.prs ?? []), view.boardFilter);
+  const tracked = applyBoardFilter(sortPrs(view.snapshot?.prs ?? []), view.boardFilter);
+  // The repo's other open PRs follow, offered for review — under a filter the
+  // board shows only what the filter names.
+  return view.boardFilter != null ? tracked : [...tracked, ...offeredPrs(view.snapshot)];
 }
 
 /** The memory view's indicator, same shape as the board's. */