@a-t-h-i/bot-lobby 0.6.48 → 0.6.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.48",
+  "version": "0.6.49",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",

package/prompts/designer.md

@@ -125,7 +125,21 @@ describe it: ask with `ask_user_question` and give every option an
 `htmlPreview`, a mockup of that option in HTML and CSS, laid out for a page
 about 1200px wide, with the real content, palette and proportions of what you
 would build, in the project's existing design language, never grey
-placeholder boxes. Make every mockup interactive: use real `button`, `input`,
+placeholder boxes.
+
+Build mockups from the project's real styles whenever it has them, not from a
+lookalike. Find the stylesheets that carry its design tokens, theme and
+component styles (for example `src/index.css`, `app/globals.css`, a
+`theme.css`) and name them in the mockup's `stylesheets`: their rules go in
+front of your CSS, Tailwind `@theme` tokens included, so `var(--primary)`, the
+font stacks, the radii and the project's own classes work in the mockup. Use
+the markup and class names of the project's existing components (read them
+first), and write CSS only for what the option changes. Utility classes that
+only exist after a build (Tailwind's `px-3`, `bg-primary`) do not reach the
+mockup: write those few rules yourself with the project's variables. When the
+styles live in JavaScript (CSS-in-JS, a theme object), copy their actual
+values into the mockup's CSS. Only a project with no UI yet gets styles you
+choose, and then you ask first. Make every mockup interactive: use real `button`, `input`,
 `select`, `textarea`, `label` and `details`/`summary` elements with their
 hover, focus, active, checked and open states, and CSS transitions and
 `@keyframes` for the motion the option proposes (a pop-over opening, a

package/prompts/master.md

@@ -144,7 +144,10 @@ direction), show the choices rather than describe them. When you ask about a
 visual decision, use `ask_user_question` and give each option an
 `htmlPreview` mockup (HTML and CSS of that option in the project's existing
 design language, laid out for a page about 1200px wide, with real controls and
-CSS states and animations so the user can try it); the user expands the
+CSS states and animations so the user can try it). When the project has
+stylesheets, name them in the mockup's `stylesheets` so it wears the project's
+real tokens and classes, and build it from the project's own component markup;
+the user expands the
 mockups and scrolls through the options side by side. When the choice needs real design work, delegate it to
 the designer, who asks with its own mockups. In planning, the panel draws
 mockups under its options the same way.

package/src/ask/project-styles.ts

