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

package/README.md

@@ -12,7 +12,7 @@ pi install npm:@a-t-h-i/bot-lobby
 
 Try it first with `pi -e npm:@a-t-h-i/bot-lobby`, or from a checkout with `pi -e ./src/index.ts`.
 The questionnaire and web tools are built in, so don't also install extensions with the same tool names.
-Requires **Pi 1.0.x** (1.0.1 or later).
+Requires **Pi 1.3.x** (1.3.0 or later).
 
 ## Use
 
@@ -51,7 +51,7 @@ or external boards.
 The composer appears only on **Lobby**, **Tasks**, **Plan**, **Quick fix** and **Knowledge**, including
 supported detail routes and Knowledge's Docs/Chat views. On Git, Metrics and Settings it stays mounted
 but hidden and inert, preserving drafts and attachments (including uploads that finish while hidden)
-without taking space. Phone navigation remains available.
+without taking space.
 
 | Agent | Does |
 | --- | --- |

package/THIRD_PARTY_NOTICES.md

@@ -3,7 +3,7 @@
 ## T3 Code
 
 The web UI's look (colours, radii, shadows, control and dialog styles, the
-sidebar rail, the chat rows, the work log, the composer surface, the select
+sidebar rail, the chat rows, the work log, the composer (its surface, footer controls and send button), the select
 fields and drop-down lists, the loading and status animations and the
 built-in colour themes) is adapted from T3 Code,
 https://github.com/pingdotgg/t3code. No T3 Code package is a
@@ -32,8 +32,9 @@ naming the file it came from.
 | `webui/src/components/reui/badge.tsx` | `apps/web/src/components/ui/badge.tsx` |
 | `webui/src/components/reui/select.tsx` | `apps/web/src/components/ui/select.tsx` |
 | `webui/src/components/reui/popover.tsx` | `apps/web/src/components/ui/popover.tsx` |
-| `webui/src/app/Sidebar.tsx` | `apps/web/src/components/ui/sidebar.tsx` |
-| `webui/src/app/Composer.tsx` | `apps/web/src/components/chat/ComposerSurface.tsx` |
+| `webui/src/app/Sidebar.tsx` | `apps/web/src/components/Sidebar.tsx`, `apps/web/src/components/ui/sidebar.tsx` |
+| `webui/src/app/Composer.tsx` | `apps/web/src/components/chat/ComposerSurface.tsx`, `ChatComposer.tsx`, `ComposerPrimaryActions.tsx`, `ComposerControl.tsx` |
+| `webui/src/app/TerminalDrawer.tsx` | `apps/web/src/components/ThreadTerminalDrawer.tsx` (the drawer, its floating toolbar and terminal list) |
 | `webui/src/tabs/lobby/InlineActivity.tsx` | `apps/web/src/components/chat/WorkLog.tsx` |
 | `src/webui/palette-core.ts` (the built-in themes) | `packages/shared/src/themePalettes.ts` (Blossom is their T3 Chat theme, renamed) |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@a-t-h-i/bot-lobby",
-  "version": "0.6.48",
+  "version": "0.6.50",
   "description": "Structured multi-agent software engineering orchestrator for Pi",
   "type": "module",
   "license": "Apache-2.0",
