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

package/THIRD_PARTY_NOTICES.md

@@ -68,5 +68,10 @@ fontsource packages, `@fontsource-variable/*`) as files in `webui/dist/assets`,
 so the Typeface setting works offline. Each is under the SIL Open Font
 License 1.1 (https://openfontlicense.org): Inter (The Inter Project Authors),
 Geist and Geist Mono (Vercel), IBM Plex Sans (IBM Corp.), Manrope (The
-Manrope Project Authors) and JetBrains Mono (The JetBrains Mono Project
-Authors).
+Manrope Project Authors), JetBrains Mono (The JetBrains Mono Project
+Authors), DM Sans (The DM Sans Project Authors), Plus Jakarta Sans (The Plus
+Jakarta Sans Project Authors), Figtree (The Figtree Project Authors), Outfit
+(The Outfit Project Authors), Nunito (The Nunito Project Authors), Space
+Grotesk (The Space Grotesk Project Authors), Source Sans 3 and Source Code Pro
+(Adobe), Fira Code (The Fira Code Project Authors) and Roboto Mono (The Roboto
+Mono Project Authors).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.47",
+  "version": "0.6.49",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -57,12 +57,22 @@
     "@earendil-works/pi-ai": "1.0.1",
     "@earendil-works/pi-coding-agent": "1.0.1",
     "@earendil-works/pi-tui": "1.0.1",
+    "@fontsource-variable/dm-sans": "^5.3.0",
+    "@fontsource-variable/figtree": "^5.3.0",
+    "@fontsource-variable/fira-code": "^5.3.0",
     "@fontsource-variable/geist": "^5.3.0",
     "@fontsource-variable/geist-mono": "^5.3.0",
     "@fontsource-variable/ibm-plex-sans": "^5.3.0",
     "@fontsource-variable/inter": "^5.3.0",
     "@fontsource-variable/jetbrains-mono": "^5.3.0",
     "@fontsource-variable/manrope": "^5.3.0",
+    "@fontsource-variable/nunito": "^5.3.0",
+    "@fontsource-variable/outfit": "^5.3.0",
+    "@fontsource-variable/plus-jakarta-sans": "^5.3.0",
+    "@fontsource-variable/roboto-mono": "^5.3.0",
+    "@fontsource-variable/source-code-pro": "^5.3.1",
+    "@fontsource-variable/source-sans-3": "^5.3.1",
+    "@fontsource-variable/space-grotesk": "^5.3.0",
     "@playwright/test": "1.62.0",
     "@tailwindcss/vite": "4.3.3",
     "@types/node": "^22.10.0",

package/prompts/designer.md

@@ -6,36 +6,50 @@ accessibility, frontend performance and the design language. Everything that
 runs in the browser is yours, including client-side logic and canvas,
 WebGL/three.js graphics.
 
-You have real visual taste. Your work is calm, considered and quietly
-delightful: the understated, crafted aesthetic of Anthropic's latest models,
-not a generic template. Every screen should feel intentional — clear hierarchy,
-room to breathe, and small moments of feedback that make the product feel alive
-without ever getting in the way.
-
-## Existing design language comes first
-
-Inspect the existing application before introducing new UI patterns. Prefer
-extending existing components, tokens, spacing, typography, colors,
-interactions and layouts; never introduce a visually similar but separate
-component when an existing one can be extended. Where no design system exists,
-establish a small one (tokens plus a few primitives) rather than scattering
-one-off values.
-
-## Aesthetic
-
-- Calm and editorial: generous whitespace, content first, nothing competing
-  for attention. Remove before you add.
-- Considered typography carries the hierarchy; decoration does not.
-- A restrained, warm palette: warm off-white and near-black neutrals rather
-  than pure `#fff`/`#000`, with one purposeful accent used sparingly for primary
-  actions, focus and key states.
-- Soft radii, hairline borders and subtle depth. No gratuitous gradients,
-  glassmorphism, heavy shadows or visual noise unless the product already
-  speaks that language.
-- Consistency is taste: the same thing always looks and behaves the same way.
+You bring craft, not a house style. The look of the product is the user's
+call: you never impose an aesthetic of your own, and nothing visual should
+surprise the user once it is built.
+
+## The existing design language comes first
+
+In a project that already has a UI, follow its design language exactly: its
+components, tokens, spacing, typography, colours, radii, shadows, icons,
+element types and motion. Inspect the existing application before you add
+anything, extend the components it has instead of making visually similar
+new ones, and match how it already does the same kind of thing (if it uses
+pop-overs for quick edits, so do you). Depart from it only when the user
+explicitly asks for a different style, and then only as far as they asked.
+Where no design system exists yet, establish a small one (tokens plus a few
+primitives) from the choices the user makes, rather than scattering one-off
+values.
+
+## Ask, don't assume
+
+The user makes the design decisions; you make them concrete. Before you build
+anything visual that the existing UI does not already settle, ask the user
+with `ask_user_question` about every choice that is theirs to make, for
+example:
+
+- the visual style or direction (when there is no existing one to follow);
+- sizes: buttons and controls, spacing density, type scale;
+- element types: a modal or a pop-over, a drawer or a page, rich text or a
+  plain text field, a tooltip or inline help, tabs or a segmented switch,
+  a toast or an inline message;
+- motion: whether something animates, how, and how fast;
+- colours, radii, icons and empty, loading and error states where they are
+  new.
+
+Group related choices into one questionnaire (one question each, with a
+recommendation marked) instead of asking one at a time, and say what the
+existing UI already does when it does. Decide yourself only what the existing
+design language already answers, or what the user has said to leave to you.
+When you report, list each design decision and who made it.
 
 ## Styling craft
 
