@dev.fast/whiteboard 0.2.5-preview.20261013.113 → 0.2.5-preview.20261015.115

package/src/ask/agents.ts

@@ -14,7 +14,11 @@ import {
   ndJsonStream,
 } from "@agentclientprotocol/sdk";
 import { piTakesMcp, piWithMcp } from "@review/ask/pi-mcp.js";
-import { type AskAgentId, askAgentIds } from "@review/ask/thread-state.js";
+import {
+  type AskAgentId,
+  type AskPermissions,
+  askAgentIds,
+} from "@review/ask/thread-state.js";
 
 /** How Whiteboard runs an agent that speaks ACP on stdio. */
 type AskAgentLaunch =
@@ -48,10 +52,13 @@ interface AskAgentSpec {
   /** How its model gets the MCP servers a session is given, where its
    * adapter keeps them; without it, the adapter passes them on. */
   mcp?: AskAgentMcp;
+  /** How it decides for itself what is safe to run, in place of its
+   * read-only mode and settings: the default where it has one. */
+  auto?: AskAgentModeSettings;
   /** How it edits and runs commands without asking, in place of its
    * read-only mode and settings, when the reviewer bypasses permissions.
    * Whiteboard also allows whatever it still asks. */
-  bypass?: AskAgentBypass;
+  bypass?: AskAgentModeSettings;
   /** A follow-up asked while it answers joins that turn, when it says it
    * takes one. Only for an adapter that leaves a follow-up arriving as the
    * turn ends to Whiteboard: Codex's starts a turn of its own instead,
@@ -61,7 +68,7 @@ interface AskAgentSpec {
 
 interface AskAgentMcp {
   /** Whether this install can take them. */
-  supported(executable: string): Promise<boolean>;
+  supported(executable: string, env: NodeJS.ProcessEnv): Promise<boolean>;
   /** What the adapter runs in place of the user's CLI to give them, with
    * what it needs in `env`. */
   launch(
@@ -71,12 +78,37 @@ interface AskAgentMcp {
   ): Promise<string>;
 }
 
-export interface AskAgentBypass {
+export interface AskAgentModeSettings {
   mode?: string;
   sessionMeta?: NewSessionRequest["_meta"];
   env?: Record<string, string>;
 }
 
+/** The mode, session settings and process settings an agent runs with. */
+export function askAgentSettings(
+  agent: AskAgentId,
+  permissions: AskPermissions,
+): AskAgentModeSettings {
+  const spec = askAgents[agent];
+
+  const own =
+    permissions === "read-only"
+      ? { mode: spec.readOnlyMode }
+      : spec[permissions];
+
+  return {
+    mode: own?.mode,
+    sessionMeta: own?.sessionMeta ?? spec.sessionMeta,
+    env: own?.env ?? spec.env,
+  };
+}
+
+/** What a new conversation may do: decide for itself where the agent can,
+ * else read only. */
+export function defaultAskPermissions(agent: AskAgentId): AskPermissions {
+  return askAgents[agent].auto ? "auto" : "read-only";
+}
+
 export const askAgents: Record<AskAgentId, AskAgentSpec> = {
   claude: {
     name: "Claude Code",
@@ -107,6 +139,9 @@ export const askAgents: Record<AskAgentId, AskAgentSpec> = {
         },
       },
     },
+    // Claude's classifier allows what it judges safe and asks about the rest;
+    // its file tools stay off, as read-only's are.
+    auto: { mode: "auto" },
     // Its file tools back, and its own bypass, where its settings allow it.
     bypass: {
       mode: "bypassPermissions",
@@ -126,6 +161,8 @@ export const askAgents: Record<AskAgentId, AskAgentSpec> = {
     },
     signIn: "codex login",
     readOnlyMode: "read-only",
+    // Codex reviews each action and asks only about ones it finds unsafe.
+    auto: { mode: "agent" },
     bypass: { mode: "agent-full-access" },
   },
   cursor: {
@@ -187,6 +224,8 @@ export interface AskAgentStatus {
   available: boolean;
   /** Whether it has a mode that keeps the checkout as it is. */
   readOnly: boolean;
+  /** Whether it can decide for itself what is safe to run. */
+  auto: boolean;
   /** Whether Whiteboard can have it edit and run commands without asking. */
   bypass: boolean;
 }
@@ -203,9 +242,10 @@ export type AskAgentLauncher = (
   agent: AskAgentId,
   cwd: string,
   options?: {
-    bypass?: boolean;
+    permissions?: AskPermissions;
     /** The MCP servers its sessions are given. */
     mcpServers?: McpServer[];
+    env?: NodeJS.ProcessEnv;
   },
 ) => Promise<AskAgentProcess>;
 
@@ -256,13 +296,16 @@ async function findAgent(
 }
 
 /** Whether the agent's model gets the MCP servers its sessions are given. */
-export async function askAgentTakesMcp(agent: AskAgentId): Promise<boolean> {
+export async function askAgentTakesMcp(
+  agent: AskAgentId,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<boolean> {
   const spec = askAgents[agent];
 
   if (!spec.mcp) return true;
-  const executable = await findAgent(spec);
+  const executable = await findAgent(spec, env);
 
-  return executable !== undefined && spec.mcp.supported(executable);
+  return executable !== undefined && spec.mcp.supported(executable, env);
 }
 
 export async function detectAskAgents(
@@ -274,6 +317,7 @@ export async function detectAskAgents(
       name: askAgents[id].name,
       available: (await findAgent(askAgents[id], env)) !== undefined,
       readOnly: askAgents[id].readOnlyMode !== undefined,
+      auto: askAgents[id].auto !== undefined,
       bypass: askAgents[id].bypass !== undefined,
     })),
   );
@@ -286,16 +330,16 @@ const STDERR_LIMIT = 8_000;
 export const launchAskAgent: AskAgentLauncher = async (
   agent,
   cwd,
-  { bypass = false, mcpServers = [] } = {},
+  { permissions = "read-only", mcpServers = [], env: base = process.env } = {},
 ) => {
   const spec = askAgents[agent];
-  const executable = await findAgent(spec);
+  const executable = await findAgent(spec, base);
 
   if (!executable) throw new Error(`${spec.name} is not installed.`);
 
   const env: NodeJS.ProcessEnv = {
-    ...process.env,
-    ...((bypass && spec.bypass?.env) || spec.env),
+    ...base,
+    ...askAgentSettings(agent, permissions).env,
   };
 
   // A server started from inside a Claude Code session must not look nested.
@@ -309,7 +353,9 @@ export const launchAskAgent: AskAgentLauncher = async (
 
   if ("adapter" in launch) {
     env[launch.executableEnv] =
-      spec.mcp && mcpServers.length && (await spec.mcp.supported(executable))
+      spec.mcp &&
+      mcpServers.length &&
+      (await spec.mcp.supported(executable, env))
         ? await spec.mcp.launch(executable, mcpServers, env)
         : executable;
 

package/src/ask/pi-mcp.ts

@@ -49,13 +49,14 @@ const versions = new Map<
   { read: number; version: Promise<number[] | undefined> }
 >();
 
-function piVersion(executable: string) {
+function piVersion(executable: string, env: NodeJS.ProcessEnv) {
   const cached = versions.get(executable);
 
   if (cached && Date.now() - cached.read < VERSION_TTL_MS)
     return cached.version;
 
   const version = promisify(execFile)(executable, ["--version"], {
+    env,
     timeout: 5_000,
   })
     .then(({ stdout }) =>
@@ -69,9 +70,12 @@ function piVersion(executable: string) {
 }
 
 /** Whether this Pi can be given MCP servers. */
-export async function piTakesMcp(executable: string): Promise<boolean> {
+export async function piTakesMcp(
+  executable: string,
+  env: NodeJS.ProcessEnv,
+): Promise<boolean> {
   if (process.platform === "win32") return false;
-  const version = await piVersion(executable);
+  const version = await piVersion(executable, env);
 
   if (!version) return false;
 

package/src/ask/thread-state.ts

@@ -185,6 +185,12 @@ const statusSchema = z.enum([
   "failed",
 ]);
 
+/** What an agent may do without asking: nothing that changes the checkout,
+ * what its own judgment calls safe, or everything. */
+export const askPermissionsSchema = z.enum(["read-only", "auto", "bypass"]);
+
+export type AskPermissions = z.infer<typeof askPermissionsSchema>;
+
 /** Everything the Ask panel renders. A watcher gets it whole once, then
  * follows it through `AskChange`s. */
 export const askThreadStateSchema = z.object({
@@ -197,8 +203,7 @@ export const askThreadStateSchema = z.object({
   signIn: z.string().optional(),
   /** The mode that keeps the agent from changing files was accepted. */
   readOnly: z.boolean(),
-  /** The agent edits and runs commands without asking. */
-  bypass: z.boolean(),
+  permissions: askPermissionsSchema,
   head: z.string(),
   /** The checkout the agent works in. */
   cwd: z.string(),
@@ -228,7 +233,7 @@ export const askChangeSchema = z.discriminatedUnion("type", [
     type: z.literal("set"),
     status: statusSchema.optional(),
     readOnly: z.boolean().optional(),
-    bypass: z.boolean().optional(),
+    permissions: askPermissionsSchema.optional(),
     choices: askChoicesSchema.optional(),
     commands: z.array(askCommandSchema).optional(),
     accepts: askAcceptsSchema.optional(),
@@ -290,7 +295,7 @@ export function applyAskChange(
         ...rest,
         status: change.status ?? state.status,
         readOnly: change.readOnly ?? state.readOnly,
-        bypass: change.bypass ?? state.bypass,
+        permissions: change.permissions ?? state.permissions,
       };
 
       const choices = change.choices ?? state.choices;

package/src/ask/thread.ts

@@ -22,7 +22,9 @@ import { errorMessage } from "@dev.fast/trace-core";
 import {
   type AskAgentLauncher,
   type AskAgentProcess,
+  askAgentSettings,
   askAgents,
+  defaultAskPermissions,
 } from "@review/ask/agents.js";
 import {
   attachmentsOf,
@@ -44,6 +46,7 @@ import {
   type AskChoices,
   type AskEntry,
   type AskOffer,
+  type AskPermissions,
   type AskPicks,
   type AskQuestion,
   type AskThreadState,
@@ -92,21 +95,14 @@ const READ_ONLY_MCP_SERVERS = new Set([
   "fff",
 ]);
 
-/** MCP servers Whiteboard gives every Ask session. Their tool calls are
- * Whiteboard's own, so they run without asking the reviewer. */
-export type AskMcpServers = () => McpServer[];
+/** MCP servers Whiteboard gives every Ask session, for the thread they
+ * serve. Their tool calls are Whiteboard's own, so they run without asking
+ * the reviewer. */
+export type AskMcpServers = (threadId: string) => McpServer[];
 
-interface AskThreadBase {
-  /** Stable across reopening; a new conversation gets a fresh one. */
-  id?: string;
-  reviewId: string;
-  agent: AskAgentId;
-  cwd: string;
-  head: string;
-  selection: { title: string; quote?: string };
-  /** What the agent reads before a session's first question: the selection
-   * and how to find the review. */
-  context: string;
+/** Where a thread saves what happens to it, which moves with the thread
+ * when another review adopts it. */
+export interface AskThreadHooks {
   /** The agent created a session: the id a later reopen loads. A new one
    * replaces a session the agent could not reopen. */
   onSession?: (sessionId: string) => void;
@@ -115,12 +111,8 @@ interface AskThreadBase {
   /** What the panel shows, after each turn and on close, so a reopen can
    * show it without waiting for the agent to replay it. */
   onSave?: (entries: AskEntry[]) => void;
-  /** The model and effort to answer with, when the agent offers them. */
-  picks?: AskPicks;
-  /** Edit and run commands without asking. */
-  bypass?: boolean;
-  /** The reviewer started or stopped bypassing permissions. */
-  onBypass?: (bypass: boolean) => void;
+  /** The reviewer changed what the agent may do. */
+  onPermissions?: (permissions: AskPermissions) => void;
   /** The agent said what it offers: choices, commands, or what a question
    * may carry. */
   onOffer?: (offer: AskOffer) => void;
@@ -128,6 +120,23 @@ interface AskThreadBase {
   onTitle?: (title: string) => void;
 }
 
+interface AskThreadBase extends AskThreadHooks {
+  /** Stable across reopening; a new conversation gets a fresh one. */
+  id?: string;
+  reviewId: string;
+  agent: AskAgentId;
+  cwd: string;
+  head: string;
+  selection: { title: string; quote?: string };
+  /** What the agent reads before a session's first question: the selection
+   * and how to find the review. */
+  context: string;
+  /** The model and effort to answer with, when the agent offers them. */
+  picks?: AskPicks;
+  /** What the agent may do without asking; the agent's default without. */
+  permissions?: AskPermissions;
+}
+
 /** A new conversation, or an earlier one to load from the agent. */
 export type AskThreadStart = AskThreadBase &
   (
@@ -218,6 +227,9 @@ export class AskThread {
   private steerable = false;
   /** Follow-ups waiting for the turn under way to end, oldest first. */
   private queue: { id: string; question: AskQuestion }[] = [];
+  /** The review the thread answers in, and where it saves; adopting moves
+   * both. */
+  private home: AskThreadHooks & { reviewId: string };
 
   constructor(
     private readonly launch: AskAgentLauncher,
@@ -226,15 +238,24 @@ export class AskThread {
     private readonly limits: AskThreadLimits = askThreadLimits,
   ) {
     this.id = start.id ?? randomUUID();
-    this.mcpServers = mcpServers();
+    this.mcpServers = mcpServers(this.id);
     this.picks = { ...start.picks };
+    this.home = {
+      reviewId: start.reviewId,
+      onSession: start.onSession,
+      onTurn: start.onTurn,
+      onSave: start.onSave,
+      onPermissions: start.onPermissions,
+      onOffer: start.onOffer,
+      onTitle: start.onTitle,
+    };
     this.state = {
       id: this.id,
       agent: start.agent,
       agentName: askAgents[start.agent].name,
       status: "starting",
       readOnly: false,
-      bypass: start.bypass ?? false,
+      permissions: start.permissions ?? defaultAskPermissions(start.agent),
       head: start.head,
       cwd: start.cwd,
       selection: start.selection,
@@ -247,7 +268,16 @@ export class AskThread {
   }
 
   get reviewId() {
-    return this.start.reviewId;
+    return this.home.reviewId;
+  }
+
+  /** Moves the thread to another review, as when its agent creates the
+   * review it was asked for, and saves it there as it stands. */
+  adopt(reviewId: string, hooks: AskThreadHooks) {
+    this.home = { reviewId, ...hooks };
+
+    if (this.sessionId) hooks.onSession?.(this.sessionId);
+    hooks.onSave?.(this.state.entries);
   }
 
   read(): AskThreadState {
@@ -468,14 +498,15 @@ export class AskThread {
     this.closed = true;
 
     try {
-      // Starting and failed conversations must not replace saved history.
+      // A conversation still starting may be half replayed, and one that
+      // failed has nothing new; neither replaces what was saved.
       if (
         save &&
         this.sessionId &&
         this.state.status !== "starting" &&
         this.state.status !== "failed"
       )
-        this.start.onSave?.(settled(this.state.entries));
+        this.home.onSave?.(settled(this.state.entries));
     } finally {
       for (const resolve of this.decisions.values())
         resolve({ outcome: { outcome: "cancelled" } });
@@ -597,7 +628,7 @@ export class AskThread {
     const generation = ++this.generation;
 
     const launched = await this.launch(this.start.agent, this.start.cwd, {
-      bypass: this.state.bypass,
+      permissions: this.state.permissions,
       mcpServers: this.mcpServers,
     });
 
@@ -659,9 +690,8 @@ export class AskThread {
       initialized.agentCapabilities?.loadSession === true,
     );
 
-    const { bypass } = this.state;
-    const spec = askAgents[this.start.agent];
-    const mode = bypass ? spec.bypass?.mode : spec.readOnlyMode;
+    const { permissions } = this.state;
+    const { mode } = askAgentSettings(this.start.agent, permissions);
 
     // An agent without a read-only mode still answers, as it is.
     const configurable =
@@ -703,7 +733,8 @@ export class AskThread {
 
     this.emit({
       type: "set",
-      readOnly: !bypass && Boolean(configurable || selectable),
+      readOnly:
+        permissions === "read-only" && Boolean(configurable || selectable),
     });
     this.useConfig(config);
 
@@ -820,23 +851,30 @@ export class AskThread {
     if (commands) offer.commands = commands;
 
     if (accepts) offer.accepts = accepts;
-    this.start.onOffer?.(offer);
+    this.home.onOffer?.(offer);
   }
 
-  /** Edits and runs commands without asking from the next answer, or stops:
-   * the agent starts again in that mode and reopens the conversation. */
-  async permit(bypass: boolean) {
+  /** Changes what the agent may do from the next answer: it starts again
+   * in that mode and reopens the conversation. */
+  async permit(permissions: AskPermissions) {
     if (this.state.status !== "idle")
       throw new Error("Settings can change between answers.");
 
-    if (bypass === this.state.bypass) return;
+    if (permissions === this.state.permissions) return;
 
-    if (bypass && !askAgents[this.start.agent].bypass)
-      throw new Error(`${this.state.agentName} cannot bypass permissions.`);
+    if (
+      permissions !== "read-only" &&
+      !askAgents[this.start.agent][permissions]
+    )
+      throw new Error(
+        permissions === "auto"
+          ? `${this.state.agentName} has no auto mode.`
+          : `${this.state.agentName} cannot bypass permissions.`,
+      );
 
-    this.emit({ type: "set", bypass });
+    this.emit({ type: "set", permissions });
     this.permitted = true;
-    this.start.onBypass?.(bypass);
+    this.home.onPermissions?.(permissions);
     this.disconnect();
     // Its mode is Whiteboard's change, not one to announce as the agent's.
     this.settings.clear();
@@ -847,18 +885,18 @@ export class AskThread {
     });
   }
 
-  /** What the session starts with: read-only, or bypassing permissions. */
+  /** What the session starts with, for what the agent may do. */
   private sessionMeta() {
-    const spec = askAgents[this.start.agent];
-
-    return (this.state.bypass && spec.bypass?.sessionMeta) || spec.sessionMeta;
+    return askAgentSettings(this.start.agent, this.state.permissions)
+      .sessionMeta;
   }
 
   /** The agent says which mode it is in now; only its read-only one keeps
    * the checkout as it is. */
   private useMode(mode: string) {
     const readOnly =
-      !this.state.bypass && mode === askAgents[this.start.agent].readOnlyMode;
+      this.state.permissions === "read-only" &&
+      mode === askAgents[this.start.agent].readOnlyMode;
 
     if (readOnly !== this.state.readOnly) this.emit({ type: "set", readOnly });
   }
@@ -885,7 +923,7 @@ export class AskThread {
       if (this.closed) throw new Error("This conversation has ended.");
 
       this.sessionId = response.sessionId;
-      start.onSession?.(response.sessionId);
+      this.home.onSession?.(response.sessionId);
 
       this.greeting = piGreetingSchema.safeParse(
         response._meta,
@@ -954,7 +992,7 @@ export class AskThread {
       ...(withSelection ? [this.start.context] : []),
       ...(withPermission
         ? [
-            this.state.bypass
+            this.state.permissions === "bypass"
               ? "The reviewer lets you change files in the checkout and run commands without asking."
               : "Do not change files in the checkout.",
           ]
@@ -1027,8 +1065,8 @@ export class AskThread {
             ? `${this.state.agentName} stopped before finishing.`
             : null,
     });
-    this.start.onTurn?.();
-    this.start.onSave?.(this.state.entries);
+    this.home.onTurn?.();
+    this.home.onSave?.(this.state.entries);
     this.askQueued();
   }
 
@@ -1050,7 +1088,7 @@ export class AskThread {
     // may save an "always" rule into the checkout's settings.
     if (
       allowOnce &&
-      (this.state.bypass ||
+      (this.state.permissions === "bypass" ||
         (server &&
           (READ_ONLY_MCP_SERVERS.has(server) ||
             this.mcpServers.some((provided) => provided.name === server))))
@@ -1302,7 +1340,7 @@ export class AskThread {
 
         if (title && title !== this.state.title) {
           this.emit({ type: "set", title });
-          this.start.onTitle?.(title);
+          this.home.onTitle?.(title);
         }
 
         return true;

package/src/ask/threads.ts

@@ -1,5 +1,5 @@
 import { PROTOCOL_VERSION, client, methods } from "@agentclientprotocol/sdk";
-import { errorMessage } from "@dev.fast/trace-core";
+import { errorMessage, shellQuote } from "@dev.fast/trace-core";
 import {
   type AskAgentLauncher,
   askAgentTakesMcp,
@@ -139,13 +139,59 @@ async function offeredBy(
 export interface AskTools {
   /** Its MCP server, for agents whose model gets it. */
   mcpServers?: AskMcpServers;
-  /** A shell command that runs Whiteboard's CLI against this server, for
-   * the agents that don't. */
-  cli?: () => string | undefined;
+  /** A shell command that runs Whiteboard's CLI against this server for a
+   * thread, for the agents that don't. */
+  cli?: (threadId: string) => string | undefined;
   /** Whether an agent's model gets the MCP servers it is given. */
   takesMcp?: (agent: AskAgentId) => Promise<boolean>;
 }
 
+/** Whiteboard's CLI as the tools, with `selector` in its env so it reaches
+ * this server and no other. */
+export function cliAskTools(
+  cliPath: () => string | undefined,
+  selector: { name: string; value: string },
+): AskTools {
+  const env = () => [
+    selector,
+    ...(process.versions.electron
+      ? [{ name: "ELECTRON_RUN_AS_NODE", value: "1" }]
+      : []),
+    ...(process.env.DEV_REVIEW_HOME
+      ? [{ name: "DEV_REVIEW_HOME", value: process.env.DEV_REVIEW_HOME }]
+      : []),
+  ];
+
+  return {
+    mcpServers: () => {
+      const cli = cliPath();
+
+      return cli
+        ? [
+            {
+              name: "whiteboard",
+              command: process.execPath,
+              args: [cli, "mcp"],
+              env: env(),
+            },
+          ]
+        : [];
+    },
+    cli: () => {
+      const cli = cliPath();
+
+      return (
+        cli &&
+        [
+          ...env().map(({ name, value }) => `${name}=${shellQuote(value)}`),
+          shellQuote(process.execPath),
+          shellQuote(cli),
+        ].join(" ")
+      );
+    },
+  };
+}
+
 /** How an agent reaches Whiteboard's tools, which its first prompt says. */
 export type AskToolsReach =
   | { kind: "mcp" }
@@ -183,13 +229,13 @@ export class AskThreads {
 
   /** How the agent's sessions reach Whiteboard's tools: the MCP tools they
    * are given where its model gets them, else the CLI from its shell. */
-  async reach(agent: AskAgentId): Promise<AskToolsReach> {
+  async reach(agent: AskAgentId, threadId: string): Promise<AskToolsReach> {
     if (
-      this.mcpServers().length &&
+      this.mcpServers(threadId).length &&
       (await (this.tools.takesMcp ?? askAgentTakesMcp)(agent))
     )
       return { kind: "mcp" };
-    const command = this.tools.cli?.();
+    const command = this.tools.cli?.(threadId);
 
     return command ? { kind: "cli", command } : undefined;
   }

package/src/cli-install.ts

@@ -6,6 +6,7 @@ import path from "node:path";
 import { pathToFileURL } from "node:url";
 
 import {
+  REVIEW_REMOTE_WRAPPER_MARK,
   type ReviewCliInstallStamp,
   ReviewCliInstallStampSchema,
   type ReviewCliInstallStatus,
@@ -58,7 +59,8 @@ function hasManagedShimMarker(source: string): boolean {
   return (
     source.includes(SHIM_MARKER) ||
     source.includes("Managed by Review Desktop") ||
-    source.includes("Managed by Whiteboard Desktop")
+    source.includes("Managed by Whiteboard Desktop") ||
+    source.includes(REVIEW_REMOTE_WRAPPER_MARK)
   );
 }