@electric-ax/agents 0.4.12 → 0.4.14

package/dist/index.js

@@ -1,7 +1,7 @@
 import { mergeElectricPrincipalHeader } from "./server-headers-KD5yHFYT.js";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { MOONSHOT_API_BASE_URL, MOONSHOT_PROVIDER, appendPathToUrl, completeWithLowCostModel, createEntityRegistry, createPullWakeRunner, createRuntimeHandler, createSkillTools, createSkillsRegistry, db, detectAvailableProviders, getMoonshotApiKey, getMoonshotModels, readCodexAccessToken, registerToolProvider, unregisterToolProvider } from "@electric-ax/agents-runtime";
+import { MOONSHOT_API_BASE_URL, MOONSHOT_PROVIDER, appendPathToUrl, buildSkillSlashCommands, completeWithLowCostModel, createContextSkillLoader, createEntityRegistry, createPullWakeRunner, createRuntimeHandler, createSkillsRegistry, db, detectAvailableProviders, getMoonshotApiKey, getMoonshotModel, getMoonshotModels, readCodexAccessToken, registerToolProvider, unregisterToolProvider } from "@electric-ax/agents-runtime";
 import { braveSearchTool, braveSearchTool as braveSearchTool$1, createBashTool, createEditTool, createEventSourceTools, createFetchUrlTool, createReadFileTool, createSendTool, createWriteTool } from "@electric-ax/agents-runtime/tools";
 import { chooseDefaultSandbox, isE2BAvailable, remoteSandbox } from "@electric-ax/agents-runtime/sandbox";
 import fsSync from "node:fs";
@@ -15,6 +15,7 @@ import { load } from "sqlite-vec";
 import { nanoid } from "nanoid";
 import { getModels } from "@mariozechner/pi-ai";
 import { bridgeMcpTool, buildPromptTools, buildResourceTools, createRegistry, keychainPersistence, loadConfig, mcp, watchConfig } from "@electric-ax/agents-mcp";
+import { Agent, cacheStores, interceptors, setGlobalDispatcher } from "undici";
 
 //#region src/log.ts
 const LOG_LEVEL = process.env.ELECTRIC_AGENTS_LOG_LEVEL ?? `info`;