+Sound practice for whatever style the project has or the user picks; where the
+existing UI does something differently, the existing UI wins.
+
 - **Type:** a modular scale (ratio about 1.2–1.25) with at most two families.
   Body text at 16px or larger, line-height about 1.5; headings tighter (about
   1.1–1.25) with slightly reduced letter-spacing at large sizes. Keep line
@@ -91,8 +105,8 @@ product, and a generic render is a failed one.
 
 ## Interaction and motion
 
-You like interactive UIs that give the user subtle, fun feedback — never
-over-animated.
+Motion and feedback follow the existing UI and what the user chose; where
+neither says, ask. As defaults to offer:
 
 - Every action gets a response: pressed states, optimistic updates, inline
   confirmation ("Saved"), skeletons or progress for waits over ~300ms, and
@@ -100,25 +114,43 @@ over-animated.
 - Motion explains change: animate only `transform` and `opacity`, 150–250ms,
   ease-out when entering and ease-in when leaving. Never animate layout
   properties, and never delay the user to show an animation.
-- Small playful touches are welcome where they fit the product — a gentle
-  check-mark draw, a soft spring on a toggle, a light stagger on a short list —
-  but no looping or attention-seeking motion.
 - Always honor `prefers-reduced-motion`: keep the state change, drop the
   movement.
 
 ## Show the options
 
 When a visual decision is the user's to make (a layout, a screen, how a
-component looks, a direction for the whole UI), show it rather than describe
-it: ask with `ask_user_question` and give every option an `htmlPreview`, a
-static mockup of that option — HTML and CSS only (no scripts, images, fonts or
-links: the sandbox strips them), laid out for a page about 1200px wide, with
-the real content, palette and proportions of what you would build, never grey
-placeholder boxes. The user sees the focused option's mockup beside the
-question, expands it and scrolls through all the options side by side, so
-draw each option at the same fidelity. Ask before you build, and only about
-what is theirs to choose; decide the rest yourself. In the planning panel,
-draw the same mockups as fenced `mockup` blocks under your options.
+component looks or behaves, a direction for the whole UI), show it rather than
+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.
+
+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
+toggle, a list arriving), at the speed you would ship. There are no scripts,
+images, fonts or links (the sandbox strips them), so build the behaviour from
+CSS: `:hover`, `:focus-within`, `:checked` with sibling selectors, and
+`details[open]`. The user sees the focused option's mockup beside the
+question, tries it there, expands it and scrolls through all the options side
+by side, so draw each option at the same fidelity. Ask before you build. In
+the planning panel, draw the same mockups as fenced `mockup` blocks under
+your options.
 
 ## Accessibility
 
@@ -133,8 +165,8 @@ screen.
 
 - Mobile-first, responsive from 320px up; test the narrowest and widest
   layouts.
-- Reuse existing components and tokens; keep components small, typed and
-  composable, with state lifted only as far as needed.
+- Reuse the project's existing components, styles and tokens; keep components
+  small, typed and composable, with state lifted only as far as needed.
 - Performance is UX: no layout shift (reserve space for media and async
   content), lazy-load below-the-fold assets, size images correctly, keep
   bundles lean and avoid needless re-renders.

package/prompts/master.md

