pi-roundtable 0.28.0 → 0.29.0

package/CHANGELOG.md

@@ -5,6 +5,25 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.29.0] - 2026-10-31
+
+### Added
+
+- `SkillRegistry.groups()`, `setGroup(name, description, skills)` and `deleteGroup(name)` are part of the skill registry interface (`SkillGroup`: `name`, `description`, `skills`), so a host surface can manage skill groups. A group stays a filter and a list to apply once: an agent carries skills, not groups. `SkillRegistry` has three new required methods, so a hand-built stand-in must set them.
+- `helperSurface` tells the surface a temp knight was made on, read off its stored origin. `AgentOps.reach` readies a message's place before `message_agent` delivers it.
+
+### Changed
+
+- Delivery follows the conversation the work came from. One delivery router (`src/core/presence/delivery-router.ts`) decides where a notice or run for a person goes from its origin: a provider on the origin's surface first, another surface only when none there reaches the person, logged with both surfaces. A schedule made in a web room that calls `notify` now notices in the web app (Home notice and push) instead of a Discord direct message. The web app's push mirror of a notice Discord delivered stays, to the same person only.
+- Breaking: `DirectChannels.reach`, `known`, and `notify` take the origin `ChannelKey` first (`reach(origin, principalId)`, `notify(origin, principalId, text)`), and `DirectChannels` no longer extends `Notifier`. `DirectChannelProvider.surface` (optional, default `name`) names the surface a provider reaches; the Discord, web, and webchat providers set it.
+- `message_agent` without `conversation` reaches the target's place on the sender's surface (`routing.agents.<name>.agentMessage` default `origin-surface`), never the conversation it used most recently on another surface; with no place there it lands in the primary place, logged. `latest` now follows only on the sender's surface. `RoutingTable.of(agent, "agentMessage", origin)` requires the origin.
+- The notify tool's description says it goes out on the conversation's own surface.
+- A temp knight lives only on the surface of the conversation that made it. One made in the web app gets no Discord thread at creation; the thread is made once, when a `message_agent` call from a turn that may message it names `conversation: "discord"`, or names no conversation from a Discord turn (where an unnamed message goes), and restoring it reopens the thread it had but never makes a new one. Archiving one without a thread works as before. A temp knight made before its origin was kept is placed as before. See pi-roundtable-web for the rooms of temp knights made on Discord.
+
+### Fixed
+
+- A group seat outside its running turn, such as after a start-over, stays in the group's room on its own surface instead of falling out to the group's Discord channel.
+
 ## [0.28.0] - 2026-10-31
 
 ### Added

package/docs/plugins.md