@@ -47,16 +47,16 @@
     "test": "node --test --test-reporter=dot test/*.test.ts"
   },
   "peerDependencies": {
-    "@earendil-works/pi-ai": ">=1.0.1 <1.1.0",
-    "@earendil-works/pi-coding-agent": ">=1.0.1 <1.1.0",
-    "@earendil-works/pi-tui": ">=1.0.1 <1.1.0",
+    "@earendil-works/pi-ai": ">=1.3.0 <1.4.0",
+    "@earendil-works/pi-coding-agent": ">=1.3.0 <1.4.0",
+    "@earendil-works/pi-tui": ">=1.3.0 <1.4.0",
     "typebox": "*"
   },
   "devDependencies": {
     "@axe-core/playwright": "4.13.0",
-    "@earendil-works/pi-ai": "1.0.1",
-    "@earendil-works/pi-coding-agent": "1.0.1",
-    "@earendil-works/pi-tui": "1.0.1",
+    "@earendil-works/pi-ai": "1.3.0",
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-tui": "1.3.0",
     "@fontsource-variable/dm-sans": "^5.3.0",
     "@fontsource-variable/figtree": "^5.3.0",
     "@fontsource-variable/fira-code": "^5.3.0",
@@ -79,6 +79,8 @@
     "@types/react": "19.3.0",
     "@types/react-dom": "19.3.0",
     "@vitejs/plugin-react": "6.1.1",
+    "@xterm/addon-fit": "0.11.0",
+    "@xterm/xterm": "6.0.0",
     "class-variance-authority": "0.7.1",
     "clsx": "2.1.1",
     "lucide-react": "1.49.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/classifier/classifier.ts

@@ -2,7 +2,8 @@
  * The classifier facade every feature calls. It never throws into the
  * workflow: any failure (no key, a timeout, an API error, a request over
  * budget) returns undefined, and the caller falls back to what bot-lobby did
- * before the classifier existed. It answers with Jev on its host, or with the
+ * before the classifier existed. It answers with Jev on its host (through pi's
+ * classifier catalog and logins when pi lists it), or with the
  * model `classifier.engine` names (any classifier or chat model pi is signed
  * in to; see `models.ts`). Three failures in a row pause it for ten
  * minutes with a single warning, so a dead endpoint cannot tax every step.
@@ -12,7 +13,7 @@ import type { ClassifierConfig, ClassifierFeature } from "../schemas/configurati
 import type { MetricRecord } from "../state/metrics.ts";
 import { JevError, noul, systemOne, type Answer, type FetchLike, type SystemOneRequest } from "./client.ts";
 import { fitsBudget, requestSize, LIMITS } from "./limits.ts";
-import { keyHint, resolveTarget, type KeySource } from "./hosts.ts";
+import { keyHint, piModelRef, resolveTarget, type KeySource } from "./hosts.ts";
 import type { EngineAnswer } from "./models.ts";
 
 export type ClassifierPurpose = ClassifierFeature | "test";
@@ -32,6 +33,8 @@ export interface ClassifierDeps {
   keys?: KeySource;
   /** Answers with the model `classifier.engine` names, through pi's registry; absent before a session starts. */
   engine?: EngineAnswer;
+  /** Whether pi's registry lists a classifier model (`provider/id`); Jev on its host goes through pi when it does. */
+  lists?: (ref: string) => boolean;
   fetch?: FetchLike;
   sleep?: (ms: number) => Promise<void>;
   env?: NodeJS.ProcessEnv;
@@ -112,6 +115,15 @@ export class Classifier {
       }
       return { ok: false, error };
     }
+    const ref = piModelRef(host, config);
+    if (!config.baseUrl && this.deps.engine && this.deps.lists?.(ref)) {
+      const result = await this.callEngine(purpose, ref, request, options);
+      // A limited-time free model that ends answers 404/410; never switch to the paid one silently.
+      if (!result.ok && model.endsWith("-free") && /\b(404|410)\b|not found|gone/i.test(result.error)) {
+        return { ok: false, error: `${result.error} — ${host.label}'s free ${model} may have ended; set the classifier's model to ${model.replace(/-free$/, "")} (paid) in /bot-lobby settings to keep using Jev there` };
+      }
+      return result;
+    }
     const started = this.now();
     try {
       const response = await systemOne(request, {

package/src/classifier/hosts.ts

@@ -6,14 +6,17 @@
  * - OpenCode Zen serves Jev with the OpenCode key pi uses for Zen and Go
  *   (`/login opencode` or `opencode-go`, or OPENCODE_API_KEY), on the free
  *   `jev-1.13-free` model while OpenCode offers it.
- * - TypeSafe direct: bot-lobby registers a `typesafe` provider so `/login
- *   typesafe` stores the key in pi's auth.json.
+ * - TypeSafe direct: pi's own `typesafe` provider (`/login typesafe` or
+ *   TYPESAFE_API_KEY).
  * - OpenRouter and Vercel AI Gateway use the key pi holds for them.
  *
+ * Every host's Jev is in pi's classifier catalog, so the classifier calls it
+ * through pi (`piModel` is its id there); only a custom URL or a model pi does
+ * not list goes to the System One API directly (see `classifier.ts`).
+ *
  * `auto` (the default) takes OpenCode when pi holds an OpenCode key, else
  * TypeSafe.
  */
-import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import type { ClassifierConfig, JevHostName } from "../schemas/configuration.ts";
 
 export type JevHostId = Exclude<JevHostName, "auto">;
@@ -27,13 +30,15 @@ export interface JevHost {
   env: string;
   baseUrl: string;
   model: string;
+  /** The default model's id in pi's classifier catalog, when it differs from `model`. */
+  piModel?: string;
   headers?: Readonly<Record<string, string>>;
 }
 
 export const JEV_HOST_TABLE: Readonly<Record<JevHostId, JevHost>> = Object.freeze({
   opencode: { name: "opencode", label: "OpenCode Zen", piProviders: ["opencode", "opencode-go"], env: "OPENCODE_API_KEY", baseUrl: "https://opencode.ai/zen", model: "jev-1.13-free" },
   typesafe: { name: "typesafe", label: "TypeSafe", piProviders: ["typesafe"], env: "TYPESAFE_API_KEY", baseUrl: "https://api.typesafe.ai", model: "jev-latest" },
-  openrouter: { name: "openrouter", label: "OpenRouter", piProviders: ["openrouter"], env: "OPENROUTER_API_KEY", baseUrl: "https://openrouter.ai/api", model: "jev-latest", headers: { "HTTP-Referer": "https://github.com/a-t-h-i/bot-lobby", "X-Title": "bot-lobby" } },
+  openrouter: { name: "openrouter", label: "OpenRouter", piProviders: ["openrouter"], env: "OPENROUTER_API_KEY", baseUrl: "https://openrouter.ai/api", model: "jev-latest", piModel: "~typesafe/jev-latest", headers: { "HTTP-Referer": "https://github.com/a-t-h-i/bot-lobby", "X-Title": "bot-lobby" } },
   vercel: { name: "vercel", label: "Vercel AI Gateway", piProviders: ["vercel-ai-gateway"], env: "AI_GATEWAY_API_KEY", baseUrl: "https://ai-gateway.vercel.sh/typesafe", model: "typesafe-ai/jev" },
 });
 
@@ -129,18 +134,7 @@ export function describeKey(host: JevHost, status: StatusSource | undefined, env
   return `missing: ${host.name === "typesafe" ? "/login typesafe → Use an API key" : `/login ${host.piProviders[0]}`}, or set ${host.env}`;
 }
 
-/**
- * Register TypeSafe as a pi provider with no chat models, so `/login
- * typesafe` stores the Jev key with pi's own locking and `/logout` removes
- * it. Nothing is added to `/model`. A pi that refuses the registration only
- * loses the login entry: the environment variable still works.
- */
-export function registerJevProvider(pi: ExtensionAPI): boolean {
-  const host = JEV_HOST_TABLE.typesafe;
-  try {
-    pi.registerProvider(host.piProviders[0]!, { name: "TypeSafe (Jev classifier)", baseUrl: host.baseUrl, apiKey: `$${host.env}`, models: [] });
-    return true;
-  } catch {
-    return false;
-  }
+/** The `provider/id` pi lists a host's Jev under: the host's first pi provider, with the config's model if it names one. */
+export function piModelRef(host: JevHost, config: Pick<ClassifierConfig, "model">): string {
+  return `${host.piProviders[0]}/${config.model || host.piModel || host.model}`;
 }

package/src/classifier/instance.ts

@@ -11,7 +11,7 @@ import { isSubagentProcess } from "../pi/quiet.ts";
 import { Classifier } from "./classifier.ts";
 import { scriptPicker } from "./scripts.ts";
 import type { ScriptPicker } from "../scripts/pick.ts";
-import { registerJevProvider, type KeySource, type KeyStatus } from "./hosts.ts";
+import type { KeySource, KeyStatus } from "./hosts.ts";
 import { fileHinter, type FileHinter, type FileScope } from "./files.ts";
 import { withRepoMap } from "../knowledge/repo-map.ts";
 import { knowledgePicker, type KnowledgePicker } from "./knowledge.ts";
@@ -19,7 +19,7 @@ import { lobbyFeed } from "../lobby/feed.ts";
 import { triageLine, triageWithContext } from "./triage.ts";
 import type { TaskTriage } from "../schemas/task.ts";
 import { effortRouter, type EffortRouter } from "./effort.ts";
-import { engineAnswer, engineClassifiers, type EngineAnswer, type EngineModel, type Registry } from "./models.ts";
+import { engineAnswer, engineClassifiers, splitRef, type EngineAnswer, type EngineModel, type Registry } from "./models.ts";
 
 interface Binding {
   cwd: string;
@@ -43,6 +43,10 @@ export function classifier(): Classifier {
       if (!binding) throw new Error(`${ref} is not reachable before a pi session starts`);
       return binding.engine(ref, request, options);
     },
+    lists: (ref) => {
+      const parts = splitRef(ref);
+      return Boolean(parts && binding?.registry.findOfType("classifier", parts.provider, parts.id));
+    },
     metrics: (record) => {
       if (binding) appendMetrics(binding.root, binding.configDir, [record]);
     },
@@ -114,9 +118,8 @@ export function availableClassifiers(): EngineModel[] {
   return classifierModels;
 }
 
-/** Register the `typesafe` login entry and bind the classifier to each session's key store. */
+/** Bind the classifier to each session's key store and model registry. */
 export function registerClassifier(pi: ExtensionAPI, configDir: string): void {
-  registerJevProvider(pi);
   pi.on("session_start", (_event, ctx) => {
     binding = {
       cwd: ctx.cwd,

package/src/execution/delegation.ts

@@ -75,7 +75,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   const tools = [...new Set([...baseTools, "codemode", "tool_search", ...(canDelegate(agent, quota.used) ? [DELEGATE_TOOL] : [])])];
   const mcpTools = options.mcpTools ?? agentProfile(config, agent.domain, agent.role).mcpTools ?? [];
   const policy: AgentPolicy = { tools, mcpTools, readOnly: !editable, depth };
-  if (depth > 1) return { tools, env: { ...options.env, [AGENT_ENV]: JSON.stringify(policy), [DELEGATION_ENV]: "" }, note: "You are a child agent. Finish only your assigned brief and report evidence to your parent; you cannot delegate further.", close: async () => {}, onStart: options.onStart, children: [] as AgentRun[] };
+  if (depth > 1) return { tools, mcpTools, env: { ...options.env, [AGENT_ENV]: JSON.stringify(policy), [DELEGATION_ENV]: "" }, note: "You are a child agent. Finish only your assigned brief and report evidence to your parent; you cannot delegate further.", close: async () => {}, onStart: options.onStart, children: [] as AgentRun[] };
 
   const address = options.env?.[DESK_ENV.address];
   let desk = address ? deskSessionAt(address) : undefined;
@@ -189,6 +189,7 @@ export async function delegationHost(options: PiRunOptions, run: ProcessRunner)
   let closed = false;
   return {
     tools: desk ? [...new Set([...tools, ...DESK_TOOLS])] : tools,
+    mcpTools,
     env: { ...options.env, ...(desk ? desk.env(parentDeskId) : {}), [AGENT_ENV]: JSON.stringify({ ...policy, tools: desk ? [...new Set([...tools, ...DESK_TOOLS])] : tools }), [DELEGATION_ENV]: JSON.stringify({ address: server.address, token, timeoutMs: options.timeoutMs }) },
     note: `${canDelegate(agent, quota.used) ? `Work directly when you can finish the brief yourself. Use ${DELEGATE_TOOL} only for useful, separable work with disjoint files, at most five children total; children share your remaining time and cannot delegate further. Integrate and verify their work yourself. ` : ""}Use codemode for concise parallel calls, inspect failures, and return only useful evidence.${desk ? " Before edit/write, claim_file; handover_file when finished. Release files before delegating or waiting." : ""}`,
     onStart: (handle: Parameters<NonNullable<PiRunOptions["onStart"]>>[0]) => {

package/src/execution/pi-runner.ts

@@ -362,12 +362,21 @@ export function finishedThought(line: string): string | undefined {
   return text.length > MAX_THOUGHT_CHARS ? `${text.slice(0, MAX_THOUGHT_CHARS - 1)}…` : text;
 }
 
+/** pi's MCP resource tools; the agent policy lets them reach only servers with a granted tool. */
+export const MCP_RESOURCE_TOOLS: readonly string[] = ["list_mcp_resources", "list_mcp_resource_templates", "read_mcp_resource"];
+
 /** Build the `pi` argv for one isolated, headless RPC agent run; the task goes over stdin. */
 export function buildPiArgs(options: Omit<PiRunOptions, "task"> & { systemPromptFile?: string }): string[] {
   const args = ["--mode", "rpc", "--no-session", "--no-prompt-templates", "--no-themes", "--extension", fileURLToPath(new URL("../index.ts", import.meta.url))];
   if (options.model && options.model !== "inherit") args.push("--model", options.model);
   if (options.thinking) args.push("--thinking", options.thinking);
-  if (options.tools && options.tools.length > 0) args.push("--tools", options.tools.join(","));
+  if (options.tools && options.tools.length > 0) {
+    // pi keeps every MCP tool under --tools unless an entry names one, so name the granted ones (and the resource
+    // tools their servers need), or run without MCP at all when nothing is granted.
+    const mcp = options.mcpTools?.filter((name) => name.startsWith("mcp__")) ?? [];
+    args.push("--tools", [...options.tools, ...(mcp.length ? [...mcp, ...MCP_RESOURCE_TOOLS] : [])].join(","));
+    if (!mcp.length) args.push("--no-mcp");
+  }
   if (options.systemPromptFile) args.push("--append-system-prompt", options.systemPromptFile);
   return args;
 }
@@ -775,7 +784,7 @@ export async function runPiAgent(given: PiRunOptions, run: ProcessRunner = spawn
   try {
     prompt = writePromptFile([options.systemPrompt, host.note].filter(Boolean).join("\n\n"));
     if (options.signal?.aborted) return { status: "cancelled", output: "", usage: { input: 0, output: 0, cost: 0, turns: 0 } };
-    const args = buildPiArgs({ ...options, tools: host.tools, systemPromptFile: prompt.file });
+    const args = buildPiArgs({ ...options, tools: host.tools, mcpTools: host.mcpTools, systemPromptFile: prompt.file });
     const outcome = await run(args, {
       cwd: options.cwd,
       signal: options.signal,

package/src/lobby/host.ts

@@ -160,6 +160,10 @@ export interface LobbyService {
   sessionName(): string | undefined;
   /** Background sessions this window started, oldest first. */
   sessions(): readonly BackgroundSession[];
+  /** Rename this window's session (no key) or a background one; returns a notice (throws when it cannot). */
+  renameSession?(key: string | undefined, name: string): string;
+  /** Put an ended background session away from the list, or bring it back; returns a notice (throws when it cannot). */
+  archiveSession?(key: string, archived: boolean): string;
   /** Start a task in a new background session, named after the task; the session, or why not. */
   startSession(start: { request?: string; plan?: PlannedTask; auto?: boolean }): BackgroundSession | string;
   /** Auto mode for any task, whichever session drives it. */
@@ -174,6 +178,8 @@ export interface LobbyService {
    */
   resumeTask?(taskId: string): Promise<{ notice: string; key?: string }>;
   acceptTask?(taskId: string): Promise<{ notice: string }>;
+  /** Skip a plan step (0-based, named by its text too) with the user's reason. */
+  skipTaskStep?(taskId: string, step: number, text: string, reason: string): Promise<{ notice: string }>;
   forceCloseTask?(taskId: string, title: string): Promise<{ notice: string }>;
   canForceCloseTask?(taskId: string): boolean;
   resolveTaskApproval?(taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }>;

package/src/lobby/keys.ts

@@ -9,9 +9,10 @@ export const LOBBY_ACTIONS = {
   help: { key: "alt+h", help: "show or hide this list" },
   settings: { key: "alt+s", help: "settings: each agent's model and effort" },
   savePlan: { key: "ctrl+s", help: "save the plan from the Plan tab" },
-  sidebar: { key: "alt+b", help: "open the sidebar on a phone" },
+  sidebar: { key: "alt+b", help: "fold or open the sidebar (on a phone, open it)" },
   activity: { key: "alt+a", help: "open or fold every step in the Lobby conversation" },
   thinking: { key: "alt+t", help: "show or hide Thinking on the Lobby" },
+  terminal: { key: "ctrl+`", help: "show or hide the terminal" },
   nextTab: { key: "alt+]", help: "next tab" },
   prevTab: { key: "alt+[", help: "previous tab" },
 } as const;