@@ -142,9 +142,13 @@ and reason about the change inside it:
 For anything the user will see (a UI request, a layout, a screen, a visual
 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 (static HTML and CSS of that option, laid out for a page
-about 1200px wide); the user expands the mockups and scrolls through the
-options side by side. When the choice needs real design work, delegate it to
+`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). 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";
 
@@ -22,9 +23,10 @@ export { ASK_TOOL };
 
 const OptionSchema = Type.Object({
   htmlPreview: Type.Optional(Type.Object({
-    html: Type.String({ maxLength: MAX_PREVIEW_HTML, description: "Static HTML of a mockup of this option; scripts, images, fonts and links are stripped." }),
+    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 })),
-  }, { additionalProperties: false, description: "A static HTML/CSS mockup of this option, 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)." })),
+    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." })),
   preview: Type.Optional(Type.String({ description: "Markdown shown beside the options while this one is focused: a mockup, a code snippet, a diagram, a config. Only when seeing it helps the user compare." })),
@@ -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/execution/agent-runner.ts

@@ -46,6 +46,8 @@ export interface AgentRequest {
   context: AgentContext;
   model?: string;
   mcpTools?: string[];
+  /** False when the agent's settings turn its auto-compaction off. */
+  autoCompact?: boolean;
   delegationQuota?: { used: number };
   thinking?: string;
   timeoutMs: number;
@@ -254,6 +256,7 @@ async function runAgentOnce(request: AgentRequest, run: ProcessRunner, attempt:
         request.onUpdate?.(child);
       },
       mcpTools: request.mcpTools,
+      ...(request.autoCompact === false ? { autoCompact: false } : {}),
       task: request.instruction,
       systemPrompt,
       tools: toolsFor(request),

package/src/execution/pi-runner.ts

@@ -1,6 +1,7 @@
 import type { AgentRun } from "../schemas/findings.ts";
 import type { Domain, Role } from "../schemas/agent.ts";
 import { delegationHost } from "./delegation.ts";
+import { AUTO_COMPACT_ENV } from "../pi/quiet.ts";
 import { fileURLToPath } from "node:url";
 import { spawn, type ChildProcess } from "node:child_process";
 import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
@@ -44,6 +45,8 @@ export interface PiRunOptions {
   onEvent?: (event: PiStreamEvent) => void;
   /** Extra environment for the subagent process. */
   env?: Record<string, string>;
+  /** False when the agent's settings turn its auto-compaction off. */
+  autoCompact?: boolean;
   /** Kill the agent after this long without any output; 0 disables. */
   stallTimeoutMs?: number;
   /** Silence allowed while one tool call is in flight (tests, builds); 0 disables. */
@@ -765,7 +768,8 @@ function writePromptFile(prompt: string): { file: string; cleanup: () => void }
 }
 
 /** Run one isolated subagent and normalise its outcome. */
-export async function runPiAgent(options: PiRunOptions, run: ProcessRunner = spawnPiProcess): Promise<PiRunResult> {
+export async function runPiAgent(given: PiRunOptions, run: ProcessRunner = spawnPiProcess): Promise<PiRunResult> {
+  const options = given.autoCompact === false ? { ...given, env: { ...given.env, [AUTO_COMPACT_ENV]: "0" } } : given;
   const host = await delegationHost(options, run);
   let prompt: ReturnType<typeof writePromptFile> | undefined;
   try {

package/src/knowledge/oracle-digest.ts

@@ -0,0 +1,66 @@
+/**
+ * What the oracle learns, shared on its compaction loop. When the oracle's own context is compacted, the checkpoint
+ * it writes ends with a "Knowledge to share" section: durable project facts, standards and decisions, each tagged
+ * with the agent it belongs to. Those lines go into that agent's knowledge files (through `applyKnowledge`, which
+ * drops duplicates), so the oracle keeps its own knowledge current and the domain agents (designer, backend, QA)
+ * get what concerns them without the oracle having to remember to write it down.
+ */
+import { applyKnowledge, type KnowledgeKind } from "./store.ts";
+import type { KnowledgeAgent } from "./paths.ts";
+
+export const DIGEST_HEADING = "Knowledge to share";
+
+/** Added to the oracle's compaction instruction. */
+export const DIGEST_INSTRUCTION = [
+  `Finish with a section headed "## ${DIGEST_HEADING}": the durable things this stretch of work established about the project that an agent will need again, one per line, each as \`- [agent:kind] text\`.`,
+  "agent is master (you: how the user works, project-wide facts), designer (UI, UX, design language, frontend), backend (APIs, data, services, infrastructure) or qa (testing, verification, known failures).",
+  "kind is knowledge (a fact or a useful pattern), standard (a rule the user wants followed) or decision (a choice the user made, with its reason).",
+  "Give the user's own words where they set a rule or a preference. Leave out task progress, guesses, and anything only true for this task. Write `- none` when nothing qualifies. At most 12 lines.",
+].join(" ");
+
+const AGENTS: readonly KnowledgeAgent[] = ["master", "designer", "backend", "qa"];
+const KINDS: readonly KnowledgeKind[] = ["knowledge", "standard", "decision"];
+const MAX_ITEMS = 12;
+const MAX_CHARS = 400;
+
+export interface DigestItem {
+  agent: KnowledgeAgent;
+  kind: KnowledgeKind;
+  text: string;
+}
+
+/** The tagged lines under the "Knowledge to share" heading; anything malformed is skipped. */
+export function parseDigest(summary: string): DigestItem[] {
+  const lines = summary.split(/\r?\n/);
+  const start = lines.findIndex((line) => /^#{1,4}\s*knowledge to share\s*$/i.test(line.trim()));
+  if (start < 0) return [];
+  const items: DigestItem[] = [];
+  for (const line of lines.slice(start + 1)) {
+    if (/^#{1,4}\s/.test(line.trim())) break;
+    const match = /^\s*[-*]\s*\[\s*([a-z]+)\s*:\s*([a-z]+)\s*\]\s*(.+?)\s*$/i.exec(line);
+    if (!match) continue;
+    const agent = match[1]!.toLowerCase() as KnowledgeAgent;
+    const kind = match[2]!.toLowerCase() as KnowledgeKind;
+    const text = match[3]!.replace(/\s+/g, " ").trim();
+    if (!AGENTS.includes(agent) || !KINDS.includes(kind) || !text || text.length > MAX_CHARS) continue;
+    items.push({ agent, kind, text });
+    if (items.length >= MAX_ITEMS) break;
+  }
+  return items;
+}
+
+/** Write each item into its agent's knowledge; returns how many were new, by agent. */
+export function shareDigest(dataRoot: string, items: readonly DigestItem[], now = new Date()): Partial<Record<KnowledgeAgent, number>> {
+  const added: Partial<Record<KnowledgeAgent, number>> = {};
+  for (const item of items) {
+    const text = item.kind === "decision" ? item.text : `- ${item.text}`;
+    if (applyKnowledge({ dataRoot, agent: item.agent, kind: item.kind, text, now }).result === "added") added[item.agent] = (added[item.agent] ?? 0) + 1;
+  }
+  return added;
+}
+
+/** "2 for the designer, 1 for QA" */
+export function describeShared(added: Partial<Record<KnowledgeAgent, number>>): string {
+  const names: Record<KnowledgeAgent, string> = { master: "the oracle", designer: "the designer", backend: "backend", qa: "QA" };
+  return AGENTS.filter((agent) => added[agent]).map((agent) => `${added[agent]} for ${names[agent]}`).join(", ");
+}

package/src/lobby/planner.ts

@@ -1008,6 +1008,8 @@ export class PlanningSession {
           model,
           thinking,
           mcpTools: profile.mcpTools,
+        ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+          ...(profile.autoCompact === false ? { autoCompact: false } : {}),
           onChildRun: (child) => {
             this.deps.feed?.step(label, `child ${child.runId.slice(0, 8)}: ${child.step ?? child.status}`, child.runId);
             if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");

package/src/lobby/pr-review.ts

@@ -279,6 +279,7 @@ export class PullReviews {
         model,
         thinking,
         mcpTools: profile.mcpTools,
+        ...(profile.autoCompact === false ? { autoCompact: false } : {}),
         onChildRun: (child) => {
           this.deps.feed?.step(REVIEW_SOURCE, `child ${child.runId.slice(0, 8)}: ${child.step ?? child.status}`, child.runId);
           if (child.status !== "running") this.deps.feed?.end(child.runId, child.status !== "success");

package/src/lobby/quickfix.ts

@@ -92,6 +92,8 @@ export interface QuickFixProfile {
   timeoutMs: number;
   instructions?: string;
   mcpTools?: string[];
+  /** False when its settings turn the agent's auto-compaction off. */
+  autoCompact?: boolean;
   /** Where the job goes when its model runs out of usage or is unavailable. */
 }
 
@@ -340,6 +342,8 @@ export class QuickFixQueue {
           model,
           thinking,
           mcpTools: profile.mcpTools,
+        ...(profile.autoCompact === false ? { autoCompact: false } : {}),
+          ...(profile.autoCompact === false ? { autoCompact: false } : {}),
           delegationQuota: quota,
           agent: { runId: job.id, taskId: job.id, domain: "backend", role: "worker" },
           onChildRun: (child) => {

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}`,