@a-t-h-i/bot-lobby 0.6.2 → 0.6.4

package/src/execution/git.ts

@@ -1,4 +1,6 @@
 import { execFile } from "node:child_process";
+import { readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
 import { promisify } from "node:util";
 import { truncate } from "../text.ts";
 
@@ -10,33 +12,128 @@ async function git(cwd: string, args: string[]): Promise<string> {
   return stdout.trim();
 }
 
-/** `git diff HEAD`, falling back to index+worktree when HEAD does not exist yet. */
-async function diffAgainstHead(cwd: string): Promise<string> {
+/** `git diff <base>` (HEAD by default), falling back to index+worktree when HEAD does not exist yet. */
+async function diffAgainst(cwd: string, base: string, extra: readonly string[] = [], paths: readonly string[] = []): Promise<string> {
   try {
-    return await git(cwd, ["diff", "HEAD"]);
+    return await git(cwd, ["diff", ...extra, base, "--", ...paths]);
   } catch {
-    const [unstaged, staged] = await Promise.all([git(cwd, ["diff"]), git(cwd, ["diff", "--cached"])]);
+    const [unstaged, staged] = await Promise.all([git(cwd, ["diff", ...extra, "--", ...paths]), git(cwd, ["diff", ...extra, "--cached", "--", ...paths])]);
     return [unstaged, staged].filter((part) => part.length > 0).join("\n");
   }
 }
 
+/** The commit HEAD points at, or undefined (no commits yet, or no git). */
+export async function headCommit(cwd: string): Promise<string | undefined> {
+  try {
+    return (await git(cwd, ["rev-parse", "--verify", "HEAD"])) || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** The newest commit on HEAD made before `iso` (where a task started), or undefined. */
+export async function commitBefore(cwd: string, iso: string): Promise<string | undefined> {
+  try {
+    return (await git(cwd, ["rev-list", "-1", `--before=${iso}`, "HEAD"])) || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export interface DiffOptions {
+  /** Bound on the whole text. */
+  limitChars?: number;
+  /** The commit to compare with (where the task started), so work already committed still shows; HEAD when absent. */
+  base?: string;
+  /** Paths (relative to `cwd`) left out: bot-lobby's own records. */
+  exclude?: readonly string[];
+}
+
+/** Longest new file shown whole; past it (or binary) only its name is listed. */
+const MAX_NEW_FILE_CHARS = 4000;
+const MAX_NEW_FILE_BYTES = 200 * 1024;
+
 /**
- * Repository evidence for a reviewer: working-tree status plus the diff against
- * HEAD. Returns an explanatory string instead of throwing when git is unusable
- * so a review can still proceed on other evidence.
+ * Repository evidence for a reviewer: working-tree status, the files changed
+ * since `base` (listed first, so a long diff never hides which files moved),
+ * the diff itself, and the content of new files (which `git diff` leaves
+ * out). Returns an explanatory string instead of throwing when git is
+ * unusable so a review can still proceed on other evidence.
  */
-export async function readRepositoryDiff(cwd: string, limitChars = 20_000): Promise<string> {
+export async function readRepositoryDiff(cwd: string, options: DiffOptions = {}): Promise<string> {
+  const limit = options.limitChars ?? 20_000;
+  const paths = options.exclude?.length ? [".", ...options.exclude.map((path) => `:(exclude)${path}`)] : [];
+  const base = options.base ?? "HEAD";
+  const label = options.base ? `since ${options.base.slice(0, 7)}, where the task started (committed work included)` : "HEAD";
   try {
-    const [status, diff] = await Promise.all([
-      git(cwd, ["status", "--porcelain"]),
-      diffAgainstHead(cwd),
+    const [status, stat, diff, untracked] = await Promise.all([
+      git(cwd, ["status", "--porcelain", "--", ...paths]),
+      diffAgainst(cwd, base, ["--stat"], paths),
+      diffAgainst(cwd, base, [], paths),
+      git(cwd, ["ls-files", "--others", "--exclude-standard", "--", ...paths]),
     ]);
-    const parts = [
+    const head = [
       status ? `Status:\n${status}` : "Status: clean working tree",
-      diff ? `Diff (HEAD):\n${diff}` : "Diff (HEAD): none",
+      stat ? `Changed files (${label}):\n${stat}` : "",
+    ].filter(Boolean).join("\n\n");
+    const fresh = untracked ? newFiles(cwd, untracked.split("\n").filter(Boolean)) : "";
+    const room = Math.max(0, limit - head.length);
+    // The diff and the new files share what is left; new files get at least a third when there are any.
+    const diffRoom = fresh ? Math.max(Math.floor(room * 0.66), room - fresh.length) : room;
+    const parts = [
+      head,
+      diff ? `Diff (${label}):\n${truncate(diff, diffRoom)}` : `Diff (${label}): none`,
+      fresh ? `New files (untracked):\n${truncate(fresh, Math.max(0, room - Math.min(diff.length, diffRoom)))}` : "",
     ];
-    return truncate(parts.join("\n\n"), limitChars);
+    return truncate(parts.filter(Boolean).join("\n\n"), limit + 200);
   } catch (error) {
     return `Unable to read git state: ${(error as Error).message}`;
   }
 }
+
+/** New files as a reviewer reads them: each whole when it is small text, otherwise just named. */
+function newFiles(cwd: string, files: readonly string[]): string {
+  return files.map((file) => {
+    try {
+      const path = join(cwd, file);
+      if (statSync(path).size > MAX_NEW_FILE_BYTES) return `--- ${file} (large; read it directly)`;
+      const text = readFileSync(path, "utf8");
+      if (text.includes("\0")) return `--- ${file} (binary)`;
+      return `--- ${file}\n${truncate(text, MAX_NEW_FILE_CHARS)}`;
+    } catch {
+      return `--- ${file} (unreadable)`;
+    }
+  }).join("\n\n");
+}
+
+/** Most changed files one look reports; the rest are summarised by the diff. */
+export const MAX_CHANGED_FILES = 400;
+
+/**
+ * The repository's top folder and every file changed, relative to it: what
+ * `git status` reports (renames by their new path, untracked files one by
+ * one), plus what was committed since `base`; undefined when git is unusable.
+ */
+export async function changedFiles(cwd: string, base?: string): Promise<{ top: string; files: string[] } | undefined> {
+  try {
+    const [top, status, committed] = await Promise.all([
+      git(cwd, ["rev-parse", "--show-toplevel"]),
+      run("git", ["status", "--porcelain", "-z", "--untracked-files=all"], { cwd, maxBuffer: MAX_BUFFER }),
+      // Work committed since the task started is still the task's to review.
+      base ? run("git", ["diff", "--name-only", "-z", base], { cwd, maxBuffer: MAX_BUFFER }).then((result) => result.stdout, () => "") : Promise.resolve(""),
+    ]);
+    const entries = status.stdout.split("\0");
+    const files = new Set<string>();
+    for (let index = 0; index < entries.length && files.size < MAX_CHANGED_FILES; index += 1) {
+      const entry = entries[index]!;
+      if (entry.length < 4) continue;
+      files.add(entry.slice(3));
+      // A rename or copy is followed by the path it came from.
+      if (/[RC]/.test(entry.slice(0, 2))) index += 1;
+    }
+    for (const file of committed.split("\0")) if (file && files.size < MAX_CHANGED_FILES) files.add(file);
+    return { top, files: [...files] };
+  } catch {
+    return undefined;
+  }
+}

package/src/execution/pi-runner.ts

@@ -4,12 +4,20 @@ import { tmpdir } from "node:os";
 import { basename, join } from "node:path";
 import { activityWord } from "../pi/activity.ts";
 import { shortDuration } from "../text.ts";
+import { readRelayRequest } from "../ask/relay.ts";
+import type { AskQuestion, AskResult } from "../ask/types.ts";
 
 /** Live control over one running subagent: queue a steering message for its next turn. */
 export interface RunHandle {
   steer(text: string): void;
 }
 
+/**
+ * Puts a subagent's relayed questions to the user (see ask/relay.ts). The
+ * signal aborts when the run ends first, so the questionnaire is put away.
+ */
+export type RelayAsk = (questions: AskQuestion[], signal: AbortSignal) => Promise<AskResult>;
+
 export interface PiRunOptions {
   cwd: string;
   task: string;
@@ -33,6 +41,28 @@ export interface PiRunOptions {
   wrapUpAtMs?: number;
   /** Receives the steering handle once the process is running. */
   onStart?: (handle: RunHandle) => void;
+  /** Under a task time budget: when the agent is warned, when its time is up, and who decides on more (see ProcessRunOptions). */
+  time?: TimeLimit;
+  /** Answers the agent's relayed questions; without it they are cancelled like any other dialog. */
+  onAsk?: RelayAsk;
+}
+
+/**
+ * A run's allotted time under a task budget. At `headsUpAtMs` the agent is
+ * told how much is left; at `upAtMs` it is steered to stop and report where it
+ * left off. Once that report is in (its turn ended), `onTimeUp` decides: more
+ * ms keeps the same process going with its context (a follow-up prompt), 0
+ * ends it. The hard deadline (`timeoutMs`) and the stall watchdog wait while
+ * the decision is pending, and move out with any time granted.
+ */
+export interface TimeLimit {
+  upAtMs: number;
+  headsUpAtMs?: number;
+  headsUpMessage?: string;
+  upMessage: string;
+  onTimeUp?: (report: string) => Promise<{ extraMs: number; message?: string }>;
+  /** Time the agent gets to write its report after `upAtMs` before it is stopped. */
+  graceMs: number;
 }
 
 export interface ProcessOutcome {
@@ -47,6 +77,10 @@ export interface ProcessOutcome {
   wrappedUp?: boolean;
   /** The RPC host rejected the prompt itself. */
   protocolError?: string;
+  /** Stopped at its allotted time and not given more: its report says where it left off. */
+  timeUp?: boolean;
+  /** Time granted past its allotment, in ms. */
+  extendedMs?: number;
 }
 
 /** Streaming agent events forwarded as they arrive on stdout. */
@@ -61,8 +95,16 @@ export type PiStreamEvent =
   | { type: "compaction" }
   | { type: "usage"; input: number; output: number; cost: number; model?: string }
   | { type: "wrap_up" }
+  /** Its allotted time is up: it was asked to stop and report where it left off. */
+  | { type: "time_up" }
+  /** It was given `ms` more and carries on. */
+  | { type: "extended"; ms: number }
   /** One finished thinking block, bounded to `MAX_THOUGHT_CHARS`. */
   | { type: "thought"; text: string }
+  /** It asked the user (relayed); its clocks wait until the answers are back. */
+  | { type: "asking"; questions: number }
+  /** The answers went back after `waitedMs` of waiting on the user. */
+  | { type: "answered"; waitedMs: number }
   | { type: "heartbeat" };
 
 /** Longest thought forwarded from a subagent stream. */
@@ -84,6 +126,8 @@ export interface ProcessRunOptions {
   onStart?: (handle: RunHandle) => void;
   /** Grace between the deadline abort and the hard kill. */
   graceMs?: number;
+  time?: TimeLimit;
+  onAsk?: RelayAsk;
 }
 
 export type ProcessRunner = (
@@ -99,6 +143,8 @@ export interface PiRunResult {
   model?: string;
   stalled?: boolean;
   wrappedUp?: boolean;
+  timeUp?: boolean;
+  extendedMs?: number;
 }
 
 export interface ParsedStream {
@@ -134,12 +180,17 @@ export interface ControlEvent {
   method?: string;
   willRetry?: boolean;
   delayMs?: number;
+  /** extension_ui_request: the dialog's title and (editor) prefilled text. */
+  title?: string;
+  prefill?: string;
 }
 
 /** Buffers one JSON-mode stream, keeping only lines parsePiStream consumes. */
 export interface StreamCollector {
   push(chunk: string): void;
   finish(): string;
+  /** What is kept so far, without ending the stream. */
+  peek(): string;
 }
 
 const INTERESTING = [
@@ -268,6 +319,9 @@ export function createStreamCollector(
       if (partial.length > 0) keep(partial.splice(0).join(""));
       return kept.join("\n");
     },
+    peek() {
+      return kept.join("\n");
+    },
   };
 }
 
@@ -422,6 +476,14 @@ interface RunState {
   wrappedUp: boolean;
   settled: boolean;
   protocolError?: string;
+  /** Told its time is up; its next turn end waits on the decision. */
+  timeUp: boolean;
+  headsUp: boolean;
+  /** Waiting on the decision: the agent is idle, so the deadline and the stall watchdog wait too. */
+  deciding: boolean;
+  /** Relayed questions waiting on the user: every clock and the watchdog wait. */
+  asking: number;
+  extendedMs: number;
 }
 
 /** Smallest positive limit, used to pick a watchdog cadence that can see it. */
@@ -452,9 +514,14 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       windowsHide: true,
       stdio: ["pipe", "pipe", "pipe"],
     });
-    const state: RunState = { killed: false, timedOut: false, stalled: false, wrappedUp: false, settled: false };
+    const state: RunState = { killed: false, timedOut: false, stalled: false, wrappedUp: false, settled: false, timeUp: false, headsUp: false, deciding: false, asking: 0, extendedMs: 0 };
     const input = rpcInput(proc);
     const started = Date.now();
+    const time = options.time;
+    // The allotted time counts from here; a grant restarts it.
+    let clockStart = started;
+    let upAtMs = time?.upAtMs ?? 0;
+    let headsUpAtMs = time?.headsUpAtMs ?? 0;
     let lastOutput = started;
     let quietGraceUntil = 0;
     let toolsInFlight = 0;
@@ -462,6 +529,11 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
     let exitCode: number | undefined;
     let settleTimer: ReturnType<typeof setTimeout> | undefined;
     let done = false;
+    // Time spent waiting on the user's answers is not the agent's: its limits move out by it.
+    let deadlineAt = started + options.timeoutMs;
+    let askStarted = 0;
+    let pausedMs = 0;
+    const asks = new AbortController();
 
     const onEvent = (event: PiStreamEvent) => {
       if (event.type === "tool_execution_start") toolsInFlight += 1;
@@ -469,18 +541,84 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       if (event.type === "retry") quietGraceUntil = Date.now() + event.delayMs;
       options.onEvent?.(event);
     };
+    // A turn that ended after the time ran out waits on the decision; any other ends the run.
+    let turnDone = false;
+    const turnOver = () => {
+      if (turnDone) return;
+      turnDone = true;
+      clearTimeout(settleTimer);
+      settleTimer = undefined;
+      if (state.timeUp && time?.onTimeUp && !done && !state.killed) decide(time.onTimeUp);
+      else input.close();
+    };
+    const decide = (onTimeUp: NonNullable<TimeLimit["onTimeUp"]>) => {
+      state.deciding = true;
+      clearTimeout(deadline);
+      const report = parsePiStream(collector.peek()).text;
+      onTimeUp(report).then(({ extraMs, message }) => {
+        if (done || state.killed) return;
+        state.deciding = false;
+        if (extraMs <= 0) return input.close();
+        // Granted: the same agent carries on where it stopped, its context intact.
+        state.timeUp = false;
+        state.headsUp = false;
+        state.settled = false;
+        state.extendedMs += extraMs;
+        turnDone = false;
+        clockStart = Date.now();
+        lastOutput = clockStart;
+        upAtMs = extraMs;
+        // The user just named the time it has: no heads-up quoting the old allotment.
+        headsUpAtMs = 0;
+        deadlineAt = Date.now() + extraMs + (time?.graceMs ?? 0);
+        deadline = setTimeout(onDeadline, extraMs + (time?.graceMs ?? 0));
+        input.send({ type: "prompt", message: message ?? "You have more time: carry on from where you left off and finish." });
+        options.onEvent?.({ type: "extended", ms: extraMs });
+      }, () => {
+        state.deciding = false;
+        input.close();
+      });
+    };
+    const relay = (id: string | undefined, questions: AskQuestion[], ask: RelayAsk) => {
+      state.asking += 1;
+      if (state.asking === 1) {
+        askStarted = Date.now();
+        clearTimeout(deadline);
+      }
+      options.onEvent?.({ type: "asking", questions: questions.length });
+      ask(questions, asks.signal)
+        .catch((): AskResult => ({ answers: [], cancelled: true }))
+        .then((result) => {
+          state.asking -= 1;
+          if (done || state.killed) return;
+          if (state.asking === 0) {
+            const now = Date.now();
+            const waited = now - askStarted;
+            pausedMs += waited;
+            deadlineAt += waited;
+            clockStart += waited;
+            lastOutput = now;
+            if (!state.deciding) deadline = setTimeout(onDeadline, Math.max(0, deadlineAt - now));
+            options.onEvent?.({ type: "answered", waitedMs: waited });
+          }
+          input.send({ type: "extension_ui_response", id, value: JSON.stringify(result) });
+        });
+    };
     const onControl = (event: ControlEvent) => {
+      const relayed = event.type === "extension_ui_request" && event.method === "editor" && options.onAsk ? readRelayRequest(event.title, event.prefill) : undefined;
       if (event.type === "response" && event.command === "prompt" && event.success === false) {
         state.protocolError = event.error ?? "the prompt was rejected";
         input.close();
+      } else if (relayed && options.onAsk) {
+        relay(event.id, relayed, options.onAsk);
       } else if (event.type === "extension_ui_request" && event.method && DIALOG_METHODS.has(event.method)) {
         // Nobody can answer a dialog inside a subagent; cancel it instead of blocking forever.
         input.send({ type: "extension_ui_response", id: event.id, cancelled: true });
       } else if (event.type === "agent_settled") {
         state.settled = true;
-        input.close();
-      } else if (event.type === "agent_end" && event.willRetry !== true && !settleTimer) {
-        settleTimer = setTimeout(() => input.close(), SETTLE_FALLBACK_MS);
+        turnOver();
+      } else if (event.type === "agent_end" && event.willRetry !== true && !settleTimer && !turnDone) {
+        settleTimer = setTimeout(turnOver, SETTLE_FALLBACK_MS);
       }
     };
     const collector = createStreamCollector(onEvent, onControl);
@@ -501,12 +639,15 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       clearTimeout(deadline);
       clearTimeout(settleTimer);
       clearInterval(watch);
+      // Questions still open when the run ends are put away.
+      asks.abort();
       options.signal?.removeEventListener("abort", onAbort);
       input.close();
       // Reap anything the agent left running in its group.
       if (POSIX) signalGroup(proc, "SIGTERM");
       const { killed, timedOut, stalled, wrappedUp, protocolError } = state;
-      resolve({ exitCode: code, stdout: collector.finish(), stderr, killed, timedOut, stalled, wrappedUp, protocolError });
+      const timeUp = state.timeUp && !killed;
+      resolve({ exitCode: code, stdout: collector.finish(), stderr, killed, timedOut, stalled, wrappedUp, protocolError, ...(timeUp ? { timeUp } : {}), ...(state.extendedMs > 0 ? { extendedMs: state.extendedMs } : {}) });
     };
     const onAbort = () => {
       state.killed = true;
@@ -514,21 +655,31 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
       input.close();
       terminate(proc, 3000);
     };
-    const deadline = setTimeout(() => {
+    const onDeadline = () => {
       state.killed = true;
       state.timedOut = true;
       input.send({ type: "abort" });
       input.close();
       setTimeout(() => terminate(proc), options.graceMs ?? DEADLINE_GRACE_MS).unref();
-    }, options.timeoutMs);
+    };
+    let deadline = setTimeout(onDeadline, options.timeoutMs);
     const watch = setInterval(() => {
-      if (state.killed || done) return;
+      if (state.killed || done || state.deciding || state.asking > 0) return;
       const now = Date.now();
-      if (!state.wrappedUp && !state.settled && options.wrapUpAtMs && options.wrapUpAtMs > 0 && now - started >= options.wrapUpAtMs) {
+      if (!state.wrappedUp && !state.settled && options.wrapUpAtMs && options.wrapUpAtMs > 0 && now - started - pausedMs >= options.wrapUpAtMs) {
         state.wrappedUp = true;
         input.send({ type: "steer", message: options.wrapUpMessage ?? WRAP_UP_MESSAGE });
         options.onEvent?.({ type: "wrap_up" });
       }
+      if (time && !state.headsUp && !state.timeUp && !turnDone && headsUpAtMs > 0 && now - clockStart >= headsUpAtMs) {
+        state.headsUp = true;
+        if (time.headsUpMessage) input.send({ type: "steer", message: time.headsUpMessage });
+      }
+      if (time && !state.timeUp && !turnDone && upAtMs > 0 && now - clockStart >= upAtMs) {
+        state.timeUp = true;
+        input.send({ type: "steer", message: time.upMessage });
+        options.onEvent?.({ type: "time_up" });
+      }
       const limit = toolsInFlight > 0 ? options.toolStallTimeoutMs : options.stallTimeoutMs;
       if (limit && limit > 0 && now - Math.max(lastOutput, quietGraceUntil) >= limit) {
         state.killed = true;
@@ -536,7 +687,7 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
         input.close();
         terminate(proc, 3000);
       }
-    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs, options.wrapUpAtMs));
+    }, watchInterval(options.stallTimeoutMs, options.toolStallTimeoutMs, options.wrapUpAtMs, time?.upAtMs, time?.headsUpAtMs));
     watch.unref();
 
     proc.on("exit", (code, signal) => {
@@ -557,7 +708,7 @@ export function spawnPiProcess(args: string[], options: ProcessRunOptions): Prom
 }
 
 function toResult(parsed: ParsedStream, outcome: ProcessOutcome, aborted: boolean, options: PiRunOptions): PiRunResult {
-  const base = { output: parsed.text, usage: parsed.usage, model: parsed.model, wrappedUp: outcome.wrappedUp === true };
+  const base = { output: parsed.text, usage: parsed.usage, model: parsed.model, wrappedUp: outcome.wrappedUp === true, ...(outcome.timeUp ? { timeUp: true } : {}), ...(outcome.extendedMs ? { extendedMs: outcome.extendedMs } : {}) };
   if (outcome.stalled) {
     const quiet = shortDuration(options.stallTimeoutMs ?? 0);
     return { ...base, status: "timeout", stalled: true, error: `stalled: no output for ${quiet}` };
@@ -602,6 +753,8 @@ export async function runPiAgent(options: PiRunOptions, run: ProcessRunner = spa
       stallTimeoutMs: options.stallTimeoutMs,
       toolStallTimeoutMs: options.toolStallTimeoutMs,
       wrapUpAtMs: options.wrapUpAtMs,
+      ...(options.time ? { time: options.time } : {}),
+      ...(options.onAsk ? { onAsk: options.onAsk } : {}),
       onStart: options.onStart,
       onEvent: (event) => {
         if (event.type === "tool_execution_start") options.onActivity?.(activityWord(event.toolName));

package/src/index.ts

@@ -10,10 +10,15 @@ import { registerLobbyEvents } from "./lobby/runtime.ts";
 import { registerOwner } from "./pi/owner.ts";
 import { registerClassifier } from "./classifier/instance.ts";
 import { registerClassifierTools } from "./classifier/tools.ts";
+import { registerFreshContext } from "./pi/fresh-context.ts";
+import { registerAskTool } from "./ask/tool.ts";
+import { registerWebTools } from "./web/tools.ts";
 
 export default function (pi: ExtensionAPI): void {
   // First, so every session_start handler below finds the classifier bound to this session's keys.
   registerClassifier(pi, CONFIG_DIR_NAME);
+  // Before the lifecycle, so a task that ended while the oracle was idle is closed before it builds the next turn's prompt.
+  registerFreshContext(pi, CONFIG_DIR_NAME);
   registerLifecycle(pi, CONFIG_DIR_NAME);
   // After the lifecycle, so the lobby opens over a task the widget state already knows.
   registerLobbyEvents(pi, CONFIG_DIR_NAME);
@@ -21,6 +26,10 @@ export default function (pi: ExtensionAPI): void {
   onTransition((task) => pingTransition(task));
   registerCommands(pi, CONFIG_DIR_NAME);
   registerOrchestrateTool(pi, CONFIG_DIR_NAME);
+  // The questionnaire the oracle (and pi without a task) asks the user with; no other extension is needed for it.
+  registerAskTool(pi);
+  // The web tools, for the researcher and for pi without a task (the oracle leaves them to the researcher).
+  registerWebTools(pi);
   // Parallel workers share files through the master's file desk.
   if (isSubagentProcess()) registerDeskClient(pi);
   // Subagents look files up with the classifier (the engine allows the tool only while file hints are on).

package/src/lobby/ask.ts

@@ -1,59 +1,17 @@
 /**
- * The oracle puts the planning panel's questions to the user one at a time
- * through the ask-user-question library (`@juicesharp/rpiv-ask-user-question`):
- * a tabbed questionnaire with each seat's options, the recommended one first,
- * and a free-text row on every question. The library only publishes a pi
- * extension entry point, so its `ask_user_question` tool is captured by
- * calling that entry with a `pi` whose `registerTool` keeps the definition
- * instead of registering it; its `execute` then runs the real questionnaire.
- * Without the library, pi's own select and input dialogs ask the same
- * questions in the same order.
+ * The oracle puts the planning panel's questions to the user through the
+ * questionnaire (`../ask`): a tab per question with each seat's options, the
+ * recommended one first, and a row for an answer in the user's own words.
+ * The panel's questions become questionnaires of at most four, and the
+ * answers become the user's turn for the next round.
  */
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import type { PanelQuestion } from "./planner.ts";
+import { MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskAnswer, type AskOption, type AskQuestion, type AskResult } from "../ask/types.ts";
+import type { Asker } from "../ask/dialog.ts";
 
-/** The library's limits: at most 4 questions per questionnaire, 2-4 options each. */
-export const MAX_QUESTIONS = 4;
-export const MIN_OPTIONS = 2;
-export const MAX_OPTIONS = 4;
-const MAX_HEADER = 16;
-const MAX_LABEL = 60;
-/** Labels the library reserves for its own rows. */
-const RESERVED = new Set(["other", "type something.", "next"]);
-
-export interface AskOption {
-  label: string;
-  description: string;
-}
-
-export interface AskQuestion {
-  question: string;
-  header: string;
-  options: AskOption[];
-  multiSelect?: boolean;
-}
-
-export interface AskAnswer {
-  questionIndex: number;
-  question: string;
-  kind: "option" | "custom" | "multi";
-  answer: string | null;
-  selected?: string[];
-  notes?: string;
-}
-
-export interface AskResult {
-  answers: AskAnswer[];
-  cancelled: boolean;
-  globalNote?: string;
-}
-
-/** Puts up to `MAX_QUESTIONS` questions to the user and returns what they chose. */
-export type Asker = (questions: readonly AskQuestion[], ctx: ExtensionContext) => Promise<AskResult>;
-
-interface ToolLike {
-  execute(toolCallId: string, params: unknown, signal: AbortSignal | undefined, onUpdate: undefined, ctx: ExtensionContext): Promise<{ details?: unknown }>;
-}
+export { MAX_QUESTIONS, MIN_OPTIONS, MAX_OPTIONS, type AskAnswer, type AskOption, type AskQuestion, type AskResult, type Asker };
+export { askUser, dialogAsker } from "../ask/dialog.ts";
 
 function clip(text: string, max: number): string {
   const flat = text.replace(/\s+/g, " ").trim();
@@ -143,74 +101,6 @@ export function answerMessage(questions: readonly PanelQuestion[], results: read
   ].join("\n");
 }
 
-/**
- * Capture the library's tool through its public extension entry: the entry
- * registers the tool on the `pi` it is given, so a `pi` whose `registerTool`
- * keeps the definition (and whose `on` ignores the library's own tool-list
- * reconciler) yields it without touching the session's tools. Undefined when
- * the library is missing or registers nothing.
- */
-/**
- * The library ships TypeScript sources; a non-literal specifier keeps them out
- * of this package's typecheck (they are compiled by pi's loader at runtime).
- */
-const ASK_LIBRARY: string = "@juicesharp/rpiv-ask-user-question";
-
-export async function loadAskTool(pi: ExtensionAPI, load: () => Promise<unknown> = () => import(ASK_LIBRARY)): Promise<ToolLike | undefined> {
-  try {
-    const module = (await load()) as { default?: (pi: ExtensionAPI) => void };
-    if (typeof module.default !== "function") return undefined;
-    let captured: ToolLike | undefined;
-    const capture = new Proxy(pi, {
-      get(target, property, receiver) {
-        if (property === "registerTool") return (tool: ToolLike & { name?: string }) => {
-          if (tool.name === "ask_user_question") captured = tool;
-        };
-        if (property === "on") return () => () => {};
-        return Reflect.get(target, property, receiver);
-      },
-    });
-    module.default(capture);
-    return captured;
-  } catch {
-    return undefined;
-  }
-}
-
-/** Run one questionnaire through the captured tool. */
-export function toolAsker(tool: ToolLike): Asker {
-  return async (questions, ctx) => {
-    const result = await tool.execute(`bot-lobby-panel-${Date.now().toString(36)}`, { questions }, undefined, undefined, ctx);
-    const details = result.details as Partial<AskResult> | undefined;
-    return { answers: details?.answers ?? [], cancelled: details?.cancelled !== false, ...(details?.globalNote ? { globalNote: details.globalNote } : {}) };
-  };
-}
-
-const TYPE_ANSWER = "Type an answer…";
-const SKIP = "Skip";
-
-/** The same questions through pi's built-in dialogs: pick an option, type an answer, or skip; esc stops. */
-export function dialogAsker(): Asker {
-  return async (questions, ctx) => {
-    const answers: AskAnswer[] = [];
-    for (const [index, question] of questions.entries()) {
-      const choices = [...question.options.map((option) => option.label), TYPE_ANSWER, SKIP];
-      const title = `${question.header} · ${index + 1}/${questions.length}\n\n${question.question}`;
-      const choice = await ctx.ui.select(title, choices);
-      if (choice === undefined) return { answers, cancelled: true };
-      if (choice === SKIP) continue;
-      if (choice === TYPE_ANSWER) {
-        const typed = await ctx.ui.input(question.question, "your answer");
-        if (typed === undefined) return { answers, cancelled: true };
-        if (typed.trim()) answers.push({ questionIndex: index, question: question.question, kind: "custom", answer: typed.trim() });
-        continue;
-      }
-      answers.push({ questionIndex: index, question: question.question, kind: "option", answer: choice });
-    }
-    return { answers, cancelled: false };
-  };
-}
-
 /**
  * Put every question to the user, one questionnaire after another. Stopping
  * a questionnaire (esc) stops the rest; what was answered before it is kept.