@mgiles/perk 1.1.0 → 2.0.0

package/extension/doors/prReviewBrowser.ts

@@ -0,0 +1,341 @@
+// The warm `/pr-review-browser` door: the BROWSER entry into human-in-the-loop adversarial PR
+// review — plannotator always, no provider dispatch (the surface-named command IS the selection).
+//
+// Three modes, keyed off the arg parse + the active-PR resolution ladder (the parse is IMPORTED
+// from prReviewTerminal.ts — one function ⇒ identical arg semantics by construction):
+//   foreign — `/pr-review-browser <pr|url> [focus]`: the detached `perk pr review checkout`, the
+//             browser opened in the background on the PR URL, the async adversarial-reviewer
+//             fan-out with per-angle annotation waves streamed to the local plannotator server.
+//   active  — `/pr-review-browser [focus]` from a plan worktree whose branch HAS a PR: the same
+//             flow re-homed to the human's own worktree (no checkout, no cleanup).
+//   local   — no PR yet (`perk pr url` → `no_pr`): the absorbed pre-PR since-base browser review
+//             ({cwd, diffType: "since-base", defaultBranch: the plan-ref base}) — NO reviewers,
+//             no guidance injection, no port dance (no waves to stream); the door ends
+//             immediately and the single respond routes back later.
+//
+// THE BACKGROUND OPEN: the server URL is deterministic the moment the port is picked
+// (plannotator reads `PLANNOTATOR_PORT` at bind time — see plannotatorHandoff.ts), so in the PR
+// modes the handler starts `startPlannotatorBrowser`, injects the mode guidance IMMEDIATELY, and
+// ends its turn — no blocking readiness poll in the handler. The readiness promise is observed
+// in a background task: ready → an info note; timeout / an error-or-unavailable bridge settle →
+// a loud error plus a degrade notice injected to the model (findings render in-session; posting
+// unchanged). The guidance's wave discipline is hold-and-accumulate: a refused POST before any
+// door failure notice means "not up yet", never a degrade.
+//
+// THE POSTING FLIP (contracts §8.4): plannotator's native platform-posting is THE GitHub path —
+// the human posts inline comments + APPROVE/COMMENT directly from the UI. Perk composes nothing
+// by default; `submit_pr_review` (gates unchanged) is used ONLY for a request-changes verdict
+// (the UI cannot post it) or on the human's explicit request. The door registers NO tools — the
+// annotation waves are agent-driven HTTP per the guidance, and perk-side posting reuses
+// `submit_pr_review` (registered by `registerSubmitPrReview`).
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { bindingSuffix } from "../substrate/bindingDelivery.ts";
+import { runColdDoor } from "../substrate/coldDoor.ts";
+import { registerPerkCommand } from "../substrate/command.ts";
+import { loadPerkConfig } from "../substrate/config.ts";
+import { interceptConsoleError } from "../substrate/consoleCapture.ts";
+import { render } from "../substrate/prompts.ts";
+import { type ReportTarget, report } from "../surfaces/report.ts";
+import { type CheckoutOk, decodeCheckout } from "./hunkHandoff.ts";
+import {
+  decodePrUrl,
+  LOCAL_REVIEW_DIFF_TYPE,
+  plannotatorPresent,
+  planRefBaseOf,
+  type RespondSink,
+  requestPlannotatorCodeReview,
+  resolveReviewTarget,
+  routeBrowserRespond,
+  routePrReviewOutcome,
+  type StartedBrowser,
+  startPlannotatorBrowser,
+} from "./plannotatorHandoff.ts";
+import { parseReviewDoorArgs } from "./prReviewTerminal.ts";
+
+/** The door's report scope — also the `command:<id>` binding trigger id. */
+const SCOPE = "pr-review-browser";
+
+// ------------------------------------------------------------------------ guidance
+
+/** The per-mode guidance selector input (the local mode injects no guidance at all). */
+export interface PrReviewBrowserGuidanceOpts {
+  mode: "foreign" | "active";
+  pr: number;
+  prUrl: string;
+  worktree: string;
+  url: string;
+  model?: string;
+  directive?: string;
+}
+
+/**
+ * The seed guidance the door injects (the perk-pr-review-browser skill pointer rides the
+ * skill-binding suffix — command:pr-review-browser — not hardcoded here). Pure + exported for
+ * offline tests.
+ * Mode selects the arm file under `prompts/stages/pr-review-browser/` (the bodies differ
+ * load-bearingly: foreign carries the untrusted-checkout framing + cleanup; active re-homes to
+ * the human's worktree with neither). The local mode has no template — the door injects nothing.
+ */
+export function prReviewBrowserGuidance(opts: PrReviewBrowserGuidanceOpts): string {
+  return render(`stages/pr-review-browser/${opts.mode}.md`, {
+    pr: String(opts.pr),
+    pr_url: opts.prUrl,
+    worktree: opts.worktree,
+    url: opts.url,
+    model: opts.model ?? "",
+    directive: opts.directive ?? "",
+  });
+}
+
+// ------------------------------------------------------------------------ the background open
+
+/**
+ * The degrade notice injected when the browser never comes up — the model renders the findings
+ * in-session and runs the same triage conversationally; the posting contract is unchanged.
+ */
+const DEGRADE_NOTICE =
+  "The plannotator browser review is unavailable (the review server never became ready) — " +
+  "degrade in-session: render the reviewers' reconciled findings as a table in your reply and " +
+  "run the same triage loop conversationally. Posting is unchanged: perk composes nothing by " +
+  "default; `submit_pr_review` (dry-run first; gates unchanged) only for a request-changes " +
+  "verdict or on the human's explicit request.";
+
+/**
+ * Observe the readiness poll in the background (the handler has already injected the guidance
+ * and ended): ready → an info note naming the URL; timeout / an error-or-unavailable bridge
+ * settle → a loud error report PLUS the degrade notice injected to the model (idle → immediate,
+ * streaming → followUp). A bridge that settled `handled` (the human finished before the poll saw
+ * the server) or `aborted` routes via the respond routing alone — no degrade. Structural param
+ * slices keep it offline-testable; exported for the door tests.
+ */
+export async function observeBrowserReadiness(
+  pi: RespondSink,
+  ctx: ReportTarget & Pick<ExtensionContext, "isIdle">,
+  started: StartedBrowser,
+): Promise<void> {
+  const state = await started.readiness;
+  if (state === "ready") {
+    report(ctx, SCOPE, "info", `plannotator is up at ${started.url} — browser opening`);
+    return;
+  }
+  if (state === "aborted") return; // the turn was interrupted — no-op
+  if (state === "bridge_settled") {
+    const out = await started.bridgePromise;
+    if (out.status === "handled" || out.status === "aborted") return;
+  }
+  report(
+    ctx,
+    SCOPE,
+    "error",
+    `the plannotator review server did not become ready at ${started.url} — the browser ` +
+      "review is unavailable",
+    { alsoLog: true },
+  );
+  if (ctx.isIdle()) {
+    pi.sendUserMessage(DEGRADE_NOTICE);
+  } else {
+    pi.sendUserMessage(DEGRADE_NOTICE, { deliverAs: "followUp" });
+  }
+}
+
+/**
+ * The shared PR-mode arm (foreign + active): start the browser open in the background, inject
+ * the mode guidance immediately (the URL is deterministic once the port is picked), and return —
+ * the readiness observation and the bridge respond both ride background tasks. While plannotator
+ * sets up, its in-process `console.error` chatter re-routes through the TUI-safe report() seam
+ * (the debounce restores once setup goes quiet, with the `finally` as a backstop).
+ */
+async function openBrowserAndGuide(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  opts: Omit<PrReviewBrowserGuidanceOpts, "url">,
+): Promise<void> {
+  let started: StartedBrowser;
+  try {
+    started = await startPlannotatorBrowser(pi.events, {
+      prUrl: opts.prUrl,
+      cwd: ctx.cwd,
+      signal: ctx.signal,
+    });
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    report(
+      ctx,
+      SCOPE,
+      "error",
+      `could not pick a free local port for the plannotator review server: ${detail}`,
+      { alsoLog: true },
+    );
+    return;
+  }
+
+  void observeBrowserReadiness(pi, ctx, started);
+
+  void (async () => {
+    const interceptor = interceptConsoleError((line) => report(ctx, SCOPE, "info", line), {
+      // plannotator can pause up to ~4s between setup lines — keep the quiet window above that.
+      quietMs: 6000,
+    });
+    try {
+      const out = await started.bridgePromise;
+      routeBrowserRespond(pi, ctx, out, SCOPE);
+    } finally {
+      interceptor.restore();
+    }
+  })();
+
+  pi.sendUserMessage(
+    prReviewBrowserGuidance({ ...opts, url: started.url }) +
+      bindingSuffix(ctx.cwd, `command:${SCOPE}`),
+  );
+}
+
+// ------------------------------------------------------------------------ registration
+
+/** Register the warm `/pr-review-browser` command (no tools — posting rides submit_pr_review). */
+export function registerPrReviewBrowser(pi: ExtensionAPI): void {
+  registerPerkCommand(pi, SCOPE, {
+    description:
+      "Review a PR human-in-the-loop in the plannotator browser UI: no arg reviews the active " +
+      "worktree's PR (or, pre-PR, opens a since-base browser review); a PR number/URL reviews " +
+      "that foreign PR. Any other text is a focus note for the reviewers. You post to GitHub " +
+      "from the browser.",
+    handler: async (args, ctx: ExtensionContext) => {
+      // Entry gates, in order — nothing executed on refusal, each a loud error.
+      const parsed = parseReviewDoorArgs(args ?? "");
+      if (parsed === null) {
+        report(ctx, SCOPE, "error", "usage: /pr-review-browser [pr number|url] [focus note]");
+        return;
+      }
+      if (!ctx.hasUI) {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          "/pr-review-browser requires an interactive session — the plannotator browser " +
+            "surface and the human are constitutive",
+        );
+        return;
+      }
+      if (!plannotatorPresent(pi)) {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          "the plannotator extension is not loaded (its /plannotator-review command was not " +
+            "found) — select the plannotator plan provider (`[providers] plan = " +
+            '"plannotator-plan"`), run `perk init`, then restart pi',
+        );
+        return;
+      }
+
+      const config = loadPerkConfig(ctx.cwd);
+      const model = config.subagents["adversarial-reviewer"] ?? "";
+
+      if (parsed.mode === "foreign") {
+        // The foreign arm: the detached checkout, then the background browser open.
+        const checkout = await runColdDoor<CheckoutOk>(
+          pi,
+          ctx,
+          ["pr", "review", "checkout", "--pr", String(parsed.pr), "--json"],
+          { label: "perk pr review checkout", decode: decodeCheckout },
+        );
+        if (!checkout.ok) {
+          report(
+            ctx,
+            SCOPE,
+            "error",
+            `perk pr review checkout failed (${checkout.errorType}): ${checkout.message}`,
+            { alsoLog: true },
+          );
+          return;
+        }
+        report(
+          ctx,
+          SCOPE,
+          "info",
+          parsed.directive
+            ? `PR #${parsed.pr} → adversarial reviewers (focus: ${parsed.directive}) → plannotator browser triage → you post from the browser`
+            : `PR #${parsed.pr} → adversarial reviewers → plannotator browser triage → you post from the browser`,
+        );
+        await openBrowserAndGuide(pi, ctx, {
+          mode: "foreign",
+          pr: parsed.pr,
+          prUrl: checkout.data.url,
+          worktree: checkout.data.path,
+          model,
+          directive: parsed.directive,
+        });
+        return;
+      }
+
+      // The active arm: resolve the worktree's own PR via the shared ladder.
+      const r = await runColdDoor<{ number: number; url: string }>(
+        pi,
+        ctx,
+        ["pr", "url", "--json"],
+        { label: "perk pr url", decode: decodePrUrl },
+      );
+      const target = resolveReviewTarget(r, planRefBaseOf(ctx.cwd));
+      if (target.mode === "fail") {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          `${target.message} (${target.errorType}) — pass a PR number/URL, or run from a plan ` +
+            "worktree",
+        );
+        return;
+      }
+
+      if (target.mode === "pr") {
+        report(
+          ctx,
+          SCOPE,
+          "info",
+          parsed.directive
+            ? `PR #${target.number} (active worktree) → adversarial reviewers (focus: ${parsed.directive}) → plannotator browser triage → you post from the browser`
+            : `PR #${target.number} (active worktree) → adversarial reviewers → plannotator browser triage → you post from the browser`,
+        );
+        await openBrowserAndGuide(pi, ctx, {
+          mode: "active",
+          pr: target.number,
+          prUrl: target.prUrl,
+          worktree: ctx.cwd,
+          model,
+          directive: parsed.directive,
+        });
+        return;
+      }
+
+      // The local / pre-PR mode (the absorbed since-base browser review): no reviewers, no
+      // guidance, no port dance (no waves to stream — no endpoint needed). The bridge runs in
+      // the background and the single respond routes back via routePrReviewOutcome.
+      report(
+        ctx,
+        SCOPE,
+        "info",
+        `No PR yet — opening plannotator local review (since-base vs ${target.defaultBranch ?? "repo default"}) …`,
+      );
+      void (async () => {
+        const interceptor = interceptConsoleError((line) => report(ctx, SCOPE, "info", line), {
+          // plannotator can pause up to ~4s between setup lines — keep the quiet window
+          // comfortably above that so the debounce doesn't restore mid-setup.
+          quietMs: 6000,
+        });
+        try {
+          const out = await requestPlannotatorCodeReview(pi.events, {
+            cwd: ctx.cwd,
+            diffType: LOCAL_REVIEW_DIFF_TYPE,
+            defaultBranch: target.defaultBranch,
+            signal: ctx.signal,
+          });
+          routePrReviewOutcome(pi, ctx, out, SCOPE);
+        } finally {
+          interceptor.restore();
+        }
+      })();
+    },
+  });
+}

