@a-t-h-i/bot-lobby 0.6.0 → 0.6.2

package/src/pi/tools.ts

@@ -5,10 +5,11 @@ import { Type } from "typebox";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { ProcessRunner } from "../execution/pi-runner.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { classifier, effortFor, hintsFor, triageFor } from "../classifier/instance.ts";
 import { truncate } from "../text.ts";
 import { applyStatus, reportRuns, summarizeRun } from "./ui.ts";
 import { isQuiet } from "./quiet.ts";
-import { createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
+import { checkThinking, createProfileResolver, modelRef, type ModelLookup } from "./model-support.ts";
 import { agentName, describeRun } from "./run-summary.ts";
 import {
   ORCHESTRATE_ACTIONS,
@@ -22,7 +23,7 @@ const OrchestrateSchema = Type.Object({
   action: StringEnum(ORCHESTRATE_ACTIONS, { description: "Workflow step to run" }),
   taskId: Type.Optional(Type.String({ description: "Task id; defaults to the active task" })),
   question: Type.Optional(Type.String({ description: "clarify: question for the user" })),
-  options: Type.Optional(Type.Array(Type.String(), { description: "clarify: optional answer choices" })),
+  options: Type.Optional(Type.Array(Type.String(), { description: "clarify: optional answer choices; put your recommended one first and mark it (Recommended)" })),
   domains: Type.Optional(Type.Array(Type.String(), { description: "scout: any of designer, backend, qa" })),
   instruction: Type.Optional(Type.String({ description: "scout/research: what to investigate (for scout, also used to target-verify a claim)" })),
   proposal: Type.Optional(Type.String({ description: "propose: the user-facing proposal as a short `- ` bullet list, one line per change" })),
@@ -104,6 +105,10 @@ export function workflowDeps(
     signal,
     onUpdate,
     runProcess,
+    hints: hintsFor({ cwd: ctx.cwd, root, configDir }),
+    classifier: classifier(),
+    triage: (request, triageSignal) => triageFor({ cwd: ctx.cwd, root, configDir }, request, triageSignal),
+    effort: effortFor((model, thinking) => checkThinking(modelLookup(ctx)(model), thinking).level),
     ask: async (question) => (hasUI ? ctx.ui.input(question) : undefined),
     choose: async (title, options) => (hasUI ? ctx.ui.select(title, options) : undefined),
     notify: (message, level = "info") => {

package/src/schemas/configuration.ts

@@ -108,6 +108,59 @@ export interface LobbyConfig {
   keys: Record<string, string>;
   /** Clicks and the wheel work in the lobby (click a draft line to comment on it); shift+drag still selects text. */
   mouse: boolean;
+  /**
+   * Planning rounds before the oracle finalizes the plan on its own: the last
+   * round skips the seats and asks nothing; later replies only revise. 0 = unlimited.
+   */
+  maxPlanningRounds: number;
+}
+
+/** Decisions the classifier can make, each switched on or off on its own. */
+export const CLASSIFIER_FEATURES = ["seats", "answers", "files", "triage", "effort"] as const;
+export type ClassifierFeature = (typeof CLASSIFIER_FEATURES)[number];
+
+/** Hosts that serve Jev behind the same System One API; `auto` takes OpenCode's free Jev when pi holds an OpenCode key, else TypeSafe. */
+export const JEV_HOSTS = ["auto", "opencode", "typesafe", "openrouter", "vercel"] as const;
+export type JevHostName = (typeof JEV_HOSTS)[number];
+
+/** Probability and confidence cut-offs, 0 to 1; edited in the config file only. */
+export interface ClassifierThresholds {
+  /** A planning seat runs when the idea or the latest answers touch its domain at least this likely. */
+  seatAt: number;
+  /** A seat that was READY comes back only at this probability. */
+  reseatReadyAt: number;
+  /** An obvious question is answered for you at this probability, when the pick is the recommended option… */
+  autoAnswerAt: number;
+  /** …and leads the runner-up by at least this much. */
+  autoAnswerMargin: number;
+  /** A file is a likely file at this relevance. */
+  fileRelevantAt: number;
+  /** A step scored simple at this confidence runs one thinking level lower. */
+  simpleAt: number;
+  /** A step scored trivial at this confidence runs on the cheaper model. */
+  trivialAt: number;
+  /** A quick fix scored large at this confidence is held instead of started. */
+  quickFixLargeAt: number;
+}
+
+/** The Jev classifier: a fast model for obvious decisions, so large models spend fewer tokens on them. */
+export interface ClassifierConfig {
+  enabled: boolean;
+  /** Where Jev is called; the key comes from pi's own key store for that host. */
+  provider: JevHostName;
+  /** A pinned Jev model; empty uses the host's default. */
+  model: string;
+  /** A base URL override (a proxy); empty uses the host's. */
+  baseUrl: string;
+  /** Time limit per classifier call. */
+  timeoutMs: number;
+  features: Record<ClassifierFeature, boolean>;
+  thresholds: ClassifierThresholds;
+  fileHints: { topK: number; maxCandidates: number; budgetMs: number };
+  /** The cheaper model trivial steps run on; `inherit` keeps the configured model and only lowers thinking. */
+  effort: { cheapModel: ModelRef };
+  /** Path globs never sent to the classifier (file hints). */
+  exclude: string[];
 }
 
 export interface BotLobbyConfig {
@@ -122,6 +175,7 @@ export interface BotLobbyConfig {
   workflow: WorkflowConfig;
   knowledge: KnowledgeConfig;
   lobby: LobbyConfig;
+  classifier: ClassifierConfig;
 }
 
 export const DEFAULT_CONFIG: BotLobbyConfig = {
@@ -162,9 +216,34 @@ export const DEFAULT_CONFIG: BotLobbyConfig = {
     panels: { animations: false, conversation: true, activity: true, thinking: true },
     keys: {},
     mouse: true,
+    maxPlanningRounds: 5,
+  },
+  classifier: {
+    enabled: false,
+    provider: "auto",
+    model: "",
+    baseUrl: "",
+    timeoutMs: 4000,
+    features: { seats: true, answers: true, files: true, triage: true, effort: true },
+    thresholds: {
+      seatAt: 0.35,
+      reseatReadyAt: 0.6,
+      autoAnswerAt: 0.9,
+      autoAnswerMargin: 0.5,
+      fileRelevantAt: 0.5,
+      simpleAt: 0.7,
+      trivialAt: 0.8,
+      quickFixLargeAt: 0.8,
+    },
+    fileHints: { topK: 8, maxCandidates: 480, budgetMs: 1500 },
+    effort: { cheapModel: INHERIT_MODEL },
+    exclude: [],
   },
 };
 
+/** Choices the settings menu cycles through for the planning round limit; 0 = unlimited. */
+export const PLANNING_ROUND_CHOICES = [2, 3, 5, 8, 0] as const;
+
 function positive(value: unknown): number | undefined {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
 }
@@ -191,7 +270,7 @@ function flag(value: unknown, fallback: boolean): boolean {
 }
 
 function normalizeLobby(value: unknown): LobbyConfig {
-  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown } | undefined;
+  const source = value as { autoOpen?: unknown; planningPanel?: unknown; autoAsk?: unknown; issues?: unknown; panels?: unknown; keys?: unknown; mouse?: unknown; maxPlanningRounds?: unknown } | undefined;
   const defaults = DEFAULT_CONFIG.lobby;
   const panel = Array.isArray(source?.planningPanel)
     ? [...new Set(source.planningPanel.filter((entry): entry is PanelMember => typeof entry === "string" && isPanelMember(entry)))]
@@ -206,6 +285,50 @@ function normalizeLobby(value: unknown): LobbyConfig {
     panels: Object.fromEntries(LOBBY_PANELS.map((name) => [name, flag(panels[name], defaults.panels[name])])) as Record<LobbyPanel, boolean>,
     keys: Object.fromEntries(Object.entries(keys).filter((entry): entry is [string, string] => typeof entry[1] === "string" && entry[1].trim().length > 0)),
     mouse: flag(source?.mouse, defaults.mouse),
+    maxPlanningRounds: roundLimit(source?.maxPlanningRounds, defaults.maxPlanningRounds),
+  };
+}
+
+/** A whole number of rounds, 0 for unlimited; anything else keeps the default. */
+function roundLimit(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : fallback;
+}
+
+function probability(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1 ? value : fallback;
+}
+
+function count(value: unknown, fallback: number): number {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+
+function text(value: unknown, fallback: string): string {
+  return typeof value === "string" ? value.trim() : fallback;
+}
+
+function normalizeClassifier(value: unknown): ClassifierConfig {
+  const source = (value && typeof value === "object" ? value : {}) as Record<string, unknown>;
+  const defaults = DEFAULT_CONFIG.classifier;
+  const features = (source.features ?? {}) as Partial<Record<ClassifierFeature, unknown>>;
+  const thresholds = (source.thresholds ?? {}) as Partial<Record<keyof ClassifierThresholds, unknown>>;
+  const hints = (source.fileHints ?? {}) as Record<string, unknown>;
+  const effort = (source.effort ?? {}) as Record<string, unknown>;
+  const provider = typeof source.provider === "string" && (JEV_HOSTS as readonly string[]).includes(source.provider) ? source.provider as JevHostName : defaults.provider;
+  return {
+    enabled: flag(source.enabled, defaults.enabled),
+    provider,
+    model: text(source.model, defaults.model),
+    baseUrl: text(source.baseUrl, defaults.baseUrl),
+    timeoutMs: count(source.timeoutMs, defaults.timeoutMs),
+    features: Object.fromEntries(CLASSIFIER_FEATURES.map((name) => [name, flag(features[name], defaults.features[name])])) as Record<ClassifierFeature, boolean>,
+    thresholds: Object.fromEntries(Object.entries(defaults.thresholds).map(([name, fallback]) => [name, probability(thresholds[name as keyof ClassifierThresholds], fallback)])) as unknown as ClassifierThresholds,
+    fileHints: {
+      topK: count(hints.topK, defaults.fileHints.topK),
+      maxCandidates: count(hints.maxCandidates, defaults.fileHints.maxCandidates),
+      budgetMs: count(hints.budgetMs, defaults.fileHints.budgetMs),
+    },
+    effort: { cheapModel: typeof effort.cheapModel === "string" && effort.cheapModel.trim() ? effort.cheapModel.trim() : defaults.effort.cheapModel },
+    exclude: Array.isArray(source.exclude) ? source.exclude.filter((entry): entry is string => typeof entry === "string" && entry.trim().length > 0) : [...defaults.exclude],
   };
 }
 
@@ -229,6 +352,7 @@ export function resolveConfig(partial: unknown): BotLobbyConfig {
     workflow,
     knowledge,
     lobby: normalizeLobby(src.lobby),
+    classifier: normalizeClassifier(src.classifier),
   };
 }
 

package/src/schemas/findings.ts

@@ -133,4 +133,8 @@ export interface AgentRun {
   wrappedUp?: boolean;
   /** File this worker is queued for at the file desk. */
   waitingFor?: string;
+  /** The classifier routed this run down: the configured profile it came from (`p/big · medium`). */
+  routedFrom?: string;
+  /** Why and where it was routed (`trivial 0.88: p/big · medium → p/cheap · low`). */
+  route?: string;
 }

package/src/schemas/task.ts

@@ -89,11 +89,31 @@ export interface RunLogEntry {
   stalled?: boolean;
   wrappedUp?: boolean;
   error?: string;
+  /** The classifier routed this run down from this configured profile. */
+  routedFrom?: string;
 }
 
 /** Upper bound on persisted run-log entries. */
 export const MAX_RUN_LOG = 64;
 
+export type TriageSize = "trivial" | "small" | "medium" | "large";
+
+/** What the classifier made of the request when the task started: hints for the Master, never rules. */
+export interface TaskTriage {
+  size: TriageSize;
+  sizeConfidence: number;
+  /** How likely each domain is touched, 0 to 1. */
+  domains: Partial<Record<Domain, number>>;
+  /** How likely building it needs outside facts. */
+  research: number;
+  /** How likely it is ambiguous as written. */
+  ambiguous: number;
+  kind?: string;
+  kindProbability?: number;
+  likelyFiles?: string[];
+  at: string;
+}
+
 export interface Task {
   id: string;
   title: string;
@@ -121,6 +141,10 @@ export interface Task {
   ownerSessionId?: string;
   /** The planned task (PLAN-…) whose plan the user agreed in the planning panel: its proposal needs no approval. */
   approvedPlan?: string;
+  /** When the task was archived from the lobby (it then lives under archive/tasks, out of every list). */
+  archivedAt?: string;
+  /** The classifier's read of the request, when it was on as the task started. */
+  triage?: TaskTriage;
 }
 
 export function createTask(

package/src/state/archive.ts

@@ -0,0 +1,99 @@
+/**
+ * Archiving and deleting tasks from the lobby. An archived task moves, whole,
+ * out of the task tree to `archive/tasks/<id>` beside the knowledge archive:
+ * no list, widget or session sees it any more, and it can be restored as it
+ * was. Deleting removes a task's folder for good. A task still under way is
+ * abandoned before it is archived, so it never comes back half-driven.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
+import { taskDir, tasksRoot } from "../knowledge/paths.ts";
+import { transition } from "./task-state.ts";
+import { dataRoot, readDataRoots } from "./project.ts";
+
+export function archiveRoot(root: string, configDir: string): string {
+  return join(dataRoot(root, configDir), "archive", "tasks");
+}
+
+/** Task ids become folder names: only ever one plain path segment. */
+function checkId(taskId: string): string {
+  if (!/^[\w.-]+$/.test(taskId) || taskId === "." || taskId === "..") throw new Error(`not a task id: ${taskId}`);
+  return taskId;
+}
+
+function readAt(dir: string): Task | undefined {
+  try {
+    return JSON.parse(readFileSync(join(dir, "state.json"), "utf8")) as Task;
+  } catch {
+    return undefined;
+  }
+}
+
+function writeAt(dir: string, task: Task): void {
+  writeFileSync(join(dir, "state.json"), JSON.stringify(task, null, 2), "utf8");
+}
+
+/** Where a task on the list lives: the newest tree that has it (bot-lobby, then the pre-rename ones). */
+function liveDir(root: string, configDir: string, taskId: string): string | undefined {
+  return readDataRoots(root, configDir).map((dr) => taskDir(dr, taskId)).find((dir) => existsSync(join(dir, "state.json")));
+}
+
+function archivedDir(root: string, configDir: string, taskId: string): string {
+  return join(archiveRoot(root, configDir), checkId(taskId));
+}
+
+/** Archived tasks, most recently archived first. */
+export function listArchivedTasks(root: string, configDir: string): Task[] {
+  const dir = archiveRoot(root, configDir);
+  if (!existsSync(dir)) return [];
+  const tasks: Task[] = [];
+  for (const entry of readdirSync(dir)) {
+    const task = readAt(join(dir, entry));
+    if (task) tasks.push(task);
+  }
+  return tasks.sort((a, b) => (b.archivedAt ?? b.updatedAt).localeCompare(a.archivedAt ?? a.updatedAt));
+}
+
+/**
+ * Move a task out of every list into the archive; one still under way is
+ * abandoned first (and says so in its decisions). Returns the archived task.
+ */
+export function archiveTask(root: string, configDir: string, taskId: string, now = new Date()): Task {
+  const from = liveDir(root, configDir, checkId(taskId));
+  const task = from ? readAt(from) : undefined;
+  if (!from || !task) throw new Error(`no task ${taskId}`);
+  const to = archivedDir(root, configDir, taskId);
+  if (existsSync(to)) throw new Error(`${taskId} is already in the archive`);
+  const stamp = now.toISOString();
+  if (!TERMINAL_STATES.includes(task.state)) {
+    transition(task, "abandoned", stamp);
+    task.decisions.push({ domain: "master", text: "Abandoned when it was archived from the lobby.", createdAt: stamp });
+  }
+  task.archivedAt = stamp;
+  writeAt(from, task);
+  mkdirSync(dirname(to), { recursive: true });
+  renameSync(from, to);
+  return task;
+}
+
+/** Bring an archived task back to the lists, as it was when archived. */
+export function restoreTask(root: string, configDir: string, taskId: string): Task {
+  const from = archivedDir(root, configDir, taskId);
+  const task = readAt(from);
+  if (!task) throw new Error(`${taskId} is not in the archive`);
+  const to = taskDir(dataRoot(root, configDir), taskId);
+  if (existsSync(to)) throw new Error(`a task ${taskId} is already on the list`);
+  delete task.archivedAt;
+  writeAt(from, task);
+  mkdirSync(tasksRoot(dataRoot(root, configDir)), { recursive: true });
+  renameSync(from, to);
+  return task;
+}
+
+/** Remove a task for good: its folder, from the list or from the archive. */
+export function deleteTask(root: string, configDir: string, taskId: string, where: "list" | "archive" = "list"): void {
+  const dir = where === "archive" ? archivedDir(root, configDir, taskId) : liveDir(root, configDir, checkId(taskId));
+  if (!dir || !existsSync(dir)) throw new Error(where === "archive" ? `${taskId} is not in the archive` : `no task ${taskId}`);
+  rmSync(dir, { recursive: true, force: true });
+}

package/src/state/inbox.ts

@@ -1,17 +1,21 @@
 /**
- * The task inbox: messages for a task's oracle written from any pi session
- * (the lobby of another window talking to a task it does not drive). Like plan
- * comments they live beside the task as an append-only JSON-lines log, never
- * inside state.json, and the session that owns the task delivers them to its
- * Master and records the delivery.
+ * Inboxes: messages for another session's oracle written from any pi session
+ * (the lobby of another window talking to a session it does not drive). A
+ * task's inbox lives beside the task, so a message waits there until some
+ * session drives the task; a session's inbox lives beside its heartbeat, for
+ * a running session with no task. Like plan comments they are append-only
+ * JSON-lines logs, never inside state.json, and the session they are for
+ * delivers them to its Master and records the delivery.
  */
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { taskDirFor } from "./persistence.ts";
+import { presenceDir } from "./presence.ts";
 
 export interface InboxMessage {
   id: string;
-  taskId: string;
+  /** The task it was left for; absent for a session's own inbox. */
+  taskId?: string;
   text: string;
   createdAt: string;
   /** The pi session that wrote it. */
@@ -30,6 +34,10 @@ export function inboxPath(root: string, configDir: string, taskId: string): stri
   return join(taskDirFor(root, configDir, taskId), "inbox.jsonl");
 }
 
+export function sessionInboxPath(root: string, configDir: string, sessionId: string): string {
+  return join(presenceDir(root, configDir), `${sessionId.replace(/[^\w.-]/g, "_")}.inbox.jsonl`);
+}
+
 function append(path: string, event: InboxEvent): void {
   mkdirSync(dirname(path), { recursive: true });
   appendFileSync(path, `${JSON.stringify(event)}\n`, "utf8");
@@ -56,12 +64,11 @@ function readEvents(path: string): InboxEvent[] {
   return events;
 }
 
-/** The task's messages, oldest first, with whether each reached the oracle. */
-export function readInbox(root: string, configDir: string, taskId: string): InboxMessage[] {
+function readAt(path: string, taskId?: string): InboxMessage[] {
   const byId = new Map<string, InboxMessage>();
-  for (const event of readEvents(inboxPath(root, configDir, taskId))) {
+  for (const event of readEvents(path)) {
     if (event.kind === "message" && !byId.has(event.id)) {
-      byId.set(event.id, { id: event.id, taskId, text: event.text, createdAt: event.at, ...(event.by ? { by: event.by } : {}), delivered: false });
+      byId.set(event.id, { id: event.id, ...(taskId ? { taskId } : {}), text: event.text, createdAt: event.at, ...(event.by ? { by: event.by } : {}), delivered: false });
     } else if (event.kind === "delivered") {
       const message = byId.get(event.id);
       if (message) message.delivered = true;
@@ -70,17 +77,44 @@ export function readInbox(root: string, configDir: string, taskId: string): Inbo
   return [...byId.values()];
 }
 
-/** Leave a message for the task's oracle; returns it. */
-export function sendToInbox(root: string, configDir: string, taskId: string, text: string, by?: string, now = new Date()): InboxMessage {
+function sendAt(path: string, text: string, by: string | undefined, now: Date, taskId?: string): InboxMessage {
   const body = text.trim().slice(0, MAX_INBOX_CHARS);
   if (!body) throw new Error("a message needs some text");
   const id = `${now.getTime().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-  append(inboxPath(root, configDir, taskId), { kind: "message", id, text: body, at: now.toISOString(), ...(by ? { by } : {}) });
-  return { id, taskId, text: body, createdAt: now.toISOString(), ...(by ? { by } : {}), delivered: false };
+  append(path, { kind: "message", id, text: body, at: now.toISOString(), ...(by ? { by } : {}) });
+  return { id, ...(taskId ? { taskId } : {}), text: body, createdAt: now.toISOString(), ...(by ? { by } : {}), delivered: false };
+}
+
+function markAt(path: string, ids: readonly string[], now: Date): void {
+  for (const id of ids) append(path, { kind: "delivered", id, at: now.toISOString() });
+}
+
+/** The task's messages, oldest first, with whether each reached the oracle. */
+export function readInbox(root: string, configDir: string, taskId: string): InboxMessage[] {
+  return readAt(inboxPath(root, configDir, taskId), taskId);
+}
+
+/** Leave a message for the task's oracle; returns it. */
+export function sendToInbox(root: string, configDir: string, taskId: string, text: string, by?: string, now = new Date()): InboxMessage {
+  return sendAt(inboxPath(root, configDir, taskId), text, by, now, taskId);
 }
 
 export function markInboxDelivered(root: string, configDir: string, taskId: string, ids: readonly string[], now = new Date()): void {
-  for (const id of ids) append(inboxPath(root, configDir, taskId), { kind: "delivered", id, at: now.toISOString() });
+  markAt(inboxPath(root, configDir, taskId), ids, now);
+}
+
+/** A running session's own messages (it has no task to hold them), oldest first. */
+export function readSessionInbox(root: string, configDir: string, sessionId: string): InboxMessage[] {
+  return readAt(sessionInboxPath(root, configDir, sessionId));
+}
+
+/** Leave a message for a running session's oracle; returns it. */
+export function sendToSession(root: string, configDir: string, sessionId: string, text: string, by?: string, now = new Date()): InboxMessage {
+  return sendAt(sessionInboxPath(root, configDir, sessionId), text, by, now);
+}
+
+export function markSessionInboxDelivered(root: string, configDir: string, sessionId: string, ids: readonly string[], now = new Date()): void {
+  markAt(sessionInboxPath(root, configDir, sessionId), ids, now);
 }
 
 /** The message the owning session sends its Master for undelivered inbox messages. */

package/src/state/metrics.ts

@@ -11,7 +11,7 @@ import type { AgentRun } from "../schemas/findings.ts";
 import type { RunLogEntry, Task } from "../schemas/task.ts";
 import { dataRoot } from "./project.ts";
 
-export const METRIC_KINDS = ["master", "scout", "worker", "reviewer", "researcher", "quickfix", "planner", "panel"] as const;
+export const METRIC_KINDS = ["master", "scout", "worker", "reviewer", "researcher", "quickfix", "planner", "panel", "classifier"] as const;
 export type MetricKind = (typeof METRIC_KINDS)[number];
 
 export type MetricStatus = "success" | "failed" | "cancelled" | "timeout";
@@ -33,6 +33,67 @@ export interface MetricRecord {
   cost?: number;
   taskId?: string;
   stalled?: boolean;
+  /** Classifier calls: what the call decided (seats, answers, files, triage, effort, test). */
+  purpose?: string;
+  /** A run the classifier routed down: the configured profile it came from. */
+  routedFrom?: string;
+  /** Classifier calls: what the decision spared (seat runs skipped, questions answered, quick fixes held). */
+  saved?: number;
+}
+
+/** What the classifier did and spared, for the Metrics tab. */
+export interface ClassifierSummary {
+  calls: number;
+  ok: number;
+  p50Ms: number;
+  p90Ms: number;
+  /** Tokens Jev read across every call. */
+  input: number;
+  /** Calls per decision (seats, answers, files, triage, effort, test). */
+  byPurpose: Record<string, number>;
+  seatRunsSkipped: number;
+  questionsAnswered: number;
+  quickFixesHeld: number;
+  /** Agent runs the classifier routed down, and how many of them succeeded. */
+  routed: number;
+  routedOk: number;
+}
+
+function quantile(sorted: readonly number[], q: number): number {
+  if (sorted.length === 0) return 0;
+  return sorted[Math.min(sorted.length - 1, Math.floor(q * sorted.length))]!;
+}
+
+/** Classifier calls and the agent runs it routed, summarised; undefined when it never ran. */
+export function summarizeClassifier(calls: readonly MetricRecord[], runs: readonly MetricRecord[]): ClassifierSummary | undefined {
+  const routed = runs.filter((record) => record.routedFrom);
+  if (calls.length === 0 && routed.length === 0) return undefined;
+  const times = calls.map((record) => record.durationMs).sort((a, b) => a - b);
+  const byPurpose: Record<string, number> = {};
+  let seatRunsSkipped = 0;
+  let questionsAnswered = 0;
+  let quickFixesHeld = 0;
+  for (const record of calls) {
+    const purpose = record.purpose ?? "other";
+    byPurpose[purpose] = (byPurpose[purpose] ?? 0) + 1;
+    const saved = record.saved ?? 0;
+    if (purpose === "seats") seatRunsSkipped += saved;
+    else if (purpose === "answers") questionsAnswered += saved;
+    else if (purpose === "triage") quickFixesHeld += saved;
+  }
+  return {
+    calls: calls.length,
+    ok: calls.filter((record) => record.status === "success").length,
+    p50Ms: quantile(times, 0.5),
+    p90Ms: quantile(times, 0.9),
+    input: calls.reduce((total, record) => total + (record.input ?? 0), 0),
+    byPurpose,
+    seatRunsSkipped,
+    questionsAnswered,
+    quickFixesHeld,
+    routed: routed.length,
+    routedOk: routed.filter((record) => record.status === "success").length,
+  };
 }
 
 /** Newest records kept in memory for aggregation. */
@@ -58,7 +119,17 @@ function isRecord(value: unknown): value is MetricRecord {
   return Boolean(record && typeof record.id === "string" && typeof record.kind === "string" && typeof record.durationMs === "number");
 }
 
+/** Agent runs for the Metrics tab; classifier calls, a few hundred milliseconds each, are read apart. */
 export function readMetrics(root: string, configDir: string, limit = MAX_READ): MetricRecord[] {
+  return readRecords(root, configDir, limit).filter((record) => record.kind !== "classifier");
+}
+
+/** Classifier calls only. */
+export function readClassifierMetrics(root: string, configDir: string, limit = MAX_READ): MetricRecord[] {
+  return readRecords(root, configDir, limit).filter((record) => record.kind === "classifier");
+}
+
+function readRecords(root: string, configDir: string, limit: number): MetricRecord[] {
   const path = metricsPath(root, configDir);
   if (!existsSync(path)) return [];
   let text: string;
@@ -110,6 +181,7 @@ export function metricFromRun(run: AgentRun): MetricRecord {
     ...(run.usage ? { input: run.usage.input, output: run.usage.output, cost: run.usage.cost } : {}),
     taskId: run.taskId,
     ...(run.stalled ? { stalled: true } : {}),
+    ...(run.routedFrom ? { routedFrom: run.routedFrom } : {}),
   };
 }
 
@@ -130,6 +202,7 @@ export function metricFromLog(entry: RunLogEntry, taskId: string): MetricRecord
     ...(entry.input !== undefined ? { input: entry.input, output: entry.output ?? 0, cost: entry.cost ?? 0 } : {}),
     taskId,
     ...(entry.stalled ? { stalled: true } : {}),
+    ...(entry.routedFrom ? { routedFrom: entry.routedFrom } : {}),
   };
 }
 

package/src/state/presence.ts

@@ -0,0 +1,99 @@
+/**
+ * Which pi sessions are running in this project right now. Every interactive
+ * or headless session with bot-lobby loaded (never a subagent) keeps a small
+ * heartbeat file beside the tasks, refreshed on its owner clock and removed
+ * when it ends; the lobby reads them to list the live sessions it can view,
+ * message or switch to. A heartbeat older than a few beats, or from a process
+ * that is gone, does not count.
+ */
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dataRoot } from "./project.ts";
+
+export interface Presence {
+  sessionId: string;
+  pid: number;
+  /** The pi session's name (a task's title once it starts one). */
+  name?: string;
+  /** The saved session file, so another window can switch to it once it ends. */
+  sessionFile?: string;
+  /** The task it drives, if any. */
+  taskId?: string;
+  /** `tui` for a terminal, `rpc` for a session another window started in the background. */
+  mode: string;
+  updatedAt: string;
+}
+
+/** A heartbeat older than this means the session is gone (its owner clock ticks every few seconds). */
+export const PRESENCE_TTL_MS = 15_000;
+/** A heartbeat this old is removed even if its process still runs (it switched sessions without saying so). */
+const FORGET_MS = 10 * 60_000;
+
+export function presenceDir(root: string, configDir: string): string {
+  return join(dataRoot(root, configDir), "sessions");
+}
+
+/** Session ids become file names: keep them to safe characters. */
+function safeId(sessionId: string): string | undefined {
+  return /^[\w.-]+$/.test(sessionId) ? sessionId : undefined;
+}
+
+function presencePath(root: string, configDir: string, sessionId: string): string | undefined {
+  const id = safeId(sessionId);
+  return id ? join(presenceDir(root, configDir), `${id}.json`) : undefined;
+}
+
+/** Record (or refresh) this session's heartbeat; atomic, so readers never see half a file. */
+export function writePresence(root: string, configDir: string, presence: Omit<Presence, "updatedAt">, now = new Date()): void {
+  const path = presencePath(root, configDir, presence.sessionId);
+  if (!path) return;
+  mkdirSync(presenceDir(root, configDir), { recursive: true });
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify({ ...presence, updatedAt: now.toISOString() }), "utf8");
+  renameSync(tmp, path);
+}
+
+export function removePresence(root: string, configDir: string, sessionId: string): void {
+  const path = presencePath(root, configDir, sessionId);
+  if (path) rmSync(path, { force: true });
+}
+
+/** Whether a process is running: signal 0 checks without touching it (EPERM still means it exists). */
+export function processAlive(pid: number): boolean {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code === "EPERM";
+  }
+}
+
+/**
+ * The sessions running in this project, newest heartbeat first. Heartbeats
+ * of processes that are gone are removed; merely late ones are skipped.
+ */
+export function livePresence(root: string, configDir: string, now = Date.now(), alive: (pid: number) => boolean = processAlive): Presence[] {
+  const dir = presenceDir(root, configDir);
+  if (!existsSync(dir)) return [];
+  const live: Presence[] = [];
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith(".json") || file.endsWith(".tmp")) continue;
+    let presence: Presence;
+    try {
+      presence = JSON.parse(readFileSync(join(dir, file), "utf8")) as Presence;
+    } catch {
+      continue;
+    }
+    if (typeof presence?.sessionId !== "string" || typeof presence.pid !== "number") continue;
+    const age = now - Date.parse(presence.updatedAt);
+    // Gone, or so long silent that its process has moved on to another session: clear it away.
+    if (!alive(presence.pid) || !(age < FORGET_MS)) {
+      rmSync(join(dir, file), { force: true });
+      continue;
+    }
+    if (age > PRESENCE_TTL_MS) continue;
+    live.push(presence);
+  }
+  return live.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+}