pi-roundtable 0.21.0 → 0.22.0

package/CHANGELOG.md

@@ -5,6 +5,14 @@ The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.22.0] - 2026-10-21
+
+### Added
+
+- Worker sessions for plugins (`pi-roundtable`). A new built-in plugin, `worker-sessions` (after `modules`), provides `WORKER_SESSIONS`, a `WorkerSessions`: `run(request)` runs a `WorkerSessionRequest` (`task`, `signal`, `prompt`, `extensions`, `toolNames`, and optionally `model`, `thinking` and `aborted`) in a fresh, unsaved Pi session on the host's model login and resolves to the worker's final answer, rejecting with an `AgentRunError` when it ends without one and with the signal's reason when it is aborted; the session is disposed either way. The session has no built-in tool, skill, context file, memory or agent tool, and only the tools its `extensions` register and `toolNames` names are active, even if an extension activates another. `model` and `thinking` default to the host's `delegation` settings, shown as `WorkerSessions.delegation`. The delegation worker for web research now runs on the same code. It is a separate plugin, not part of `modules`, so a host that replaces `BACKGROUND_TURNS` and `DELEGATION` still replaces that plugin whole. The built-in plugin names gain `worker-sessions`, so a plugin of that name is now refused. See [Workers of your own](docs/plugins.md#workers-of-your-own).
+- `pi-roundtable-browser`, a new official workspace package published in lockstep (not yet on npm; see `.github/PACKAGE-RELEASES.md`): `browserAgent(options)` adds the owner-tier tool `browser_task({ task, url? })`, which runs a fresh worker session that drives a real browser through a `BrowserDriver` and returns its report, attaching the screenshots it kept to the agent's reply. The default driver runs agent-browser and Chromium in a Docker container started per task and removed after it, with no network but a unix socket to a host-side proxy that refuses every destination that is not a public address. See the package README and `site/src/content/docs/plugins/browser-package.mdx`.
+- Skills from an npm package (`pi-roundtable`, `pi-roundtable-web`). `skills: { packages: ["pi-workflow-skills"] }` (the new type `SkillsConfig`) names packages the host installed; at startup the registry reads each package's `pi.skills` folders and offers every skill found as a fourth kind, `package` (`SkillSource` gains `{ kind: "package"; package }`; `SkillCatalogEntry.source` and the web console's skill list show the package). A package skill is read-only, named by its frontmatter and resolved to the installed file on every read, so upgrading the package changes the skill with no database write. Agents carry package skills and groups include them exactly like linked or written ones (`agent_skills`, `agent_create`, `skill_group_set`, `repo_task`); `skill_unlink`, `skill_update` and `skill_delete` refuse a package skill with a message saying it comes from the package, and `skill_link` and `skill_create` refuse a name a package skill holds. A package that is not installed, a package without `pi.skills`, two packages offering one name, or a package skill named like a built-in, linked or written skill stops startup with a `PluginError` naming the fix. A carried package skill that an upgrade removed is reported missing and skipped, as a vanished linked skill is.
+
 ## [0.21.0] - 2026-10-20
 
 ### Added

package/docs/plugins.md

@@ -50,6 +50,29 @@ Their exported names are grouped by area in the source, with one entry for each;
 The [changelog](../CHANGELOG.md) lists every exported name, including type-only contracts.
 Import fixtures and fake threads from `pi-roundtable/testing` for tests.
 
+#### Workers of your own
+
+A plugin that gives a model its own small set of tools, such as a worker that drives a browser, asks the host for a worker session instead of building one from Pi's parts:
+
+```ts
+const sessions = context.services.get(WORKER_SESSIONS);
+const report = await sessions.run({
+	task: "What the worker is asked to do.",
+	signal: turn.signal,
+	prompt: "You are a ... worker. Report in the task's language.",
+	extensions: [registersTheWorkersTools],
+	toolNames: ["my_tool"],
+});
+```
+
+`run` starts a fresh session that is never saved, on the host's model login (the same credentials and refreshes the agents use), with the `model` and `thinking` of the host's `delegation` settings unless the request names its own (`model` is `<provider>/<id>`; `sessions.delegation` shows the defaults).
+The session has no built-in tool, no skills, no context files, no memory and none of the agents' tools: only the tools the `extensions` register with `pi.registerTool` and `toolNames` lists are active, and an extension that activates another tool is undone.
+`prompt` is added to its system prompt, so the standing rules and any instructions the worker should follow, such as a tool's usage guide, go there.
+`run` resolves to the worker's final answer, rejects with an `AgentRunError` when it ends without one, and rejects when `signal` aborts (`aborted` is the message of that rejection, default "the worker ran out of time"); the session is disposed either way.
+The tools are the plugin's to bound: the worker has no tier, no hold and no conversation, so a tool checks what the worker asks for, limits its work, and cleans up in a `finally` around `run`.
+A file a tool produces reaches the person only through the tool that called `run`: collect it and call `turn.attachFile` after `run` returns, as the [browser package source][browser-source] does with screenshots.
+The `worker-sessions` plugin provides the service on every host.
+
 #### Helpers for a Pi session of your own
 
 Use the kit's building blocks for a plugin that runs Pi itself, such as a coding worker:
@@ -218,6 +241,7 @@ The built-in plugins provide these, from the main entry:
 | `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` |
 | `BACKGROUND_TURNS` | `BackgroundTurns` | `modules` | Turns nobody wrote: `runScheduled`, `runDelegated`, `runErrorReport` |
 | `DELEGATION` | `Delegator` | `modules` | `start(request)` a background task, `runningChannels()`, `idle()` |
