@quickchatai/quickreview 1.1.0 → 1.2.0

package/src/reviewnow.ts

@@ -0,0 +1,76 @@
+// "Review this PR now" — the operator's `review-now` command (src/commands.ts,
+// root-sealed operator channel only).
+//
+// It queues ONE pull request for a human-asked round, the same state-machine
+// event a fresh trigger label produces (`trigger`, source `manual`, so the
+// round's provenance is the person's ask and dispatch reviews it in full),
+// and then pumps dispatch. It makes no GitHub write to ask for the review:
+// the label path stays the way later reviews are requested, and every write
+// the round itself makes still goes through the one MutationGate.
+//
+// The PR is read from GitHub first (one GET), so a closed or merged PR, or a
+// number that is not a PR of the reviewed repo, is refused with its reason
+// instead of being adopted into the state store.
+import type { PrRef } from "./github.js";
+import type { FileOutcome } from "./improvements.js";
+import { applyEvent } from "./statemachine.js";
+import type { StateStore } from "./state.js";
+
+export interface ReviewNowDeps {
+  store: StateStore;
+  /** The PR as GitHub has it (read-only). */
+  getPr(n: number): Promise<PrRef>;
+  pump(): Promise<void>;
+  /** The App's bot login, whose own PRs are never reviewed. Absent on the
+   * own-account route, where the "bot" is the person and their own PRs are
+   * exactly what they ask to have reviewed. */
+  botLogin?: string;
+  now?: () => Date;
+}
+
+export async function reviewNow(deps: ReviewNowDeps, pr: number): Promise<FileOutcome> {
+  let ref: PrRef;
+  try {
+    ref = await deps.getPr(pr);
+  } catch (err) {
+    return {
+      ok: false,
+      reason: `could not read PR #${pr} from GitHub: ${err instanceof Error ? err.message : String(err)}`,
+    };
+  }
+  if (ref.merged) return { ok: false, reason: `PR #${pr} is merged — there is nothing to review` };
+  if (ref.state !== "open") return { ok: false, reason: `PR #${pr} is closed` };
+  const local = deps.store.getPr(pr);
+  if (local?.paused)
+    return { ok: false, reason: `PR #${pr} is paused — resume it first (qcr resume-pr ${pr})` };
+  // The worker crash-loop breaker parks a PR after repeated worker failures
+  // (a missing model login is the usual first-install cause). Asking for this
+  // PR's review is the operator's word that it may run again, exactly as
+  // rerun-round's unpark is — without it the new round could never start.
+  if (deps.store.clearWorkerBreaker(pr))
+    deps.store.logEvent("worker_unparked", pr, { by: "review-now" });
+  const result = applyEvent(
+    deps.store,
+    pr,
+    { type: "trigger", source: "manual" },
+    {
+      title: ref.title,
+      head_sha: ref.head_sha,
+      author: ref.author,
+      trigger_ts: (deps.now ?? (() => new Date()))().toISOString(),
+    },
+    {
+      ...(deps.botLogin ? { botLogin: deps.botLogin } : {}),
+      ...(deps.now ? { now: deps.now } : {}),
+      reason: "operator:review-now",
+    },
+  );
+  if (result.skipped === "bot-author")
+    return {
+      ok: false,
+      reason: `PR #${pr} is authored by the bot itself — it never reviews its own PRs`,
+    };
+  await deps.pump();
+  const state = deps.store.getPr(pr)?.state ?? result.to;
+  return { ok: true, pr, state, head_sha: ref.head_sha };
+}

package/src/state.ts

@@ -7767,12 +7767,30 @@ export interface RoundStageBounds {
 export const PR_RUNTIMES = ["tmux", "worker", "answer", "idle", "debug", "takeover"] as const;
 export type PrRuntime = (typeof PR_RUNTIMES)[number];
 
+/** One open pull request as the board lists it (src/reconcile.ts lists them). */
+export interface OpenPrSummary {
+  number: number;
+  title: string;
+  author: string;
+  draft: boolean;
+  updated_at: string;
+}
+
+export interface OpenPrsSnapshot {
+  listed_at: string;
+  prs: OpenPrSummary[];
+}
+
 export interface StatusSnapshot {
   written_at: string;
   dry_run: boolean;
   /** Where the daemon runs (src/runhost.ts). Absent: not reported (an older
    * daemon, or one assembled without its host facts). */
   run_host?: import("./runhost.js").RunHostStatus;
+  /** Every open pull request of the reviewed repo, as the last successful
+   * reconcile pass listed it (tracked or not): what the board offers to
+   * review. Absent until a pass has listed them. */
+  open_prs?: OpenPrsSnapshot;
   prs: Array<
     Pick<PrStateRow, "number" | "state" | "title" | "head_sha" | "stale_recheck"> &
       Partial<Pick<PrStateRow, "trigger_ts" | "updated_at" | "author" | "paused">> & {

package/src/statemachine.ts

@@ -205,7 +205,10 @@ function applyEventTransaction(
   const now = opts.now ?? (() => new Date());
   const existing = store.getPr(pr);
   const author = meta.author ?? existing?.author ?? "";
-  if (opts.botLogin && author && isBotAuthor(author, opts.botLogin)) {
+  // `botLogin` is the bot ACCOUNT (identity.ts `botAccountLogin`): "" in
+  // person mode, where the person's own PRs are the target and only
+  // `[bot]`-suffixed accounts are skipped. Absent ⇒ nothing is skipped.
+  if (opts.botLogin !== undefined && author && isBotAuthor(author, opts.botLogin)) {
     return {
       pr,
       from: existing?.state ?? null,

package/src/takeoverpi.ts

@@ -28,6 +28,7 @@ import { chmodSync, copyFileSync, existsSync, readFileSync, unlinkSync } from "n
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { GITHUB_TOKEN_ENVS } from "@quickchatai/pi-quickreview/src/envstrip.js";
+import { routeModelSpecForLogin } from "@quickchatai/pi-quickreview/src/modelroute.js";
 import { CAP_FD_INDEX } from "./ipc/capability.js";
 import {
   PI_REFRESH_MARGIN_MS,
@@ -102,6 +103,15 @@ export function readTakeoverSpec(file: string): TakeoverSpec {
   return raw as TakeoverSpec;
 }
 
+/** The login file in an agent dir, as text; null when there is none. */
+export function readLogin(agentDir: string): string | null {
+  try {
+    return readFileSync(join(agentDir, "auth.json"), "utf8");
+  } catch {
+    return null;
+  }
+}
+
 /**
  * The pi's own agent dir: the owner's login borrowed as a refresh-blanked copy
  * (0600, refused when its token would expire inside the lease's idle window plus
@@ -259,6 +269,9 @@ export async function runTakeover(specFile: string, deps: TakeoverRunDeps = {}):
     return 3;
   }
   const env = takeoverEnv(procEnv, spec);
+  // An OpenAI model runs on the OpenAI login the borrowed copy holds
+  // (packages/pi-plugin/src/modelroute.ts): the spec's own provider when it is there.
+  spec = { ...spec, model: routeModelSpecForLogin(spec.model, readLogin(spec.borrow_dir), env) };
   const pi = paneLaunch(takeoverArgv(spec), deps.piBin ?? spec.pi_bin);
   const launch = toolIsolation(pi.bin, pi.argv, procEnv);
   if ("refused" in launch) {

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 — qcr onboard${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" },