@patimweb/pi-teams 1.15.0 → 2.0.0

package/docs/listen-mode.md

@@ -50,7 +50,7 @@ never sees.
 | `mentionOnly` | `false` | whether a message has to address you: `true`/`false`, or `{ default, chats, people }` for overrides. See [below](#who-has-to-address-pi). |
 | `cooldownSeconds` | `300` | stay quiet in a chat after waking pi for it |
 | `maxTriggersPerHour` | `10` | hard cap on wakes per hour |
-| `dispatch` | `{ "mode": "session" }` | where a wake is answered: in this session, or by one pi process per chat. See [below](#one-pi-process-per-chat). |
+| `historyReaders` | `[]` | who may use `teams_history` from their one-to-one chat, where each chat has a process of its own. See [below](#parallel-chats-with-pi-lanes). |
 
 Set it globally, or per account — the account level wins field by field.
 `teams_watch` writes the same keys; `/teams-listen` writes to the session's
@@ -158,81 +158,42 @@ when the message is picked up. A wake that arrives while pi is still answering
 another chat waits in the queue; pinning it right away would take the pin away
 from the answer that is still being written, and that answer would be refused.
 
-In [dispatch mode](#one-pi-process-per-chat) every worker is pinned to its chat
-for its whole life: it exists to answer that one conversation.
+A process that answers one chat only (see [below](#parallel-chats-with-pi-lanes))
+is pinned to it for its whole life.
 
-## One pi process per chat
+## Parallel chats with pi-lanes
 
-By default every wake is a follow-up in the session that runs the watcher. That
-session works on one chat at a time: while it answers Anna, Bob waits, and when
-Anna asked for something that takes twenty minutes, Bob waits twenty minutes.
+Every wake is a follow-up in the session that runs the watcher. That session
+works on one chat at a time: while it answers Anna, Bob waits.
 
-`dispatch.mode: "process"` hands every chat a pi process of its own:
+With [pi-lanes](https://github.com/Smotherer007/pi-lanes) installed, every
+chat gets a pi process of its own, with a session that carries on from message
+to message; different chats are answered in parallel. pi-teams does not do the
+routing itself. Before each wake prompt it emits a hint on pi's event bus
+(`pi-lanes:route`), and a router takes it from there. Without a router nobody
+listens, and everything stays as described above.
 
-```json
-"watch": {
-  "dispatch": {
-    "mode": "process",
-    "maxConcurrent": 3,
-    "maxWorkers": 6,
-    "idleMinutes": 30,
-    "freshAfterHours": 72,
-    "args": ["--model", "provider/model-id"],
-    "stopWords": ["stop", "stopp", "abbrechen"],
-    "resetWords": ["neues thema", "new topic"],
-    "historyReaders": ["you@contoso.com"]
-  }
-}
-```
+The hint carries:
 
-| Key | Default | Meaning |
-|-----|---------|---------|
-| `mode` | `"session"` | `"process"` switches the worker pool on |
-| `maxConcurrent` | `3` | chats worked on at the same time (1-16); more wait in line |
-| `maxWorkers` | `6` | processes kept alive, busy or idle; the longest-idle one makes room |
-| `idleMinutes` | `30` | an idle worker exits after this; its session stays on disk |
-| `freshAfterHours` | `72` | a chat quiet for longer starts a fresh session (`0` = always continue) |
-| `command` | `"pi"` | the pi executable |
-| `args` | `[]` | extra arguments for every worker, e.g. the model |
-| `stopWords` | `stop, stopp, abbrechen, abbruch, cancel` | a message that is only this word aborts the running work |
-| `resetWords` | `neues thema, new topic, reset` | a message that is only this word starts the chat over |
-| `historyReaders` | `[]` | who may use `teams_history` from their one-to-one chat with pi |
-
-How it behaves:
-
-| In Teams | What happens |
-|----------|--------------|
-| Messages in different chats | answered in parallel, each by its chat's worker |
-| Next message in the same chat | the chat's session continues, with the whole conversation so far |
-| A message while the worker is busy | steered into the running turn: read after the current step, not after the task |
-| `stopp` | the running turn is aborted; the model confirms in one line |
-| `neues Thema` | the worker ends, the chat starts a fresh session; the old one stays on disk |
-| More busy chats than `maxConcurrent` | the next chat waits for a free slot; a newer message replaces its waiting one |
-
-Each worker runs `pi --mode rpc --session-dir <agent dir>/pi-teams-chats/<hash>`
-with `--continue` while the chat's last session is recent. It loads the same
-extensions and config as any pi, with three differences set through its
-environment (`PI_TEAMS_WORKER_CHAT` and friends): it never starts a watcher, it
-may write to its own chat only, and `teams_watch`, `teams_setup` and
-`teams_logout` are closed to it. Dialogs a worker would show are cancelled,
-because nobody sits in front of it, so run it with `safetyLevel: "open"` and
-keep the guardrails in `from`, the pin and the permission rules.
-
-The watching session only routes. `/teams-dispatch` shows which chats are being
-worked on, which are idle and which wait.
-
-### What pi said in other chats
+| Field | Value |
+|-------|-------|
+| `lane` | `teams:<account>:<chat id>`: same chat, same process and session |
+| `env` | `PI_TEAMS_WORKER_CHAT` and friends (below) |
+| `command` | the newest message without mention and punctuation, so "Neo, stopp!" reads as `stopp` |
+| `trusted` | `true` only in a one-to-one chat with a person in `historyReaders` |
 
-Separate sessions mean that no single context knows what pi told somebody else.
-Two logs do, and `teams_history` reads them:
+A process started with `PI_TEAMS_WORKER_CHAT` answers that chat only: it is
+pinned to it for good, never starts a watcher of its own, and `teams_watch`,
+`teams_setup` and `teams_logout` are closed to it. Listen mode also starts on
+its own only in the terminal session (`ctx.mode === "tui"`), never in a pi
+driven over RPC.
 
-- `kind: "sent"`: every message pi sent, from the audit log (`audit: true`).
-- `kind: "dispatch"`: every request a worker picked up and a short form of its
-  answer, from `pi-teams-dispatch.jsonl` in the agent directory.
+### What pi said in other chats
 
-Nothing from one chat reaches another chat's context by itself. Inside a worker
-the tool answers only in a one-to-one chat with a person listed in
-`historyReaders`; the watching session is never restricted.
+Separate processes mean that no single context knows what pi told somebody
+else. The audit log does (`audit: true`), and `teams_history` reads it. In a
+process that answers one chat the tool works only in a one-to-one chat with a
+person listed in `historyReaders`; the terminal session is never restricted.
 
 ## Cost
 

package/docs/tools.md

@@ -21,7 +21,7 @@ the default account. See [configuration.md](configuration.md).
 | Tool | Description |
 |------|-------------|
 | `teams_inbox` | Chats with new messages plus recent mentions of you |
-| `teams_history` | What pi sent across chats (audit log), or what the per-chat workers were asked and answered (dispatch journal). Read-only; see [listen mode](listen-mode.md#what-pi-said-in-other-chats) |
+| `teams_history` | What pi sent across chats, from the audit log. Read-only; see [listen mode](listen-mode.md#what-pi-said-in-other-chats) |
 | `teams_list_chats` | Recent chats with a preview of the last message |
 | `teams_read_chat` | Messages of one chat |
 | `teams_list_teams` | Teams you belong to |
@@ -75,7 +75,6 @@ usual; correcting a channel post stays in the Teams client.
 | `/teams-login` | Sign in to Teams as yourself |
 | `/teams-inbox` | What needs your attention right now |
 | `/teams-listen` | Listen mode: `on`, `off`, or `status` |
-| `/teams-dispatch` | Listen mode with one pi process per chat: who is being worked on, who is idle, who waits |
 | `/teams-permissions` | What pi may and may not do |
 | `/teams-doctor` | Diagnose the setup |
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@patimweb/pi-teams",
-  "version": "1.15.0",
+  "version": "2.0.0",
   "description": "Microsoft Teams integration for pi coding agent — acts fully as the signed-in user across multiple accounts and tenants: chats, channels, meetings, presence, with configurable guardrails",
   "keywords": [
     "pi-package",

package/src/config/index.ts

@@ -135,72 +135,15 @@ export interface WatchConfig {
 	cooldownSeconds?: number;
 	/** Hard cap on wakes per hour, across all chats (default: 10) */
 	maxTriggersPerHour?: number;
-	/**
-	 * How a wake reaches a model. See `DispatchConfig`. Absent means the
-	 * classic behaviour: every wake is a turn in this pi session.
-	 */
-	dispatch?: DispatchConfig;
-}
-
-/**
- * Where the answer to a wake is worked out.
- *
- * `session` (default) queues every wake as a follow-up in the pi session that
- * runs the watcher. One chat at a time: while pi works on one request, every
- * other chat waits.
- *
- * `process` gives every chat a pi process of its own (`pi --mode rpc`), with a
- * session of its own that carries on from message to message. Different chats
- * are answered in parallel; messages in the same chat stay in order, and one
- * that arrives while the worker is busy is steered into the running turn. The
- * watching session itself only routes.
- */
-export interface DispatchConfig {
-	/** "session" (default) or "process" */
-	mode?: DispatchMode;
-	/** Chats worked on at the same time (default: 3, 1-16) */
-	maxConcurrent?: number;
-	/** Worker processes kept alive, busy or idle (default: 6, at least maxConcurrent, max 32) */
-	maxWorkers?: number;
-	/** An idle worker exits after this many minutes; its session stays (default: 30) */
-	idleMinutes?: number;
-	/**
-	 * A chat quiet for longer than this starts a fresh session instead of
-	 * continuing the last one (default: 72, 0 = always continue).
-	 */
-	freshAfterHours?: number;
-	/** The pi executable (default: "pi") */
-	command?: string;
-	/** Extra arguments for every worker, e.g. ["--model", "provider/id"] */
-	args?: string[];
-	/** A message consisting of one of these aborts the running work (case-insensitive) */
-	stopWords?: string[];
-	/** A message consisting of one of these starts a fresh session for the chat */
-	resetWords?: string[];
 	/**
 	 * People who may, from their one-to-one chat with pi, read what pi wrote in
-	 * other chats (`teams_history`). Matched like `from`. Empty means nobody;
-	 * the watching session itself is never restricted.
+	 * other chats (`teams_history`). Matched like `from`. Empty means nobody.
+	 * Only matters where a pi process answers a single chat, e.g. a lane run by
+	 * pi-lanes; the session a person types in is never restricted.
 	 */
 	historyReaders?: string[];
 }
 
-export type DispatchMode = "session" | "process";
-
-/** A dispatch config after every default and clamp has been applied. */
-export interface ResolvedDispatchConfig {
-	mode: DispatchMode;
-	maxConcurrent: number;
-	maxWorkers: number;
-	idleMinutes: number;
-	freshAfterHours: number;
-	command: string;
-	args: string[];
-	stopWords: string[];
-	resetWords: string[];
-	historyReaders: string[];
-}
-
 /**
  * Where a mention is required, and where it is not.
  *
@@ -253,7 +196,7 @@ export interface ResolvedWatchConfig {
 	mentionOnly: ResolvedMentionOnly;
 	cooldownSeconds: number;
 	maxTriggersPerHour: number;
-	dispatch: ResolvedDispatchConfig;
+	historyReaders: string[];
 }
 
 /**
@@ -449,25 +392,7 @@ export const WATCH_DEFAULTS: ResolvedWatchConfig = {
 	mentionOnly: { default: false, chats: [], people: [] },
 	cooldownSeconds: 300,
 	maxTriggersPerHour: 10,
-	dispatch: {
-		mode: "session",
-		maxConcurrent: 3,
-		maxWorkers: 6,
-		idleMinutes: 30,
-		freshAfterHours: 72,
-		command: "pi",
-		args: [],
-		stopWords: ["stop", "stopp", "abbrechen", "abbruch", "cancel"],
-		resetWords: ["neues thema", "new topic", "reset"],
-		historyReaders: [],
-	},
-};
-
-const DISPATCH_BOUNDS = {
-	maxConcurrent: { min: 1, max: 16 },
-	maxWorkers: { min: 1, max: 32 },
-	idleMinutes: { min: 1, max: 1440 },
-	freshAfterHours: { min: 0, max: 8760 },
+	historyReaders: [],
 };
 
 /**
@@ -886,36 +811,7 @@ export function resolveWatchConfig(
 			WATCH_BOUNDS.maxTriggersPerHour,
 			WATCH_DEFAULTS.maxTriggersPerHour,
 		),
-		dispatch: resolveDispatchConfig(pick("dispatch")),
-	};
-}
-
-/**
- * Normalise the dispatch settings. Exported for tests.
- *
- * `maxWorkers` is raised to `maxConcurrent` when set lower: a worker that is
- * busy is alive, so fewer live workers than parallel chats is not a limit but
- * a contradiction.
- */
-export function resolveDispatchConfig(value: DispatchConfig | undefined): ResolvedDispatchConfig {
-	const d = WATCH_DEFAULTS.dispatch;
-	const v = value && typeof value === "object" && !Array.isArray(value) ? value : {};
-	const words = (list: unknown, fallback: string[]): string[] =>
-		Array.isArray(list)
-			? list.filter((w): w is string => typeof w === "string" && w.trim() !== "").map((w) => w.trim().toLowerCase())
-			: fallback;
-	const maxConcurrent = clamp(v.maxConcurrent, DISPATCH_BOUNDS.maxConcurrent, d.maxConcurrent);
-	return {
-		mode: v.mode === "process" ? "process" : "session",
-		maxConcurrent,
-		maxWorkers: Math.max(maxConcurrent, clamp(v.maxWorkers, DISPATCH_BOUNDS.maxWorkers, d.maxWorkers)),
-		idleMinutes: clamp(v.idleMinutes, DISPATCH_BOUNDS.idleMinutes, d.idleMinutes),
-		freshAfterHours: clamp(v.freshAfterHours, DISPATCH_BOUNDS.freshAfterHours, d.freshAfterHours),
-		command: typeof v.command === "string" && v.command.trim() ? v.command.trim() : d.command,
-		args: Array.isArray(v.args) ? v.args.filter((a): a is string => typeof a === "string") : [...d.args],
-		stopWords: words(v.stopWords, d.stopWords),
-		resetWords: words(v.resetWords, d.resetWords),
-		historyReaders: normalizePatterns(v.historyReaders),
+		historyReaders: normalizePatterns(pick("historyReaders")),
 	};
 }
 

package/src/extension/index.ts

@@ -11,7 +11,6 @@ import { Box, Text } from "@earendil-works/pi-tui";
 
 import {
 	ensureConfigTemplate,
-	getAgentDir,
 	getConfigPath,
 	setWatchConfig,
 	type ResolvedMentionOnly,
@@ -35,14 +34,15 @@ import {
 	setActiveWatchLoop,
 	startWatchLoop,
 	stopActiveWatchLoop,
+	type WatchEvent as WakeEvent,
 	type WatchLoop,
 } from "../watch/loop.ts";
 import { composeWatchPrompt } from "../watch/prompt.ts";
 import { setChatReadState } from "../graph/chats.ts";
 import { claimWakePin, clearWakeTarget, pinViolation, queueWakePin } from "../watch/pin.ts";
-import { ChatDispatcher, excerpt } from "../watch/dispatch.ts";
-import { controlAction } from "../watch/control.ts";
-import { workerIdentity, workerViolation } from "../watch/worker.ts";
+import { commandText } from "../watch/control.ts";
+import { workerEnv, workerIdentity, workerViolation } from "../watch/worker.ts";
+import { matchesPattern } from "../config/scope.ts";
 import { withSenderAddresses } from "../watch/index.ts";
 import { readWatchCursor, writeWatchCursor } from "../watch/cursor.ts";
 
@@ -107,6 +107,48 @@ function mentionSummary(mentionOnly: ResolvedMentionOnly): string {
 	return overrides > 0 ? `${base} (${overrides} override${overrides === 1 ? "" : "s"})` : base;
 }
 
+/**
+ * The event-bus channel a lane router listens on (pi-lanes). Emitting on it is
+ * free when nobody listens, so pi-teams needs no dependency on the router.
+ */
+const LANE_HINT_CHANNEL = "pi-lanes:route";
+
+/** One line, at most `max` characters. */
+function oneLine(text: string | undefined, max = 160): string | undefined {
+	const flat = text?.replace(/\s+/g, " ").trim();
+	if (!flat) return undefined;
+	return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
+}
+
+/**
+ * The routing hint for one wake: which conversation it belongs to, and what
+ * the process that answers it must know about itself.
+ *
+ * - `lane` is the chat, per account: same chat, same lane and session.
+ * - `env` pins that process to the chat (../watch/worker.ts).
+ * - `command` is the newest message without mention and punctuation, so the
+ *   router can recognise "stopp" or "neues Thema".
+ * - `trusted` is true only in a one-to-one chat with a `historyReaders` entry:
+ *   the only place where looking at other conversations is allowed.
+ */
+export function laneHint(conn: TeamsConnection, event: WakeEvent, prompt: string) {
+	const message = withSenderAddresses(event.message, event.chat);
+	const oneOnOne = event.chat.chatType === "oneOnOne";
+	const address = message.from?.mail ?? message.from?.upn;
+	const peer = oneOnOne ? address : undefined;
+	const trusted = !!peer && conn.watch.historyReaders.some((pattern) => matchesPattern(pattern, peer));
+	return {
+		text: prompt,
+		lane: `teams:${conn.account}:${event.chat.id}`,
+		label: `Teams: ${event.chat.label}`,
+		env: workerEnv({ chatId: event.chat.id, label: event.chat.label, chatType: event.chat.chatType, peer }),
+		command: commandText(message, event.me?.displayName),
+		request: oneLine(message.text),
+		from: message.from?.displayName,
+		trusted,
+	};
+}
+
 /** Every tool, in the order they appear in the documentation. */
 const tools = [
 	// Setup & session
@@ -186,36 +228,11 @@ export default function (pi: ExtensionAPI) {
 	let watchSignature: string | undefined;
 
 	/**
-	 * Set when this process is a chat worker started by a dispatcher: it answers
-	 * one chat, never watches, and may write nowhere else (see ../watch/worker.ts).
+	 * Set when this process answers one chat only (a lane started for it, see
+	 * ../watch/worker.ts): it never watches, and may write nowhere else.
 	 */
 	const worker = workerIdentity();
 
-	/** The per-chat worker pool, in dispatch mode `process`. Created on the first wake. */
-	let dispatcher: ChatDispatcher | undefined;
-	/** The context the dispatcher reports problems to. */
-	let dispatchCtx: any;
-
-	const dispatcherFor = (conn: TeamsConnection, ctx: any): ChatDispatcher => {
-		dispatchCtx = ctx;
-		if (dispatcher) {
-			dispatcher.configure(conn.watch.dispatch);
-			return dispatcher;
-		}
-		dispatcher = new ChatDispatcher({
-			config: conn.watch.dispatch,
-			agentDir: getAgentDir(),
-			cwd: ctx?.cwd ?? process.cwd(),
-			onError: (message) => dispatchCtx?.ui?.notify?.(message, "warning"),
-		});
-		return dispatcher;
-	};
-
-	const stopDispatcher = () => {
-		dispatcher?.stopAll();
-		dispatcher = undefined;
-	};
-
 	/** The last polling error the user was told about, so it is said once. */
 	let reportedWatchError: string | undefined;
 
@@ -269,26 +286,16 @@ export default function (pi: ExtensionAPI) {
 				}
 				const prompt = composeWatchPrompt(event, event.me);
 
-				// Dispatch mode: the chat's own worker answers, in parallel with other chats.
-				if (conn.watch.dispatch.mode === "process") {
-					const message = withSenderAddresses(event.message, event.chat);
-					dispatcherFor(conn, ctx).deliver({
-						chatId: event.chat.id,
-						label: event.chat.label,
-						chatType: event.chat.chatType,
-						from: message.from?.displayName,
-						peer: message.from?.mail ?? message.from?.upn,
-						prompt,
-						request: excerpt(message.text),
-						control: controlAction(message, conn.watch.dispatch, event.me?.displayName),
-					});
-					return;
-				}
+				// Tell a router which conversation this prompt belongs to. With
+				// pi-lanes installed, every chat is answered by a pi process of its
+				// own, in parallel with the others; without it nobody listens and the
+				// prompt takes the usual way into this session.
+				pi.events.emit(LANE_HINT_CHANNEL, laneHint(conn, event, prompt));
 
-				// Session mode: the turn this prompt starts may only answer the chat
-				// that woke pi. The pin is taken when the prompt enters the transcript,
-				// not now: while pi is busy the prompt waits in the queue, and pinning
-				// here would take the pin away from the answer still being written.
+				// The turn this prompt starts may only answer the chat that woke pi.
+				// The pin is taken when the prompt enters the transcript, not now:
+				// while pi is busy the prompt waits in the queue, and pinning here
+				// would take the pin away from the answer still being written.
 				queueWakePin(prompt, event.chat.id, event.chat.label);
 				pi.sendUserMessage(prompt, { deliverAs: "followUp" });
 			},
@@ -441,40 +448,12 @@ export default function (pi: ExtensionAPI) {
 					conn.watch.from.length > 0 ? `people: ${conn.watch.from.join(", ")}` : "any sender",
 					mentionSummary(conn.watch.mentionOnly),
 					runtime ? `${runtime.wakesThisHour} wake(s) this hour` : "not running in this session",
-					conn.watch.dispatch.mode === "process"
-						? `one process per chat (${dispatcher?.status().busy ?? 0}/${conn.watch.dispatch.maxConcurrent} busy)`
-						: "answers in this session",
 				].join(" · "),
 				"info",
 			);
 		},
 	});
 
-	pi.registerCommand("teams-dispatch", {
-		description: "Show the per-chat workers of listen mode (dispatch mode process)",
-		handler: async (_args, ctx) => {
-			const conn = refresh();
-			if (!conn || conn.watch.dispatch.mode !== "process") {
-				ctx.ui.notify("Teams dispatch: off. Every wake is a turn in this session (watch.dispatch.mode).", "info");
-				return;
-			}
-			const status = dispatcher?.status();
-			if (!status || status.alive + status.queued === 0) {
-				ctx.ui.notify(`Teams dispatch: no worker running (max ${conn.watch.dispatch.maxConcurrent} in parallel).`, "info");
-				return;
-			}
-			const minutes = (ms: number) => `${Math.max(0, Math.round(ms / 60_000))} min`;
-			ctx.ui.notify(
-				[
-					`Teams dispatch: ${status.busy}/${status.maxConcurrent} busy, ${status.alive} alive, ${status.queued} waiting`,
-					...status.chats.map((c) => `- ${c.label}: ${c.busy ? `working for ${minutes(c.sinceMs)}` : `idle for ${minutes(c.sinceMs)}`}`),
-					...status.waiting.map((c) => `- ${c.label}: waiting for a slot`),
-				].join("\n"),
-				"info",
-			);
-		},
-	});
-
 	pi.registerCommand("teams-inbox", {
 		description: "Show what needs your attention in Microsoft Teams",
 		handler: async (_args, ctx) => {
@@ -541,9 +520,10 @@ export default function (pi: ExtensionAPI) {
 		// and the same config: autoStart there would run a second watcher that
 		// answers chats inside a throwaway process and advances the shared cursor,
 		// so the real session never sees those messages.
-		// A chat worker (--mode rpc, so hasUI is true) is excluded by name: it is
-		// started by the watcher and must never become one.
-		if (connection.watch.autoStart && ctx.hasUI && !worker) startWatch(ctx, { explicit: true });
+		// A pi driven over RPC (a lane, an IDE) has a UI too, but nobody is
+		// typing in it: only the terminal session listens on its own.
+		const interactive = (ctx.mode ?? (ctx.hasUI ? "tui" : "print")) === "tui";
+		if (connection.watch.autoStart && interactive && !worker) startWatch(ctx, { explicit: true });
 
 		paintStatus(ctx);
 
@@ -602,8 +582,6 @@ export default function (pi: ExtensionAPI) {
 		// The timer would be unref'd anyway, but a poll in flight during shutdown
 		// would still be a Graph call for a session that is gone.
 		stopWatch();
-		// Workers end with the session that started them; their sessions stay on disk.
-		stopDispatcher();
 	});
 
 	// A queued wake prompt has entered the transcript: its turn starts now, so
@@ -706,7 +684,6 @@ export default function (pi: ExtensionAPI) {
 			// A watcher polling a session that was just removed only produces
 			// errors; leaving it running would be noise, not service.
 			stopWatch();
-			stopDispatcher();
 		} else if (WATCH_CONFIG_TOOLS.has(event.toolName)) {
 			// Only `enable` is a decision. A status call, or a re-read after
 			// teams_setup, may stop the loop but never start it.

package/src/tools/teams-history.ts

@@ -1,24 +1,21 @@
 /**
- * teams_history — what pi wrote in Teams, and what the chat workers were asked.
+ * teams_history — what pi wrote in Teams, across chats.
  *
- * In dispatch mode every chat has a session of its own, so no single context
- * knows what pi said elsewhere. This tool answers "what did you tell Anna
- * today?" from the two logs that do know: the audit log (every message pi
- * sent, see ../safety/audit.ts) and the dispatch journal (every request a chat
- * worker picked up, and its answer, see ../watch/dispatch.ts).
+ * When every chat is answered by a pi process of its own (a lane, e.g. with
+ * pi-lanes), no single context knows what pi said elsewhere. The audit log
+ * does (every message pi sent, see ../safety/audit.ts), and this tool reads it
+ * to answer "what did you tell Anna today?".
  *
- * Reading across chats is exactly what the per-chat sessions exist to prevent
- * by default, so inside a chat worker the tool answers only in a one-to-one
- * chat with somebody listed in `watch.dispatch.historyReaders`. The watching
- * session — the user at the keyboard — is never restricted.
+ * Reading across chats is exactly what separate processes prevent by default,
+ * so in a process that answers one chat the tool works only in a one-to-one
+ * chat with somebody listed in `watch.historyReaders`. The session a person
+ * types in is never restricted.
  */
 
 import { existsSync, openSync, readSync, closeSync, statSync } from "node:fs";
 import { Type } from "typebox";
-import { getAgentDir } from "../config/index.ts";
 import { matchesPattern } from "../config/scope.ts";
 import { getAuditPath } from "../safety/audit.ts";
-import { getDispatchJournalPath } from "../watch/dispatch.ts";
 import { workerIdentity, type WorkerIdentity } from "../watch/worker.ts";
 import { errorResult, run, textResult, type ToolContext, type ToolResult } from "./shared.ts";
 
@@ -64,12 +61,11 @@ export function historyRefusal(identity: WorkerIdentity | undefined, readers: st
 	if (allowed) return undefined;
 	return (
 		"What pi wrote in other chats is not available in this chat. Each chat keeps its own context, and only " +
-		"the people listed in watch.dispatch.historyReaders may look across chats, from their one-to-one chat with pi."
+		"the people listed in watch.historyReaders may look across chats, from their one-to-one chat with pi."
 	);
 }
 
 interface HistoryParams {
-	kind?: "sent" | "dispatch";
 	chat?: string;
 	sinceHours?: number;
 	limit?: number;
@@ -77,7 +73,6 @@ interface HistoryParams {
 
 /** Filter and render log entries. Exported for tests. */
 export function renderHistory(entries: Record<string, any>[], params: HistoryParams, now = Date.now()): string {
-	const kind = params.kind ?? "sent";
 	const limit = Math.min(Math.max(params.limit ?? 20, 1), 200);
 	const since = now - Math.min(Math.max(params.sinceHours ?? 24, 1), 24 * 90) * 3_600_000;
 	const needle = params.chat?.trim().toLowerCase();
@@ -86,29 +81,16 @@ export function renderHistory(entries: Record<string, any>[], params: HistoryPar
 		const at = Date.parse(entry.at ?? "");
 		if (!Number.isFinite(at) || at < since) return false;
 		if (!needle) return true;
-		const haystack =
-			kind === "sent"
-				? `${entry.target ?? ""} ${entry.summary ?? ""}`
-				: `${entry.chat ?? ""} ${entry.chatId ?? ""} ${entry.from ?? ""}`;
-		return haystack.toLowerCase().includes(needle);
+		return `${entry.target ?? ""} ${entry.summary ?? ""}`.toLowerCase().includes(needle);
 	});
 
 	const shown = hits.slice(-limit);
-	if (shown.length === 0) return kind === "sent" ? "No messages sent in that window." : "No dispatch entries in that window.";
+	if (shown.length === 0) return "No messages sent in that window.";
 
 	const lines = shown.map((entry) => {
 		const at = new Date(entry.at).toLocaleString();
-		if (kind === "sent") {
-			const failed = entry.error ? ` (failed: ${entry.error})` : "";
-			return `- ${at} · ${entry.tool} → ${entry.target}: ${entry.summary}${failed}`;
-		}
-		const parts = [`- ${at} · ${entry.chat} · ${entry.event}`];
-		if (entry.from) parts.push(`from ${entry.from}`);
-		if (entry.request) parts.push(`asked: ${entry.request}`);
-		if (entry.result) parts.push(`answered: ${entry.result}`);
-		if (entry.durationMs) parts.push(`${Math.round(entry.durationMs / 1000)} s`);
-		if (entry.detail) parts.push(entry.detail);
-		return parts.join(" · ");
+		const failed = entry.error ? ` (failed: ${entry.error})` : "";
+		return `- ${at} · ${entry.tool} → ${entry.target}: ${entry.summary}${failed}`;
 	});
 	const more = hits.length > shown.length ? `\n\n(${hits.length - shown.length} older entries not shown)` : "";
 	return lines.join("\n") + more;
@@ -117,15 +99,9 @@ export function renderHistory(entries: Record<string, any>[], params: HistoryPar
 export const teamsHistoryTool = {
 	name: "teams_history",
 	description:
-		"Look up what pi did in Teams across chats: kind 'sent' lists messages pi sent (from the audit log), kind " +
-		"'dispatch' lists requests the per-chat workers picked up and what they answered. Use it when someone asks " +
-		"what pi told another person or chat. Read-only.",
+		"Look up what pi sent in Teams across chats (from the audit log). Use it when someone asks what pi told " +
+		"another person or chat. Read-only.",
 	parameters: Type.Object({
-		kind: Type.Optional(
-			Type.Union([Type.Literal("sent"), Type.Literal("dispatch")], {
-				description: "'sent' (default): messages pi sent. 'dispatch': requests and answers of the chat workers.",
-			}),
-		),
 		chat: Type.Optional(Type.String({ description: "Only entries whose chat or person contains this text" })),
 		sinceHours: Type.Optional(Type.Number({ description: "How far back, in hours (default 24, max 2160)" })),
 		limit: Type.Optional(Type.Number({ description: "Most recent entries to show (default 20, max 200)" })),
@@ -140,11 +116,11 @@ export const teamsHistoryTool = {
 		ctx: ToolContext,
 	): Promise<ToolResult> {
 		return run(async () => {
-			const readers = ctx.connection?.watch.dispatch.historyReaders ?? [];
+			const readers = ctx.connection?.watch.historyReaders ?? [];
 			const refusal = historyRefusal(workerIdentity(), readers);
 			if (refusal) return errorResult(refusal);
 
-			const path = (params.kind ?? "sent") === "sent" ? getAuditPath() : getDispatchJournalPath(getAgentDir());
+			const path = getAuditPath();
 			const text = renderHistory(readJsonlTail(path), params);
 			return textResult(text, { path });
 		});

package/src/tools/teams-watch.ts

@@ -16,7 +16,6 @@ import {
 	type ResolvedMentionOnly,
 	type TeamsConnection,
 	type WatchConfig,
-	type ResolvedDispatchConfig,
 } from "../config/index.ts";
 import { getActiveWatchLoop, type WatchRuntimeStatus } from "../watch/loop.ts";
 import { getWatchCursorPath } from "../watch/cursor.ts";
@@ -73,7 +72,6 @@ function describe(watch: {
 	mentionOnly: ResolvedMentionOnly;
 	cooldownSeconds: number;
 	maxTriggersPerHour: number;
-	dispatch?: ResolvedDispatchConfig;
 }): string {
 	return [
 		`- enabled: ${watch.enabled}`,
@@ -84,9 +82,6 @@ function describe(watch: {
 		describeMentionOnly(watch.mentionOnly),
 		`- cooldown per chat: ${watch.cooldownSeconds} s`,
 		`- wake limit: ${watch.maxTriggersPerHour} per hour`,
-		watch.dispatch?.mode === "process"
-			? `- dispatch: one pi process per chat, ${watch.dispatch.maxConcurrent} in parallel`
-			: "- dispatch: every wake is a turn in this session",
 	].join("\n");
 }
 

package/src/watch/control.ts

@@ -1,22 +1,15 @@
 /**
- * Listen mode — control words in a chat.
+ * Listen mode — the text of a trigger, as a command.
  *
- * In dispatch mode a chat has a pi process that may be in the middle of
- * something. Two short messages steer that process instead of adding to its
- * work: a stop word aborts what it is doing, a reset word starts the chat over
- * with a fresh session. Both still reach the model afterwards, so the person
- * gets a one-line confirmation in the chat instead of silence.
- *
- * Deliberately strict: the whole message has to be the word (a mention of pi
- * and punctuation aside). "Stop the deployment on hera" is a request, not a
- * control word, and must be read by the model like any other.
+ * A router such as pi-lanes can treat a short message as a control word
+ * ("stopp", "neues Thema") instead of a request. It needs the message the way
+ * the person meant it: without the mention of pi in front, without
+ * punctuation. This module produces exactly that, and nothing more; which
+ * words mean what is the router's business.
  */
 
-import type { ResolvedDispatchConfig } from "../config/index.ts";
 import type { MessageSummary } from "../types.ts";
 
-export type ControlAction = "stop" | "reset";
-
 const escapeRegExp = (value: string) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 
 /** Lower-case the text and drop mentions, punctuation and extra spaces. */
@@ -45,16 +38,8 @@ export function selfNames(displayName: string | undefined): string[] {
 	return [displayName, short].filter(Boolean);
 }
 
-/** Whether the newest message is a control word, and which. */
-export function controlAction(
-	message: Pick<MessageSummary, "text" | "mentions">,
-	dispatch: Pick<ResolvedDispatchConfig, "stopWords" | "resetWords">,
-	myDisplayName?: string,
-): ControlAction | undefined {
+/** The newest message as a command: no mentions, no punctuation, lower case. */
+export function commandText(message: Pick<MessageSummary, "text" | "mentions">, myDisplayName?: string): string {
 	const names = [...(message.mentions ?? []).map((m) => m.displayName), ...selfNames(myDisplayName)];
-	const text = normalizeCommand(message.text ?? "", names);
-	if (!text) return undefined;
-	if (dispatch.resetWords.includes(text)) return "reset";
-	if (dispatch.stopWords.includes(text)) return "stop";
-	return undefined;
+	return normalizeCommand(message.text ?? "", names);
 }

package/src/watch/worker.ts

@@ -1,14 +1,15 @@
 /**
  * Listen mode — who a chat worker is.
  *
- * In dispatch mode (`watch.dispatch.mode: "process"`) every chat that wakes pi
- * gets a pi process of its own. That process loads this extension like any
- * other, so it has to know two things the moment it starts: that it must never
- * run a watcher of its own, and which single chat it may write to.
+ * Where a chat is answered by a pi process of its own (a lane, e.g. with
+ * pi-lanes), that process loads this extension like any other, so it has to
+ * know two things the moment it starts: that it must never run a watcher of
+ * its own, and which single chat it may write to.
  *
- * Both travel in the environment, set by the dispatcher when it spawns the
- * worker. An environment variable is the one channel that exists before the
- * first line of the extension runs, and the model cannot change it.
+ * Both travel in the environment, set by the router that starts the lane (see
+ * `laneHint` in ../extension/index.ts). An environment variable is the one
+ * channel that exists before the first line of the extension runs, and the
+ * model cannot change it.
  */
 
 /** Environment variables a chat worker is started with. */

package/src/watch/dispatch.ts

@@ -1,577 +0,0 @@
-/**
- * Listen mode — one pi process per chat.
- *
- * With `watch.dispatch.mode: "process"` a wake does not become a turn in the
- * session that runs the watcher. It goes to a worker: a `pi --mode rpc` process
- * that belongs to that one chat and keeps its own session from message to
- * message. Different chats are worked on at the same time; the watching
- * session only routes and stays small.
- *
- * The rules, in the order they are applied:
- *
- * - A chat whose worker is busy gets the new wake **steered** into the running
- *   turn. Nobody waits for a long task to finish before "stop, take repo X
- *   instead" is read.
- * - A chat without a busy worker starts one, if fewer than `maxConcurrent`
- *   chats are being worked on. Otherwise it waits in line; a newer wake for a
- *   chat already in line replaces the older one (its prompt carries every open
- *   message anyway).
- * - A stop word aborts the running turn; a reset word ends the worker and the
- *   chat starts over with a fresh session. Both prompts still reach the model,
- *   so the person gets a confirmation.
- * - An idle worker exits after `idleMinutes`. Its session stays on disk, and
- *   the next message in that chat continues it — unless the chat has been
- *   quiet for longer than `freshAfterHours`.
- *
- * Everything a worker is asked and answers is written to a journal
- * (`pi-teams-dispatch.jsonl`), so "what did pi tell whom" can be answered
- * across chats without mixing their contexts.
- *
- * The process handling is injectable (`spawn`), so the scheduling rules are
- * tested without starting pi.
- */
-
-import { spawn as nodeSpawn } from "node:child_process";
-import { createHash } from "node:crypto";
-import { appendFileSync, chmodSync, existsSync, mkdirSync, readdirSync, statSync } from "node:fs";
-import { join } from "node:path";
-import type { ResolvedDispatchConfig } from "../config/index.ts";
-import type { ControlAction } from "./control.ts";
-import { workerEnv, type WorkerIdentity } from "./worker.ts";
-
-// ---------------------------------------------------------------------------
-// Types
-// ---------------------------------------------------------------------------
-
-/** One wake, ready to be handed to a worker. */
-export interface DispatchJob {
-	chatId: string;
-	label: string;
-	/** "oneOnOne" | "group" | "meeting" */
-	chatType?: string;
-	/** Display name of the sender of the newest message */
-	from?: string;
-	/** Address of the other person in a one-to-one chat */
-	peer?: string;
-	/** The wake prompt, exactly as a session-mode wake would receive it */
-	prompt: string;
-	/** Short form of the newest message, for the journal */
-	request?: string;
-	control?: ControlAction;
-}
-
-export type DispatchOutcome = "started" | "steered" | "queued" | "stopped" | "reset";
-
-export type DispatchEvent =
-	| "start"
-	| "steer"
-	| "queued"
-	| "stop"
-	| "reset"
-	| "done"
-	| "error"
-	| "idle-exit";
-
-export interface DispatchJournalEntry {
-	at: string;
-	chatId: string;
-	chat: string;
-	event: DispatchEvent;
-	from?: string;
-	request?: string;
-	/** The worker's last answer text, shortened */
-	result?: string;
-	durationMs?: number;
-	detail?: string;
-}
-
-/** The part of a child process the dispatcher uses. */
-export interface WorkerProcess {
-	pid?: number;
-	stdin: { write(chunk: string): unknown; end(): unknown; on(event: "error", listener: (err: Error) => void): unknown } | null;
-	stdout: { on(event: "data", listener: (chunk: Buffer | string) => void): unknown } | null;
-	stderr: { on(event: "data", listener: (chunk: Buffer | string) => void): unknown } | null;
-	on(event: "exit", listener: (code: number | null, signal: NodeJS.Signals | null) => void): unknown;
-	on(event: "error", listener: (err: Error) => void): unknown;
-	kill(signal?: NodeJS.Signals): unknown;
-}
-
-export type SpawnWorker = (
-	command: string,
-	args: string[],
-	options: { cwd: string; env: NodeJS.ProcessEnv },
-) => WorkerProcess;
-
-export interface DispatcherOptions {
-	config: ResolvedDispatchConfig;
-	/** pi's agent directory: chat sessions and the journal live below it */
-	agentDir: string;
-	/** Working directory of the workers */
-	cwd: string;
-	spawn?: SpawnWorker;
-	now?: () => number;
-	/** Environment the workers inherit (default: process.env) */
-	env?: NodeJS.ProcessEnv;
-	/** Journal writer (default: append to pi-teams-dispatch.jsonl) */
-	journal?: (entry: DispatchJournalEntry) => void;
-	/** A worker failed in a way the user should hear about */
-	onError?: (message: string) => void;
-	/** Interval of the idle sweep in ms (default: 60 000, 0 = no timer) */
-	sweepIntervalMs?: number;
-}
-
-export interface DispatchStatus {
-	mode: "process";
-	busy: number;
-	alive: number;
-	queued: number;
-	maxConcurrent: number;
-	chats: Array<{ chatId: string; label: string; busy: boolean; sinceMs: number }>;
-	waiting: Array<{ chatId: string; label: string }>;
-}
-
-interface Worker {
-	identity: WorkerIdentity;
-	proc: WorkerProcess;
-	busy: boolean;
-	job?: DispatchJob;
-	startedAt: number;
-	lastActivity: number;
-	buffer: string;
-	lastText?: string;
-	stderrTail: string;
-	/** Set when the dispatcher itself ended the process */
-	retiring: boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Paths and journal
-// ---------------------------------------------------------------------------
-
-export function getDispatchJournalPath(agentDir: string): string {
-	return join(agentDir, "pi-teams-dispatch.jsonl");
-}
-
-/** The session directory of one chat. Hashed: chat IDs contain ':' and '@'. */
-export function chatSessionDir(agentDir: string, chatId: string): string {
-	const key = createHash("sha256").update(chatId).digest("hex").slice(0, 16);
-	return join(agentDir, "pi-teams-chats", key);
-}
-
-/** Append a journal entry. Never throws. */
-export function appendDispatchJournal(agentDir: string, entry: DispatchJournalEntry): void {
-	try {
-		if (!existsSync(agentDir)) mkdirSync(agentDir, { recursive: true, mode: 0o700 });
-		const path = getDispatchJournalPath(agentDir);
-		const isNew = !existsSync(path);
-		appendFileSync(path, `${JSON.stringify(entry)}\n`, { encoding: "utf-8", mode: 0o600 });
-		if (isNew) chmodSync(path, 0o600);
-	} catch {
-		/* the journal must never stop an answer */
-	}
-}
-
-/** One line, at most `max` characters. */
-export function excerpt(text: string | undefined, max = 300): string | undefined {
-	if (!text) return undefined;
-	const flat = text.replace(/\s+/g, " ").trim();
-	if (!flat) return undefined;
-	return flat.length > max ? `${flat.slice(0, max - 1)}…` : flat;
-}
-
-/**
- * Whether the chat's last session is recent enough to continue.
- *
- * `freshAfterHours: 0` means always continue. No session at all means there is
- * nothing to continue.
- */
-export function shouldContinue(dir: string, freshAfterHours: number, now: number): boolean {
-	let newest = 0;
-	try {
-		for (const name of readdirSync(dir)) {
-			if (!name.endsWith(".jsonl")) continue;
-			const mtime = statSync(join(dir, name)).mtimeMs;
-			if (mtime > newest) newest = mtime;
-		}
-	} catch {
-		return false;
-	}
-	if (newest === 0) return false;
-	if (freshAfterHours === 0) return true;
-	return now - newest <= freshAfterHours * 3_600_000;
-}
-
-/** The text of an assistant message, or undefined. */
-function assistantText(message: any): string | undefined {
-	if (!message || message.role !== "assistant") return undefined;
-	const content = message.content;
-	if (typeof content === "string") return content;
-	if (!Array.isArray(content)) return undefined;
-	const text = content
-		.filter((part: any) => part?.type === "text" && typeof part.text === "string")
-		.map((part: any) => part.text)
-		.join("\n")
-		.trim();
-	return text || undefined;
-}
-
-const DIALOG_METHODS = new Set(["select", "confirm", "input", "editor"]);
-
-// ---------------------------------------------------------------------------
-// Dispatcher
-// ---------------------------------------------------------------------------
-
-export class ChatDispatcher {
-	private config: ResolvedDispatchConfig;
-	private readonly workers = new Map<string, Worker>();
-	private queue: DispatchJob[] = [];
-	private readonly spawnWorker: SpawnWorker;
-	private readonly now: () => number;
-	private readonly journalWriter: (entry: DispatchJournalEntry) => void;
-	private sweepTimer?: ReturnType<typeof setInterval>;
-	private stopped = false;
-	private readonly options: DispatcherOptions;
-
-	constructor(options: DispatcherOptions) {
-		this.options = options;
-		this.config = options.config;
-		this.spawnWorker =
-			options.spawn ??
-			((command, args, opts) =>
-				nodeSpawn(command, args, { cwd: opts.cwd, env: opts.env, stdio: ["pipe", "pipe", "pipe"] }) as WorkerProcess);
-		this.now = options.now ?? Date.now;
-		this.journalWriter = options.journal ?? ((entry) => appendDispatchJournal(options.agentDir, entry));
-		const every = options.sweepIntervalMs ?? 60_000;
-		if (every > 0) {
-			this.sweepTimer = setInterval(() => this.sweep(), every);
-			this.sweepTimer.unref?.();
-		}
-	}
-
-	/** Apply changed settings. Running workers keep going; limits apply from now on. */
-	configure(config: ResolvedDispatchConfig): void {
-		this.config = config;
-		this.drain();
-	}
-
-	/** Hand a wake to its chat's worker. */
-	deliver(job: DispatchJob): DispatchOutcome {
-		if (this.stopped) return "queued";
-		const worker = this.workers.get(job.chatId);
-
-		if (job.control === "reset") {
-			this.dropQueued(job.chatId);
-			if (worker) this.retire(worker, "reset");
-			this.record(job, "reset");
-			this.start(job, { fresh: true, force: true });
-			return "reset";
-		}
-
-		if (job.control === "stop") {
-			this.dropQueued(job.chatId);
-			if (worker?.busy) {
-				this.send(worker, { type: "clear_queue" });
-				this.send(worker, { type: "abort" });
-				this.record(job, "stop");
-				// Queued behind the abort: the model confirms in the chat once it is idle.
-				this.send(worker, { type: "prompt", message: job.prompt, streamingBehavior: "followUp" });
-				worker.job = job;
-				return "stopped";
-			}
-			this.record(job, "stop", { detail: "nothing was running" });
-		}
-
-		if (worker?.busy) {
-			this.send(worker, { type: "prompt", message: job.prompt, streamingBehavior: "steer" });
-			worker.lastActivity = this.now();
-			this.record(job, "steer");
-			return "steered";
-		}
-
-		if (this.busyCount() >= this.config.maxConcurrent) {
-			this.dropQueued(job.chatId);
-			this.queue.push(job);
-			this.record(job, "queued", { detail: `${this.busyCount()} chat(s) in progress` });
-			return "queued";
-		}
-
-		this.start(job, { fresh: false });
-		return "started";
-	}
-
-	/** Snapshot for status commands. */
-	status(): DispatchStatus {
-		const now = this.now();
-		return {
-			mode: "process",
-			busy: this.busyCount(),
-			alive: this.workers.size,
-			queued: this.queue.length,
-			maxConcurrent: this.config.maxConcurrent,
-			chats: [...this.workers.values()].map((w) => ({
-				chatId: w.identity.chatId,
-				label: w.identity.label,
-				busy: w.busy,
-				sinceMs: now - (w.busy ? w.startedAt : w.lastActivity),
-			})),
-			waiting: this.queue.map((job) => ({ chatId: job.chatId, label: job.label })),
-		};
-	}
-
-	/** End idle workers that have been quiet for longer than `idleMinutes`. */
-	sweep(): void {
-		const now = this.now();
-		const limit = this.config.idleMinutes * 60_000;
-		for (const worker of [...this.workers.values()]) {
-			if (!worker.busy && now - worker.lastActivity > limit) {
-				this.journalWriter({
-					at: new Date(now).toISOString(),
-					chatId: worker.identity.chatId,
-					chat: worker.identity.label,
-					event: "idle-exit",
-				});
-				this.retire(worker, "idle");
-			}
-		}
-	}
-
-	/** End every worker. Their sessions stay on disk. */
-	stopAll(): void {
-		this.stopped = true;
-		if (this.sweepTimer) clearInterval(this.sweepTimer);
-		this.queue = [];
-		for (const worker of [...this.workers.values()]) this.retire(worker, "shutdown");
-	}
-
-	// -----------------------------------------------------------------------
-
-	private busyCount(): number {
-		let busy = 0;
-		for (const worker of this.workers.values()) if (worker.busy) busy += 1;
-		return busy;
-	}
-
-	private dropQueued(chatId: string): void {
-		this.queue = this.queue.filter((job) => job.chatId !== chatId);
-	}
-
-	private record(job: DispatchJob, event: DispatchEvent, extra: Partial<DispatchJournalEntry> = {}): void {
-		this.journalWriter({
-			at: new Date(this.now()).toISOString(),
-			chatId: job.chatId,
-			chat: job.label,
-			event,
-			from: job.from,
-			request: job.request,
-			...extra,
-		});
-	}
-
-	private send(worker: Worker, command: Record<string, unknown>): void {
-		try {
-			worker.proc.stdin?.write(`${JSON.stringify(command)}\n`);
-		} catch {
-			/* a dead pipe shows up as an exit event */
-		}
-	}
-
-	private start(job: DispatchJob, { fresh, force = false }: { fresh: boolean; force?: boolean }): void {
-		let worker = this.workers.get(job.chatId);
-		if (!worker) worker = this.launch(job, fresh);
-		if (!worker) return;
-
-		const now = this.now();
-		worker.busy = true;
-		worker.job = job;
-		worker.startedAt = now;
-		worker.lastActivity = now;
-		worker.lastText = undefined;
-		// followUp: harmless when idle, and correct if the worker is still
-		// finishing something the dispatcher did not see yet.
-		this.send(worker, { type: "prompt", message: job.prompt, streamingBehavior: "followUp" });
-		this.record(job, "start", force ? { detail: "fresh session" } : {});
-	}
-
-	private launch(job: DispatchJob, fresh: boolean): Worker | undefined {
-		this.makeRoom();
-
-		const identity: WorkerIdentity = {
-			chatId: job.chatId,
-			label: job.label,
-			chatType: job.chatType,
-			peer: job.chatType === "oneOnOne" ? job.peer : undefined,
-		};
-		const dir = chatSessionDir(this.options.agentDir, job.chatId);
-		try {
-			mkdirSync(dir, { recursive: true, mode: 0o700 });
-		} catch {
-			/* spawn reports the real problem */
-		}
-
-		const resume = !fresh && shouldContinue(dir, this.config.freshAfterHours, this.now());
-		const args = [
-			...this.config.args,
-			"--mode",
-			"rpc",
-			"--session-dir",
-			dir,
-			...(resume ? ["--continue"] : ["--name", `teams: ${job.label}`]),
-		];
-
-		let proc: WorkerProcess;
-		try {
-			proc = this.spawnWorker(this.config.command, args, {
-				cwd: this.options.cwd,
-				env: { ...(this.options.env ?? process.env), ...workerEnv(identity) },
-			});
-		} catch (err) {
-			const message = err instanceof Error ? err.message : String(err);
-			this.record(job, "error", { detail: `could not start ${this.config.command}: ${message}` });
-			this.options.onError?.(`Teams dispatch: could not start a worker for "${job.label}": ${message}`);
-			return undefined;
-		}
-
-		const now = this.now();
-		const worker: Worker = {
-			identity,
-			proc,
-			busy: false,
-			startedAt: now,
-			lastActivity: now,
-			buffer: "",
-			stderrTail: "",
-			retiring: false,
-		};
-		this.workers.set(job.chatId, worker);
-
-		proc.stdin?.on("error", () => undefined);
-		proc.stdout?.on("data", (chunk) => this.onData(worker, chunk));
-		proc.stderr?.on("data", (chunk) => {
-			worker.stderrTail = (worker.stderrTail + chunk.toString()).slice(-2000);
-		});
-		proc.on("error", (err) => this.onExit(worker, `error: ${err.message}`));
-		proc.on("exit", (code, signal) => this.onExit(worker, signal ? `signal ${signal}` : `exit code ${code}`));
-		return worker;
-	}
-
-	/** Keep the number of live workers under `maxWorkers` by ending the longest-idle one. */
-	private makeRoom(): void {
-		while (this.workers.size >= this.config.maxWorkers) {
-			const idle = [...this.workers.values()].filter((w) => !w.busy).sort((a, b) => a.lastActivity - b.lastActivity);
-			if (idle.length === 0) return;
-			this.retire(idle[0]!, "room");
-		}
-	}
-
-	/** End a worker on purpose. Closing stdin lets pi shut down cleanly. */
-	private retire(worker: Worker, _why: string): void {
-		worker.retiring = true;
-		if (this.workers.get(worker.identity.chatId) === worker) this.workers.delete(worker.identity.chatId);
-		try {
-			worker.proc.stdin?.end();
-		} catch {
-			/* ignore */
-		}
-		const timer = setTimeout(() => {
-			try {
-				worker.proc.kill("SIGTERM");
-			} catch {
-				/* already gone */
-			}
-		}, 10_000);
-		timer.unref?.();
-	}
-
-	private onData(worker: Worker, chunk: Buffer | string): void {
-		worker.buffer += chunk.toString();
-		let index = worker.buffer.indexOf("\n");
-		while (index >= 0) {
-			const line = worker.buffer.slice(0, index).replace(/\r$/, "");
-			worker.buffer = worker.buffer.slice(index + 1);
-			if (line.trim()) this.onLine(worker, line);
-			index = worker.buffer.indexOf("\n");
-		}
-	}
-
-	private onLine(worker: Worker, line: string): void {
-		let event: any;
-		try {
-			event = JSON.parse(line);
-		} catch {
-			return;
-		}
-		if (!event || typeof event !== "object") return;
-
-		switch (event.type) {
-			case "agent_start":
-				// A steer that arrived just after the worker settled starts a new run.
-				if (!worker.busy) {
-					worker.busy = true;
-					worker.startedAt = this.now();
-				}
-				return;
-			case "message_end": {
-				const text = assistantText(event.message);
-				if (text) worker.lastText = text;
-				return;
-			}
-			case "agent_settled":
-				this.finish(worker);
-				return;
-			case "extension_ui_request":
-				// Nobody sits in front of a worker. A dialog would wait forever.
-				if (DIALOG_METHODS.has(event.method)) {
-					this.send(worker, { type: "extension_ui_response", id: event.id, cancelled: true });
-				}
-				return;
-			case "response":
-				if (event.success === false) {
-					const detail = `${event.command ?? "command"} failed: ${event.error ?? "unknown error"}`;
-					if (worker.job) this.record(worker.job, "error", { detail });
-					this.options.onError?.(`Teams dispatch (${worker.identity.label}): ${detail}`);
-					if (event.command === "prompt" && worker.busy) this.finish(worker, true);
-				}
-				return;
-			default:
-				return;
-		}
-	}
-
-	private finish(worker: Worker, failed = false): void {
-		if (!worker.busy) return;
-		const now = this.now();
-		worker.busy = false;
-		worker.lastActivity = now;
-		if (worker.job && !failed) {
-			this.record(worker.job, "done", { durationMs: now - worker.startedAt, result: excerpt(worker.lastText) });
-		}
-		this.drain();
-	}
-
-	private onExit(worker: Worker, how: string): void {
-		const current = this.workers.get(worker.identity.chatId) === worker;
-		if (current) this.workers.delete(worker.identity.chatId);
-		if (!worker.retiring && worker.busy && worker.job) {
-			const detail = `worker ended (${how})${worker.stderrTail ? `: ${excerpt(worker.stderrTail, 200)}` : ""}`;
-			this.record(worker.job, "error", { detail });
-			this.options.onError?.(`Teams dispatch (${worker.identity.label}): ${detail}`);
-		}
-		worker.busy = false;
-		worker.retiring = true;
-		if (!this.stopped) this.drain();
-	}
-
-	/** Start waiting chats while there is room. */
-	private drain(): void {
-		while (this.queue.length > 0 && this.busyCount() < this.config.maxConcurrent) {
-			const job = this.queue.shift()!;
-			const worker = this.workers.get(job.chatId);
-			if (worker?.busy) {
-				this.send(worker, { type: "prompt", message: job.prompt, streamingBehavior: "steer" });
-				this.record(job, "steer");
-				continue;
-			}
-			this.start(job, { fresh: false });
-		}
-	}
-}