@@ -0,0 +1,64 @@
+/**
+ * A mockup in the project's own clothes. An `htmlPreview` can name the
+ * project's stylesheets (`stylesheets: ["src/index.css"]`); before the
+ * question is asked their rules are read and put in front of the mockup's own
+ * CSS, so the mockup wears the project's real tokens, fonts stacks and
+ * component classes instead of an approximation of them. Tailwind v4 sources
+ * are made readable for a browser on the way: `@theme` blocks become `:root`
+ * (their variables are the design tokens) and build-time directives
+ * (`@import`, `@plugin`, `@apply`, …) are dropped. Paths outside the project,
+ * files that are not CSS and anything past the size cap are refused.
+ */
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { extname, isAbsolute, relative, resolve } from "node:path";
+import { MAX_PREVIEW_CSS } from "./types.ts";
+
+/** How many stylesheets one mockup may name. */
+export const MAX_STYLESHEETS = 6;
+
+/** The browser-readable rules of one project stylesheet. */
+export function browserCss(source: string): string {
+  return source
+    .replace(/\/\*[\s\S]*?\*\//g, "")
+    .replace(/@theme(\s+(inline|static|reference))*\s*\{/g, ":root {")
+    .replace(/@(import|plugin|source|config|reference|custom-variant|tailwind)\b[^;{]*;/g, "")
+    .replace(/@apply\b[^;}]*;?/g, "")
+    .replace(/url\([^)]*\)/g, "none")
+    .replace(/image-set\([^;]*\)/g, "none")
+    // The preview refuses a whole stylesheet that holds a backslash (escaped class names, CSS escapes), so those rules go.
+    .replace(/[^{}]*\{[^{}]*\}/g, (rule) => (rule.includes("\\") ? "" : rule))
+    .replace(/^[^{}\n]*\\[^{}\n]*;\s*$/gm, "")
+    .replace(/(expression|behavior|-moz-binding)[^;}]*;?/gi, "")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+/** Read the named stylesheets from the project; throws with a reason the model can act on. */
+export function projectStyles(root: string, paths: readonly string[]): string {
+  if (paths.length > MAX_STYLESHEETS) throw new Error(`name at most ${MAX_STYLESHEETS} stylesheets`);
+  const base = realpathSync(root);
+  const parts: string[] = [];
+  for (const path of paths) {
+    if (![".css", ".pcss"].includes(extname(path).toLowerCase())) throw new Error(`${path} is not a .css file`);
+    let file: string;
+    try {
+      file = realpathSync(resolve(base, path));
+    } catch {
+      throw new Error(`${path} does not exist in the project`);
+    }
+    const inside = relative(base, file);
+    if (!inside || inside.startsWith("..") || isAbsolute(inside)) throw new Error(`${path} is outside the project`);
+    if (!statSync(file).isFile()) throw new Error(`${path} is not a file`);
+    parts.push(`/* ${inside} */\n${browserCss(readFileSync(file, "utf8"))}`);
+  }
+  return parts.join("\n");
+}
+
+/** The mockup's CSS with the project's stylesheets in front; throws when the whole would not fit. */
+export function withProjectStyles(root: string, preview: { html: string; css?: string; stylesheets?: string[] }): { html: string; css?: string } {
+  const { stylesheets, ...rest } = preview;
+  if (!stylesheets?.length) return rest;
+  const css = [projectStyles(root, stylesheets), rest.css ?? ""].filter(Boolean).join("\n");
+  if (css.length > MAX_PREVIEW_CSS) throw new Error(`the stylesheets and the mockup's CSS come to ${css.length} characters, over the ${MAX_PREVIEW_CSS} a mockup can carry: name the file with the design tokens and the components the mockup uses, not the whole build`);
+  return { ...rest, css };
+}

package/src/ask/tool.ts

@@ -12,9 +12,10 @@ import { Type } from "typebox";
 import { isSubagentProcess } from "../pi/quiet.ts";
 import { askUser } from "./web.ts";
 import { relayAsker, relayEnabled } from "./relay.ts";
-import { ASK_TOOL, isImagePath, validHtmlPreview, MAX_PREVIEW_HTML, MAX_PREVIEW_CSS, MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskQuestion, type AskResult, type Asker } from "./types.ts";
+import { ASK_TOOL, isImagePath, validHtmlPreview, MAX_PREVIEW_HTML, MAX_PREVIEW_CSS, MAX_HEADER, MAX_LABEL, MAX_OPTIONS, MAX_QUESTIONS, MIN_OPTIONS, RESERVED, type AskOption, type AskQuestion, type AskResult, type Asker } from "./types.ts";
 
 import { detectProjectRoot } from "../state/project.ts";
+import { MAX_STYLESHEETS, withProjectStyles } from "./project-styles.ts";
 import { ownedTask } from "../state/persistence.ts";
 import { withBlockingRequest } from "../state/blocking-requests.ts";
 
@@ -24,6 +25,7 @@ const OptionSchema = Type.Object({
   htmlPreview: Type.Optional(Type.Object({
     html: Type.String({ maxLength: MAX_PREVIEW_HTML, description: "HTML of a mockup of this option. Controls (button, input, select, textarea, label, details/summary) stay live and CSS transitions and keyframes run, so the user can try it; scripts, forms, images, fonts and links are stripped." }),
     css: Type.Optional(Type.String({ maxLength: MAX_PREVIEW_CSS })),
+    stylesheets: Type.Optional(Type.Array(Type.String(), { maxItems: MAX_STYLESHEETS, description: "Project-relative paths of the project's own CSS files (design tokens, theme, component styles, e.g. \"src/index.css\") whose rules go in front of `css`, so the mockup uses the project's real variables and classes. Tailwind `@theme` tokens are kept; build-time directives such as `@apply` are dropped. Together with `css` at most " + MAX_PREVIEW_CSS + " characters." })),
   }, { additionalProperties: false, description: "An interactive HTML/CSS mockup of this option (no scripts: interaction through CSS states), laid out for a page about 1200px wide: shown as a thumbnail beside the question, which the user expands to scroll through every option's mockup. Give one to every option of a visual question (a layout, a screen, a component's look)." })),
   label: Type.String({ maxLength: MAX_LABEL, description: `The option as the user sees and picks it: 1-5 words, at most ${MAX_LABEL} characters.` }),
   description: Type.Optional(Type.String({ description: "What choosing it means: its trade-offs or consequences. Markdown." })),
@@ -73,6 +75,23 @@ export function invalidQuestions(questions: readonly AskQuestion[]): string | un
   return undefined;
 }
 
+/** Each mockup that names project stylesheets gets their rules in front of its own CSS. */
+export function dressMockups(questions: readonly AskQuestion[], root: string | undefined): AskQuestion[] {
+  return questions.map((question, index) => ({
+    ...question,
+    options: question.options.map((option) => {
+      const preview = option.htmlPreview as (AskOption["htmlPreview"] & { stylesheets?: string[] }) | undefined;
+      if (!preview?.stylesheets) return option;
+      if (!root) throw new Error(`question ${index + 1}: the project's stylesheets cannot be read here; put the styles in \`css\`.`);
+      try {
+        return { ...option, htmlPreview: withProjectStyles(root, preview) };
+      } catch (error) {
+        throw new Error(`question ${index + 1}, "${option.label}": ${error instanceof Error ? error.message : String(error)}.`);
+      }
+    }),
+  }));
+}
+
 /** What the model does with questions the user left unanswered: wait, never fill them in. */
 const STILL_OPEN = "Do not assume answers, do not pick the recommended options, and do not go on with work that depends on them. Say in one short line that the questions are waiting, end your turn, and put them to the user again when they next write.";
 const NOT_ANSWERED = `The user left the questions without answering. ${STILL_OPEN}`;
@@ -119,11 +138,11 @@ export function registerAskTool(pi: ExtensionAPI, ask?: Asker, configDir = ".pi"
     ],
     parameters: AskParams,
     async execute(_toolCallId, params, signal, _onUpdate, ctx) {
-      const questions = (params as { questions: AskQuestion[] }).questions;
-      const invalid = invalidQuestions(questions);
-      if (invalid) throw new Error(`${invalid}.`);
       // A context without a cwd or session cannot be attributed to a task, so the ask runs untracked.
       const root = ctx.cwd ? detectProjectRoot(ctx.cwd, configDir) : undefined;
+      const questions = dressMockups((params as { questions: AskQuestion[] }).questions, root ?? ctx.cwd);
+      const invalid = invalidQuestions(questions);
+      if (invalid) throw new Error(`${invalid}.`);
       const sessionId = ctx.sessionManager?.getSessionId();
       const task = subagent || !root || !sessionId ? undefined : ownedTask(root, configDir, sessionId);
       const tracked = task && root && sessionId ? { root, configDir, taskId: task.id, sessionId } : undefined;

package/src/ask/types.ts

@@ -17,7 +17,7 @@ export const MAX_OPTIONS = 4;
 export const MAX_HEADER = 16;
 export const MAX_LABEL = 60;
 export const MAX_PREVIEW_HTML = 100_000;
-export const MAX_PREVIEW_CSS = 50_000;
+export const MAX_PREVIEW_CSS = 120_000;
 
 /** The row under every question's options where the user writes their own answer. */
 export const OWN_ANSWER = "Type something.";

package/src/ask/web.ts

@@ -3,18 +3,36 @@
  * the prompt hub, and waits there for the answer. Nothing is drawn in the
  * terminal. A question nobody can answer (no page is served, as in a print
  * run) is put away at once, so a model never waits on a screen that is not
- * there.
+ * there. A background session (started "in a new session" from the lobby) has
+ * no page of its own: its questions go to the window that started it, as RPC
+ * dialogs, and that window puts them in its own pop-up.
  */
 import { isAbsolute, resolve } from "node:path";
 import { currentWebServer } from "../webui/server.ts";
 import { promptHub } from "../lobby/prompt-hub.ts";
+import { relayAsker } from "./relay.ts";
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { validHtmlPreview, type AskAnswer, type AskQuestion, type AskResult, type Asker } from "./types.ts";
 
 let availability: (() => boolean) | undefined;
 
-/** Whether the page is up to answer. */
+/** Env flag the lobby sets on the headless sessions it starts. */
+export const BACKGROUND_ENV = "BOT_LOBBY_BACKGROUND";
+
+/** Whether this pi is a background session, asking through the window that started it. */
+export function isBackgroundSession(env: NodeJS.ProcessEnv = process.env): boolean {
+  // Its subagents inherit the flag; they ask through their own runner, never the window directly.
+  return env[BACKGROUND_ENV] === "1" && env.BOT_LOBBY_SUBAGENT !== "1";
+}
+
+/** Whether questions go through the starting window rather than a page of this pi's own. */
+function viaWindow(): boolean {
+  return currentWebServer() === undefined && isBackgroundSession();
+}
+
+/** Whether the page (this pi's, or the starting window's) is up to answer. */
 export function canAsk(): boolean {
-  return availability ? availability() : currentWebServer() !== undefined;
+  return availability ? availability() : currentWebServer() !== undefined || isBackgroundSession();
 }
 
 /** Tests say whether a page is there to answer. */
@@ -31,7 +49,7 @@ function withAbsoluteImages(questions: readonly AskQuestion[], cwd: string): Ask
 }
 
 /** What the page sent back, kept to the shape of a result; anything else reads as put away. */
-function readResult(value: unknown): AskResult | undefined {
+export function readResult(value: unknown): AskResult | undefined {
   const raw = value as Partial<AskResult> | null;
   if (!raw || !Array.isArray(raw.answers)) return undefined;
   return {
@@ -45,20 +63,23 @@ function readResult(value: unknown): AskResult | undefined {
 export const askUser: Asker = async (questions, ctx, signal, from) => {
   if (questions.some((question) => question.options.some((option) => option.htmlPreview !== undefined && !validHtmlPreview(option.htmlPreview)))) throw new Error("Invalid static HTML/CSS preview");
   if (questions.length === 0 || !canAsk()) return { answers: [], cancelled: true };
+  if (viaWindow()) return relayAsker(questions, ctx, signal, from);
   const outcome = await promptHub.ask("questionnaire", from ?? "oracle", { questions: withAbsoluteImages(questions, ctx.cwd) }, signal ? { signal } : undefined);
   return (outcome.how === "answered" ? readResult(outcome.value) : undefined) ?? { answers: [], cancelled: true };
 };
 
 /** A free-text answer (possibly several lines) in the page; undefined when put away. */
-export async function askText(question: string, from = "orchestrate"): Promise<string | undefined> {
+export async function askText(question: string, from = "orchestrate", ctx?: Pick<ExtensionContext, "ui">): Promise<string | undefined> {
   if (!canAsk()) return undefined;
+  if (viaWindow()) return ctx ? (await ctx.ui.editor(question, ""))?.trim() || undefined : undefined;
   const outcome = await promptHub.ask("text", from, { question });
   return outcome.how === "answered" && typeof outcome.value === "string" ? outcome.value : undefined;
 }
 
 /** One of `options` picked in the page; undefined when put away. */
-export async function askChoice(title: string, options: string[], from = "orchestrate"): Promise<string | undefined> {
+export async function askChoice(title: string, options: string[], from = "orchestrate", ctx?: Pick<ExtensionContext, "ui">): Promise<string | undefined> {
   if (!canAsk()) return undefined;
+  if (viaWindow()) return ctx ? ctx.ui.select(title, options) : undefined;
   const outcome = await promptHub.ask("choose", from, { title, options });
   return outcome.how === "answered" && typeof outcome.value === "string" ? outcome.value : undefined;
 }

package/src/lobby/service.ts

@@ -37,6 +37,7 @@ import { deliverComments, setAuto } from "../pi/owner.ts";
 import { chatFromEntries, lobbyFeed, type ChatEntry } from "./feed.ts";
 import { availableClassifiers, classifier, effortFor, hintsFor } from "../classifier/instance.ts";
 import { launchPi, SessionRegistry, type BackgroundSession, type SessionLauncher } from "./sessions.ts";
+import { askForSession } from "./session-questions.ts";
 import { SessionChats } from "./session-files.ts";
 import { answerMessage, questionnaires, settledQuestions } from "./ask.ts";
 import { askUser } from "../ask/web.ts";
@@ -270,7 +271,7 @@ function startSession(state: Runtime, start: { request?: string; plan?: PlannedT
   // A request may lead with flags (`--worktree add login`); the session is named after what follows them.
   const name = taskName(plan?.title ?? (stripStartFlags(request!) || request!));
   try {
-    const session = sessionRegistry().start(state.ctx.cwd, { name, projectRoot: state.root, onDialog: dialogTracker(state), ...(plan ? { planId: plan.id } : { request: request! }), ...(start.auto ? { auto: true } : {}) }, sessionModel(state.ctx));
+    const session = sessionRegistry().start(state.ctx.cwd, { name, projectRoot: state.root, onDialog: dialogTracker(state), ask: askForSession, ...(plan ? { planId: plan.id } : { request: request! }), ...(start.auto ? { auto: true } : {}) }, sessionModel(state.ctx));
     lobbyFeed.log("LOBBY", `started "${name}" in a new session`, "success");
     return session;
   } catch (error) {
@@ -284,7 +285,7 @@ export function resumeSession(state: Runtime, start: Relaunch): BackgroundSessio
     const session = sessionRegistry().start(state.ctx.cwd, {
       name: start.name,
       projectRoot: state.root,
-      onDialog: dialogTracker(state),
+      onDialog: dialogTracker(state), ask: askForSession,
       sessionFile: start.sessionFile,
       ...(start.message ? { message: start.message } : {}),
     });
@@ -374,7 +375,7 @@ async function resumeTask(state: Runtime, taskId: string): Promise<{ notice: str
     const session = sessionRegistry().start(state.ctx.cwd, {
       name: task.title,
       projectRoot: state.root,
-      onDialog: dialogTracker(state),
+      onDialog: dialogTracker(state), ask: askForSession,
       taskId,
       ...(file ? { sessionFile: file } : {}),
       message: `/bot-lobby carry-on ${taskId}`,

package/src/lobby/session-questions.ts

@@ -0,0 +1,49 @@
+/**
+ * A background session's questions, asked wherever the user is. A session
+ * started "in a new session" runs headless, so every question it asks (its
+ * oracle's questionnaire, a pick, a line of text, a yes/no) reaches this
+ * window as an RPC dialog. Each one is put in this window's question queue,
+ * the same pop-up the user's own session asks in, named after the session it
+ * comes from, so nobody has to switch sessions to answer. The answer goes
+ * back to the session; a dialog answered some other way (or a session that
+ * ends) takes its question back out of the queue.
+ */
+import { readRelayRequest } from "../ask/relay.ts";
+import { readResult } from "../ask/web.ts";
+import { promptHub, type PromptHub } from "./prompt-hub.ts";
+import type { DialogAnswer, SessionDialog } from "./sessions.ts";
+
+export interface SessionQuestion {
+  /** The session's name, shown as who asks. */
+  from: string;
+  dialog: SessionDialog;
+  signal: AbortSignal;
+}
+
+/** Put a session's dialog to the user in the question pop-up; undefined when it was taken back first. */
+export async function askForSession({ from, dialog, signal }: SessionQuestion, hub: PromptHub = promptHub): Promise<DialogAnswer | undefined> {
+  const options = { signal };
+  const relayed = dialog.method === "editor" ? readRelayRequest(dialog.title, dialog.prefill) : undefined;
+  if (relayed) {
+    const outcome = await hub.ask("questionnaire", from, { questions: relayed }, options);
+    if (outcome.how === "cancelled") return undefined;
+    const result = outcome.how === "answered" ? readResult(outcome.value) : undefined;
+    return { value: JSON.stringify(result ?? { answers: [], cancelled: true }) };
+  }
+  if (dialog.method === "select") {
+    const outcome = await hub.ask("choose", from, { title: dialog.title, options: dialog.options ?? [] }, options);
+    return settled(outcome, (value) => (typeof value === "string" ? { value } : undefined));
+  }
+  if (dialog.method === "confirm") {
+    const outcome = await hub.ask("confirm", from, { question: dialog.title, ...(dialog.message ? { detail: dialog.message } : {}) }, options);
+    return settled(outcome, (value) => (typeof value === "boolean" ? { confirmed: value } : undefined));
+  }
+  const outcome = await hub.ask("text", from, { question: dialog.title, ...(dialog.placeholder ? { placeholder: dialog.placeholder } : {}) }, options);
+  return settled(outcome, (value) => (typeof value === "string" ? { value } : undefined));
+}
+
+function settled(outcome: { how: "answered" | "dismissed" | "cancelled"; value: unknown }, read: (value: unknown) => DialogAnswer | undefined): DialogAnswer | undefined {
+  if (outcome.how === "cancelled") return undefined;
+  if (outcome.how === "dismissed") return { cancelled: true };
+  return read(outcome.value) ?? { cancelled: true };
+}

package/src/lobby/sessions.ts

@@ -54,6 +54,11 @@ export interface SessionStart {
   message?: string;
   /** The task it was started to carry on (resumed from the Tasks screen). */
   taskId?: string;
+  /**
+   * Put a dialog to the user (this window's question pop-up); resolves with the answer, or undefined when the
+   * dialog was settled some other way first (`signal` aborts then).
+   */
+  ask?: (question: { from: string; dialog: SessionDialog; signal: AbortSignal }) => Promise<DialogAnswer | undefined>;
 }
 
 let counter = 0;
@@ -80,6 +85,9 @@ export class BackgroundSession {
   /** Dialogs the session waits on, oldest first. */
   readonly dialogs: SessionDialog[] = [];
   private readonly onDialog: NonNullable<SessionStart["onDialog"]>;
+  private readonly ask?: SessionStart["ask"];
+  /** The dialogs being asked in the question pop-up, to take back when they are settled another way. */
+  private readonly asking = new Map<string, AbortController>();
   private readonly proc: SessionProcess;
   private buffer = "";
   private stderr = "";
@@ -96,6 +104,7 @@ export class BackgroundSession {
     if (start.planId) this.planId = start.planId;
     if (start.taskId) this.taskId = start.taskId;
     this.onDialog = start.onDialog ?? (() => {});
+    if (start.ask) this.ask = start.ask;
     this.proc = proc;
     this.onChange = onChange;
     proc.stdout?.on("data", (chunk) => this.receive(String(chunk)));
@@ -121,6 +130,8 @@ export class BackgroundSession {
     this.exitCode = code;
     for (const dialog of this.dialogs) this.onDialog(dialog.id, false, this.sessionId);
     this.dialogs.length = 0;
+    for (const controller of this.asking.values()) controller.abort();
+    this.asking.clear();
     if (this.killTimer) clearTimeout(this.killTimer);
     this.feed.say("note", reason);
     for (const resolve of this.exitWaiters.splice(0)) resolve();
@@ -175,6 +186,8 @@ export class BackgroundSession {
     const index = this.dialogs.findIndex((dialog) => dialog.id === id);
     if (index < 0) return;
     this.dialogs.splice(index, 1);
+    this.asking.get(id)?.abort();
+    this.asking.delete(id);
     this.onDialog(id, false, this.sessionId);
     if (this.alive && this.proc.stdin) this.proc.stdin.write(`${JSON.stringify({ type: "extension_ui_response", id, ...answer })}\n`);
     this.onChange();
@@ -248,6 +261,21 @@ export class BackgroundSession {
     this.onChange();
   }
 
+  /** Ask the dialog in the question pop-up, wherever the user is; its answer goes back to the session. */
+  private putToUser(dialog: SessionDialog): void {
+    if (!this.ask) return;
+    const controller = new AbortController();
+    this.asking.set(dialog.id, controller);
+    this.ask({ from: this.name, dialog, signal: controller.signal }).then(
+      (answer) => {
+        if (this.asking.get(dialog.id) !== controller) return;
+        this.asking.delete(dialog.id);
+        if (answer) this.answer(dialog.id, answer);
+      },
+      () => this.asking.delete(dialog.id),
+    );
+  }
+
   private uiRequest(event: Record<string, unknown>): void {
     const id = String(event.id ?? "");
     const method = String(event.method ?? "");
@@ -262,6 +290,7 @@ export class BackgroundSession {
         ...(typeof event.prefill === "string" ? { prefill: event.prefill } : {}),
       });
       this.onDialog(id, true, this.sessionId);
+      this.putToUser(this.dialogs.at(-1)!);
       this.feed.log("LOBBY", `waiting for you: ${String(event.title ?? "a question").split("\n")[0]}`, "warning");
     } else if (method === "notify") {
       const level = event.notifyType === "error" ? "error" : event.notifyType === "warning" ? "warning" : "info";
@@ -299,6 +328,8 @@ export const launchPi = (args: string[], cwd: string, overrides: NodeJS.ProcessE
   const env: NodeJS.ProcessEnv = { ...process.env, PI_SKIP_VERSION_CHECK: "1" };
   delete env.BOT_LOBBY_SUBAGENT;
   delete env.BOT_LOBBY_WEB_PROJECT;
+  // It has no page of its own: its questions come to this window (see ask/web.ts).
+  env.BOT_LOBBY_BACKGROUND = "1";
   Object.assign(env, overrides);
   const proc: ChildProcess = spawn(invocation.command, invocation.args, { cwd, env, shell: false, detached: POSIX, windowsHide: true, stdio: ["pipe", "pipe", "pipe"] });
   return proc as unknown as SessionProcess;

package/src/pi/tools.ts

@@ -132,8 +132,8 @@ export function workflowDeps(
     effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     // Time spent waiting on the user is not the task's: its budget clock waits too.
     // The questions go to the web page, where a free-text answer may run to several lines.
-    ask: async (question) => (canAsk() ? whileAsking(() => askText(question)) : undefined),
-    choose: async (title, options) => (canAsk() ? whileAsking(() => askChoice(title, options)) : undefined),
+    ask: async (question) => (canAsk() ? whileAsking(() => askText(question, undefined, ctx)) : undefined),
+    choose: async (title, options) => (canAsk() ? whileAsking(() => askChoice(title, options, undefined, ctx)) : undefined),
     // An agent's own questions (the designer's), relayed as the questionnaire.
     ...(canAsk() ? { askQuestions: (questions: AskQuestion[], from: string, askSignal?: AbortSignal) => whileAsking(() => askUser(questions, ctx, askSignal, from)) } : {}),
     notify: (message, level = "info") => {