package/extension/doors/prReviewTerminal.ts

@@ -0,0 +1,267 @@
+// The warm `/pr-review-terminal` door: the TERMINAL entry into human-in-the-loop adversarial PR
+// review — hunk always, no provider dispatch (the surface-named command IS the selection).
+//
+// Three modes, keyed off the arg parse + the active-PR resolution ladder:
+//   foreign — `/pr-review-terminal <pr|url> [focus]`: the detached `perk pr review checkout`,
+//             the R7 handoff, the full adversarial-reviewer flow (async fan-out + live findings
+//             streaming per the injected guidance).
+//   active  — `/pr-review-terminal [focus]` from a plan worktree whose branch HAS a PR: the same
+//             flow re-homed to the human's own worktree (no checkout, no cleanup) on the local
+//             since-base diff (`sinceBaseSha` — best-effort fetch, then merge-base).
+//   local   — no PR yet (`perk pr url` → `no_pr`): a surface-only since-base review — hunk is
+//             launched, NO reviewers are spawned and NOTHING posts to GitHub; the guidance is a
+//             minimal notes read-back loop.
+// Every launch carries `--agent-notes` so pushed findings are visible in hunk immediately.
+//
+// The door registers NO tools — posting reuses `submit_pr_review` (registered by
+// `registerSubmitPrReview`), whose gate ladder (contracts §8.4) applies unchanged.
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { bindingSuffix } from "../substrate/bindingDelivery.ts";
+import { runColdDoor } from "../substrate/coldDoor.ts";
+import { registerPerkCommand } from "../substrate/command.ts";
+import { loadPerkConfig } from "../substrate/config.ts";
+import { sinceBaseSha } from "../substrate/git.ts";
+import { render } from "../substrate/prompts.ts";
+import { report } from "../surfaces/report.ts";
+import {
+  type CheckoutOk,
+  decodeCheckout,
+  HUNK_INSTALL_HINT,
+  handleHunkLaunch,
+  hunkPresent,
+  parseReviewArgs,
+} from "./hunkHandoff.ts";
+import { decodePrUrl, planRefBaseOf, resolveReviewTarget } from "./plannotatorHandoff.ts";
+
+/** The door's report scope — also the `command:<id>` binding trigger id. */
+const SCOPE = "pr-review-terminal";
+
+// ------------------------------------------------------------------------ arg parse
+
+/** A parsed review-door invocation: foreign (a PR arg) or active (everything else). */
+export type ReviewDoorArgs =
+  | { mode: "foreign"; pr: number; directive: string }
+  | { mode: "active"; directive: string };
+
+/**
+ * Parse the review-door args (shared by BOTH doors — the browser door imports this, so one
+ * function ⇒ identical grammar by construction) — both tokens optional:
+ * - empty/whitespace → active mode, no focus;
+ * - a leading PR number/URL (the shared PR-token grammar) → foreign mode (+ optional focus);
+ * - a leading `http(s)://` token that FAILS the PR parse → null (usage error: a mistyped PR URL
+ *   never silently becomes a focus note);
+ * - anything else → active mode with the whole string as the focus note.
+ */
+export function parseReviewDoorArgs(args: string): ReviewDoorArgs | null {
+  const trimmed = args.trim();
+  if (trimmed.length === 0) return { mode: "active", directive: "" };
+  const parsed = parseReviewArgs(trimmed);
+  if (parsed !== null) return { mode: "foreign", pr: parsed.pr, directive: parsed.directive };
+  const first = trimmed.split(/\s+/, 1)[0] ?? "";
+  if (/^https?:\/\//.test(first)) return null;
+  return { mode: "active", directive: trimmed };
+}
+
+// ------------------------------------------------------------------------ guidance
+
+/** The per-mode guidance selector input (the local arm has no PR and threads no directive). */
+export type PrReviewTerminalGuidanceOpts =
+  | {
+      mode: "foreign" | "active";
+      pr: number;
+      worktree: string;
+      baseSha: string;
+      model?: string;
+      directive?: string;
+    }
+  | { mode: "local"; worktree: string; baseSha: string };
+
+/**
+ * The seed guidance the door injects (the perk-pr-review-terminal skill pointer rides the
+ * skill-binding suffix — command:pr-review-terminal — not hardcoded here). Pure + exported for
+ * offline tests.
+ * Mode selects the arm file under `prompts/stages/pr-review-terminal/` (the bodies differ
+ * load-bearingly: foreign carries the untrusted-checkout framing + cleanup; active re-homes to
+ * the human's worktree with neither; local is the reviewers-skipped surface-only note).
+ */
+export function prReviewTerminalGuidance(opts: PrReviewTerminalGuidanceOpts): string {
+  if (opts.mode === "local") {
+    return render("stages/pr-review-terminal/local.md", {
+      worktree: opts.worktree,
+      base_sha: opts.baseSha,
+    });
+  }
+  return render(`stages/pr-review-terminal/${opts.mode}.md`, {
+    pr: String(opts.pr),
+    worktree: opts.worktree,
+    base_sha: opts.baseSha,
+    model: opts.model ?? "",
+    directive: opts.directive ?? "",
+  });
+}
+
+// ------------------------------------------------------------------------ registration
+
+/** Register the warm `/pr-review-terminal` command (no tools — posting rides submit_pr_review). */
+export function registerPrReviewTerminal(pi: ExtensionAPI): void {
+  registerPerkCommand(pi, SCOPE, {
+    description:
+      "Review a PR human-in-the-loop in the hunk terminal TUI: no arg reviews the active " +
+      "worktree's PR (or, pre-PR, opens a since-base hunk review); a PR number/URL reviews " +
+      "that foreign PR. Any other text is a focus note for the reviewers.",
+    handler: async (args, ctx: ExtensionContext) => {
+      // Entry gates, in order — nothing executed on refusal, each a loud error.
+      const parsed = parseReviewDoorArgs(args ?? "");
+      if (parsed === null) {
+        report(ctx, SCOPE, "error", "usage: /pr-review-terminal [pr number|url] [focus note]");
+        return;
+      }
+      if (!ctx.hasUI) {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          "/pr-review-terminal requires an interactive session — the hunk surface and the " +
+            "human triage are constitutive",
+        );
+        return;
+      }
+      if (!(await hunkPresent(pi, ctx))) {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          `the \`hunk\` review CLI is not available — install it: ${HUNK_INSTALL_HINT}`,
+        );
+        return;
+      }
+
+      const config = loadPerkConfig(ctx.cwd);
+      const model = config.subagents["adversarial-reviewer"] ?? "";
+
+      if (parsed.mode === "foreign") {
+        // The foreign arm: detached checkout + handoff.
+        const checkout = await runColdDoor<CheckoutOk>(
+          pi,
+          ctx,
+          ["pr", "review", "checkout", "--pr", String(parsed.pr), "--json"],
+          { label: "perk pr review checkout", decode: decodeCheckout },
+        );
+        if (!checkout.ok) {
+          report(
+            ctx,
+            SCOPE,
+            "error",
+            `perk pr review checkout failed (${checkout.errorType}): ${checkout.message}`,
+            { alsoLog: true },
+          );
+          return;
+        }
+        report(
+          ctx,
+          SCOPE,
+          "info",
+          parsed.directive
+            ? `PR #${parsed.pr} → adversarial reviewers (focus: ${parsed.directive}) → hunk triage → curated post`
+            : `PR #${parsed.pr} → adversarial reviewers → hunk triage → curated post`,
+        );
+        // 12 hex chars: the full sha wraps in the TUI and a wrapped paste runs a bare
+        // `hunk diff`; git resolves 12 chars unambiguously (the first dogfood's lesson).
+        const baseSha = checkout.data.base_sha.slice(0, 12);
+        const hunkCmd = `hunk diff ${baseSha} --agent-notes`;
+        const launchLine = `cd ${checkout.data.path} && ${hunkCmd}`;
+        await handleHunkLaunch(pi, ctx, {
+          cwd: checkout.data.path,
+          hunkCmd,
+          launchLine,
+          scope: SCOPE,
+        });
+        pi.sendUserMessage(
+          prReviewTerminalGuidance({
+            mode: "foreign",
+            pr: parsed.pr,
+            worktree: checkout.data.path,
+            baseSha,
+            model,
+            directive: parsed.directive,
+          }) + bindingSuffix(ctx.cwd, `command:${SCOPE}`),
+        );
+        return;
+      }
+
+      // The active arm: resolve the worktree's own PR via the shared active-PR ladder.
+      const r = await runColdDoor<{ number: number; url: string }>(
+        pi,
+        ctx,
+        ["pr", "url", "--json"],
+        { label: "perk pr url", decode: decodePrUrl },
+      );
+      const planRefBase = planRefBaseOf(ctx.cwd);
+      const target = resolveReviewTarget(r, planRefBase);
+      if (target.mode === "fail") {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          `${target.message} (${target.errorType}) — pass a PR number/URL, or run from a plan ` +
+            "worktree",
+        );
+        return;
+      }
+
+      // The since-base merge-base (best-effort fetch first): the sha hunk diffs the working tree
+      // against. On the local arm the target threads the plan-ref's pinned base; on the PR arm
+      // the plan-ref base is read the same way (null ⇒ repo default via origin/HEAD).
+      const fullSha = sinceBaseSha(
+        ctx.cwd,
+        target.mode === "local" ? target.defaultBranch : planRefBase,
+      );
+      if (fullSha === null) {
+        report(
+          ctx,
+          SCOPE,
+          "error",
+          "could not resolve the since-base merge-base — pass a PR number/URL instead",
+        );
+        return;
+      }
+      const baseSha = fullSha.slice(0, 12);
+
+      if (target.mode === "pr") {
+        report(
+          ctx,
+          SCOPE,
+          "info",
+          parsed.directive
+            ? `PR #${target.number} (active worktree) → adversarial reviewers (focus: ${parsed.directive}) → hunk triage → curated post`
+            : `PR #${target.number} (active worktree) → adversarial reviewers → hunk triage → curated post`,
+        );
+      } else {
+        report(
+          ctx,
+          SCOPE,
+          "info",
+          "no PR yet — since-base review in hunk; reviewers skipped (no PR to review)",
+        );
+      }
+
+      const hunkCmd = `hunk diff ${baseSha} --agent-notes`;
+      const launchLine = `cd ${ctx.cwd} && ${hunkCmd}`;
+      await handleHunkLaunch(pi, ctx, { cwd: ctx.cwd, hunkCmd, launchLine, scope: SCOPE });
+
+      const guidance =
+        target.mode === "pr"
+          ? prReviewTerminalGuidance({
+              mode: "active",
+              pr: target.number,
+              worktree: ctx.cwd,
+              baseSha,
+              model,
+              directive: parsed.directive,
+            })
+          : prReviewTerminalGuidance({ mode: "local", worktree: ctx.cwd, baseSha });
+      pi.sendUserMessage(guidance + bindingSuffix(ctx.cwd, `command:${SCOPE}`));
+    },
+  });
+}