+| `WORKER_SESSIONS` | `WorkerSessions` | `worker-sessions` | Fresh Pi sessions for a plugin's own workers, on the host's model login: `delegation` is the host's delegation `model` and `thinking`, and `run({ task, signal, prompt, extensions, toolNames, model?, thinking?, aborted? })` runs the task in a session that has only the tools `extensions` register and `toolNames` names (no built-in tool, skill, context file, memory or agent tool) and returns the worker's final answer; see [Workers of your own](#workers-of-your-own) |
 
 The data types the ports use (`Schedule`, `NewSchedule`, `Agent`, `AgentGroup`, `TeamStatus`, `Memory`, `SkillSet`, `DelegationJob`, and so on) are in the main entry too.
 Your plugins run after the built-ins, so they can read every key above.
@@ -366,7 +390,16 @@ You can switch them off in the configuration.
 | Discord administration | `discord-admin` | `discord: { admin: false }` | The `discord_*` tools that read and manage the server, for the owner; they check what the primary owner may do on the server, whichever owner's turn calls them | No `discord_*` tools; the channel executor that remote MCP uses is the connection's, so it stays |
 
 Switching an addon off leaves its tables and rows unchanged, ready for when you turn it on again.
-`skills` also takes the two directories (`skills: { builtinDir, reposDir }`) when it is on.
+`skills` also takes the two directories and the skill packages (`skills: { builtinDir, reposDir, packages }`) when it is on.
+
+`skills.packages` lists npm packages the host installed, for example `["pi-workflow-skills"]`.
+At startup the registry reads each package's `pi.skills` folders (Pi's package manifest) and offers every skill it finds there as a fourth kind, `package`, beside the built-in, linked and written ones.
+A package skill is named by its frontmatter and resolved to the installed file on every read, so upgrading the package changes the skill and nothing is written to the database.
+Agents carry package skills and groups include them exactly like the others: `agent_skills`, `agent_create`'s `skills` field, `skill_group_set` and `repo_task` accept their names.
+`skill_unlink`, `skill_update` and `skill_delete` refuse a package skill, naming the package, and `skill_link` and `skill_create` refuse a name a package skill already holds.
+`SkillCatalogEntry.source` is `{ kind: "package", package }` for them, and the web console's skill list shows the package.
+A package that is not installed, a package with no `pi.skills` (or none that holds a `SKILL.md`), two packages offering one name, a package skill with the name of a built-in, linked or written skill: each stops startup with a `PluginError` naming the fix.
+A carried package skill that an upgrade removed is reported missing and skipped, as a linked skill whose file vanished is.
 
 Use `find` for an optional addon service; it returns `undefined` while the addon is off.
 Use `get` if your plugin needs the addon; it fails with a message naming the switch:
@@ -3162,7 +3195,7 @@ The [pi-roundtable-mcp][mcp-package] workspace, published separately on npm, add
 The first lets the owner add MCP servers such as Notion or a calendar from Discord and gives your code the list; the second lets an agent outside Discord reach your agent.
 Install it with `bun add pi-roundtable-mcp`.
 
-Six official packages live in this repository as Bun workspaces and publish as separate npm packages, versioned in lockstep with the core.
+Seven official packages live in this repository as Bun workspaces and publish as separate npm packages, versioned in lockstep with the core.
 The [site guide source files][package-guides] describe installation, requirements, configuration, and security considerations:
 
 - [pi-roundtable-drawing][drawing-package]: [site guide source][drawing-guide] · local relationship maps, magic circles, sigils, sacred geometry, and card spreads.
@@ -3170,6 +3203,7 @@ The [site guide source files][package-guides] describe installation, requirement
 - [pi-roundtable-web][web-package]: [site guide source][web-guide] · an owner-only console for conversations, transcripts, and memory notes with live updates.
 - [pi-roundtable-sandbox][sandbox-package]: [site guide source][sandbox-guide] · sealed guest channels on native Linux Docker with a host-only credential broker and allow-listed tools.
 - [pi-roundtable-mcp][mcp-package]: [site guide source][mcp-guide] · MCP connectors through a gateway and remote MCP endpoints for agent turns and owner-granted Discord channel tools.
