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

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.48",
   "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,29 @@ 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. 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 +151,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,10 @@ 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); 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/tool.ts

@@ -22,9 +22,9 @@ 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)." })),
+  }, { 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." })),

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/master/master.ts

@@ -60,7 +60,7 @@ export interface ScoutRequest {
 /** Model, thinking and time limit for one run, from settings. */
 function profileFields(config: BotLobbyConfig, resolver: ProfileResolver | undefined, domain: Domain, role: AgentRequest["role"]) {
   const profile = profileFor(config, resolver, domain, role);
-  return { model: profile.model, mcpTools: profile.mcpTools, thinking: profile.thinking, timeoutMs: profile.timeoutMs, time: boundedAgentTime(profile.timeoutMs) };
+  return { model: profile.model, mcpTools: profile.mcpTools, ...(profile.autoCompact === false ? { autoCompact: false } : {}), thinking: profile.thinking, timeoutMs: profile.timeoutMs, time: boundedAgentTime(profile.timeoutMs) };
 }
 
 function scoutInstruction(request: ScoutRequest, domain: Domain): string {

package/src/master/research.ts

@@ -71,6 +71,7 @@ export async function runResearch(request: ResearchRequest, run: ProcessRunner =
       context: researchContext(request),
       model: profile.model,
       mcpTools: profile.mcpTools,
+      ...(profile.autoCompact === false ? { autoCompact: false } : {}),
       thinking: profile.thinking,
       timeoutMs: profile.timeoutMs,
       ...(request.time ? { time: request.time } : {}),

package/src/pi/auto-compaction.ts

@@ -1,6 +1,31 @@
-import { compact, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, type ExtensionAPI, type TurnEndEvent } from "@earendil-works/pi-coding-agent";
+import { compact, CONFIG_DIR_NAME, DEFAULT_COMPACTION_SETTINGS, estimateTokens, findCutPoint, type ExtensionAPI, type ExtensionContext, type TurnEndEvent } from "@earendil-works/pi-coding-agent";
 import { contextMarks, freshContextOn } from "./fresh-context.ts";
-import { isSubagentProcess } from "./quiet.ts";
+import { AUTO_COMPACT_ENV, isSubagentProcess } from "./quiet.ts";
+import { dataRoot, detectProjectRoot, loadConfig } from "../state/project.ts";
+import { describeShared, DIGEST_INSTRUCTION, parseDigest, shareDigest, type DigestItem } from "../knowledge/oracle-digest.ts";
+
+const CHECKPOINT = "Write a concise checkpoint with: Requirements and constraints; Decisions; Files changed; Verification and evidence; Failed approaches (do not repeat); Unfinished work and next action; Outstanding children and their assignments. Preserve concrete file references and distinguish verified facts from guesses. The parent remains responsible for integration and verification.";
+
+export interface AutoCompactionOptions {
+  /** Whether this agent compacts on its own: a subagent by its environment, the oracle by its settings. */
+  enabled?: () => boolean;
+  /** Where the oracle's shared knowledge goes; by default the project's knowledge files. */
+  share?: (items: DigestItem[], ctx: ExtensionContext) => string;
+}
+
+function enabledBySettings(): boolean {
+  if (isSubagentProcess()) return process.env[AUTO_COMPACT_ENV] !== "0";
+  try {
+    return loadConfig().master.autoCompact !== false;
+  } catch {
+    return true;
+  }
+}
+
+function shareWithAgents(items: DigestItem[], ctx: ExtensionContext): string {
+  const root = detectProjectRoot(ctx.cwd, CONFIG_DIR_NAME);
+  return describeShared(shareDigest(dataRoot(root, CONFIG_DIR_NAME), items));
+}
 
 export const CONTEXT_TARGET = 64_000;
 
@@ -8,13 +33,20 @@ export function compactionThreshold(window: number, reserve = DEFAULT_COMPACTION
   return Math.max(1, Math.min(CONTEXT_TARGET, Math.floor(window * 0.6), window - Math.min(reserve, Math.floor(window / 2))));
 }
 
-/** Compact at a settled tool boundary; ctx.compact() would abort the turn we need to continue. */
-export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compact = compact): void {
+/**
+ * Compact at a settled tool boundary; ctx.compact() would abort the turn we need to continue. Each agent's settings
+ * can turn it off. The oracle's checkpoint also lists what it learned that is worth keeping, tagged by agent, and
+ * that goes into the knowledge base: its own, and the designer's, backend's and QA's where it concerns them.
+ */
+export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compact = compact, options: AutoCompactionOptions = {}): void {
+  const enabled = options.enabled ?? enabledBySettings;
+  const share = options.share ?? shareWithAgents;
+  const oracle = !isSubagentProcess();
   let busy = false;
   let lastLeaf: string | null | undefined;
   pi.on("session_start", () => { busy = false; lastLeaf = undefined; });
   pi.on("turn_end", async (event: TurnEndEvent, ctx) => {
-    if (busy || !ctx.model) return;
+    if (busy || !ctx.model || !enabled()) return;
     const leaf = ctx.sessionManager.getLeafId();
     if (leaf === lastLeaf) return;
     const configured = pi.getSettings().compaction;
@@ -61,9 +93,18 @@ export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compa
       const headers = auth.headers ? Object.fromEntries(Object.entries(auth.headers).filter((entry): entry is [string, string] => entry[1] !== null)) : undefined;
       const retry = pi.getSettings().retry;
       const retryPolicy = { enabled: retry?.enabled ?? true, maxRetries: retry?.maxRetries ?? 3, baseDelayMs: retry?.baseDelayMs ?? 2_000, maxAgentDelayMs: retry?.maxAgentDelayMs };
-      const result = await summarize({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, auth.baseUrl ? { ...ctx.model, baseUrl: auth.baseUrl } : ctx.model, auth.apiKey, headers, "Write a concise checkpoint with: Requirements and constraints; Decisions; Files changed; Verification and evidence; Failed approaches (do not repeat); Unfinished work and next action; Outstanding children and their assignments. Preserve concrete file references and distinguish verified facts from guesses. The parent remains responsible for integration and verification.", ctx.signal, undefined, undefined, auth.env, retryPolicy);
+      const result = await summarize({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, auth.baseUrl ? { ...ctx.model, baseUrl: auth.baseUrl } : ctx.model, auth.apiKey, headers, oracle ? `${CHECKPOINT} ${DIGEST_INSTRUCTION}` : CHECKPOINT, ctx.signal, undefined, undefined, auth.env, retryPolicy);
       ctx.signal?.throwIfAborted();
       ctx.ui.notify("Agent context compacted", "info");
+      if (oracle) {
+        try {
+          const items = parseDigest(result.summary);
+          const shared = items.length ? share(items, ctx) : "";
+          if (shared) ctx.ui.notify(`Knowledge updated: ${shared}`, "info");
+        } catch (error) {
+          ctx.ui.notify(`Could not update knowledge: ${(error as Error).message}`, "warning");
+        }
+      }
       return { entries: [...event.entries, { type: "compaction" as const, summary: result.summary, firstKeptEntryId, usage: result.usage, details: result.details }] };
     } catch (error) {
       ctx.ui.notify(`Context compaction failed: ${(error as Error).message}`, "warning");

package/src/pi/quiet.ts

@@ -58,6 +58,9 @@ export function webToolsFor(active: string[], taskActive: boolean, hidden: reado
   return { active: [...active, ...back], hidden: [] };
 }
 
+/** Set to "0" in a subagent's environment when its settings turn auto-compaction off. */
+export const AUTO_COMPACT_ENV = "BOT_LOBBY_AUTO_COMPACT";
+
 /** True inside a bot-lobby subagent process (marked in `spawnPiProcess`). */
 export function isSubagentProcess(): boolean {
   return process.env.BOT_LOBBY_SUBAGENT === "1";

package/src/schemas/configuration.ts

@@ -31,6 +31,8 @@ export interface AgentModelConfig {
   mcpTools?: string[];
   /** Time limit per run; falls back to `workflow.agentTimeoutMs`. */
   timeoutMs?: number;
+  /** Compact this agent's context on its own as it fills (on unless false); the oracle's also updates the knowledge base. */
+  autoCompact?: boolean;
 }
 
 /** Scouts pick a model and a time limit only; their thinking is fixed at `SCOUT_THINKING`. */
@@ -40,6 +42,8 @@ export interface ScoutConfig {
   timeoutMs: number;
   /** Tool calls a scout may make: it is told to wrap up at 60% and refused more past this, so it reports with what it has; 0 = no limit. */
   maxToolCalls: number;
+  /** Compact a scout's context on its own as it fills (on unless false). */
+  autoCompact?: boolean;
 }
 
 /** Subagent kinds with their own settings entry. */
@@ -351,7 +355,7 @@ function normalizeAgent(base: AgentModelConfig, override: Partial<AgentModelConf
   const thinking = isThinkingLevel(merged.thinking) ? merged.thinking : base.thinking;
   const timeoutMs = positive(merged.timeoutMs) ?? base.timeoutMs;
   const mcpTools = normalizeMcpTools(merged.mcpTools);
-  return { model: merged.model, thinking, ...(mcpTools.length ? { mcpTools } : {}), ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(timeoutMs ? { timeoutMs } : {}) };
+  return { model: merged.model, thinking, ...(mcpTools.length ? { mcpTools } : {}), ...(typeof merged.instructions === "string" ? { instructions: merged.instructions } : {}), ...(timeoutMs ? { timeoutMs } : {}), ...(merged.autoCompact === false ? { autoCompact: false } : {}) };
 }
 
 /** Scouts keep a model and a time limit; any thinking value in the file is dropped. */
@@ -363,6 +367,7 @@ function normalizeScout(override: Partial<ScoutConfig> | undefined): ScoutConfig
     timeoutMs: positive(override?.timeoutMs) ?? base.timeoutMs,
     maxToolCalls: typeof override?.maxToolCalls === "number" && Number.isFinite(override.maxToolCalls) && override.maxToolCalls >= 0 ? Math.round(override.maxToolCalls) : base.maxToolCalls,
     ...(mcpTools.length ? { mcpTools } : {}),
+    ...(override?.autoCompact === false ? { autoCompact: false } : {}),
   };
 }
 
@@ -513,6 +518,13 @@ export interface AgentProfile {
   instructions?: string;
   /** Exact native MCP tool names this profile may call; empty grants none. */
   mcpTools?: string[];
+  /** False when its settings turn auto-compaction off. */
+  autoCompact?: boolean;
+}
+
+/** `{ autoCompact: false }` when an entry turns auto-compaction off, else nothing. */
+function compactField(entry: { autoCompact?: boolean }): { autoCompact?: false } {
+  return entry.autoCompact === false ? { autoCompact: false } : {};
 }
 
 /** The settings entry a domain/role run draws from. */
@@ -537,10 +549,10 @@ export function agentProfile(config: BotLobbyConfig, domain: Domain, role: Role)
   const instructions = config.agents[domain].instructions;
   const fallback = config.workflow.agentTimeoutMs;
   if (kind === "scout") {
-    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(config.scout.mcpTools?.length ? { mcpTools: config.scout.mcpTools } : {}) };
+    return { kind, model: modelOf(config.scout.model), thinking: SCOUT_THINKING, timeoutMs: config.scout.timeoutMs || fallback, instructions, ...(config.scout.mcpTools?.length ? { mcpTools: config.scout.mcpTools } : {}), ...compactField(config.scout) };
   }
   const entry = kind === "researcher" ? config.researcher : config.agents[kind];
-  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}) };
+  return { kind, model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? fallback, instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
 }
 
 /** The settings entry of a lobby agent (quick fix or planner). */
@@ -549,19 +561,19 @@ export function lobbyAgentConfig(config: BotLobbyConfig, kind: LobbyAgentKind):
 }
 
 /** Profile for a lobby agent run, from settings alone; `model` is undefined while unset. */
-export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[] } {
+export function lobbyAgentProfile(config: BotLobbyConfig, kind: LobbyAgentKind): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[]; autoCompact?: boolean } {
   const entry = lobbyAgentConfig(config, kind);
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs: entry.timeoutMs ?? config.workflow.agentTimeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
 }
 
 /**
  * A planning panel seat's profile: the domain's (or the researcher's) model,
  * thinking and custom instructions, bounded by the planner's per-turn limit.
  */
-export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[] } {
+export function panelMemberProfile(config: BotLobbyConfig, member: PanelMember): { model?: string; thinking: string; timeoutMs: number; instructions?: string; mcpTools?: string[]; autoCompact?: boolean } {
   const entry = member === "researcher" ? config.researcher : config.agents[member];
   const timeoutMs = config.planner.timeoutMs ?? config.workflow.agentTimeoutMs;
-  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}) };
+  return { model: modelOf(entry.model), thinking: entry.thinking, timeoutMs, instructions: entry.instructions, ...(entry.mcpTools?.length ? { mcpTools: entry.mcpTools } : {}), ...compactField(entry) };
 }
 
 /** Resolves the model, thinking and time limit one subagent run uses. */