@@ -865,6 +866,15 @@ async function fetchAvailableModelIds(provider) {
 function knownModelsForProvider(provider) {
 	return provider === MOONSHOT_PROVIDER ? getMoonshotModels() : getModels(provider);
 }
+function resolveBuiltinModelContextWindow(modelConfig) {
+	const modelId = String(modelConfig.model);
+	if (modelConfig.provider === MOONSHOT_PROVIDER) return getMoonshotModel(modelId)?.contextWindow ?? null;
+	if (!modelConfig.provider) return null;
+	return knownModelsForProvider(modelConfig.provider).find((model) => model.id === modelId)?.contextWindow ?? null;
+}
+function resolveBuiltinModelSourceBudget(modelConfig) {
+	return resolveBuiltinModelContextWindow(modelConfig) ?? 1e5;
+}
 function choiceForKnownModel(provider, model) {
 	return {
 		provider,
@@ -968,6 +978,8 @@ function modelInputSchemaDefs(catalog) {
 const HORTON_MODEL = `claude-sonnet-4-6`;
 const TITLE_SYSTEM_PROMPT = "You generate concise chat session titles in 3-5 words. Respond with only the title, no quotes, no punctuation, no preamble.";
 const TITLE_USER_PROMPT = (userMessage) => `User request:\n${userMessage}`;
+const TITLE_GENERATION_TIMEOUT_MS = 8e3;
+const HORTON_SKILLS_SLASH_COMMAND_OWNER = `horton:skills`;
 const TITLE_STOP_WORDS = new Set([
 	`a`,
 	`an`,
@@ -1047,6 +1059,17 @@ function createConfiguredTitleCall(catalog, modelConfig, logPrefix) {
 		maxTokens: 64
 	});
 }
+function withTimeout(promise, ms, description) {
+	let timeout;
+	const timeoutPromise = new Promise((_resolve, reject) => {
+		timeout = setTimeout(() => {
+			reject(new Error(`${description} timed out after ${ms}ms`));
+		}, ms);
+	});
+	return Promise.race([promise, timeoutPromise]).finally(() => {
+		if (timeout) clearTimeout(timeout);
+	});
+}
 async function generateTitle(userMessage, llmCall, onFallback) {
 	try {
 		const raw = await llmCall(TITLE_USER_PROMPT(userMessage));
@@ -1176,8 +1199,12 @@ function payloadToTitleText(payload) {
 	if (typeof payload === `string`) return payload;
 	if (payload == null) return ``;
 	if (typeof payload === `object`) {
-		const text = payload.text;
-		return typeof text === `string` ? text : JSON.stringify(payload);
+		const record = payload;
+		const text = record.text;
+		if (typeof text === `string`) return text;
+		const source = record.source;
+		if (typeof source === `string`) return source;
+		return JSON.stringify(payload);
 	}
 	return String(payload);
 }
@@ -1235,10 +1262,13 @@ async function readAgentsMd(sandbox) {
 }
 function createAssistantHandler(options) {
 	const { streamFn, docsSupport, docsSearchTool, skillsRegistry, modelCatalog, docsUrl } = options;
-	const hasSkills = Boolean(skillsRegistry && skillsRegistry.catalog.size > 0);
+	const skillLoader = createContextSkillLoader(skillsRegistry, { slashCommandOwner: HORTON_SKILLS_SLASH_COMMAND_OWNER });
+	const hasSkills = skillLoader.hasSkills;
 	return async function assistantHandler(ctx, wake) {
+		const loadedSkills = await skillLoader.load(ctx);
 		const readSet = new Set();
 		const modelConfig = resolveBuiltinModelConfig(modelCatalog, ctx.args);
+		const sourceBudget = resolveBuiltinModelSourceBudget(modelConfig);
 		const sandboxCwd = ctx.sandbox.workingDirectory;
 		const agentsMd = await readAgentsMd(ctx.sandbox);
 		const tools = [
@@ -1249,7 +1279,7 @@ function createAssistantHandler(options) {
 				modelCatalog,
 				logPrefix: `[horton ${ctx.entityUrl}]`
 			}),
-			...skillsRegistry && skillsRegistry.catalog.size > 0 ? createSkillTools(skillsRegistry, ctx) : [],
+			...loadedSkills.tools,
 			...mcp.tools()
 		];
 		const hasEventSourceTools = tools.some((tool) => getToolName(tool) === `list_event_sources`);
@@ -1258,21 +1288,22 @@ function createAssistantHandler(options) {
 			if (!firstUserMessage) return;
 			let title = null;
 			try {
-				const result = await generateTitle(firstUserMessage, createConfiguredTitleCall(modelCatalog, modelConfig, `[horton ${ctx.entityUrl}]`), (reason) => {
+				const result = await generateTitle(firstUserMessage, (prompt) => withTimeout(createConfiguredTitleCall(modelCatalog, modelConfig, `[horton ${ctx.entityUrl}]`)(prompt), TITLE_GENERATION_TIMEOUT_MS, `title generation`), (reason) => {
 					serverLog.warn(`[horton ${ctx.entityUrl}] title generation fell back to local title: ${reason}`);
 				});
 				if (result.length > 0) title = result;
 			} catch (err) {
 				serverLog.warn(`[horton ${ctx.entityUrl}] title generation failed: ${err instanceof Error ? err.message : String(err)}`);
+				title = buildFallbackTitle(firstUserMessage);
 			}
 			if (title !== null) try {
-				await ctx.setTag(`title`, title);
+				await withTimeout(ctx.setTag(`title`, title), TITLE_GENERATION_TIMEOUT_MS, `set title tag`);
 			} catch (err) {
 				serverLog.warn(`[horton ${ctx.entityUrl}] setTag failed: ${err instanceof Error ? err.message : String(err)}`);
 			}
 		})() : Promise.resolve();
 		if (docsSupport) ctx.useContext({
-			sourceBudget: 1e5,
+			sourceBudget,
 			sources: {
 				docs_toc: {
 					content: () => docsSupport.renderCompressedToc(),
@@ -1293,21 +1324,13 @@ function createAssistantHandler(options) {
 					max: 2e4,
 					cache: `stable`
 				} } : {},
-				...skillsRegistry && skillsRegistry.catalog.size > 0 ? { skills_catalog: {
-					content: () => skillsRegistry.renderCatalog(2e3),
-					max: 2e3,
-					cache: `stable`
-				} } : {}
+				...skillsRegistry && skillsRegistry.catalog.size > 0 ? loadedSkills.sources : {}
 			}
 		});
 		else if (skillsRegistry && skillsRegistry.catalog.size > 0) ctx.useContext({
-			sourceBudget: 1e5,
+			sourceBudget,
 			sources: {
-				skills_catalog: {
-					content: () => skillsRegistry.renderCatalog(2e3),
-					max: 2e3,
-					cache: `stable`
-				},
+				...loadedSkills.sources,
 				conversation: {
 					content: () => ctx.timelineMessages(),
 					cache: `volatile`
@@ -1320,7 +1343,7 @@ function createAssistantHandler(options) {
 			}
 		});
 		else if (agentsMd) ctx.useContext({
-			sourceBudget: 1e5,
+			sourceBudget,
 			sources: {
 				conversation: {
 					content: () => ctx.timelineMessages(),
@@ -1377,6 +1400,16 @@ function registerHorton(registry, options) {
 	registry.define(`horton`, {
 		description: `Friendly capable assistant — chat, code, research, dispatch`,
 		creationSchema: hortonCreationSchema,
+		permissionGrants: [{
+			subject_kind: `principal_kind`,
+			subject_value: `user`,
+			permission: `spawn`
+		}, {
+			subject_kind: `principal_kind`,
+			subject_value: `user`,
+			permission: `manage`
+		}],
+		slashCommands: buildSkillSlashCommands(skillsRegistry),
 		handler: assistantHandler
 	});
 	return [`horton`];
@@ -1418,7 +1451,7 @@ function parseWorkerArgs(value) {
 	if (typeof value.reasoningEffort === `string` && REASONING_EFFORT_VALUES.includes(value.reasoningEffort)) args.reasoningEffort = value.reasoningEffort;
 	return args;
 }
-function buildToolsForWorker(tools, sandbox, ctx, readSet) {
+function buildToolsForWorker(tools, sandbox, ctx, readSet, opts) {
 	const out = [];
 	for (const name of tools) switch (name) {
 		case `bash`:
@@ -1437,7 +1470,10 @@ function buildToolsForWorker(tools, sandbox, ctx, readSet) {
 			out.push(braveSearchTool$1);
 			break;
 		case `fetch_url`:
-			out.push(createFetchUrlTool(sandbox));
+			out.push(createFetchUrlTool(sandbox, {
+				catalog: opts.modelCatalog,
+				modelConfig: opts.modelConfig
+			}));
 			break;
 		case `spawn_worker`:
 			out.push(createSpawnWorkerTool(ctx));
@@ -1548,11 +1584,23 @@ function registerWorker(registry, options) {
 	const { streamFn, modelCatalog } = options;
 	registry.define(`worker`, {
 		description: `Internal — generic worker spawned by other agents. Configure via spawn args (systemPrompt + tools + optional sharedDb).`,
+		permissionGrants: [{
+			subject_kind: `principal_kind`,
+			subject_value: `user`,
+			permission: `spawn`
+		}, {
+			subject_kind: `principal_kind`,
+			subject_value: `user`,
+			permission: `manage`
+		}],
 		async handler(ctx) {
 			const args = parseWorkerArgs(ctx.args);
 			const readSet = new Set();
-			const builtinTools = buildToolsForWorker(args.tools, ctx.sandbox, ctx, readSet);
 			const modelConfig = resolveBuiltinModelConfig(modelCatalog, args);
+			const builtinTools = buildToolsForWorker(args.tools, ctx.sandbox, ctx, readSet, {
+				modelCatalog,
+				modelConfig
+			});
 			const sharedStateTools = [];
 			if (args.sharedDb) {
 				const shared = await ctx.observe(db(args.sharedDb.id, args.sharedDb.schema));
@@ -1746,6 +1794,18 @@ function resolveCwd(args, fallback) {
 	return readWorkingDirectoryArg(args) ?? fallback;
 }
 
+//#endregion
+//#region src/durable-streams-cache.ts
+const MEMORY_CACHE_SIZE_BYTES = 100 * 1024 * 1024;
+function installDurableStreamsFetchCache(options = {}) {
+	if (options === false) return;
+	const store = options.store === `sqlite` || options.sqliteLocation ? new cacheStores.SqliteCacheStore({
+		location: options.sqliteLocation,
+		maxCount: options.maxCount
+	}) : new cacheStores.MemoryCacheStore({ maxSize: MEMORY_CACHE_SIZE_BYTES });
+	setGlobalDispatcher(new Agent().compose(interceptors.cache({ store })));
+}
+
 //#endregion
 //#region src/server.ts
 var BuiltinAgentsServer = class {
@@ -1755,6 +1815,8 @@ var BuiltinAgentsServer = class {
 	mcpToolProviderName = null;
 	mcpApplyInFlight = new Set();
 	mcpStopping = false;
+	mcpExtras = [];
+	mcpLastJsonConfig = null;
 	pullWakeRunner = null;
 	options;
 	constructor(options) {
@@ -1764,8 +1826,70 @@ var BuiltinAgentsServer = class {
 	get mcpRegistry() {
 		return this._mcpRegistry;
 	}
+	/**
+	* Replace the in-memory `extras` list and re-apply the merged config
+	* against the last-known workspace `mcp.json` state. Workspace
+	* `mcp.json` still wins on name collision. No-op once `stop()` has
+	* latched `mcpStopping`.
+	*/
+	async setExtraMcpServers(extras) {
+		if (!this._mcpRegistry || this.mcpStopping) return;
+		this.mcpExtras = extras;
+		await this.applyMerged(this.mcpLastJsonConfig);
+	}
+	async wirePersistence(cfg) {
+		const servers = [];
+		for (const s of cfg.servers) if (s.transport === `http` && s.auth?.mode === `authorizationCode`) {
+			const persist = await keychainPersistence({ server: s.name });
+			servers.push({
+				...s,
+				auth: {
+					...s.auth,
+					...persist
+				}
+			});
+		} else servers.push(s);
+		return {
+			...cfg,
+			servers
+		};
+	}
+	mergeMcp(jsonCfg) {
+		const jsonServers = jsonCfg?.servers ?? [];
+		const jsonNames = new Set(jsonServers.map((s) => s.name));
+		const filteredExtras = this.mcpExtras.filter((s) => !jsonNames.has(s.name));
+		return {
+			servers: [...filteredExtras, ...jsonServers],
+			raw: jsonCfg?.raw
+		};
+	}
+	async runApply(jsonCfg) {
+		if (this.mcpStopping) return;
+		const registry = this._mcpRegistry;
+		if (!registry) return;
+		try {
+			const wired = await this.wirePersistence(this.mergeMcp(jsonCfg));
+			if (this.mcpStopping) return;
+			await registry.applyConfig(wired);
+		} catch (e) {
+			serverLog.error(`[mcp] applyConfig:`, e);
+			try {
+				this.options.onConfigError?.(e);
+			} catch (cbErr) {
+				serverLog.error(`[mcp] onConfigError callback failed:`, cbErr);
+			}
+		}
+	}
+	applyMerged(jsonCfg) {
+		this.mcpLastJsonConfig = jsonCfg;
+		const p = this.runApply(jsonCfg);
+		this.mcpApplyInFlight.add(p);
+		p.finally(() => this.mcpApplyInFlight.delete(p));
+		return p;
+	}
 	async start() {
 		if (this.bootstrap || this.pullWakeRunner) throw new Error(`Builtin agents runtime already started`);
+		installDurableStreamsFetchCache(this.options.durableStreamsFetchCache);
 		const pullWake = this.options.pullWake;
 		if (!pullWake?.runnerId) throw new Error(`Builtin agents require a pull-wake runner id`);
 		try {
@@ -1776,76 +1900,28 @@ var BuiltinAgentsServer = class {
 			});
 			this._mcpRegistry = mcpRegistry;
 			const mcpConfigPath = this.options.loadProjectMcpConfig ? path.resolve(this.options.workingDirectory ?? process.cwd(), `mcp.json`) : null;
-			const extras = this.options.extraMcpServers ?? [];
-			const wirePersistence = async (cfg) => {
-				const servers = [];
-				for (const s of cfg.servers) if (s.transport === `http` && s.auth?.mode === `authorizationCode`) {
-					const persist = await keychainPersistence({ server: s.name });
-					servers.push({
-						...s,
-						auth: {
-							...s.auth,
-							...persist
-						}
-					});
-				} else servers.push(s);
-				return {
-					...cfg,
-					servers
-				};
-			};
-			const merge = (jsonCfg) => {
-				const jsonServers = jsonCfg?.servers ?? [];
-				const jsonNames = new Set(jsonServers.map((s) => s.name));
-				const filteredExtras = extras.filter((s) => !jsonNames.has(s.name));
-				return {
-					servers: [...filteredExtras, ...jsonServers],
-					raw: jsonCfg?.raw
-				};
-			};
-			const onConfigError = this.options.onConfigError;
-			const runApply = async (jsonCfg) => {
-				if (this.mcpStopping) return;
-				try {
-					const wired = await wirePersistence(merge(jsonCfg));
-					if (this.mcpStopping) return;
-					await mcpRegistry.applyConfig(wired);
-				} catch (e) {
-					serverLog.error(`[mcp] applyConfig:`, e);
-					try {
-						onConfigError?.(e);
-					} catch (cbErr) {
-						serverLog.error(`[mcp] onConfigError callback failed:`, cbErr);
-					}
-				}
-			};
-			const applyMerged = (jsonCfg) => {
-				const p = runApply(jsonCfg);
-				this.mcpApplyInFlight.add(p);
-				p.finally(() => this.mcpApplyInFlight.delete(p));
-				return p;
-			};
+			this.mcpExtras = this.options.extraMcpServers ?? [];
 			if (mcpConfigPath) {
 				try {
 					const cfg = await loadConfig(mcpConfigPath, process.env);
-					applyMerged(cfg);
+					this.applyMerged(cfg);
 				} catch (err) {
 					if (err.code !== `ENOENT`) throw err;
-					if (extras.length === 0) serverLog.info(`[mcp] no ${mcpConfigPath} — starting with no servers`);
-					else serverLog.info(`[mcp] no ${mcpConfigPath} — starting with ${extras.length} server(s) from extras`);
-					applyMerged(null);
+					if (this.mcpExtras.length === 0) serverLog.info(`[mcp] no ${mcpConfigPath} — starting with no servers`);
+					else serverLog.info(`[mcp] no ${mcpConfigPath} — starting with ${this.mcpExtras.length} server(s) from extras`);
+					this.applyMerged(null);
 				}
 				try {
 					this.mcpWatcherCloser = await watchConfig(mcpConfigPath, {
-						onChange: (cfg) => void applyMerged(cfg),
+						onChange: (cfg) => void this.applyMerged(cfg),
 						onError: (e) => serverLog.error(`[mcp] config error:`, e)
 					});
 				} catch (e) {
 					serverLog.error(`[mcp] config watcher failed to start:`, e);
 				}
 			} else {
-				if (extras.length > 0) serverLog.info(`[mcp] starting with ${extras.length} server(s) from extras`);
-				applyMerged(null);
+				if (this.mcpExtras.length > 0) serverLog.info(`[mcp] starting with ${this.mcpExtras.length} server(s) from extras`);
+				this.applyMerged(null);
 			}
 			this.mcpToolProviderName = `mcp`;
 			registerToolProvider({

package/docs/entities/patterns/blackboard.md

@@ -81,7 +81,7 @@ const proWorker = await ctx.spawn(
     systemPrompt: PRO_WORKER_PROMPT,
     sharedDb: { id: `debate-${ctx.entityUrl}`, schema: debateSchema },
   },
-  { initialMessage: proInitialMessage, wake: `runFinished` }
+  { initialMessage: proInitialMessage, wake: { on: `runFinished`, includeResponse: true } }
 )
 ```
 

package/docs/entities/patterns/dispatcher.md

@@ -47,7 +47,7 @@ The dispatcher exposes a `dispatch` tool. When the LLM classifies an incoming me
 
 The tool then:
 
-1. Spawns the requested entity type with `wake: 'runFinished'`.
+1. Spawns the requested entity type with `wake: { on: 'runFinished', includeResponse: true }`.
 2. Returns immediately with a status message. The dispatcher is re-invoked when the specialist finishes.
 
 ## Dispatch tool
@@ -59,7 +59,7 @@ await ctx.spawn(
   type === `worker` ? { systemPrompt, tools: [`read`] } : { systemPrompt },
   {
     initialMessage: task,
-    wake: `runFinished`,
+    wake: { on: `runFinished`, includeResponse: true },
   }
 )
 
@@ -67,7 +67,7 @@ return {
   content: [
     {
       type: `text` as const,
-      text: `Dispatched to "${type}" specialist (${id}). You will be woken when it finishes.`,
+      text: `Dispatched to "${type}" specialist (${id}). The dispatcher will continue when it finishes.`,
     },
   ],
   details: { id, type },

package/docs/entities/patterns/manager-worker.md

@@ -42,9 +42,9 @@ The manager defines a handler-scoped tool called `analyze_with_perspectives`. Wh
 
 1. Spawns 3 worker children -- optimist, pessimist, pragmatist -- each with a different system prompt.
 2. Sends the same question to all three as `initialMessage`.
-3. Uses `wake: 'runFinished'` to wait for each child to complete.
-4. Collects results with `Promise.all` and `handle.text()`.
-5. Returns the combined perspectives to the LLM for synthesis.
+3. Uses `wake: { on: 'runFinished', includeResponse: true }` so the manager is re-invoked as each child completes.
+4. Collects results from `runFinished` wake payloads or shared state after workers finish.
+5. Runs a synthesis step after all child-completion wakes have been recorded.
 
 On subsequent calls, the tool reuses existing children via `ctx.observe()` and `child.send()` instead of spawning new ones.
 
@@ -63,7 +63,7 @@ for (const perspective of PERSPECTIVES) {
       `worker`,
       childId,
       { systemPrompt: perspective.systemPrompt, tools: [`read`] },
-      { initialMessage: question, wake: `runFinished` }
+      { initialMessage: question, wake: { on: `runFinished`, includeResponse: true } }
     )
     children.insert({
       key: perspective.id,
@@ -87,28 +87,16 @@ for (const perspective of PERSPECTIVES) {
 
 ## Collecting results
 
-The `readLatestCompletedText` helper awaits the child's current run, reads all text outputs, and returns the last one:
+Do not wait for worker output inside the same wake. Spawn workers with `wake: { on: "runFinished", includeResponse: true }`, record each worker URL in manager state, and return. On each later child-completion wake, store `wake.payload.finished_child.response` (or read structured output from shared state). Once all workers have reported, run the reduce/synthesis step.
 
 ```ts
-async function readLatestCompletedText(
-  handle: EntityHandle,
-  fallback: string
-): Promise<string> {
-  await handle.run
-  const runs = await handle.text()
-  const latest = runs[runs.length - 1]?.trim()
-  return latest || fallback
+const finished = wake.payload?.finished_child
+if (finished) {
+  ctx.state.workers.update(finished.url, (draft) => {
+    draft.status = finished.run_status
+    draft.output = finished.response ?? ""
+  })
 }
-
-const results = await Promise.all(
-  handles.map(async ({ id, handle }) => ({
-    id,
-    text: await readLatestCompletedText(
-      handle,
-      `(no completed output from ${id})`
-    ),
-  }))
-)
 ```
 
 ## State

package/docs/entities/patterns/map-reduce.md

@@ -55,7 +55,7 @@ for (let i = 0; i < chunks.length; i++) {
     { systemPrompt: task, tools: [`read`] },
     {
       initialMessage: chunks[i],
-      wake: `runFinished`,
+      wake: { on: `runFinished`, includeResponse: true },
     }
   )
   ctx.db.actions.children_insert({

package/docs/entities/patterns/pipeline.md

@@ -39,7 +39,7 @@ export function registerPipeline(registry: EntityRegistry) {
 The pipeline agent exposes a `run_stage` tool. The LLM drives the pipeline one stage at a time:
 
 1. The LLM calls `run_stage` with an instruction and input for the current stage.
-2. The tool spawns a worker with the instruction as its system prompt and the input as `initialMessage`, using `wake: 'runFinished'`.
+2. The tool spawns a worker with the instruction as its system prompt and the input as `initialMessage`, using `wake: { on: 'runFinished', includeResponse: true }`.
 3. The tool returns immediately. The pipeline entity is re-invoked when the worker finishes.
 4. On each re-invocation, the wake event contains `finished_child.response` with the stage's output. The LLM then calls `run_stage` again with the next stage's instruction and the previous output as input.
 5. This repeats until all stages are complete.
@@ -74,7 +74,7 @@ function createRunStageTool(ctx: HandlerContext): AgentTool {
         `worker`,
         id,
         { systemPrompt: instruction, tools: [`read`] },
-        { initialMessage: input, wake: `runFinished` }
+        { initialMessage: input, wake: { on: `runFinished`, includeResponse: true } }
       )
       ctx.db.actions.children_insert({
         row: { key: id, url: child.entityUrl, stage: stageCount },
@@ -84,7 +84,7 @@ function createRunStageTool(ctx: HandlerContext): AgentTool {
         content: [
           {
             type: `text` as const,
-            text: `Stage ${stageCount} spawned. You will be woken when it finishes.`,
+            text: `Stage ${stageCount} spawned. The pipeline will continue when it finishes.`,
           },
         ],
         details: { stage: stageCount },