+- [pi-roundtable-browser][browser-package]: [site guide source][browser-guide] · `browser_task`, a worker that drives agent-browser in a Docker container with no route to the host's private networks, and a `BrowserDriver` for another browser.
 - [pi-roundtable-webchat][webchat-package]: [site guide source][webchat-guide] · a WebSocket chat for people an OpenID Connect provider signs in, with private conversations, live progress, and approval cards; see [web chat](#web-chat-pi-roundtable-webchat).
 
 [drawing-package]: https://github.com/wayne930242/pi-roundtable/blob/master/packages/drawing/README.md
@@ -3177,17 +3211,20 @@ The [site guide source files][package-guides] describe installation, requirement
 [web-package]: https://github.com/wayne930242/pi-roundtable/blob/master/packages/web/README.md
 [sandbox-package]: https://github.com/wayne930242/pi-roundtable/blob/master/packages/sandbox/README.md
 [mcp-package]: https://github.com/wayne930242/pi-roundtable/blob/master/packages/mcp/README.md
+[browser-package]: https://github.com/wayne930242/pi-roundtable/blob/master/packages/browser/README.md
 [package-guides]: https://github.com/wayne930242/pi-roundtable/tree/master/site/src/content/docs/plugins/
 [drawing-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/drawing-package.mdx
 [coding-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/coding-package.mdx
 [web-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/web-package.mdx
 [sandbox-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/sandbox-package.mdx
 [mcp-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/mcp-package.mdx
+[browser-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/browser-package.mdx
 [webchat-guide]: https://github.com/wayne930242/pi-roundtable/blob/master/site/src/content/docs/plugins/webchat-package.mdx
 [coding-source]: https://github.com/wayne930242/pi-roundtable/tree/master/packages/coding
 [sandbox-source]: https://github.com/wayne930242/pi-roundtable/tree/master/packages/sandbox
 [web-source]: https://github.com/wayne930242/pi-roundtable/tree/master/packages/web
 [drawing-source]: https://github.com/wayne930242/pi-roundtable/tree/master/packages/drawing
+[browser-source]: https://github.com/wayne930242/pi-roundtable/tree/master/packages/browser
 [mcp-source]: https://github.com/wayne930242/pi-roundtable/tree/master/packages/mcp
 [codex-images-template]: https://github.com/wayne930242/pi-roundtable/blob/master/templates/official/codex-images/plugin.ts
 [dice-template]: https://github.com/wayne930242/pi-roundtable/blob/master/templates/official/dice/plugin.ts
@@ -3455,7 +3492,7 @@ The host's `run()` handles startup:
    The runtime plugin builds the runtime later, in its own setup: from the `runtime` slot when a plugin fills it, else the Pi runtime.
 2. The database is opened and every plugin's migrations run, in plugin order.
 3. Every plugin's `setup` runs, in plugin order.
-   The order is the built-ins (`memory`, `schedule-store`, `prechecks`, `discord`, `modules`, `discord-admin`, `skills`, `conversations`, `runtime`, `agent-server`, `seeds`; an addon that is switched off is not there, and without Discord neither are `discord`, `discord-admin`, `skills`, `agent-server`, or `seeds`), then yours in the order of `plugins` in `roundtable.config.ts`, then the built-in `schedules`, so a due schedule fires only once everything it can reach is running.
+   The order is the built-ins (`memory`, `schedule-store`, `prechecks`, `discord`, `modules`, `worker-sessions`, `discord-admin`, `skills`, `conversations`, `runtime`, `agent-server`, `seeds`; an addon that is switched off is not there, and without Discord neither are `discord`, `discord-admin`, `skills`, `agent-server`, or `seeds`), then yours in the order of `plugins` in `roundtable.config.ts`, then the built-in `schedules`, so a due schedule fires only once everything it can reach is running.
 4. The contributions are linked: tool tiers, hold rules, the session plan, the channel router, and the events.
    From here `sessions()`, `conversations`, `surfaces`, `turns`, and `dashboard()` work.
 5. Every plugin's `preflight` runs, in plugin order.
@@ -3543,7 +3580,7 @@ These are the messages as the code writes them, with `<...>` where your names go
 | `no runtime provider is configured: the runtime plugin builds the Pi runtime when no plugin fills the runtime slot; read the running one from services.get(RUNTIME)` | Only a plugin that calls `providers.runtime` without `providers.filled.has("runtime")` sees it; read `services.get(RUNTIME)` instead |
 | `session tool <name> takes a core extension name. Rename it.` | Pick a name other than the core's |
 | `plugin <name>: setup failed: the database was queried during setup…` (from `Roundtable.check()`, `roundtable doctor` or `start`) | A plugin's `setup` ran a query. Take `database()` in setup and query from a service's `start` or from a handler |
-| `two plugins are named <name>.` (from `roundtable doctor`) | Rename yours; the built-in plugins are `memory`, `schedule-store`, `prechecks`, `discord`, `modules`, `discord-admin`, `skills`, `conversations`, `runtime`, `agent-server`, `seeds`, and `schedules` |
+| `two plugins are named <name>.` (from `roundtable doctor`) | Rename yours; the built-in plugins are `memory`, `schedule-store`, `prechecks`, `discord`, `modules`, `worker-sessions`, `discord-admin`, `skills`, `conversations`, `runtime`, `agent-server`, `seeds`, and `schedules` |
 | `migration <plugin>/<name> is declared twice` | A plugin declares two migrations with one name: rename one (the same name in two plugins is fine) |
 | `/<root> <name> is added twice`, `/<name> is registered twice` | Give each slash command and subcommand its own name |
 | `route <name> is registered twice`, `routes <a> and <b> overlap on listener <id>` | Give each route its own name and a path no other route can take |
@@ -3885,8 +3922,12 @@ Import from the entries listed below; source area files are internal.
 | `SessionToolSnapshot` | `pi-roundtable` | type |
 | `SkillCatalogEntry` | `pi-roundtable` | type |
 | `SkillRegistry` | `pi-roundtable` | type |
+| `WorkerSessions` | `pi-roundtable` | type |
+| `WorkerSessionRequest` | `pi-roundtable` | type |
+| `WORKER_SESSIONS` | `pi-roundtable` | value |
 | `SkillSet` | `pi-roundtable` | type |
 | `SkillSource` | `pi-roundtable` | type |
+| `SkillsConfig` | `pi-roundtable` | type |
 | `Speaker` | `pi-roundtable` | type |
 | `SpeakerMemory` | `pi-roundtable` | type |
 | `StoredAttachment` | `pi-roundtable` | type |

package/package.json

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

package/src/core/builtin/skills.ts

@@ -1,4 +1,5 @@
 import type { SQL } from "bun";
+import { discoverPackageSkills } from "../modules/skills/package-skills.ts";
 import { StoredSkillRegistry } from "../modules/skills/skill-registry.ts";
 import { SkillStore } from "../modules/skills/skill-store.ts";
 import {
@@ -19,6 +20,10 @@ export interface SkillsOptions {
 	reposDir: string;
 	writtenDir: string;
 	builtinDir: string;
+	/** npm packages whose `pi.skills` folders offer read-only skills; the host installed them. */
+	packages?: readonly string[];
+	/** Where a package is found; default the installed package's folder. */
+	packageDir?: (name: string) => string;
 }
 
 /** Admins manage skills; every speaker may look one up. */
@@ -47,11 +52,17 @@ export function skillsPlugin(
 		// The skills are read once every plugin is set up, so a plugin may still place some in setup.
 		preflight: () => registry?.init(),
 		setup: async ({ database, services, logger }) => {
+			// Read before the store opens, so a missing package stops startup at once.
+			const packageSkills = discoverPackageSkills(
+				options.packages ?? [],
+				options.packageDir,
+			);
 			const built = new StoredSkillRegistry({
 				store: await openStore(database(), options.guildId),
 				reposDir: options.reposDir,
 				writtenDir: options.writtenDir,
 				builtinDir: options.builtinDir,
+				packageSkills,
 				logger,
 			});
 			registry = built;

package/src/core/builtin/worker-sessions.ts

@@ -0,0 +1,44 @@
+import { join } from "node:path";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
+import {
+	formatModelRef,
+	type ModelRef,
+	type ThinkingLevel,
+} from "../models.ts";
+import { workerSessions } from "../modules/delegation/worker-session.ts";
+import type { RoundtablePlugin } from "../plugin.ts";
+import { WORKER_SESSIONS } from "../services.ts";
+
+export interface WorkerSessionsPluginOptions {
+	/** Shared with the rest of the host, so logins refresh in one place. */
+	modelRuntime: ModelRuntime;
+	agentDir: string;
+	dataDir: string;
+	/** The model and thinking level a worker session uses unless its request names its own. */
+	delegation: { model: ModelRef; thinking: ThinkingLevel };
+}
+
+/** Provides `WORKER_SESSIONS`: worker sessions on the host's model login, with its delegation settings as the defaults. */
+export function workerSessionsPlugin(
+	options: WorkerSessionsPluginOptions,
+): RoundtablePlugin {
+	return {
+		name: "worker-sessions",
+		provides: [WORKER_SESSIONS],
+		setup: ({ services }) => {
+			services.provide(
+				WORKER_SESSIONS,
+				workerSessions({
+					modelRuntime: options.modelRuntime,
+					agentDir: options.agentDir,
+					workDir: join(options.dataDir, "workers"),
+					delegation: {
+						model: formatModelRef(options.delegation.model),
+						thinking: options.delegation.thinking,
+					},
+				}),
+			);
+			return {};
+		},
+	};
+}

package/src/core/config/config.ts

@@ -36,11 +36,11 @@ import {
 	number,
 	oneOf,
 	optional,
-	orOff,
 	record,
 	shape,
 	text,
 } from "./schema.ts";
+import { type SkillsConfig, skillsField } from "./skills-config.ts";
 
 export type { DiscordConfig };
 
@@ -168,7 +168,7 @@ export interface RoundtableConfig {
 	 * the `skills` addon out: agents carry no skills, and no skill tools exist. Stored skills stay
 	 * in their tables. Without `discord` there are no agents, so the addon is off.
 	 */
-	skills?: false | { builtinDir?: string; reposDir?: string };
+	skills?: false | SkillsConfig;
 	/**
 	 * Whether each speaker's memory is kept and offered as tools; default true. `false` leaves the
 	 * `memory` addon out: no memory tools, no memory prompt block, and the table stays as it is.
@@ -284,9 +284,7 @@ const schema = shape({
 	avatar: optional(text),
 	workDir: optional(text),
 	scratchDir: optional(text),
-	skills: optional(
-		orOff(shape({ builtinDir: optional(text), reposDir: optional(text) })),
-	),
+	skills: optional(skillsField),
 	memory: optional(bool),
 	ops: optional(shape({ agent: optional(text), conversation: optional(text) })),
 	drainSeconds: optional(integer(1, 3_600)),
@@ -352,7 +350,7 @@ export interface ResolvedConfig {
 	workDir: string;
 	scratchDir: string;
 	/** `false` when the skills addon is off. */
-	skills: false | { builtinDir?: string; reposDir?: string };
+	skills: false | SkillsConfig;
 	memory: boolean;
 	ops?: { agent: string } | { conversation: ChannelKey };
 	drainMs: number;

package/src/core/config/skills-config.ts

@@ -0,0 +1,23 @@
+import { list, optional, orOff, shape, text } from "./schema.ts";
+
+/** The `skills` setting when the addon is on. */
+export interface SkillsConfig {
+	/** Where the registry reads the release's built-in skills. */
+	builtinDir?: string;
+	/** Where it keeps linked repositories; default `<dataDir>/repos`. */
+	reposDir?: string;
+	/**
+	 * npm packages the host installed. Every skill in their `pi.skills` folders is offered
+	 * read-only, and carried and grouped like any other. Startup fails, naming the fix, when a
+	 * package is not installed, ships no skills, or holds a skill whose name another skill has.
+	 */
+	packages?: string[];
+}
+
+export const skillsField = orOff(
+	shape({
+		builtinDir: optional(text),
+		reposDir: optional(text),
+		packages: optional(list(text)),
+	}),
+);

package/src/core/define-roundtable.ts

@@ -13,6 +13,7 @@ import {
 	precheckPlugin,
 	scheduleStorePlugin,
 } from "./builtin/stores.ts";
+import { workerSessionsPlugin } from "./builtin/worker-sessions.ts";
 import { warnDeprecations } from "./config/access.ts";
 import {
 	type ResolvedConfig,
@@ -187,6 +188,7 @@ function discordAssembly(
 						reposDir: config.skills.reposDir ?? join(config.dataDir, "repos"),
 						writtenDir: join(config.dataDir, "skills"),
 						builtinDir: config.skills.builtinDir ?? join(ASSETS, "skills"),
+						packages: config.skills.packages ?? [],
 					}),
 				]
 			: [],
@@ -321,6 +323,12 @@ export async function defineRoundtable(
 					? { errorReporter }
 					: {}),
 			}),
+			workerSessionsPlugin({
+				modelRuntime,
+				agentDir: config.agentDir,
+				dataDir: config.dataDir,
+				delegation: config.delegation,
+			}),
 			...(assembly?.admin ?? []),
 			...(assembly?.skills ?? []),
 			conversationsPlugin(),

package/src/core/modules/delegation/web-research-worker.ts

@@ -1,20 +1,12 @@
-import { mkdirSync } from "node:fs";
-import {
-	createAgentSession,
-	DefaultResourceLoader,
-	type ModelRuntime,
-	SessionManager,
-	SettingsManager,
-} from "@earendil-works/pi-coding-agent";
+import type { ModelRuntime } from "@earendil-works/pi-coding-agent";
 import { PluginError } from "../../errors.ts";
 import {
 	formatModelRef,
 	type ModelRef,
 	type ThinkingLevel,
 } from "../../models.ts";
-import { runWorkerTask } from "../../runtime/worker-task.ts";
-import { activeToolsExtension } from "../../shared/active-tools.ts";
 import { packageDir } from "../../shared/package-dir.ts";
+import { runWorkerSession } from "./worker-session.ts";
 
 const WEB_TOOLS = ["web_search", "fetch_content", "get_search_content"];
 
@@ -50,39 +42,19 @@ export class WebResearchWorker {
 	constructor(options: WebResearchWorkerOptions) {
 		this.#options = options;
 		this.#webAccessPath = webAccessDir();
-		mkdirSync(options.workDir, { recursive: true });
 	}
 
-	async run(task: string, signal: AbortSignal): Promise<string> {
+	run(task: string, signal: AbortSignal): Promise<string> {
 		const { modelRuntime, agentDir, workDir, model, thinking } = this.#options;
-		const resourceLoader = new DefaultResourceLoader({
-			cwd: workDir,
-			agentDir,
-			noExtensions: true,
-			noSkills: true,
-			noPromptTemplates: true,
-			noThemes: true,
-			noContextFiles: true,
-			additionalExtensionPaths: [this.#webAccessPath],
-			extensionFactories: [
-				{ name: "web-only", factory: activeToolsExtension(() => WEB_TOOLS) },
-			],
-			appendSystemPrompt: [WORKER_PROMPT],
-		});
-		await resourceLoader.reload();
-		const { session } = await createAgentSession({
-			cwd: workDir,
-			agentDir,
-			thinkingLevel: thinking,
-			modelRuntime,
-			resourceLoader,
-			sessionManager: SessionManager.inMemory(workDir),
-			settingsManager: SettingsManager.inMemory({}),
-			noTools: "builtin",
-		});
-		return runWorkerTask(session, {
+		return runWorkerSession({
 			modelRuntime,
+			agentDir,
+			workDir,
 			model: formatModelRef(model),
+			thinking,
+			prompt: WORKER_PROMPT,
+			extensionPaths: [this.#webAccessPath],
+			toolNames: WEB_TOOLS,
 			task,
 			signal,
 			aborted: "the worker ran out of time",

package/src/core/modules/delegation/worker-session.ts

@@ -0,0 +1,111 @@
+import { mkdirSync } from "node:fs";
+import {
+	createAgentSession,
+	DefaultResourceLoader,
+	type ExtensionFactory,
+	type ModelRuntime,
+	SessionManager,
+	SettingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { ThinkingLevel } from "../../models.ts";
+import { runWorkerTask } from "../../runtime/worker-task.ts";
+import type { WorkerSessionRequest, WorkerSessions } from "../../services.ts";
+import { activeToolsExtension } from "../../shared/active-tools.ts";
+
+export interface WorkerSessionOptions {
+	/** Shared with the rest of the host, so the Codex login refreshes in one place. */
+	modelRuntime: ModelRuntime;
+	agentDir: string;
+	workDir: string;
+	/** `<provider>/<id>`. */
+	model: string;
+	thinking: ThinkingLevel;
+	prompt: string;
+	/** Installed Pi extension packages that register tools. */
+	extensionPaths?: readonly string[];
+	/** Extensions that register tools. */
+	extensions?: readonly { name: string; factory: ExtensionFactory }[];
+	/** The only tools active in the session; no built-in tool is. */
+	toolNames: readonly string[];
+	task: string;
+	signal: AbortSignal;
+	aborted: string;
+}
+
+/**
+ * Runs one task in a fresh, unsaved session with no built-in tool, no skills, no context files and
+ * only the named tools active, and returns the worker's report.
+ */
+export async function runWorkerSession(
+	options: WorkerSessionOptions,
+): Promise<string> {
+	const { modelRuntime, agentDir, workDir, model, thinking } = options;
+	mkdirSync(workDir, { recursive: true });
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: workDir,
+		agentDir,
+		noExtensions: true,
+		noSkills: true,
+		noPromptTemplates: true,
+		noThemes: true,
+		noContextFiles: true,
+		additionalExtensionPaths: [...(options.extensionPaths ?? [])],
+		extensionFactories: [
+			...(options.extensions ?? []),
+			// Last, so it undoes any tool another extension re-activates.
+			{
+				name: "worker-tools-only",
+				factory: activeToolsExtension(() => options.toolNames),
+			},
+		],
+		appendSystemPrompt: [options.prompt],
+	});
+	await resourceLoader.reload();
+	options.signal.throwIfAborted();
+	const { session } = await createAgentSession({
+		cwd: workDir,
+		agentDir,
+		thinkingLevel: thinking,
+		modelRuntime,
+		resourceLoader,
+		sessionManager: SessionManager.inMemory(workDir),
+		settingsManager: SettingsManager.inMemory({}),
+		noTools: "builtin",
+	});
+	return runWorkerTask(session, {
+		modelRuntime,
+		model,
+		task: options.task,
+		signal: options.signal,
+		aborted: options.aborted,
+	});
+}
+
+/** The `WORKER_SESSIONS` service: worker sessions on the host's model runtime and delegation settings. */
+export function workerSessions(options: {
+	modelRuntime: ModelRuntime;
+	agentDir: string;
+	workDir: string;
+	delegation: { model: string; thinking: ThinkingLevel };
+}): WorkerSessions {
+	return {
+		delegation: options.delegation,
+		run: (request: WorkerSessionRequest) =>
+			runWorkerSession({
+				modelRuntime: options.modelRuntime,
+				agentDir: options.agentDir,
+				workDir: options.workDir,
+				model: request.model ?? options.delegation.model,
+				thinking: request.thinking ?? options.delegation.thinking,
+				prompt: request.prompt,
+				extensions: request.extensions.map((factory, index) => ({
+					name: `worker-tools-${index}`,
+					factory,
+				})),
+				toolNames: request.toolNames,
+				task: request.task,
+				signal: request.signal,
+				aborted: request.aborted ?? "the worker ran out of time",
+			}),
+	};
+}

package/src/core/modules/skills/package-skills-fixture.ts

@@ -0,0 +1,33 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { packageDir } from "../../shared/package-dir.ts";
+
+/**
+ * Installs a fake npm package under `<root>/node_modules` with the layout of `pi-workflow-skills`:
+ * `"pi": { "skills": ["./skills"] }` and one folder with a SKILL.md per skill.
+ */
+export function installPackage(
+	root: string,
+	name: string,
+	skills: Record<string, string>,
+	manifest: Record<string, unknown> = { pi: { skills: ["./skills"] } },
+): void {
+	const dir = join(root, "node_modules", name);
+	mkdirSync(dir, { recursive: true });
+	writeFileSync(
+		join(dir, "package.json"),
+		JSON.stringify({ name, version: "1.0.0", ...manifest }),
+	);
+	for (const [skill, description] of Object.entries(skills)) {
+		mkdirSync(join(dir, "skills", skill, "playbooks"), { recursive: true });
+		writeFileSync(
+			join(dir, "skills", skill, "SKILL.md"),
+			`---\nname: ${skill}\ndescription: ${description}\n---\n\n# ${skill}\n`,
+		);
+	}
+}
+
+/** Looks packages up from `<root>`, the way a host finds its own dependencies. */
+export const packageDirIn = (root: string) => (name: string) =>
+	packageDir(name, pathToFileURL(join(root, "host.js")));

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

@@ -0,0 +1,121 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative as relativePath, resolve } from "node:path";
+import { PluginError } from "../../errors.ts";
+import { packageDir } from "../../shared/package-dir.ts";
+import {
+	BUILTIN_SKILLS,
+	checkSkillName,
+	type PackageSkill,
+	readSkillFile,
+} from "./skill-rules.ts";
+
+/** The SKILL.md files under `path`: the file itself, or each skill folder found below a directory. */
+function skillFilesAt(path: string): string[] {
+	if (statSync(path).isFile()) return [path];
+	if (existsSync(join(path, "SKILL.md"))) return [join(path, "SKILL.md")];
+	return readdirSync(path, { withFileTypes: true })
+		.filter(
+			(entry) =>
+				entry.isDirectory() &&
+				!entry.name.startsWith(".") &&
+				entry.name !== "node_modules",
+		)
+		.flatMap((entry) => skillFilesAt(join(path, entry.name)));
+}
+
+/** The `pi.skills` entries of a package manifest, or undefined when it declares none. */
+function manifestSkills(manifest: unknown): string[] | undefined {
+	const skills = (manifest as { pi?: { skills?: unknown } } | null)?.pi?.skills;
+	return Array.isArray(skills) &&
+		skills.length > 0 &&
+		skills.every((entry) => typeof entry === "string")
+		? skills
+		: undefined;
+}
+
+function packageSkillsOf(
+	name: string,
+	resolveDir: (name: string) => string,
+): PackageSkill[] {
+	let dir: string;
+	try {
+		dir = resolveDir(name);
+	} catch {
+		throw new PluginError(
+			`config skills.packages: the package "${name}" is not installed. Install it next to the host, or remove it from skills.packages.`,
+		);
+	}
+	let manifest: unknown;
+	try {
+		manifest = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+	} catch (error) {
+		throw new PluginError(
+			`config skills.packages: the package "${name}" has no readable package.json (${(error as Error).message}). Reinstall it, or remove it from skills.packages.`,
+		);
+	}
+	const entries = manifestSkills(manifest);
+	if (!entries)
+		throw new PluginError(
+			`config skills.packages: the package "${name}" lists no skills in its package.json "pi.skills". Remove it from skills.packages, or use a package that ships skills.`,
+		);
+	const files = entries.flatMap((entry) => {
+		const path = resolve(dir, entry);
+		const relative = relativePath(dir, path);
+		if (relative.startsWith("..") || isAbsolute(relative))
+			throw new PluginError(
+				`config skills.packages: "${name}" lists the skills path "${entry}" outside the package. Use a package whose pi.skills stay inside it.`,
+			);
+		if (!existsSync(path))
+			throw new PluginError(
+				`config skills.packages: "${name}" lists the skills path "${entry}", which is not in the installed package. Reinstall the package, or remove it from skills.packages.`,
+			);
+		return skillFilesAt(path);
+	});
+	if (files.length === 0)
+		throw new PluginError(
+			`config skills.packages: the package "${name}" has no SKILL.md under its pi.skills. Remove it from skills.packages, or use a package that ships skills.`,
+		);
+	return files.map((file) => {
+		const read = readSkillFile(file);
+		if ("error" in read)
+			throw new PluginError(
+				`config skills.packages: the skill file ${relativePath(dir, file)} of "${name}" cannot be read (${read.error}). Reinstall the package, or remove it from skills.packages.`,
+			);
+		try {
+			checkSkillName(read.name);
+		} catch (error) {
+			throw new PluginError(
+				`config skills.packages: "${name}" holds a skill that cannot be offered. ${(error as Error).message} Use another version of the package, or remove it from skills.packages.`,
+			);
+		}
+		return { name: read.name, package: name, file };
+	});
+}
+
+/**
+ * The skills of installed npm packages, read from each package's `pi.skills` folders (Pi's
+ * manifest). Throws a PluginError naming the fix when a package is not installed or has no
+ * skills, or when two packages (or one package twice) offer the same name or a built-in name.
+ * A clash with a linked or written skill is found by the registry, which holds those.
+ */
+export function discoverPackageSkills(
+	packages: readonly string[],
+	resolveDir: (name: string) => string = packageDir,
+): PackageSkill[] {
+	const found = new Map<string, PackageSkill>();
+	for (const name of new Set(packages))
+		for (const skill of packageSkillsOf(name, resolveDir)) {
+			const earlier = found.get(skill.name);
+			if (earlier)
+				throw new PluginError(
+					`config skills.packages: the skill "${skill.name}" comes from both "${earlier.package}" and "${skill.package}". Drop one of the packages from skills.packages.`,
+				);
+			if ((BUILTIN_SKILLS as readonly string[]).includes(skill.name))
+				throw new PluginError(
+					`config skills.packages: the skill "${skill.name}" of "${skill.package}" has the name of a built-in skill. Drop the package from skills.packages.`,
+				);
+			found.set(skill.name, skill);
+		}
+	// pi-lens-ignore: no-sort-without-comparator — skill names sort by code unit, the same order on every machine
+	return [...found.values()].sort((a, b) => (a.name < b.name ? -1 : 1));
+}

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

@@ -3,6 +3,7 @@ import {
 	BUILTIN_SKILLS,
 	cut,
 	MAX_LIST_DESCRIPTION_CHARS,
+	type PackageSkill,
 	type ResolvedSkill,
 	type SkillCatalogEntry,
 	type SkillSource,
@@ -17,6 +18,7 @@ export type SkillResolver = (
 /** Every skill, built-in ones first, with what `list` shows as text (web app spec behavior 15). */
 export function skillCatalog(
 	store: SkillStore,
+	packageSkills: readonly PackageSkill[],
 	resolveOne: SkillResolver,
 ): SkillCatalogEntry[] {
 	const sources: { name: string; source: SkillSource }[] = [
@@ -24,6 +26,10 @@ export function skillCatalog(
 			name,
 			source: { kind: "builtin" } as const,
 		})),
+		...packageSkills.map((skill) => ({
+			name: skill.name,
+			source: { kind: "package", package: skill.package } as const,
+		})),
 		...store.skills().map((entry) => ({
 			name: entry.name,
 			source:
@@ -51,6 +57,7 @@ export function skillCatalog(
 /** Every skill, or those of a group or matching a query (behavior 14). */
 export function skillListText(
 	store: SkillStore,
+	packageSkills: readonly PackageSkill[],
 	resolveOne: SkillResolver,
 	filter: { group?: string; query?: string } = {},
 ): string {
@@ -72,6 +79,10 @@ export function skillListText(
 	}));
 	const entries = [
 		...builtins,
+		...packageSkills.map((skill) => ({
+			name: skill.name,
+			source: `from the package ${skill.package}`,
+		})),
 		...store.skills().map((entry) => ({
 			name: entry.name,
 			source:

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

@@ -1,6 +1,7 @@
 import { mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { AgentError } from "../../domain/errors.ts";
+import { PluginError } from "../../errors.ts";
 import type { SkillRegistry } from "../../services.ts";
 import { planLinkedSkills } from "./skill-link.ts";
 import { skillCatalog, skillListText } from "./skill-listing.ts";
@@ -9,6 +10,7 @@ import {
 	checkBody,
 	checkDescription,
 	checkSkillName,
+	type PackageSkill,
 	type ResolvedSkill,
 	readSkillFile,
 	type SkillCatalogEntry,
@@ -22,6 +24,7 @@ export {
 	BUILTIN_SKILLS,
 	checkSkillName,
 	MAX_SKILL_BODY_CHARS,
+	type PackageSkill,
 	type ResolvedSkill,
 	type SkillCatalogEntry,
 	type SkillRegistryOptions,
@@ -32,9 +35,19 @@ export {
 /** The skill registry and what each agent carries. */
 export class StoredSkillRegistry implements SkillRegistry {
 	readonly #options: SkillRegistryOptions;
+	readonly #packageSkills = new Map<string, PackageSkill>();
 
+	/** Throws a PluginError when a package skill has the name of a linked or written one. */
 	constructor(options: SkillRegistryOptions) {
 		this.#options = options;
+		for (const skill of options.packageSkills ?? []) {
+			const stored = options.store.skill(skill.name);
+			if (stored)
+				throw new PluginError(
+					`The skill "${skill.name}" of the package "${skill.package}" clashes with a ${stored.kind} skill of the same name. Drop the package from skills.packages and start, remove the ${stored.kind} skill (${stored.kind === "linked" ? "skill_unlink" : "skill_delete"}), then list the package again.`,
+				);
+			this.#packageSkills.set(skill.name, skill);
+		}
 	}
 
 	/** Writes every agent-written skill for Pi and removes folders left by deleted ones. */
@@ -105,13 +118,18 @@ export class StoredSkillRegistry implements SkillRegistry {
 
 	/** Every skill, built-in ones first, with what `list` shows as text (web app spec behavior 15). */
 	catalog(): SkillCatalogEntry[] {
-		return skillCatalog(this.#options.store, (name) => this.#resolveOne(name));
+		return skillCatalog(
+			this.#options.store,
+			[...this.#packageSkills.values()],
+			(name) => this.#resolveOne(name),
+		);
 	}
 
 	/** Every skill, or those of a group or matching a query (behavior 14). */
 	list(filter: { group?: string; query?: string } = {}): string {
 		return skillListText(
 			this.#options.store,
+			[...this.#packageSkills.values()],
 			(name) => this.#resolveOne(name),
 			filter,
 		);
@@ -119,7 +137,7 @@ export class StoredSkillRegistry implements SkillRegistry {
 
 	/** Throws when a name is not registered; built-in names are carried already. */
 	checkRegistered(names: readonly string[]): void {
-		const unknown = names.filter((name) => !this.#options.store.skill(name));
+		const unknown = names.filter((name) => !this.#registered(name));
 		if (unknown.length > 0)
 			throw new AgentError(
 				`Unknown skills: ${unknown.join(", ")}. Find names with skill_list.${unknown.some((n) => (BUILTIN_SKILLS as readonly string[]).includes(n)) ? " Built-in skills are always carried." : ""}`,
@@ -142,6 +160,7 @@ export class StoredSkillRegistry implements SkillRegistry {
 	}
 
 	async unlink(name: string): Promise<string> {
+		this.#refusePackage(name);
 		const entry = this.#entry(name);
 		if (entry.kind !== "linked")
 			throw new AgentError(
@@ -206,7 +225,7 @@ export class StoredSkillRegistry implements SkillRegistry {
 			throw new AgentError("A skill group needs a description.");
 		const unknown = skills.filter(
 			(skill) =>
-				!this.#options.store.skill(skill) &&
+				!this.#registered(skill) &&
 				!(BUILTIN_SKILLS as readonly string[]).includes(skill),
 		);
 		if (unknown.length > 0)
@@ -270,6 +289,8 @@ export class StoredSkillRegistry implements SkillRegistry {
 		const { store, reposDir, writtenDir, builtinDir } = this.#options;
 		if ((BUILTIN_SKILLS as readonly string[]).includes(name))
 			return join(builtinDir, name, "SKILL.md");
+		const fromPackage = this.#packageSkills.get(name);
+		if (fromPackage) return fromPackage.file;
 		const entry = store.skill(name);
 		if (!entry) return undefined;
 		return entry.kind === "linked"
@@ -288,7 +309,24 @@ export class StoredSkillRegistry implements SkillRegistry {
 		return entry;
 	}
 
+	#registered(name: string): boolean {
+		return (
+			this.#packageSkills.has(name) ||
+			this.#options.store.skill(name) !== undefined
+		);
+	}
+
+	/** Package skills change with their package, never here. */
+	#refusePackage(name: string): void {
+		const fromPackage = this.#packageSkills.get(name);
+		if (fromPackage)
+			throw new AgentError(
+				`${name} comes from the package ${fromPackage.package} and is read-only here. It changes when the package is upgraded.`,
+			);
+	}
+
 	#writable(name: string): Extract<SkillEntry, { kind: "written" }> {
+		this.#refusePackage(name);
 		const entry = this.#entry(name);
 		if (entry.kind !== "written")
 			throw new AgentError(
@@ -298,8 +336,14 @@ export class StoredSkillRegistry implements SkillRegistry {
 	}
 
 	#checkFreeName(name: string): void {
+		const fromPackage = this.#packageSkills.get(name);
+		if (fromPackage)
+			throw new AgentError(
+				`A skill named "${name}" already exists: it comes from the package ${fromPackage.package}.`,
+			);
 		if (
 			(BUILTIN_SKILLS as readonly string[]).includes(name) ||
+			this.#packageSkills.has(name) ||
 			this.#options.store.skill(name)
 		)
 			throw new AgentError(`A skill named "${name}" already exists.`);

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

@@ -28,7 +28,8 @@ export interface SkillSet {
 export type SkillSource =
 	| { kind: "builtin" }
 	| { kind: "linked"; repo: string; path: string }
-	| { kind: "written" };
+	| { kind: "written" }
+	| { kind: "package"; package: string };
 
 /** One skill as the web app lists it; a skill whose file cannot be read has `missing` instead. */
 export interface SkillCatalogEntry {
@@ -43,6 +44,15 @@ export interface SkillCatalogEntry {
 	carriers: string[];
 }
 
+/** A skill an installed npm package offers through its `pi.skills` folders. */
+export interface PackageSkill {
+	name: string;
+	/** The npm package that holds it. */
+	package: string;
+	/** Its SKILL.md in the installed package. */
+	file: string;
+}
+
 export interface SkillRegistryOptions {
 	store: SkillStore;
 	/** Managed repositories, as `<dir>/<owner>/<repo>`. */
@@ -51,6 +61,8 @@ export interface SkillRegistryOptions {
 	writtenDir: string;
 	/** The release's built-in skills, as `<dir>/<name>/SKILL.md`. */
 	builtinDir: string;
+	/** Skills of installed packages, as `discoverPackageSkills` found them at startup. */
+	packageSkills?: readonly PackageSkill[];
 	logger: Logger;
 }
 

package/src/core/services.ts

@@ -1,3 +1,4 @@
+import type { ExtensionFactory } from "@earendil-works/pi-coding-agent";
 import type { Agent, AgentGroup } from "./agents/agent-rules.ts";
 import type { AvatarMode } from "./agents/agent-tools.ts";
 import type { TeamStatus } from "./agents/team-status.ts";
@@ -12,7 +13,7 @@ import type { PendingConfirmation } from "./domain/conversation.ts";
 import type { HttpRoute } from "./http/listeners.ts";
 import type { IdentityLinks } from "./identity/identity-links.ts";
 import type { IdentityService } from "./identity/identity-service.ts";
-import type { ThinkingSetting } from "./models.ts";
+import type { ThinkingLevel, ThinkingSetting } from "./models.ts";
 import type {
 	DelegationJob,
 	DelegationOutcome,
@@ -91,6 +92,12 @@ export const BACKGROUND_TURNS: ServiceKey<BackgroundTurns> =
 export const DELEGATION: ServiceKey<Delegator> = serviceKey<Delegator>(
 	"roundtable.delegation",
 );
+/**
+ * Worker sessions on the host's models: a fresh, unsaved Pi session that has only the tools a
+ * plugin gives it. Provided by the `worker-sessions` plugin.
+ */
+export const WORKER_SESSIONS: ServiceKey<WorkerSessions> =
+	serviceKey<WorkerSessions>("roundtable.worker-sessions");
 /**
  * The remembered facts of each speaker. Provided by the `memory` plugin, an addon: read it with
  * `find` when your plugin works without memory, and with `get` when it cannot.
@@ -267,6 +274,42 @@ export interface Delegator {
 	idle(): Promise<void>;
 }
 
+/** One task for a worker session. */
+export interface WorkerSessionRequest {
+	/** What the worker is asked to do, as its one prompt. */
+	task: string;
+	/** Aborting it stops the worker; `run` then rejects. */
+	signal: AbortSignal;
+	/** Appended to the worker's system prompt: its role, its rules, and any instructions it should follow. */
+	prompt: string;
+	/** Extensions that register the worker's tools with `pi.registerTool`. */
+	extensions: readonly ExtensionFactory[];
+	/** The only tools active in the session. The session has no built-in tool, skill, context file or other extension. */
+	toolNames: readonly string[];
+	/** `<provider>/<id>`; default: the host's delegation model. */
+	model?: string;
+	/** Default: the host's delegation thinking level. */
+	thinking?: ThinkingLevel;
+	/** Why an aborted run stopped, as the rejection's message; default "the worker ran out of time". */
+	aborted?: string;
+}
+
+/**
+ * Runs one task in a fresh, unsaved Pi session on the host's model login and returns the worker's
+ * final answer. The session is disposed of either way. It has no access to the conversation, the
+ * owner's memory or the agents' tools: it can do only what `toolNames` lets it, and the tools a
+ * plugin registers for it are that plugin's to bound.
+ */
+export interface WorkerSessions {
+	/** The model and thinking level a request without its own uses: the host's `delegation` settings. */
+	readonly delegation: {
+		readonly model: string;
+		readonly thinking: ThinkingLevel;
+	};
+	/** Rejects with an `AgentRunError` when the worker ends without an answer. */
+	run(request: WorkerSessionRequest): Promise<string>;
+}
+
 /** Remembered facts, each speaker's own; every agent shares the memory of whoever is speaking. */
 export interface MemoryStore {
 	/** One speaker's memory; it never reads or changes another's. */

package/src/index.ts

@@ -39,6 +39,7 @@ export type {
 	RoundtableConfig,
 	TierConfig,
 } from "./core/config/config.ts";
+export type { SkillsConfig } from "./core/config/skills-config.ts";
 export type {
 	AttachmentPort,
 	AttachmentRefusalCode,
@@ -309,6 +310,8 @@ export type {
 	ScheduleStore,
 	SkillRegistry,
 	SpeakerMemory,
+	WorkerSessionRequest,
+	WorkerSessions,
 } from "./core/services.ts";
 export {
 	AGENTS,
@@ -322,6 +325,7 @@ export {
 	RUNTIME,
 	SCHEDULES,
 	SKILLS,
+	WORKER_SESSIONS,
 } from "./core/services.ts";
 export type {
 	AgentTurnScope,