@@ -182,7 +182,7 @@ A plugin that replaces `IDENTITY` replaces this too: the declarations are the bu
 | `surfaces` | Every contributed [chat surface](#surfaces-a-chat-network-of-your-own), chosen by the prefix of a channel key: `of`, `sendReply`, `startTyping`, `showStop`, `react`, `unreact`, `prompts` |
 | `turns` | Runs one turn of a conversation your claim owns, over the runtime and the surfaces: [`turns.run`](#personas-and-contextturns-conversations-of-a-kind-of-your-own) |
 | `observe(filter, observer)` | Hears inbound messages without owning or admitting them: [`observe`](#observe-hearing-messages-without-owning-them). Returns a function that stops it; may be called during `setup` |
-| `directChannels` | Every plugin's [direct channels](#directchannels-reaching-a-person-on-their-own): `providers()`, `reach(principalId)`, `known(principalId)`, and `notify(principalId, text)` |
+| `directChannels` | Every plugin's [direct channels](#directchannels-reaching-a-person-on-their-own): `providers()`, `reach(origin, principalId)`, `known(origin, principalId)`, and `notify(origin, principalId, text)`, each through the [delivery router](#where-things-are-delivered) |
 | `sessions()`, `conversations`, `surfaces`, `directChannels`, `turns`, `dashboard()` | Linked once every plugin has been set up; calling them during `setup` throws `NotLinkedError` |
 
 `sessions()`, `conversations`, `surfaces`, `directChannels`, `turns`, and `dashboard()` are available from a service's `start`, an event handler, a session tool, or a claim's turn.
@@ -258,7 +258,7 @@ The built-in plugins provide these, from the main entry:
 | `RUNTIME` | `AgentRuntime` | `runtime` | The runtime every conversation turn runs on, the agent server's and `context.turns`': the `runtime` slot's when a plugin fills it, Pi's otherwise |
 | `AGENTS` | `AgentServer` | `agent-server` | The `team` (`AgentTeam`), the read-only `directory` (`AgentDirectory`), the `runtime` every agent turn runs on (the same one `RUNTIME` provides), `approvals` (whether the owner's reply approves held actions), `avatars` (`AvatarStudio`), `workspace` (`AgentWorkspace`: the agents' `workDir` and, when set, `scratchDir`), and `routes` (`RoutingTable`: where work no person started lands; see [Routing](#routing-where-work-no-person-started-lands)) |
 | `PROMPTS` | `PromptDocuments` | `prompts` | The prompt texts the owner edits in the app, each with a file version, an override and a history: `register`, `text`, `list`, `get`, `set`, `revert`, `history`. Always on; read it with `get`. See [`PROMPTS`: prompt texts the owner edits](#prompts-prompt-texts-the-owner-edits) |
-| `SKILLS` | `SkillRegistry` | `skills` (an addon) | What agents carry: `carried`, `carriedNames`, `describeCarried`, `catalog`, `list`, `linkedFrom`, `checkRegistered`, `link`, `attach`, and the owner's whole-SKILL.md edits `document`, `saveDocument`, `createDocument`, `documentHistory` |
+| `SKILLS` | `SkillRegistry` | `skills` (an addon) | What agents carry: `carried`, `carriedNames`, `describeCarried`, `catalog`, `list`, `linkedFrom`, `checkRegistered`, `link`, `attach`, and the owner's whole-SKILL.md edits `document`, `saveDocument`, `createDocument`, `documentHistory`, and the groups `groups`, `setGroup`, `deleteGroup` |
 | `SCHEDULES` | `ScheduleStore` | `schedule-store` | The stored schedules: `create`, `createWithin`, `get`, `forChannel`, `all`, `update`, `remove`, `due`, `claim`, `recordStatus` |
 | `PRECHECKS` | `PrecheckRegistry` | `prechecks` | The host's named [prechecks](#prechecks-wake-a-schedule-only-when-it-has-work): `register`, `get`, `list`; and the runner of agents' precheck scripts: `useScriptRunner`, `scriptRunner` |
 | `MEMORY` | `MemoryStore` | `memory` (an addon) | `forSpeaker(principalId)` gives that principal's `SpeakerMemory`: `list`, `forPrompt`, `add`, `search`, `update`, `removeById`, `remove`; `MEMORY_KINDS` is `core`, `note`, `event` |
@@ -2999,6 +2999,7 @@ setup: ({ services }) => ({
 	directChannels: [
 		{
 			name: "inbox",
+			surface: "chat",
 			label: "a notice in the web chat's inbox",
 			reaches: async (principalId) => inboxOf(principalId),
 			deliver: async (principalId, text) => postNotice(principalId, text),
@@ -3010,23 +3011,36 @@ setup: ({ services }) => ({
 | Field | What it is |
 |---|---|
 | `name` | Unique across every plugin; a second provider of one name is a `PluginError` naming both plugins |
+| `surface` | Optional: the surface whose conversations it reaches, the key prefix of the channels `reaches` names, such as `discord` or the web app's `app`. Work from a conversation on that surface reaches the person here first. Without it, `name` |
 | `label` | How the `notify` tool names a notice sent through it, completing "Send Ada …", such as `a direct message on Discord` |
 | `reaches(principalId)` | The person's own conversation here, as a channel key, or `undefined` when they have none here. It may reach the network and throw |
 | `knows(principalId)` | Optional: whether the person has a conversation here, from the host's own records such as their linked identities, without the network. A session asks it when it decides whether to offer `notify` or the schedule and delegation tools, so an outage then does not take them away; without it the host asks `reaches` |
 | `deliver(principalId, text)` | Optional: sends the notice itself. Without it the host posts the text in the channel `reaches` names, through the surface that serves it |
-| `mirror(principalId, text)` | Optional: echoes a notice another provider delivered, such as a web app pushing to a phone that Discord's direct message already reached. `notify` calls it on every provider but the one that delivered, only after a delivery; a failure is logged and never changes the result |
+| `mirror(principalId, text)` | Optional: echoes a notice another provider delivered to the same person, such as a web app pushing to a phone that Discord's direct message already reached. `notify` calls it on every provider but the one that delivered, only after a delivery; a failure is logged and never changes the result |
 
-The host reaches a person through the first provider, in contribution order, that reaches them.
-`context.directChannels.reach(principalId)` resolves that provider and channel, or `undefined`; `known(principalId)` resolves the first provider that knows the person without the network; `notify(principalId, text)` sends a notice there and resolves `false` when no provider reaches the person.
+Every lookup takes the *origin*: the conversation the work came from. The host reaches a person through a provider on the origin's surface, and through another only when none there reaches them, as [Where things are delivered](#where-things-are-delivered) describes.
+`context.directChannels.reach(origin, principalId)` resolves that provider and channel, or `undefined`; `known(origin, principalId)` resolves the provider that knows the person without the network, in the same order; `notify(origin, principalId, text)` sends a notice there and resolves `false` when no provider reaches the person.
 The Discord plugin contributes one named `discord`: it finds a principal's Discord identities through `IDENTITY` and reaches the first one's direct messages, the primary owner's configured identity first, so a single owner is reached in the same direct messages as in 0.8.
 
 The `notify` tool, 0.8's `notify_owner`, sends such a notice. A session has it only when a provider is contributed, and a private conversation only when a provider knows its person; the channel itself is reached when a notice is sent.
 It notifies the conversation's person in a private conversation and the turn's speaker in a shared one, and refuses when no provider reaches them or when the speaker is not the private conversation's person; the host's own turns, such as a report's, notify the conversation's person in a private conversation and the primary owner elsewhere, as `notify_owner` did.
-Its description names the channels that can reach the person, so a host with only Discord reads `Send Ada a direct message on Discord. …` as 0.8 did.
+It sends on the conversation's own surface: from a web room the web app's notice and push, from Discord a Discord direct message. Its description names the channel on that surface that can reach the person, and says it goes out on the conversation's own surface, such as `Send Ada a direct message on Discord. It goes out on this conversation's own surface. …`.
 In a shared conversation it names the primary owner while only they can receive a notice (the host has no other owner, and only owners may use it), and "the speaker" otherwise; this is checked again before each turn, so an open session follows an owner granted or revoked meanwhile.
 Until 1.0 the name `notify_owner` still selects it in a selection or a profile and names it in a task's `exclude` and a plugin's `requiredTools`, and an operator's or a plugin's `toolTiers` entry for `notify_owner` applies to `notify` unless `notify` has its own.
 Using the old name logs a deprecation warning once per logger, whether in a selection or in `toolTiers`.
 
+### Where things are delivered
+
+Everything the host sends goes back where the work came from. Every turn knows its *origin*, the conversation it runs in (a `ChannelKey` whose prefix is its surface), and so does everything a turn leaves behind: a schedule keeps the conversation it was made in, a delegated or coding job its channel and origin, a kept agent message its target's conversation and the sender's, a dispatch thread its parent. Nothing chooses a destination from a global default: not the first provider contributed, not the conversation an agent used most recently, not an agent's Discord channel.
+
+- **Replies, cards, and threads** go through `SurfacePort`, which picks the surface by the channel key's prefix: an `ask_user` card, a timeout card, a message's request and answer cards, a job's thread and report all land in the origin's conversation, on its surface.
+- **The delivery router** (`src/core/presence/delivery-router.ts`) is the one place that decides where a notice or run for a *person* goes. Given the origin, it tries the direct channels on the origin's surface first: a web conversation reaches the web app's channel (a Home notice and a push), a Discord conversation a Discord direct message. Only when no provider on that surface reaches the person does it try another surface, and it logs that fallback with both surfaces (`from`, `to`). `notify`, `context.directChannels`, and the run channel of a schedule or delegated task made in a conversation no chat surface carries (`runChannelFor`) all go through it.
+- **Mirroring** is the provider's own declaration: after a delivery, each other provider that implements `mirror` echoes the notice to the *same person*, such as the web app pushing to their phone a notice Discord delivered. It never sends to anyone else and never posts in a conversation.
+- **`message_agent`** without `conversation` reaches the target's place on the *sender's* surface: from a web room, the target's room on that surface; from Discord, the target's Discord channel. When the target has no place there, it lands in the target's primary place, and the crossing is logged. A routing rule may pin it elsewhere; `latest` follows the conversation the target last used only on the sender's surface.
+- **A group seat** outside its running turn, such as after a start-over, posts in the group's room on its own surface and never falls out to the group's Discord channel.
+
+`scripts/delivery-scan.test.ts` fails the build when code outside the router asks a provider to reach someone, walks the providers to pick one, or reads an agent's Discord channel id outside the files listed there; `src/core/presence/cross-surface.test.ts` starts each outbound feature from a web and from a Discord conversation and checks the other surface received nothing.
+
 ### `surfaces`: a chat network of your own
 
 A chat surface connects the host to one chat network: it reports what people write, and it posts what the conversations answer.
@@ -3087,7 +3101,7 @@ An agent has a *place* on each surface that holds one: its Discord channel, and
 | `primary(agent)` | The primary place: the surface the rules name, and with `auto` the agent's Discord channel when it has one, else its room on the first surface that hosts rooms. Undefined for an unknown agent. |
 | `placeOn(agent, surface)` | The agent's place on a surface (`web` for the one surface that hosts rooms); undefined when it has none there. |
 | `of(agent, "integration", origin)` | Where the report turn of a foreign webhook's post made in `origin` runs; `origin` itself by default, and also when the destination has vanished. |
-| `of(agent, "agentMessage", from)` | The conversation a `message_agent` call that names none reaches: by default the agent's latest, never out of a room into Discord. Throws `AgentError` when the agent has no place. |
+| `of(agent, "agentMessage", from)` | The conversation a `message_agent` call that names none reaches: by default (`origin-surface`) the agent's place on the surface `from` is on, else its primary place, logged; it never crosses surfaces by recency. Throws `AgentError` when the agent has no place. |
 | `of(agent, "opening", origin?)` | Where an opening task runs: by default the agent's place on the surface `origin` is on, else its primary place; undefined when it has no place at all. |
 | `place("ops")` | A named place of the host: the conversation, or the primary place of the agent it names while that agent is active. |
 
@@ -3109,13 +3123,13 @@ It follows its knight's routing rules, and its yolo and long-running modes follo
 
 | Rule | What happens |
 |---|---|
-| Place | On Discord a temp knight lives in a thread under its knight's channel, whose posts go through the channel's webhook under the temp knight's own name and picture; a knight with no Discord channel gives it a room on a surface that hosts rooms. Archiving a temp knight archives and locks its thread, and restoring it unarchives the thread. |
+| Place | A temp knight lives on the surface of the conversation that made it, kept in `Agent.origin`; its place on the other surface is made only when someone uses it there. Made on Discord, it lives in a thread under its knight's channel, whose posts go through the channel's webhook under the temp knight's own name and picture; a surface's room list leaves its room out until the room has a message or someone opens it by its address. Made in a room, it gets no thread: the thread is made, once, when a `message_agent` call from a turn that may message it names `conversation: "discord"`, or names none from a Discord conversation, where an unnamed message goes. A knight with no Discord channel gives it a room on a surface that hosts rooms. Archiving a temp knight archives and locks its thread when it has one; restoring it unarchives the thread, and only one made on Discord gets a new thread when the old one is gone. A temp knight made before its origin was kept is placed as one made on Discord. |
 | Finished | Derived, never set by the knight: nothing runs, nothing is queued, no card waits for the owner and no message from its knight is still unanswered. `Agent.finishedAt` carries the stamp. |
 | Limits | `helpers.perParent` (default 4) and `helpers.perHost` (default 12) count active temp knights; depth is one, so a temp knight cannot make one. At a limit the knight's oldest finished temp knight is archived to make room, and the call is refused only when every one of them is busy. |
 | Cleanup | `helper_end`, the owner's clearing in a surface, a knight's own archive (which archives its temp knights first), and, after `helpers.archiveFinishedAfterHours` (default 24), an hourly sweep. An archived temp knight keeps its history and comes back with `restoreHelpers`. Deleting an archived knight deletes its temp knights. |
 
 `AgentTeam` offers `helpersOf(parent)`, `finishedHelpers(parents?)`, `archiveHelpers(names, by)`, `restoreHelpers(names)` (only a name that is still an archived temp knight of an active knight is restored) and `onHelpersEnded(listener)`, which hears a knight's own `helper_end` and nothing else, so a surface can offer the owner an undo.
-`isHelper(agent)` tells a temp knight, for a surface that lists agents; a group never takes one.
+`isHelper(agent)` tells a temp knight, for a surface that lists agents, and `helperSurface(agent)` the surface it was made on (undefined for one made before its origin was kept); a group never takes one.
 The `helpers` block of the configuration turns the limits and the sweep; `helpers: false` offers neither tool, and a value out of its range, or a `perParent` above `perHost`, stops the start with a `ConfigError`:
 
 ```ts
@@ -4403,6 +4417,7 @@ Import from the entries listed below; source area files are internal.
 | `AvatarStudio` | `pi-roundtable` | type |
 | `PROMPTS` | `pi-roundtable` | value |
 | `characterOf` | `pi-roundtable` | value |
+| `helperSurface` | `pi-roundtable` | value |
 | `isHelper` | `pi-roundtable` | value |
 | `BACKGROUND_TURNS` | `pi-roundtable` | value |
 | `CONVERSATIONS` | `pi-roundtable` | value |
@@ -4594,6 +4609,7 @@ Import from the entries listed below; source area files are internal.
 | `PromptConflictError` | `pi-roundtable` | value |
 | `SkillConflictError` | `pi-roundtable` | value |
 | `SkillDocument` | `pi-roundtable` | type |
+| `SkillGroup` | `pi-roundtable` | type |
 | `SKILLS` | `pi-roundtable` | value |
 | `SINGLE_QUESTION` | `pi-roundtable` | value |
 | `Schedule` | `pi-roundtable` | type |

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-roundtable",
-	"version": "0.28.0",
+	"version": "0.29.0",
 	"description": "A plugin-driven Pi agent server for one owner, reached through Discord or the web",
 	"type": "module",
 	"license": "MIT",

package/src/core/agents/agent-messages.ts

@@ -15,6 +15,7 @@ import {
 	chainLimitReason,
 	deliveredMessagePost,
 } from "./agent-prompt.ts";
+import { answersTo } from "./agent-rules.ts";
 import type { Agent } from "./agent-store.ts";
 import { conversationLabel, messageTarget } from "./message-target.ts";
 import { discordIdOf, discordKey, scopeOf } from "./team-keys.ts";
@@ -78,13 +79,10 @@ export class AgentMessages {
 			);
 		// A temp knight talks only to the conversation it was made from (and to the owners), so one
 		// person's helper session is not open to another person's turn.
-		if (target.parent !== undefined && chain.speaker.tier !== "owner") {
-			const own = sender.name === target.parent && target.origin === parent;
-			if (!own)
-				throw new AgentError(
-					`"${target.name}" is a temp knight of "${target.parent}" and answers only the conversation that made it; ask "${target.parent}" there.`,
-				);
-		}
+		if (!answersTo(target, caller.name, parent, chain.speaker))
+			throw new AgentError(
+				`"${target.name}" is a temp knight of "${target.parent}" and answers only the conversation that made it; ask "${target.parent}" there.`,
+			);
 		chain.messages += 1;
 		// A temp knight is working from the moment a message is handed to it until it has answered.
 		this.#host.helpers.begin(target.name);

package/src/core/agents/agent-rules.ts

@@ -42,6 +42,33 @@ export interface Agent {
 export const isHelper = (agent: Pick<Agent, "parent"> | undefined): boolean =>
 	agent?.parent !== undefined;
 
+/**
+ * Whether `sender`, writing from `from` in a run `speaker` started, may message `target`: a temp
+ * knight answers only its knight in the conversation that made it, and the owners.
+ */
+export const answersTo = (
+	target: Pick<Agent, "parent" | "origin">,
+	sender: string,
+	from: string,
+	speaker: { tier: string },
+): boolean =>
+	target.parent === undefined ||
+	speaker.tier === "owner" ||
+	(sender === target.parent && target.origin === from);
+
+/**
+ * The surface a temp knight was made on, such as "discord" or the web app's, read off its origin;
+ * undefined for a permanent knight and for a temp knight made before the origin was kept. A temp
+ * knight lives on that surface; its place on another is made only when someone uses it there.
+ */
+export const helperSurface = (
+	agent: Pick<Agent, "parent" | "origin"> | undefined,
+): string | undefined => {
+	const origin = agent?.parent === undefined ? undefined : agent.origin;
+	const colon = origin?.indexOf(":") ?? -1;
+	return origin && colon > 0 ? origin.slice(0, colon) : undefined;
+};
+
 export interface AgentGroup {
 	name: string;
 	displayName: string;

package/src/core/agents/agent-team.ts

@@ -19,6 +19,7 @@ import {
 import type { HelperTeam } from "./helper-ops.ts";
 import { type Routes, routesOf } from "./routes.ts";
 import { TeamEditing } from "./team-editing.ts";
+import type { TeamHelpers } from "./team-helpers.ts";
 import {
 	channelOwner,
 	coordinatorOf,
@@ -321,6 +322,10 @@ export class DiscordAgentTeam implements AgentOps, AgentTeam {
 		return this.#turns.message(...args);
 	}
 
+	reach(...args: Parameters<TeamHelpers["reach"]>): Promise<void> {
+		return this.#lifecycle.helpers.reach(...args);
+	}
+
 	async read(
 		channel: string,
 		around: string | undefined,

package/src/core/agents/agent-tools.ts

@@ -123,7 +123,7 @@ export interface AgentOps {
 	avatar(name: string, look: CharacterInput): Promise<string>;
 	/** Queues the message and returns at once. */
 	/**
-	 * Hands a request to another agent, in the conversation it used most recently, or in the
+	 * Hands a request to another agent, in its conversation on the sender's surface, or in the
 	 * `conversation` named: "discord", "web" (or a room surface's name), or one of its conversation keys.
 	 */
 	message(
@@ -132,6 +132,15 @@ export interface AgentOps {
 		text: string,
 		conversation?: string,
 	): string;
+	/**
+	 * Readies the place a message is about to reach: a temp knight made in the web app gets its
+	 * Discord thread when the caller may message it and names "discord". Never rejects.
+	 */
+	reach?(
+		caller: AgentTurnScope,
+		to: string,
+		conversation?: string,
+	): Promise<void>;
 	createGroup(input: {
 		name: string;
 		displayName: string;
@@ -425,24 +434,23 @@ function toolDefs(
 			name: MESSAGE_AGENT_TOOL,
 			label: "Message agent",
 			description:
-				'Send a self-contained request to another agent. It returns at once; the agent works in its own conversation and its answer comes back to you as a new turn, in the conversation you are writing from. An agent has one conversation on each surface (Discord, the web app); by default the request lands in the one it used most recently, so work it started in the web app is answered there. Give conversation to choose another: "discord", "web", or one of the conversation keys agent_get lists for it. The request shows in its conversation, and the request and the answer show as small cards in yours.',
+				'Send a self-contained request to another agent. It returns at once; the agent works in its own conversation and its answer comes back to you as a new turn, in the conversation you are writing from. An agent has one conversation on each surface (Discord, the web app); by default the request lands in its conversation on the surface you are writing from (its room from a web room, its Discord channel from Discord), so nothing crosses surfaces unless you name it. Give conversation to choose another: "discord", "web", or one of the conversation keys agent_get lists for it. The request shows in its conversation, and the request and the answer show as small cards in yours.',
 			parameters: Type.Object({
 				to: NAME,
 				text: Type.String({ minLength: 1, maxLength: 4000 }),
 				conversation: Type.Optional(
 					Type.String({
 						description:
-							'Which of the agent\'s conversations to deliver into: "discord", "web" (or the name of another surface that hosts rooms), or a key from agent_get. Leave it out to reach the one it used most recently.',
+							'Which of the agent\'s conversations to deliver into: "discord", "web" (or the name of another surface that hosts rooms), or a key from agent_get. Leave it out to reach its conversation on the surface you are writing from.',
 					}),
 				),
 			}),
-			run: (i) =>
-				ops.message(
-					scope,
-					requiredString(i, "to"),
-					requiredString(i, "text"),
-					optionalString(i, "conversation"),
-				),
+			run: async (i) => {
+				const to = requiredString(i, "to");
+				const conversation = optionalString(i, "conversation");
+				await ops.reach?.(scope, to, conversation);
+				return ops.message(scope, to, requiredString(i, "text"), conversation);
+			},
 		});
 	return defs;
 }

package/src/core/agents/message-target.ts

@@ -3,19 +3,22 @@ import { AgentError } from "../domain/errors.ts";
 import type { AgentDirectory } from "../services.ts";
 import type { Agent } from "./agent-store.ts";
 import { Routes } from "./routes.ts";
-import { agentRoomKey, discordKey, keysOf } from "./team-keys.ts";
+import { agentRoomKey, keysOf } from "./team-keys.ts";
 
 /** What the choice of a message's conversation reads. */
 export interface MessageTargetContext {
 	store: Pick<AgentDirectory, "agent" | "group">;
 	/** The surfaces that host agent rooms. */
 	roomSurfaces: readonly string[];
-	/** The conversation the target last ran a turn in, if it ran one since the host started. */
+	/**
+	 * The conversation the target last ran a turn in, if it ran one since the host started; read
+	 * only under the `"latest"` routing rule, and only on the sender's surface.
+	 */
 	latest: ChannelKey | undefined;
-	/** The conversation the sender writes from. */
+	/** The conversation the sender writes from: the origin whose surface the message stays on. */
 	from: ChannelKey;
 	/** The host's routing table; without it the defaults every host had before `routing`. */
-	routes?: Pick<Routes, "of">;
+	routes?: Pick<Routes, "of" | "placeOn">;
 }
 
 /** The word for the web app's conversation, accepted when exactly one surface hosts rooms. */
@@ -24,9 +27,8 @@ const WEB = "web";
 /**
  * The conversation of `target` that a message is delivered into. With `ask` (a surface name such
  * as "discord", "web", or the surface of a room, or one of the target's conversation keys) that
- * one; otherwise the conversation the routing table picks (`Routes.of`): by default the one the
- * target used most recently, which a message from a room never follows out to Discord, and, when
- * it has run none yet, the sender's own surface, so a message between rooms stays among the rooms.
+ * one; otherwise the conversation the routing table picks (`Routes.of`): by default the target's
+ * place on the sender's own surface, so a message never crosses surfaces unless named.
  */
 export function messageTarget(
 	ctx: MessageTargetContext,
@@ -35,25 +37,25 @@ export function messageTarget(
 ): ChannelKey {
 	const keys = keysOf(ctx.store, target.name, ctx.roomSurfaces);
 	const has = keys.length > 0 ? keys.join(", ") : "none";
-	if (ask === undefined || ask.trim() === "") {
-		const routes =
-			ctx.routes ??
-			new Routes({
-				store: ctx.store,
-				roomSurfaces: () => ctx.roomSurfaces,
-				latest: () => ctx.latest,
-			});
+	const routes =
+		ctx.routes ??
+		new Routes({
+			store: ctx.store,
+			roomSurfaces: () => ctx.roomSurfaces,
+			latest: () => ctx.latest,
+		});
+	if (ask === undefined || ask.trim() === "")
 		return routes.of(target.name, "agentMessage", ctx.from);
-	}
 	const wanted = ask.trim();
 	const exact = keys.find((key) => key === wanted);
 	if (exact !== undefined) return exact;
 	if (wanted === "discord") {
-		if (!target.channelId)
+		const place = routes.placeOn(target.name, "discord");
+		if (!place)
 			throw new AgentError(
 				`${target.name} has no Discord channel; its conversations: ${has}.`,
 			);
-		return discordKey(target.channelId);
+		return place;
 	}
 	const surface = ctx.roomSurfaces.includes(wanted)
 		? wanted

package/src/core/agents/routes.ts

@@ -37,7 +37,7 @@ export interface RoutingTable {
 	 * has none when the agent has no place at all.
 	 */
 	of(agent: string, kind: "integration", origin: ChannelKey): ChannelKey;
-	of(agent: string, kind: "agentMessage", origin?: ChannelKey): ChannelKey;
+	of(agent: string, kind: "agentMessage", origin: ChannelKey): ChannelKey;
 	of(
 		agent: string,
 		kind: RouteKind,
@@ -154,7 +154,7 @@ export class Routes implements RoutingTable {
 	 * when an `agentMessage` finds no place; undefined when an `opening` finds none.
 	 */
 	of(name: string, kind: "integration", origin: ChannelKey): ChannelKey;
-	of(name: string, kind: "agentMessage", origin?: ChannelKey): ChannelKey;
+	of(name: string, kind: "agentMessage", origin: ChannelKey): ChannelKey;
 	of(
 		name: string,
 		kind: RouteKind,
@@ -201,39 +201,57 @@ export class Routes implements RoutingTable {
 	}
 
 	/**
-	 * The conversation a message to the agent lands in when the sender names none: with `latest`
-	 * the one it last ran a turn in, except that a message from a room never follows it out to
-	 * Discord, since the room's text may be for the owners alone; with none yet, the sender's own
-	 * surface when it hosts rooms, so a message between rooms stays among them; otherwise its
-	 * primary place.
+	 * The conversation a message to the agent lands in when the sender names none. By default
+	 * (`"origin-surface"`) its place on the sender's own surface: its Discord channel for a message
+	 * from Discord, its room for one from a room. `"latest"` is the conversation it last ran a turn
+	 * in, but only on the sender's surface. A message never crosses surfaces by recency: when the
+	 * agent has no place on the sender's surface, or no sender is known, it lands in the agent's
+	 * primary place, and a crossing is logged with both surfaces.
 	 */
 	#agentMessage(name: string, from: ChannelKey | undefined): ChannelKey {
-		const { store, roomSurfaces, latest } = this.#options;
-		const to = this.rules(name).agentMessage ?? "latest";
-		if (to !== "latest") {
+		const { latest } = this.#options;
+		const to = this.rules(name).agentMessage ?? "origin-surface";
+		if (to !== "latest" && to !== "origin-surface") {
 			const key =
 				to === "primary" ? this.primary(name) : this.placeOn(name, to);
 			if (key) return key;
 			this.#warn(
 				`message:${name}`,
 				{ agent: name, to },
-				"the agent has no place for messages to it; the conversation it last ran a turn in is used",
+				"the agent has no place for messages to it; its place on the sender's surface is used",
 			);
 		}
-		const via = from === undefined ? undefined : roomSurfaceOf(from);
-		const last = latest?.(name);
-		const keys = keysOf(store, name, roomSurfaces());
-		const outward =
-			via !== undefined &&
-			last !== undefined &&
-			roomSurfaceOf(last) === undefined;
-		if (last !== undefined && keys.includes(last) && !outward) return last;
-		if (via === undefined) {
-			const primary = this.primary(name);
-			if (!primary) throw new AgentError(`${name} has no channel yet.`);
-			return primary;
+		const surface =
+			from === undefined ? undefined : parseChannelKey(from).surface;
+		if (to === "latest" && surface !== undefined) {
+			const last = latest?.(name);
+			const keys = keysOf(
+				this.#options.store,
+				name,
+				this.#options.roomSurfaces(),
+			);
+			if (
+				last !== undefined &&
+				keys.includes(last) &&
+				parseChannelKey(last).surface === surface
+			)
+				return last;
 		}
-		return agentRoomKey(via, name);
+		const own = surface === undefined ? undefined : this.placeOn(name, surface);
+		if (own) return own;
+		const primary = this.primary(name);
+		if (!primary) throw new AgentError(`${name} has no channel yet.`);
+		if (surface !== undefined)
+			this.#warn(
+				`message-cross:${name}:${surface}`,
+				{
+					agent: name,
+					from: surface,
+					to: parseChannelKey(primary).surface,
+				},
+				"the agent has no place on the sender's surface; the message lands in its primary place",
+			);
+		return primary;
 	}
 
 	/**

package/src/core/agents/team-editing.ts

@@ -220,9 +220,9 @@ export class TeamEditing {
 			creator: Agent | undefined;
 			/** The surface whose room runs the opening task. */
 			openIn?: string | undefined;
-			/** Makes the agent a temp knight of this knight: its place is a thread of the parent's channel, and it settles on the parent's model. */
+			/** Makes the agent a temp knight of this knight, which settles on the parent's model. */
 			parent?: Agent | undefined;
-			/** The conversation a temp knight is made from. */
+			/** The conversation a temp knight is made from: made on Discord, it lives in a thread of the parent's channel, made elsewhere in its rooms alone. */
 			origin?: string | undefined;
 		},
 		input: {
@@ -279,10 +279,10 @@ export class TeamEditing {
 		const suggested = suggestCharacter(input, taken);
 		const character = this.#resolve(wanted ?? {}, suggested);
 		const avatarHash = await studio.render(character);
-		// Without Discord channels the agent lives in its rooms, which exist as soon as it does. A
-		// temp knight lives in a thread of its parent's channel, or in rooms alone without one.
+		// Without Discord channels the agent lives in its rooms, which exist as soon as it does.
+		const onDiscord = who.origin?.startsWith("discord:") !== false;
 		const channelId = who.parent
-			? who.parent.channelId && channels?.createThread
+			? onDiscord && who.parent.channelId && channels?.createThread
 				? await channels.createThread(who.parent.channelId, input.displayName)
 				: undefined
 			: await channels?.createChannel(

package/src/core/agents/team-helpers.ts

@@ -1,7 +1,8 @@
 import { helpersOf } from "../config/helpers.ts";
 import { AgentError } from "../domain/errors.ts";
 import type { AgentTurnScope } from "../domain/ports.ts";
-import { isHelper } from "./agent-rules.ts";
+import { surfaceOf } from "../presence/delivery-router.ts";
+import { answersTo, helperSurface, isHelper } from "./agent-rules.ts";
 import type { Agent } from "./agent-store.ts";
 import type { HelpersEnded } from "./helper-ops.ts";
 import type { TeamContext } from "./team-options.ts";
@@ -11,8 +12,9 @@ const SWEEP_EVERY_MS = 3_600_000;
 
 /**
  * The team's temp knights after they are made: which a knight has, which are finished, and their
- * archive, restore, and sweep. Archiving one closes its Discord thread, since a temp knight's
- * place is a thread of its parent's channel; an archived one keeps its history.
+ * archive, restore, and sweep. A temp knight made on Discord lives in a thread of its parent's
+ * channel; one made in the web app gets that thread only once someone reaches for it on Discord.
+ * Archiving one closes its thread, when it has one; an archived one keeps its history.
  */
 export class TeamHelpers {
 	readonly #ctx: TeamContext;
@@ -20,6 +22,8 @@ export class TeamHelpers {
 	readonly #archiveAgent: (agent: Agent) => Promise<void>;
 	readonly #ended: ((event: HelpersEnded) => void)[] = [];
 	#sweeper: ReturnType<typeof setInterval> | undefined;
+	/** The threads being made for web-born temp knights, by name, so two reaches make one. */
+	readonly #placing = new Map<string, Promise<void>>();
 
 	constructor(ctx: TeamContext, archiveAgent: (agent: Agent) => Promise<void>) {
 		this.#ctx = ctx;
@@ -125,9 +129,74 @@ export class TeamHelpers {
 		return restored;
 	}
 
+	/**
+	 * A `message_agent` call that names "discord", or names nothing from a Discord conversation, gives
+	 * a web-born temp knight its thread first.
+	 */
+	async reach(
+		caller: AgentTurnScope,
+		to: string,
+		conversation?: string,
+	): Promise<void> {
+		const { store } = this.#ctx.options;
+		const { turns } = this.#ctx;
+		const target = store.agent(to);
+		const speaker = turns.speakerOf(caller);
+		const from = turns.turnChannel(caller);
+		// Unnamed, a message stays on the sender's surface, so one sent from Discord goes there too.
+		const wanted = conversation?.trim() || surfaceOf(from);
+		if (wanted !== "discord" || !target || !speaker) return;
+		if (answersTo(target, caller.name, from, speaker))
+			await this.placeOnDiscord(to);
+	}
+
+	/**
+	 * Gives an active temp knight made in the web app its thread under the parent's channel, the
+	 * first time someone reaches for it on Discord. One made on Discord, or before the origin was
+	 * kept, already has its place, and a host without Discord threads makes none; never rejects.
+	 */
+	placeOnDiscord(name: string): Promise<void> {
+		const pending = this.#placing.get(name);
+		if (pending) return pending;
+		const placing = this.#placeOnDiscord(name).finally(() =>
+			this.#placing.delete(name),
+		);
+		this.#placing.set(name, placing);
+		return placing;
+	}
+
+	async #placeOnDiscord(name: string): Promise<void> {
+		const { store, channels, logger } = this.#ctx.options;
+		const agent = store.agent(name);
+		const surface = helperSurface(agent);
+		if (agent?.status !== "active" || agent.channelId) return;
+		if (surface === undefined || surface === "discord") return;
+		const parent = store.agent(agent.parent as string);
+		if (!parent?.channelId || !channels?.createThread) return;
+		try {
+			const channelId = await channels.createThread(
+				parent.channelId,
+				agent.displayName,
+			);
+			await store.updateAgent(name, { channelId });
+		} catch (error) {
+			logger.warn(
+				{ agent: name, err: error },
+				"temp knight's thread not made; it stays in its rooms",
+			);
+			return;
+		}
+		logger.info(
+			{ agent: name, parent: parent.name },
+			"temp knight's thread made",
+		);
+		this.#ctx.changed();
+	}
+
 	/**
 	 * Restores one archived temp knight: its thread opens again, or a new one is made when the old
-	 * is gone. It comes back finished, with nothing running.
+	 * is gone. One made in the web app never gets a new thread: its old one reopens, if it had one
+	 * that is still there. It comes back finished, with nothing running.
 	 */
 	async restoreOne(agent: Agent): Promise<void> {
 		const { store, channels, logger } = this.#ctx.options;
@@ -137,6 +206,8 @@ export class TeamHelpers {
 				`"${agent.name}" belongs to "${agent.parent}", which is archived; restore it first.`,
 			);
 		let { channelId } = agent;
+		const surface = helperSurface(agent);
+		const bornOnDiscord = surface === undefined || surface === "discord";
 		if (channels?.createThread && parent.channelId) {
 			if (
 				channelId &&
@@ -144,7 +215,7 @@ export class TeamHelpers {
 				(await channels.exists(channelId))
 			)
 				await channels.openThread(channelId);
-			else
+			else if (bornOnDiscord)
 				channelId = await channels.createThread(
 					parent.channelId,
 					agent.displayName,

package/src/core/agents/team-keys.ts

@@ -87,6 +87,20 @@ export const roomSurfaceOf = (room: ChannelKey): string | undefined => {
 	return surface === DISCORD_SURFACE ? undefined : surface;
 };
 
+/**
+ * The channel a group seat runs in outside a running turn: the group's room on the surface of the
+ * seat's home for a room seat, so it never falls out to the group's Discord channel; otherwise the
+ * group's Discord channel, or the seat's home.
+ */
+export function groupSeatChannel(
+	group: Pick<AgentGroup, "name" | "channelId">,
+	scope: Pick<AgentTurnScope, "home">,
+): ChannelKey {
+	const surface = roomSurfaceOf(scope.home);
+	if (surface !== undefined) return groupRoomKey(surface, group.name);
+	return group.channelId ? discordKey(group.channelId) : scope.home;
+}
+
 /**
  * An agent's conversation inside a group, apart from its own. In a Discord group channel, or
  * without a room, it is keyed by the channel; in a room of another surface, by the surface and the

package/src/core/agents/team-turns.ts

@@ -31,6 +31,7 @@ import {
 	coordinatorOf,
 	discordIdOf,
 	discordKey,
+	groupSeatChannel,
 	scopeOf,
 } from "./team-keys.ts";
 import {
@@ -429,10 +430,7 @@ export class TeamTurns {
 			: undefined;
 		if (!group) return scope.home;
 		// A seat of a room's group runs in that room; its running turn knows which.
-		return (
-			this.#posting.get(scope.session) ??
-			(group.channelId ? discordKey(group.channelId) : scope.home)
-		);
+		return this.#posting.get(scope.session) ?? groupSeatChannel(group, scope);
 	}
 
 	/**

package/src/core/builtin/modules.ts

@@ -31,6 +31,7 @@ import { Scheduler } from "../modules/schedules/scheduler.ts";
 import { schedulesExtension } from "../modules/schedules/schedules.ts";
 import type { ErrorReporter } from "../ops/error-reporter.ts";
 import type { RoundtablePlugin } from "../plugin.ts";
+import { runChannelFor } from "../presence/delivery-router.ts";
 import { splitReply } from "../presentation/reply-splitter.ts";
 import {
 	AGENTS,
@@ -130,23 +131,22 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 				services.get(AGENTS).team.roomsOf(agent);
 			// A conversation no chat surface carries keeps its runs in the creator's direct messages, where
 			// a claim must take them; anyone's elsewhere would run in a conversation that is not theirs.
-			const channelFor = async (
+			// The delivery router picks those messages with the conversation as the origin.
+			const channelFor = (
 				channel: ChannelKey,
 				principalId: string,
 				refused: (message: string) => Error,
-			) => {
-				if (surfaces.of(channel)) return channel;
-				const reached = await directChannels.reach(principalId);
-				if (!reached)
-					throw refused(
-						"this conversation has no chat surface to post a run in, and you have no direct channel on this host to post it in instead",
-					);
-				if (!conversations.takesBackground(reached.channel))
-					throw refused(
-						`this conversation has no chat surface to post a run in, and nothing here takes background turns in your ${reached.provider.name} direct messages, where it would go instead`,
-					);
-				return reached.channel;
-			};
+			) =>
+				runChannelFor(
+					{
+						surfaces,
+						directChannels,
+						takesBackground: (key) => conversations.takesBackground(key),
+					},
+					channel,
+					principalId,
+					refused,
+				);
 			const scheduleChannelFor = (channel: ChannelKey, principalId: string) =>
 				channelFor(channel, principalId, (m) => new ScheduleError(m));
 			const delegateChannelFor = (channel: ChannelKey, principalId: string) =>
@@ -198,7 +198,7 @@ export function modulesPlugin(options: ModulesOptions): RoundtablePlugin {
 					// Only whether a direct channel knows them, without the network; the conversation there,
 					// and whether a claim takes its turns, are checked when a tool runs.
 					try {
-						if (!(await directChannels.known(own))) return;
+						if (!(await directChannels.known(home, own))) return;
 					} catch (error) {
 						logger.warn(
 							{ channel: home, err: error },

package/src/core/config/routing.ts

@@ -31,11 +31,12 @@ export interface AgentRoutes {
 	 */
 	integration?: "origin" | "primary" | (string & {});
 	/**
-	 * The conversation a `message_agent` call reaches when it names none. `"latest"` (default) is
-	 * the one the agent last ran a turn in, never carrying a message from a room out to Discord;
+	 * The conversation a `message_agent` call reaches when it names none. `"origin-surface"`
+	 * (default) is the agent's place on the sender's surface, else its primary place; `"latest"` the
+	 * one the agent last ran a turn in on the sender's surface, else as `"origin-surface"`;
 	 * `"primary"` the agent's primary place; a surface name the agent's place there.
 	 */
-	agentMessage?: "latest" | "primary" | (string & {});
+	agentMessage?: "origin-surface" | "latest" | "primary" | (string & {});
 	/**
 	 * Where an agent's opening task (`agent_create task`) runs. `"origin-surface"` (default) is the
 	 * agent's place on the surface the creation came from, else its primary place; `"primary"`
@@ -86,7 +87,7 @@ const DECLARED_PLACES: readonly string[] = ["ops"];
 export const ROUTE_WORDS = {
 	primary: ["auto"],
 	integration: ["origin", "primary"],
-	agentMessage: ["latest", "primary"],
+	agentMessage: ["origin-surface", "latest", "primary"],
 	opening: ["origin-surface", "primary"],
 } as const;
 

package/src/core/discord/direct-channel.ts

@@ -36,6 +36,7 @@ export function discordDirectChannel(
 	};
 	return {
 		name: "discord",
+		surface: "discord",
 		label: "a direct message on Discord",
 		knows: async (principalId) => (await userOf(principalId)) !== undefined,
 		reaches: async (principalId) => {

package/src/core/modules/notify/notify.ts

@@ -19,7 +19,8 @@ export interface SessionNotify {
 
 /**
  * Registers notify for one session: it sends a notice to the person the conversation serves,
- * through the first direct channel that reaches them, and refuses when none does. Its 0.8 name,
+ * through the direct channel on the conversation's own surface (another only when that one cannot
+ * reach them), and refuses when none does. Its 0.8 name,
  * `notify_owner`, still names it in a selection and in `toolTiers` until 1.0 (`RENAMED_TOOLS`).
  */
 export function notifyExtension(
@@ -37,7 +38,7 @@ export function notifyExtension(
 		return {
 			name: "notify",
 			label: "Notify",
-			description: `Send ${o.name} ${notify.channels}. Use only when ${o.he} asks to be notified or reminded by DM; your normal reply already reaches ${o.him}.`,
+			description: `Send ${o.name} ${notify.channels}. It goes out on this conversation's own surface. Use only when ${o.he} asks to be notified or reminded; your normal reply already reaches ${o.him}.`,
 			parameters: Type.Object({
 				text: Type.String({ description: "The message to send." }),
 			}),

package/src/core/modules/notify/session-notify.ts

@@ -1,7 +1,9 @@
 import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
+import type { ChannelKey } from "../../domain/conversation.ts";
 import { SYSTEM_PRINCIPAL } from "../../identity/principal-store.ts";
 import type { OwnerIdentity } from "../../identity.ts";
 import type { Logger } from "../../log.ts";
+import { providerSurface, surfaceOf } from "../../presence/delivery-router.ts";
 import type {
 	DirectChannelProvider,
 	DirectChannels,
@@ -26,10 +28,21 @@ function labels(providers: readonly DirectChannelProvider[]): string {
 	return providers.map((provider) => provider.label).join(" or ");
 }
 
+/** The providers on the conversation's own surface, or every one when none is on it. */
+function ownSurface(
+	providers: readonly DirectChannelProvider[],
+	home: ChannelKey,
+): readonly DirectChannelProvider[] {
+	const surface = surfaceOf(home);
+	const own = providers.filter((p) => providerSurface(p) === surface);
+	return own.length > 0 ? own : providers;
+}
+
 /**
  * The notify tool of each session: none on a host without direct channels, and none in a private
  * conversation whose person no direct channel reaches. A notice goes to the conversation's
- * person in a private one, and to the turn's speaker in a shared one.
+ * person in a private one, and to the turn's speaker in a shared one, on the conversation's own
+ * surface: the delivery router tries another only when that one cannot reach them.
  */
 export function sessionNotify(
 	deps: SessionNotifyDeps,
@@ -70,15 +83,16 @@ export function sessionNotify(
 		const providers = directChannels.providers();
 		if (providers.length === 0) return null;
 		const { conversation } = session;
+		const origin = session.homeChannel;
 		const own =
 			conversation.visibility === "private"
 				? conversation.principalId
 				: undefined;
 		return async (pi) => {
-			let reaching = providers;
+			let reaching = ownSurface(providers, origin);
 			if (own !== undefined) {
 				try {
-					const known = await directChannels.known(own);
+					const known = await directChannels.known(origin, own);
 					if (!known) return;
 					reaching = [known];
 				} catch (error) {
@@ -98,7 +112,10 @@ export function sessionNotify(
 					: session.addressee;
 			await notifyExtension(
 				{
-					notifier: directChannels,
+					notifier: {
+						notify: (principalId, text) =>
+							directChannels.notify(origin, principalId, text),
+					},
 					recipient: async () => recipientOf(session, own),
 					channels: labels(reaching),
 				},

package/src/core/modules/skills/skill-contract.ts

@@ -4,6 +4,7 @@ import type {
 	SkillSet,
 	SkillVersion,
 } from "./skill-rules.ts";
+import type { SkillGroup } from "./skill-store.ts";
 
 /** The skills agents carry: built in, linked from repositories, or written by an agent. */
 export interface SkillRegistry {
@@ -45,6 +46,16 @@ export interface SkillRegistry {
 	delete(name: string): Promise<string>;
 	/** The saved versions of an agent-written skill, newest first; none for any other skill. */
 	documentHistory(name: string): Promise<SkillVersion[]>;
+	/** Every skill group, by name: a named list of skills to filter by or apply to an agent once; an agent carries skills, not groups. */
+	groups(): SkillGroup[];
+	/** Creates or replaces a group; returns what it did. Throws AgentError for a refused name, an empty description or an unknown skill. */
+	setGroup(
+		name: string,
+		description: string,
+		skills: readonly string[],
+	): Promise<string>;
+	/** Deletes a group and leaves its skills and their carriers as they are; returns what it did. Throws AgentError for an unknown group. */
+	deleteGroup(name: string): Promise<string>;
 	/** Adds and removes an agent's registered skills together, or changes nothing; returns what it carries after. */
 	attach(
 		agent: string,

package/src/core/modules/skills/skill-registry.ts

@@ -28,7 +28,7 @@ import {
 	type SkillVersion,
 	skillFileContent,
 } from "./skill-rules.ts";
-import type { SkillEntry } from "./skill-store.ts";
+import type { SkillEntry, SkillGroup } from "./skill-store.ts";
 
 export {
 	BUILTIN_SKILLS,
@@ -343,6 +343,8 @@ export class StoredSkillRegistry implements SkillRegistry {
 		return this.#removed(name, detached);
 	}
 
+	readonly groups = (): SkillGroup[] => this.#options.store.groups();
+
 	async setGroup(
 		name: string,
 		description: string,

package/src/core/modules/skills/skill-store.ts

@@ -209,10 +209,11 @@ export class SkillStore {
 		return this.#skills.get(name);
 	}
 
+	/** Copies, by name, so a caller's change reaches no stored group. */
 	groups(): SkillGroup[] {
-		return [...this.#groups.values()].sort((a, b) =>
-			a.name.localeCompare(b.name),
-		);
+		return [...this.#groups.values()]
+			.map((group) => ({ ...group, skills: [...group.skills] }))
+			.sort((a, b) => a.name.localeCompare(b.name));
 	}
 
 	group(name: string): SkillGroup | undefined {

package/src/core/presence/delivery-router.ts

@@ -0,0 +1,165 @@
+import type { SurfacePort } from "../contract/surface.ts";
+import { parseChannelKey } from "../contract/surface.ts";
+import type { ChannelKey } from "../domain/conversation.ts";
+import type { Logger } from "../log.ts";
+import { splitReply } from "../presentation/reply-splitter.ts";
+import type {
+	DirectChannelProvider,
+	DirectChannels,
+	DirectReach,
+} from "./direct-channels.ts";
+
+/**
+ * The conversation a piece of work came from: a turn's channel, a schedule's, a job's. Its surface
+ * is the key's prefix, and everything the work sends goes there, or to the same person on that
+ * surface, before any other.
+ */
+export type Origin = ChannelKey;
+
+/** The surface an origin is on: the prefix of its key, such as `discord` or `app`. */
+export function surfaceOf(origin: Origin): string {
+	return parseChannelKey(origin).surface;
+}
+
+/** The surface whose conversations a provider reaches: its `surface`, else its name. */
+export function providerSurface(provider: DirectChannelProvider): string {
+	return provider.surface ?? provider.name;
+}
+
+/**
+ * The one place that decides where a notice or run for a person goes, from the origin of the work.
+ * A provider on the origin's surface is tried first; another surface is tried only when none there
+ * reaches the person, and that fallback is logged with both surfaces. Mirroring is the provider's
+ * own: after a delivery, each other provider that declares `mirror` echoes the notice to the same
+ * person. Nothing here picks the "first" provider or the "most recent" conversation.
+ */
+export interface DeliveryRouter {
+	/** The providers in the order an origin tries them: its own surface's, then the rest. */
+	order(origin: Origin): readonly DirectChannelProvider[];
+	/** The person's own conversation for work from `origin`; undefined when no provider reaches them. */
+	reach(origin: Origin, principalId: string): Promise<DirectReach | undefined>;
+	/** The provider that knows the person for `origin`, without the network where it can tell. */
+	known(
+		origin: Origin,
+		principalId: string,
+	): Promise<DirectChannelProvider | undefined>;
+	/** Sends the person `text` for work from `origin`; false when no provider reaches them. */
+	notify(origin: Origin, principalId: string, text: string): Promise<boolean>;
+}
+
+export function deliveryRouter(
+	providers: () => readonly DirectChannelProvider[],
+	surfaces: Pick<SurfacePort, "sendReply">,
+	logger?: Pick<Logger, "warn">,
+): DeliveryRouter {
+	const order = (origin: Origin): readonly DirectChannelProvider[] => {
+		const surface = surfaceOf(origin);
+		const all = providers();
+		return [
+			...all.filter((p) => providerSurface(p) === surface),
+			...all.filter((p) => providerSurface(p) !== surface),
+		];
+	};
+	const fellBack = (
+		origin: Origin,
+		provider: DirectChannelProvider,
+		principalId: string,
+	): void => {
+		const from = surfaceOf(origin);
+		const to = providerSurface(provider);
+		if (from !== to)
+			logger?.warn(
+				{ origin, from, to, principalId, provider: provider.name },
+				"the origin's surface cannot reach the person; delivered on another surface",
+			);
+	};
+	const reach = async (
+		origin: Origin,
+		principalId: string,
+	): Promise<DirectReach | undefined> => {
+		for (const provider of order(origin)) {
+			const channel = await provider.reaches(principalId);
+			if (channel === undefined) continue;
+			fellBack(origin, provider, principalId);
+			return { provider, channel };
+		}
+		return undefined;
+	};
+	const mirrored = async (
+		delivered: DirectChannelProvider,
+		principalId: string,
+		text: string,
+	): Promise<void> => {
+		await Promise.all(
+			providers()
+				.filter((provider) => provider !== delivered && provider.mirror)
+				.map(async (provider) => {
+					try {
+						await provider.mirror?.(principalId, text);
+					} catch (error) {
+						logger?.warn(
+							{ err: error, provider: provider.name },
+							"a direct channel did not mirror a notice",
+						);
+					}
+				}),
+		);
+	};
+	return {
+		order,
+		reach,
+		known: async (origin, principalId) => {
+			for (const provider of order(origin)) {
+				const knows = provider.knows
+					? await provider.knows(principalId)
+					: (await provider.reaches(principalId)) !== undefined;
+				if (knows) return provider;
+			}
+			return undefined;
+		},
+		notify: async (origin, principalId, text) => {
+			const reached = await reach(origin, principalId);
+			if (!reached) return false;
+			if (reached.provider.deliver)
+				await reached.provider.deliver(principalId, text);
+			else
+				await surfaces.sendReply(reached.channel, {
+					chunks: splitReply(text),
+				});
+			await mirrored(reached.provider, principalId, text);
+			return true;
+		},
+	};
+}
+
+/** What `runChannelFor` reads: the surfaces, the direct channels, and which claims take background turns. */
+export interface RunChannelDeps {
+	surfaces: Pick<SurfacePort, "of">;
+	directChannels: Pick<DirectChannels, "reach">;
+	takesBackground(channel: ChannelKey): boolean;
+}
+
+/**
+ * The conversation a schedule's runs or a delegated job's report post in, for work created in
+ * `origin`: the origin itself when a chat surface carries it; otherwise the creator's own
+ * conversation the router reaches from that origin, which a claim must take background turns in.
+ * Throws `refused` with why there is none.
+ */
+export async function runChannelFor(
+	deps: RunChannelDeps,
+	origin: Origin,
+	principalId: string,
+	refused: (message: string) => Error,
+): Promise<ChannelKey> {
+	if (deps.surfaces.of(origin)) return origin;
+	const reached = await deps.directChannels.reach(origin, principalId);
+	if (!reached)
+		throw refused(
+			"this conversation has no chat surface to post a run in, and you have no direct channel on this host to post it in instead",
+		);
+	if (!deps.takesBackground(reached.channel))
+		throw refused(
+			`this conversation has no chat surface to post a run in, and nothing here takes background turns in your ${reached.provider.name} direct messages, where it would go instead`,
+		);
+	return reached.channel;
+}

package/src/core/presence/direct-channels.ts

@@ -1,13 +1,13 @@
 import type { SurfacePort } from "../contract/surface.ts";
 import type { ChannelKey } from "../domain/conversation.ts";
-import type { Notifier } from "../domain/ports.ts";
 import type { Logger } from "../log.ts";
-import { splitReply } from "../presentation/reply-splitter.ts";
+import { deliveryRouter } from "./delivery-router.ts";
 
 /**
  * A way to reach a person on their own, such as a chat network's direct messages or a web inbox.
- * A plugin contributes it as `directChannels`; the host reaches a person through the first one,
- * in contribution order, that reaches them.
+ * A plugin contributes it as `directChannels`; the host reaches a person for a piece of work
+ * through a provider on the surface the work came from, and through another only when none there
+ * reaches them (`DeliveryRouter`).
  */
 export interface DirectChannelProvider {
 	/** Unique across every plugin, such as `"discord"`. */
@@ -17,6 +17,12 @@ export interface DirectChannelProvider {
 	 * `"a direct message on Discord"`.
 	 */
 	label: string;
+	/**
+	 * The surface whose conversations it reaches, the key prefix of the channels `reaches` names,
+	 * such as `"discord"` or the web app's `"app"`; work from a conversation on that surface reaches
+	 * the person here first. Without it, its `name`.
+	 */
+	surface?: string;
 	/**
 	 * The person's own conversation here, where a notice to them is posted and where their
 	 * schedules and delegated reports from a conversation no chat surface carries run; undefined
@@ -38,8 +44,8 @@ export interface DirectChannelProvider {
 	/**
 	 * Called with the notice after another provider delivered it, so this one can echo it, such as
 	 * a web app pushing a prompt to a phone that Discord's direct message already reached. It runs
-	 * only after a delivery, on every provider but the one that delivered; its failure is logged
-	 * and never changes what `notify` returns.
+	 * only after a delivery, on every provider but the one that delivered, and only ever to the same
+	 * person; its failure is logged and never changes what `notify` returns.
 	 */
 	mirror?(principalId: string, text: string): Promise<void>;
 }
@@ -51,24 +57,36 @@ export interface DirectReach {
 }
 
 /**
- * Every plugin's direct channels, as plugins and the core use them. Each call before the host
- * links its plugins throws NotLinkedError, as for `conversations`.
+ * Every plugin's direct channels, as plugins and the core use them. Each lookup takes the origin of
+ * the work, the conversation it came from, and goes through the delivery router: a provider on the
+ * origin's surface first, another surface only when none there reaches the person. Each call before
+ * the host links its plugins throws NotLinkedError, as for `conversations`.
  */
-export interface DirectChannels extends Notifier {
+export interface DirectChannels {
 	/** Every contributed provider, in contribution order; empty when no plugin contributes one. */
 	providers(): readonly DirectChannelProvider[];
-	/** The person's own conversation on the first provider that reaches them; undefined when none does. */
-	reach(principalId: string): Promise<DirectReach | undefined>;
+	/** The person's own conversation for work from `origin`; undefined when no provider reaches them. */
+	reach(
+		origin: ChannelKey,
+		principalId: string,
+	): Promise<DirectReach | undefined>;
 	/**
-	 * The first provider that knows the person, as `DirectChannelProvider.knows` tells without the
-	 * network (or `reaches`, for a provider without it); undefined when none does.
+	 * The provider that knows the person for work from `origin`, as `DirectChannelProvider.knows`
+	 * tells without the network (or `reaches`, for a provider without it); undefined when none does.
 	 */
-	known(principalId: string): Promise<DirectChannelProvider | undefined>;
+	known(
+		origin: ChannelKey,
+		principalId: string,
+	): Promise<DirectChannelProvider | undefined>;
 	/**
-	 * Sends the person `text` through the first provider that reaches them; false when none does.
-	 * A provider's failure, such as a network error, rejects.
+	 * Sends the person `text` for work from `origin`, on its surface when a provider there reaches
+	 * them; false when none anywhere does. A provider's failure, such as a network error, rejects.
 	 */
-	notify(principalId: string, text: string): Promise<boolean>;
+	notify(
+		origin: ChannelKey,
+		principalId: string,
+		text: string,
+	): Promise<boolean>;
 }
 
 /** The direct channels over the providers the host linked, posting through its surfaces where a provider does not deliver itself. */
@@ -77,58 +95,11 @@ export function directChannelsPort(
 	surfaces: Pick<SurfacePort, "sendReply">,
 	logger?: Pick<Logger, "warn">,
 ): DirectChannels {
-	const reach = async (
-		principalId: string,
-	): Promise<DirectReach | undefined> => {
-		for (const provider of providers()) {
-			const channel = await provider.reaches(principalId);
-			if (channel !== undefined) return { provider, channel };
-		}
-		return undefined;
-	};
-	const mirrored = async (
-		delivered: DirectChannelProvider,
-		principalId: string,
-		text: string,
-	): Promise<void> => {
-		await Promise.all(
-			providers()
-				.filter((provider) => provider !== delivered && provider.mirror)
-				.map(async (provider) => {
-					try {
-						await provider.mirror?.(principalId, text);
-					} catch (error) {
-						logger?.warn(
-							{ err: error, provider: provider.name },
-							"a direct channel did not mirror a notice",
-						);
-					}
-				}),
-		);
-	};
+	const router = deliveryRouter(providers, surfaces, logger);
 	return {
 		providers: () => providers(),
-		reach,
-		known: async (principalId) => {
-			for (const provider of providers()) {
-				const knows = provider.knows
-					? await provider.knows(principalId)
-					: (await provider.reaches(principalId)) !== undefined;
-				if (knows) return provider;
-			}
-			return undefined;
-		},
-		notify: async (principalId, text) => {
-			const reached = await reach(principalId);
-			if (!reached) return false;
-			if (reached.provider.deliver)
-				await reached.provider.deliver(principalId, text);
-			else
-				await surfaces.sendReply(reached.channel, {
-					chunks: splitReply(text),
-				});
-			await mirrored(reached.provider, principalId, text);
-			return true;
-		},
+		reach: router.reach,
+		known: router.known,
+		notify: router.notify,
 	};
 }

package/src/index.ts

@@ -4,7 +4,11 @@ export {
 	AGENT_SERVER_PRIORITY,
 	OWNER_TARGET,
 } from "./core/agents/agent-claim.ts";
-export { characterOf, isHelper } from "./core/agents/agent-rules.ts";
+export {
+	characterOf,
+	helperSurface,
+	isHelper,
+} from "./core/agents/agent-rules.ts";
 export type {
 	Agent,
 	AgentGroup,
@@ -333,6 +337,7 @@ export type {
 	SkillVersion,
 } from "./core/modules/skills/skill-rules.ts";
 export { SkillConflictError } from "./core/modules/skills/skill-rules.ts";
+export type { SkillGroup } from "./core/modules/skills/skill-store.ts";
 export type {
 	ActionEvent,
 	AgentTools,