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

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.49",
+  "version": "0.6.51",
   "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/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;

package/src/lobby/service.ts

@@ -4,7 +4,7 @@
  * the prompt hub (see ../ask/web.ts).
  */
 import { SessionManager, type ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
+import { MAX_SKIP_REASON, TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { updateBlockingRequest } from "../state/blocking-requests.ts";
 import { randomUUID } from "node:crypto";
 import { loadTask, ownedTask, peekOwnedTask, peekTasks, saveTask } from "../state/persistence.ts";
@@ -36,7 +36,7 @@ import { pendingRequest, startRequest } from "../pi/route.ts";
 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 { cleanSessionName, 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";
@@ -55,6 +55,8 @@ import type { Runtime } from "./runtime.ts";
 import { findLinters } from "../execution/lint.ts";
 import { handleResolveApproval, lastQaAsks, waiveLint, waiveQa } from "../workflow/workflow.ts";
 import { recordDecision } from "../master/decisions.ts";
+import { stepViews } from "../webui/api/plan-facts.ts";
+import { truncate } from "../text.ts";
 import { fail } from "../webui/api/index.ts";
 
 /** The state background callbacks report to; set while the lobby service runs. */
@@ -218,6 +220,31 @@ export function backgroundSessions(): readonly BackgroundSession[] {
   return registry?.sessions ?? [];
 }
 
+/** Rename this window's session (no key) or one of its background sessions. */
+function renameSession(state: Runtime, key: string | undefined, name: string): string {
+  const clean = cleanSessionName(name);
+  if (!key) {
+    state.pi.setSessionName(clean);
+    lobbyTopics.bump("status");
+    lobbyTopics.bump("sessions");
+    return `renamed this window to ${clean}`;
+  }
+  const session = backgroundSessions().find((entry) => entry.key === key && entry.projectRoot === state.root);
+  if (!session) throw new Error(`no session ${key}`);
+  session.rename(clean);
+  return `renamed ${key} to ${clean}`;
+}
+
+/** Put an ended background session away from the sidebar, or bring it back. */
+function archiveSession(state: Runtime, key: string, archived: boolean): string {
+  const list = registry ? (archived ? registry.sessions : registry.archived) : [];
+  const session = list.find((entry) => entry.key === key && entry.projectRoot === state.root);
+  if (!session) throw new Error(archived ? `no session ${key} to archive` : `no archived session ${key}`);
+  if (session.alive) throw new Error(`${session.name} is still running: stop it before archiving it`);
+  registry!.archive(key, archived);
+  return archived ? `archived ${session.name}` : `brought back ${session.name}`;
+}
+
 /** A background session changed: say so when one asks something or fails. */
 function sessionsChanged(): void {
   lobbyTopics.bump("sessions");
@@ -399,9 +426,19 @@ function mutableTask(state: Runtime, taskId: string): Task {
 }
 
 async function wakeTask(state: Runtime, task: Task, message: string): Promise<string> {
+  if (!tellOracle(state, task, message)) return (await resumeTask(state, task.id)).notice;
+  return "the owning oracle has been notified";
+}
+
+/**
+ * Leave a message in the task's inbox and hand it to its oracle now when a
+ * session here runs the task; false when the task is paused or stopped, so the
+ * oracle reads it once the task carries on.
+ */
+function tellOracle(state: Runtime, task: Task, message: string): boolean {
   const inbox = sendToInbox(state.root, state.configDir, task.id, message, state.ctx.sessionManager.getSessionId());
   const route = resumeRoute(task, taskDrivers(state));
-  if (route.kind === "stopped" || route.kind === "paused") return (await resumeTask(state, task.id)).notice;
+  if (route.kind === "stopped" || route.kind === "paused") return false;
   if (task.ownerSessionId === state.ctx.sessionManager.getSessionId()) {
     state.pi.sendUserMessage(message, state.ctx.isIdle() ? undefined : { deliverAs: "followUp" });
     markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
@@ -412,7 +449,7 @@ async function wakeTask(state: Runtime, task: Task, message: string): Promise<st
       markInboxDelivered(state.root, state.configDir, task.id, [inbox.id]);
     }
   }
-  return "the owning oracle has been notified";
+  return true;
 }
 
 function canForceCloseTask(state: Runtime, taskId: string): boolean {
@@ -446,6 +483,33 @@ async function acceptTask(state: Runtime, taskId: string): Promise<{ notice: str
   return { notice: `${task.id} accepted as it is; ${wake}` };
 }
 
+/**
+ * Skip a plan step on the user's word, with their reason: kept on the task
+ * (the checklist shows it skipped, the reason under it), recorded as a
+ * decision, and passed to the task's oracle so it carries on without it. A
+ * paused or stopped task is not resumed: its oracle reads it when it carries on.
+ */
+async function skipTaskStep(state: Runtime, taskId: string, step: number, text: string, reason: string): Promise<{ notice: string }> {
+  const task = mutableTask(state, taskId);
+  const why = reason.trim().replace(/\s+/g, " ");
+  if (!why) fail(400, "bad_request", "say why you are skipping this step");
+  if (why.length > MAX_SKIP_REASON) fail(400, "bad_request", `keep the reason under ${MAX_SKIP_REASON} characters`);
+  if (!task.plan) fail(400, "bad_request", "this task has no plan yet");
+  const steps = stepViews(task, taskWork(state.root, state.configDir, task.id));
+  const found = steps[step];
+  if (!found || found.text !== text) fail(409, "conflict", "the plan changed; refresh the task");
+  if (found.status === "done") fail(409, "conflict", "that step is already done");
+  if (found.status === "skipped") fail(409, "conflict", "that step is already skipped");
+  task.skippedSteps = [...(task.skippedSteps ?? []), { text, reason: why, at: new Date().toISOString() }];
+  recordDecision(task, `The user skipped step ${step + 1} ("${truncate(text, 200)}") from the Tasks screen. Reason: ${why}`);
+  saveTask(state.root, state.configDir, task);
+  lobbyTopics.bump("tasks");
+  lobbyTopics.bump("lobby");
+  const message = `The user skipped step ${step + 1} of ${task.id}'s plan: "${text}". Their reason: ${why}. Do not delegate, build or review that step; if an agent is on it now, let it stop there or tell it to. Carry on with the next open step.`;
+  if (!tellOracle(state, task, message)) return { notice: `step ${step + 1} skipped; the oracle reads why when the task carries on` };
+  return { notice: `step ${step + 1} skipped; the oracle has been told` };
+}
+
 async function resolveTaskApproval(state: Runtime, taskId: string, approvalId: string, decision: "approved" | "rejected", note?: string): Promise<{ notice: string }> {
   const task = mutableTask(state, taskId);
   if (!task.approvals.some((entry) => entry.id === approvalId && entry.status === "pending")) fail(409, "conflict", "approval is no longer pending");
@@ -894,12 +958,15 @@ export function createLobbyService(state: Runtime): LobbyService {
     refreshWorkspace: () => refreshWorkspace(state),
     sessionName: () => state.pi.getSessionName(),
     sessions: () => backgroundSessions().filter((session) => session.projectRoot === state.root),
+    renameSession: (key, name) => renameSession(state, key, name),
+    archiveSession: (key, archived) => archiveSession(state, key, archived),
     startSession: (start) => startSession(state, start),
     isAuto: (taskId) => autoFor(state, taskId),
     setAuto: (taskId, on) => switchAuto(state, taskId, on),
     sendToTask: (taskId, text) => sendToTask(state, taskId, text),
     resumeTask: (taskId) => resumeTask(state, taskId),
     acceptTask: (taskId) => acceptTask(state, taskId),
+    skipTaskStep: (taskId, step, text, reason) => skipTaskStep(state, taskId, step, text, reason),
     forceCloseTask: (taskId, title) => forceCloseTask(state, taskId, title),
     canForceCloseTask: (taskId) => canForceCloseTask(state, taskId),
     resolveTaskApproval: (taskId, approvalId, decision, note) => resolveTaskApproval(state, taskId, approvalId, decision, note),

package/src/lobby/sessions.ts

@@ -197,6 +197,13 @@ export class BackgroundSession {
    * Stop the session: its process ends (its task keeps its state and can be
    * resumed or claimed later). One that does not end within `graceMs` is killed.
    */
+  /** Give the session a new name, here and in its pi (its saved session takes it too). */
+  rename(name: string): void {
+    this.name = name;
+    if (this.alive) this.write({ type: "set_session_name", name });
+    this.onChange();
+  }
+
   stop(graceMs = STOP_GRACE_MS): void {
     if (!this.alive) return;
     try {
@@ -337,6 +344,19 @@ export const launchPi = (args: string[], cwd: string, overrides: NodeJS.ProcessE
 
 /** Ended background sessions kept in the list (with their feeds); older ones are let go. */
 export const MAX_ENDED = 6;
+/** Archived sessions kept so an archive can be undone; older ones are let go. */
+export const MAX_ARCHIVED = 20;
+/** Longest session name the lobby sets. */
+export const MAX_SESSION_NAME = 120;
+
+/** A session name as the lobby keeps it: one line, spaces collapsed, not too long. */
+export function cleanSessionName(name: string): string {
+  const clean = name.replace(/\s+/g, " ").trim();
+  if (!clean) throw new Error("a session needs a name");
+  if (clean.length > MAX_SESSION_NAME) throw new Error(`keep the name under ${MAX_SESSION_NAME} characters`);
+  return clean;
+}
+
 
 /** Every background session this window started, oldest first (ended ones beyond the newest few let go). */
 export class SessionRegistry {
@@ -372,6 +392,21 @@ export class SessionRegistry {
     return this.sessions.find((session) => session.key === key);
   }
 
+  /** Ended sessions put away from the list, newest last; one can come back while this pi runs. */
+  readonly archived: BackgroundSession[] = [];
+
+  /** Put an ended session away (true), or bring an archived one back (false); false when there was no such session. */
+  archive(key: string, archived = true): boolean {
+    const from = archived ? this.sessions : this.archived;
+    const index = from.findIndex((session) => session.key === key && !session.alive);
+    if (index < 0) return false;
+    const [session] = from.splice(index, 1);
+    (archived ? this.archived : this.sessions).push(session!);
+    if (this.archived.length > MAX_ARCHIVED) this.archived.splice(0, this.archived.length - MAX_ARCHIVED);
+    this.onChange();
+    return true;
+  }
+
   /** The background session running a pi session id, if this window started it. */
   bySessionId(sessionId: string | undefined): BackgroundSession | undefined {
     return sessionId ? this.sessions.find((session) => session.sessionId === sessionId) : undefined;

package/src/pi/auto-compaction.ts

@@ -1,5 +1,5 @@
 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 { contextMarks, freshContextOn, staleCompaction } from "./fresh-context.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";
@@ -34,8 +34,9 @@ export function compactionThreshold(window: number, reserve = DEFAULT_COMPACTION
 }
 
 /**
- * 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
+ * Compact at a settled tool boundary, below pi's own threshold (pi 1.3 still sets that only per model in settings, and
+ * ctx.compact() would abort the turn we need to continue). Each agent's settings can turn it off. Compactions pi
+ * starts itself get the same checkpoint through `session_before_compact`. 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 {
@@ -88,26 +89,52 @@ export function registerAutoCompaction(pi: ExtensionAPI, summarize: typeof compa
     busy = true;
     ctx.ui.notify("Compacting agent context", "info");
     try {
-      const auth = await ctx.modelRegistry.getApiKeyAndHeaders(ctx.model);
-      if (!auth.ok) throw new Error(auth.error);
-      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, oracle ? `${CHECKPOINT} ${DIGEST_INSTRUCTION}` : CHECKPOINT, ctx.signal, undefined, undefined, auth.env, retryPolicy);
-      ctx.signal?.throwIfAborted();
+      const result = await checkpoint({ firstKeptEntryId, messagesToSummarize: messages, turnPrefixMessages: [], isSplitTurn: false, tokensBefore: estimate, previousSummary: previous?.type === "compaction" ? previous.summary : undefined, fileOps, settings: { enabled: true, reserveTokens: reserve, keepRecentTokens } }, ctx, ctx.signal);
       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");
-        }
-      }
+      learn(result.summary, ctx);
       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");
     } finally { busy = false; }
   });
+  // pi's own compactions (its context threshold, overflow recovery, /compact) write the same checkpoint from pi's
+  // preparation, so every summary an agent continues from has the same shape and the oracle's still feeds knowledge.
+  pi.on("session_before_compact", async (event, ctx) => {
+    if (staleCompaction(event) || !ctx.model) return undefined;
+    try {
+      const compaction = await checkpoint(event.preparation, ctx, event.signal, event.customInstructions);
+      learn(compaction.summary, ctx);
+      return { compaction };
+    } catch (error) {
+      if (event.signal.aborted) throw error;
+      ctx.ui.notify(`Checkpoint failed, using pi's summary: ${(error as Error).message}`, "warning");
+      return undefined;
+    }
+  });
+
+  /** Summarize with the checkpoint prompt (and, for the oracle, its knowledge digest) on the session's model. */
+  async function checkpoint(preparation: Parameters<typeof compact>[0], ctx: ExtensionContext, signal: AbortSignal | undefined, extra?: string) {
+    const model = ctx.model!;
+    const auth = await ctx.modelRegistry.getApiKeyAndHeaders(model);
+    if (!auth.ok) throw new Error(auth.error);
+    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 instructions = [oracle ? `${CHECKPOINT} ${DIGEST_INSTRUCTION}` : CHECKPOINT, extra].filter(Boolean).join("\n\n");
+    const result = await summarize(preparation, auth.baseUrl ? { ...model, baseUrl: auth.baseUrl } : model, auth.apiKey, headers, instructions, signal, undefined, undefined, auth.env, retryPolicy);
+    signal?.throwIfAborted();
+    return result;
+  }
+
+  /** The oracle's digest from a checkpoint, shared into the knowledge base. */
+  function learn(summary: string, ctx: ExtensionContext): void {
+    if (!oracle) return;
+    try {
+      const items = parseDigest(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");
+    }
+  }
 }

package/src/pi/events.ts

@@ -19,6 +19,7 @@ import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
 import { qaStillDue, rosterWords } from "../workflow/track.ts";
 import { previousTaskNote } from "./fresh-context.ts";
+import { skippedStepsNote } from "./plan-checklist.ts";
 import { budgetLine, budgetState, clockTask, pauseClocks, readBudget, resumeClocks, startClock, stopClocks, turnStarted } from "../state/budget.ts";
 
 /** Tools that wait on the user: the task's clock waits with them. */
@@ -52,6 +53,7 @@ export function masterTaskContext(task: Task, comments: readonly PlanComment[] =
     `Request: ${truncate(task.approvedPlan && task.plan ? requestBesidePlan(taskRequest(task)) : taskRequest(task), 2000)}`,
     task.proposal ? `Current proposal:\n${truncate(task.proposal, 2000)}` : "",
     task.plan ? `Approved plan:\n${truncate(task.plan, 3000)}` : "",
+    skippedStepsNote(task.plan, task.skippedSteps),
     task.amendments.length > 0 ? `User amendments:\n${task.amendments.map((entry) => `- ${entry}`).join("\n")}` : "",
     open.length > 0 ? `Open plan comments (from the lobby):\n${open.map((comment) => `- ${truncate(comment.text, 600)}`).join("\n")}` : "",
     task.approvedPlan ? `The user agreed this task's plan in the planning panel (${task.approvedPlan}), and it is the task's plan: delegate its steps without clarifying, scouting or proposing, and answer open questions from the plan.${task.track?.satOut?.length ? ` ${rosterWords(task.track.satOut)} sat out the panel: do not give ${task.track.satOut.length === 1 ? "it" : "them"} work${task.track.satOut.includes("qa") ? ", and there is no QA gate (complete once every step is done)" : ""}.` : ""}` : "",