@dxos/agent-runtime 0.12.0-next-73daef452f1464b62efdbca75fb0067c1066f264 → 0.14.0

package/dist/lib/chunk-AgentService.mjs

@@ -1,33 +1,38 @@
 import * as Cause from "effect/Cause";
 import * as Effect from "effect/Effect";
 import * as Layer from "effect/Layer";
-import * as Option from "effect/Option";
-import { AgentRequestBegin, AgentRequestEnd, AiContext, AiSession, HarnessControl, SkillHooks, getOperationFromTool, makeToolExecutionService, makeToolResolverFromOperations } from "@dxos/assistant";
-import { ProcessManager } from "@dxos/compute-runtime";
-import { AgentService, getSession } from "@dxos/compute/AgentService";
+import * as Atom from "effect/reactivity/Atom";
+import * as Semaphore from "effect/Semaphore";
+import { AiContext, AiSession, Alarm, HarnessControl, SessionStore, SkillHooks, getOperationFromTool, makeToolExecutionService, makeToolResolverFromOperations } from "@dxos/assistant";
+import * as Chat from "@dxos/assistant/Chat";
+import * as AgentService from "@dxos/compute/AgentService";
 import * as Process from "@dxos/compute/Process";
 import * as Skill from "@dxos/compute/Skill";
-import { Annotation, Database, Feed, Obj, Ref, Registry } from "@dxos/echo";
-import { EffectEx } from "@dxos/effect";
+import { Annotation, Database, Feed, Filter, Obj, Ref, Registry } from "@dxos/echo";
+import * as EffectEx from "@dxos/effect/EffectEx";
 import { DXN, EID } from "@dxos/keys";
 import { log } from "@dxos/log";
+import * as Tool from "effect/ai/Tool";
+import * as Toolkit from "effect/ai/Toolkit";
 import * as Clock from "effect/Clock";
 import * as DateTime from "effect/DateTime";
 import * as Duration from "effect/Duration";
 import * as Exit from "effect/Exit";
-import * as Match from "effect/Match";
+import * as Option from "effect/Option";
 import * as Schema from "effect/Schema";
 import * as Struct from "effect/Struct";
-import * as Tool from "effect/unstable/ai/Tool";
-import * as Toolkit from "effect/unstable/ai/Toolkit";
-import { AiService, OpaqueToolkit } from "@dxos/ai";
+import { AiService, Model, OpaqueToolkit } from "@dxos/ai";
+import { OperationProcess } from "@dxos/compute-runtime";
 import * as Credential from "@dxos/compute/Credential";
-import * as Instructions from "@dxos/compute/Instructions";
+import * as McpServer from "@dxos/compute/McpServer";
 import * as Operation from "@dxos/compute/Operation";
+import * as OperationHandlerSet from "@dxos/compute/OperationHandlerSet";
 import * as StorageService from "@dxos/compute/StorageService";
 import * as Trace from "@dxos/compute/Trace";
-import { ContentBlock } from "@dxos/types";
-import { trim } from "@dxos/util";
+import { AccessToken } from "@dxos/link";
+import { Actor, ContentBlock, Message } from "@dxos/types";
+import { markWork, trim } from "@dxos/util";
+import { McpOAuth } from "@dxos/mcp-client";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __exportAll = (all, no_symbols) => {
@@ -40,6 +45,51 @@ var __exportAll = (all, no_symbols) => {
 	return target;
 };
 //#endregion
+//#region src/agent-service/mcp-servers.ts
+var __dxlog_file$2 = "/__w/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/mcp-servers.ts";
+/**
+* The space's enabled MCP servers as connection options, read at the start of every turn so a server
+* added, toggled or signed in to from the chat's options applies from the next turn on.
+*/
+var loadSpaceMcpServers = () => Effect.gen(function* () {
+	const servers = yield* Database.query(Filter.type(McpServer.McpServer)).run;
+	return yield* Effect.forEach(servers.filter((server) => server.enabled !== false), toOptions);
+});
+var toOptions = (server) => Effect.gen(function* () {
+	const options = {
+		url: server.url,
+		protocol: server.protocol,
+		apiKey: server.apiKey
+	};
+	if (server.oauth?.tokens) return {
+		...options,
+		authProvider: McpOAuth.makeProvider({ store: McpServer.oauthStore(server) })
+	};
+	if (server.accessToken) {
+		const apiKey = yield* resolveAccessToken(server.accessToken);
+		return Option.isSome(apiKey) ? {
+			...options,
+			apiKey: apiKey.value
+		} : options;
+	}
+	return options;
+});
+/**
+* Resolves through {@link Credential.CredentialsService} rather than reading `token` directly, so a
+* token EDGE custodies (a managed one) resolves the same way a pasted one does.
+*/
+var resolveAccessToken = (ref) => Effect.gen(function* () {
+	const accessToken = yield* Database.load(ref);
+	const credentials = yield* Credential.CredentialsService;
+	const credential = yield* Effect.tryPromise(() => credentials.getCredential({ accessTokenId: accessToken.id }));
+	return Option.fromNullishOr(credential.apiKey);
+}).pipe(Effect.tapError((error) => Effect.sync(() => log.warn("failed to resolve MCP server credential", { error }, {
+	"~LogMeta": "~LogMeta",
+	F: __dxlog_file$2,
+	L: 60,
+	S: void 0
+}))), Effect.orElseSucceed(() => Option.none()));
+//#endregion
 //#region src/agent-service/turn-producer.ts
 /**
 * The default producer: `AiSession.Session`, which resolves the model, binds skills and context
@@ -57,224 +107,477 @@ var makeAiSessionTurnProducer = ({ feed, runtime, instructions }) => EffectEx.ac
 //#region src/agent-service/agent-process.ts
 var __dxlog_file$1 = "/__w/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/agent-process.ts";
 var AGENT_PROCESS_KEY = "org.dxos.testing.process.agent";
+var AgentPrompt = Schema.Union([Schema.String, Schema.Array(ContentBlock.Any)]);
+/**
+* Who sent a prompt: the plain-data subset of `Actor`, since the input crosses a JSON boundary
+* (EDGE decodes it with the schema's type side) where a `Ref` cannot be supplied.
+*/
+var AgentInputSender = Actor.Actor.mapFields(Struct.pick([
+	"role",
+	"name",
+	"identityDid",
+	"email"
+]));
+/**
+* Input accepted by {@link AgentProcess}: a bare prompt, or a prompt attributed to a sender (e.g. a
+* relayed Discord author) whose identity the appended `Message` records.
+*/
+var AgentInput = Schema.Union([AgentPrompt, Schema.Struct({
+	prompt: AgentPrompt,
+	sender: Schema.optional(AgentInputSender),
+	/** Foreign identity and other source metadata copied onto the message (e.g. `{ discord: { userId } }`). */
+	properties: Schema.optional(Schema.Record(Schema.String, Schema.Any))
+})]);
+/** Builds the feed message for an input; the sender defaults to the plain user role. */
+var makeInputMessage = (input) => {
+	const { prompt, sender, properties } = typeof input === "object" && "prompt" in input ? input : {
+		prompt: input,
+		sender: void 0,
+		properties: void 0
+	};
+	const blocks = typeof prompt === "string" ? [ContentBlock.Text.make({ text: prompt })] : [...prompt];
+	return Message.make({
+		sender: {
+			role: "user",
+			...sender
+		},
+		blocks,
+		properties
+	});
+};
+/**
+* How long to wait before re-reading a queue that contradicts a write this process just made, and
+* how many times. A hosted runtime serves the read from an eventually-consistent index, and the lag
+* measured on EDGE is single-digit milliseconds — the cap is what keeps a write that never lands
+* from waking the agent forever.
+*/
+var UNSEEN_WRITE_RETRY_MS = 250;
+/** How much of a sub-agent's result the trace keeps: enough to read, never the whole payload. */
+var RESULT_PREVIEW_LENGTH = 200;
+/**
+* A short, safe rendering of a sub-agent's result for the trace.
+*
+* Guarded because this sits between removing the child from `delegations` and running the strategy's
+* `onComplete`: a `BigInt` or a cycle would throw here, become a defect, and take the whole return
+* path with it — the work item would never be updated and work waiting on it never reconciled.
+* Losing the preview is survivable; losing the return is not.
+*/
+var resultPreview = (value) => {
+	let text;
+	try {
+		text = typeof value === "string" ? value : JSON.stringify(value);
+	} catch {
+		return;
+	}
+	if (text === void 0) return;
+	return text.length > RESULT_PREVIEW_LENGTH ? `${text.slice(0, RESULT_PREVIEW_LENGTH)}…` : text;
+};
+var MAX_UNSEEN_WRITE_WAKES = 20;
 /**
 * Hosts a persistent, suspendible AiAgent that can process a number of prompts.
 * The process target is a queue DXN string.
 */
-var AgentProcess = (options) => Process.make({
+var AgentProcess = (options) => Operation.makeDurable({
 	key: AGENT_PROCESS_KEY,
-	input: Schema.Union([Schema.String, Schema.Array(ContentBlock.Any)]),
+	input: AgentInput,
 	output: Schema.Void,
+	types: [
+		Chat.Chat,
+		Feed.Feed,
+		Message.Message,
+		Alarm.Alarm,
+		AiContext.Binding,
+		Skill.Skill,
+		McpServer.McpServer,
+		AccessToken.AccessToken
+	],
 	services: [
 		Database.Service,
 		OpaqueToolkit.OpaqueToolkitProvider,
 		Operation.Service,
 		Registry.Service,
 		StorageService.StorageService,
-		ProcessManager.ProcessOperationInvoker.Service,
+		Process.ManagerService,
+		OperationHandlerSet.OperationHandlerProvider,
 		AiService.AiService,
 		Credential.CredentialsService
 	],
 	rpcs: HarnessControl
-}, (ctx) => Effect.gen(function* () {
-	const feedDxn = Annotation.getDictionary(ctx.params.annotations, Process.TargetAnnotation).pipe(Option.getOrUndefined);
-	if (feedDxn == null) return yield* Effect.die(/* @__PURE__ */ new Error("Agent executable requires spawn options.target set to a queue DXN."));
-	const feed = yield* Database.resolve(feedDxn, Feed.Feed).pipe(Effect.orDie);
-	const instructionsDxn = Annotation.getDictionary(ctx.params.annotations, Process.InstructionsAnnotation).pipe(Option.getOrUndefined);
-	const instructions = instructionsDxn ? yield* Database.resolve(instructionsDxn, Instructions.Instructions).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
+}).pipe(Operation.withDurableHandler((ctx) => Effect.gen(function* () {
+	const chatDxn = Annotation.getDictionary(ctx.params.annotations, Process.TargetAnnotation).pipe(Option.getOrUndefined);
+	if (chatDxn == null) return yield* Effect.die(/* @__PURE__ */ new Error("Agent executable requires spawn options.target set to a Chat DXN."));
+	const chat = yield* Database.resolve(chatDxn, Chat.Chat).pipe(Effect.orDie);
+	const feed = yield* Database.load(chat.feed).pipe(Effect.orDie);
+	const instructions = chat.instructions ? yield* Database.load(chat.instructions).pipe(Effect.orElseSucceed(() => void 0)) : void 0;
 	const runtime = yield* Effect.context();
 	const session = yield* (options.makeTurnProducer ?? makeAiSessionTurnProducer)({
+		chat,
 		feed,
 		runtime,
 		instructions: instructions ? [instructions] : []
 	});
-	let inputQueue = [...yield* AgentEventsCell.get];
-	const storageService = yield* StorageService.StorageService;
-	const toolCallManager = new ToolCallManager(storageService);
+	const sessionStore = new SessionStore();
+	let toolResults = [...yield* ToolResultsCell.get];
+	let ackedEntries = [...yield* AckedEntriesCell.get];
+	let selfWakes = yield* SelfWakesCell.get;
+	const toolCallManager = new ToolCallManager(yield* StorageService.StorageService);
 	yield* toolCallManager.load();
 	const clock = yield* Clock.Clock;
-	const alarmManager = new AlarmManager({
-		storageService,
-		setAlarm: (timeout) => ctx.setAlarm(timeout),
-		now: () => clock.currentTimeMillisUnsafe()
-	});
-	yield* alarmManager.load();
-	yield* toolCallManager.reconcileWithInputQueue(inputQueue);
+	const now = () => clock.currentTimeMillisUnsafe();
+	yield* toolCallManager.reconcileWithInputQueue(toolResults);
+	const unseenAlarms = /* @__PURE__ */ new Map();
+	const reconcileAlarmWith = (state) => {
+		for (const alarm of state.pendingAlarms) unseenAlarms.delete(alarm.id);
+		const observed = state.pendingAlarms[0]?.wakeAt;
+		const wakeAts = [...observed != null ? [observed] : [], ...[...unseenAlarms.values()].map(({ wakeAt }) => wakeAt)];
+		const delay = computeAlarmDelay({
+			hasPendingWork: toolResults.length > 0 || state.pendingMessages.length > 0,
+			wakeAt: wakeAts.length > 0 ? Math.min(...wakeAts) : null,
+			now: now()
+		});
+		return delay != null ? ctx.setAlarm(delay) : Effect.void;
+	};
+	const reconcileAlarm = Effect.flatMap(sessionStore.loadPending(feed), reconcileAlarmWith);
+	const startupPending = yield* sessionStore.loadPending(feed);
+	yield* reconcileAlarmWith(startupPending);
 	const strategy = Option.fromNullishOr(options.delegationStrategy);
 	let delegations = [...yield* DelegationsCell.get];
-	const requestModelLayer = AiService.model(options.model ? DXN.getName(options.model) : "com.anthropic.model.claude-opus-4-8.default", { provider: options.provider });
-	const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+	let asyncHooks = [...yield* AsyncHooksCell.get];
+	const untrackedExits = /* @__PURE__ */ new Set();
+	const model = chat.session?.model ?? options.defaultModel;
+	const requestModelLayer = AiService.languageModel(DXN.getName(model ?? Model.claudeSonnet5.id), { provider: options.provider });
+	const childServices = yield* Effect.context();
 	const runEndRequestHooks = Effect.gen(function* () {
 		yield* SkillHooks.runHooks({
 			skills: session.getSkills(),
 			phase: "end-request",
-			invoke: (operation, input) => Effect.gen(function* () {
-				const exit = yield* (yield* operationInvoker.invokeFiber(operation, input, {
+			invoke: (operation, input, hook) => Effect.gen(function* () {
+				const handle = yield* Process.spawn(OperationProcess.make(operation), input, {
 					environment: { conversation: Obj.getURI(feed) },
 					traceMeta: { conversation: Ref.make(feed) }
-				})).await;
-				if (Exit.isFailure(exit)) return yield* Effect.failCause(exit.cause);
-			}).pipe(Effect.asVoid, Effect.orDie)
+				});
+				if (hook.async) {
+					if (untrackedExits.delete(handle.pid)) return;
+					asyncHooks.push(handle.pid);
+					yield* AsyncHooksCell.set(asyncHooks);
+					return;
+				}
+				yield* Process.awaitOutput(handle);
+			}).pipe(Effect.provide(childServices), Effect.asVoid, Effect.orDie)
 		});
 	});
-	const maybeComplete = Effect.gen(function* () {
-		if (isAgentWorkPending({
-			inputQueue,
-			alarmManager,
-			delegations,
-			toolCallManager
-		})) return;
-		yield* runEndRequestHooks;
-		if (isAgentWorkPending({
-			inputQueue,
-			alarmManager,
-			delegations,
-			toolCallManager
-		})) {
-			log("agent work enqueued by end-request hook, continuing", void 0, {
+	let turnRan = false;
+	let endHooksFired = asyncHooks.length > 0;
+	const unseenWriteIds = /* @__PURE__ */ new Set();
+	let unseenWriteWakes = 0;
+	const pendingWork = (state) => isAgentWorkPending({
+		toolResults,
+		pendingMessages: state.pendingMessages,
+		pendingAlarms: state.pendingAlarms,
+		delegations,
+		toolCallManager
+	});
+	const reportSleeping = (state) => state.pendingAlarms.length > 0 ? Trace.emitRequestPhase("sleeping") : Effect.void;
+	const maybeCompleteWith = (state) => Effect.gen(function* () {
+		for (const pid of dropReportedToolResults(toolResults, (pid) => toolCallManager.isReported(pid))) log("drop tool result reported within its turn", { pid }, {
+			"~LogMeta": "~LogMeta",
+			F: __dxlog_file$1,
+			L: 400,
+			S: this
+		});
+		if (pendingWork(state)) {
+			yield* reportSleeping(state);
+			return;
+		}
+		if (!turnRan && !endHooksFired) {
+			log("agent idle before its first turn, staying resident", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 411,
+				S: this
+			});
+			return;
+		}
+		if (!endHooksFired) {
+			endHooksFired = true;
+			yield* runEndRequestHooks;
+			const after = yield* sessionStore.loadPending(feed);
+			if (pendingWork(after)) {
+				log("agent work enqueued by end-request hook, continuing", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 422,
+					S: this
+				});
+				yield* reconcileAlarmWith(after);
+				yield* reportSleeping(after);
+				return;
+			}
+		}
+		if (asyncHooks.length > 0) {
+			log("awaiting background end-request hooks", { count: asyncHooks.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 205,
+				L: 432,
+				S: this
+			});
+			return;
+		}
+		if (options.resident) {
+			log("agent work complete, staying resident", void 0, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file$1,
+				L: 437,
 				S: this
 			});
-			alarmManager.reconcile(true);
 			return;
 		}
 		log("agent work complete, succeeding", void 0, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 210,
+			L: 441,
 			S: this
 		});
 		ctx.succeed();
 	});
+	const maybeComplete = Effect.flatMap(sessionStore.loadPending(feed), maybeCompleteWith);
 	return {
+		onSpawn: Effect.fnUntraced(function* () {
+			if (startupPending.pendingMessages.length > 0) {
+				log.info("discarding queue entries left by a previous process", { count: startupPending.pendingMessages.length }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 454,
+					S: this
+				});
+				yield* Effect.forEach(startupPending.pendingMessages, (message) => sessionStore.ack(feed, message), { discard: true });
+			}
+		}),
 		rpcHandlers: yield* HarnessControl.toHandlers({
 			setAlarm: Effect.fn(function* ({ at, message }) {
-				yield* alarmManager.setWakeAt(DateTime.toEpochMillis(at), message);
-				alarmManager.reconcile(inputQueue.length > 0);
+				const alarm = yield* sessionStore.setAlarm(feed, {
+					wakeAt: DateTime.toEpochMillis(at),
+					message: message ?? void 0
+				});
+				unseenAlarms.set(alarm.id, {
+					wakeAt: alarm.wakeAt,
+					wakes: 0
+				});
+				yield* reconcileAlarm;
 			}),
 			enqueueMessage: Effect.fn(function* ({ content }) {
-				inputQueue.push({
-					_tag: "prompt",
-					content
+				const message = Message.make({
+					sender: { role: "user" },
+					blocks: [...content]
 				});
-				yield* AgentEventsCell.set(inputQueue);
-				alarmManager.reconcile(true);
+				yield* sessionStore.enqueueMessage(feed, message);
+				unseenWriteIds.add(message.id);
+				yield* ctx.setAlarm(0);
 			})
 		}),
-		onInput: Effect.fnUntraced(function* (prompt) {
-			log("agent onInput received", { backlog: inputQueue.length }, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 229,
-				S: this
-			});
-			const content = typeof prompt === "string" ? [ContentBlock.Text.make({ text: prompt })] : [...prompt];
-			inputQueue.push({
-				_tag: "prompt",
-				content
-			});
-			log("agent onInput persisting queue", { depth: inputQueue.length }, {
+		onInput: Effect.fnUntraced(function* (input) {
+			log("agent onInput received", { backlog: toolResults.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 232,
+				L: 483,
 				S: this
 			});
-			yield* AgentEventsCell.set(inputQueue);
-			log("agent onInput persisted", { depth: inputQueue.length }, {
+			const message = makeInputMessage(input);
+			yield* sessionStore.enqueueMessage(feed, message);
+			markWork("agent.prompt-queued");
+			unseenWriteIds.add(message.id);
+			yield* ctx.setAlarm(0);
+			log("agent onInput enqueued to feed", void 0, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 234,
+				L: 489,
 				S: this
 			});
-			alarmManager.reconcile(true);
-			log("agent onInput alarm scheduled", void 0, {
+		}),
+		onAlarm: Effect.fnUntraced(function* () {
+			log("agent onAlarm fired", { backlog: toolResults.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 236,
+				L: 493,
 				S: this
 			});
-		}),
-		onAlarm: Effect.fnUntraced(function* () {
-			log("agent onAlarm fired", { pending: inputQueue.length }, {
+			markWork("agent.wake");
+			const announced = toolResults.length > 0 || unseenWriteIds.size > 0;
+			if (announced) yield* Trace.emitRequestPhase("preparing");
+			for (const pid of dropReportedToolResults(toolResults, (pid) => toolCallManager.isReported(pid))) log.info("skip tool result that was reported synchronously", { pid }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 240,
+				L: 506,
 				S: this
 			});
-			const fired = yield* alarmManager.takeFiredAlarm();
-			if (fired != null) {
-				log("agent onAlarm self-wake", { firedAt: fired.firedAt }, {
+			const toolResult = toolResults.shift();
+			let prompt;
+			let dequeued;
+			if (toolResult !== void 0) {
+				log("agent onAlarm handling", { tag: toolResult._tag }, {
 					"~LogMeta": "~LogMeta",
 					F: __dxlog_file$1,
-					L: 245,
+					L: 514,
 					S: this
 				});
-				inputQueue.push({
-					_tag: "alarm",
-					firedAt: fired.firedAt,
-					message: fired.message
-				});
-				yield* AgentEventsCell.set(inputQueue);
+				prompt = toolResultPrompt(toolResult);
+			} else {
+				const state = yield* sessionStore.loadPending(feed);
+				markWork("agent.pending-loaded");
+				const stillPending = /* @__PURE__ */ new Set([...state.pendingMessages.map((message) => message.id), ...state.pendingAlarms.map((alarm) => alarm.id)]);
+				if (ackedEntries.some((id) => !stillPending.has(id))) {
+					ackedEntries = ackedEntries.filter((id) => stillPending.has(id));
+					yield* AckedEntriesCell.set(ackedEntries);
+				}
+				const acked = new Set(ackedEntries);
+				const message = state.pendingMessages.find((candidate) => !acked.has(candidate.id));
+				const dueAlarm = state.pendingAlarms.find((alarm) => alarm.wakeAt <= now() && !acked.has(alarm.id));
+				for (const [id, entry] of unseenAlarms) {
+					if (state.pendingAlarms.some((alarm) => alarm.id === id)) continue;
+					entry.wakes++;
+					if (entry.wakes >= MAX_UNSEEN_WRITE_WAKES) unseenAlarms.delete(id);
+				}
+				if (message !== void 0) {
+					log("agent onAlarm handling", {
+						tag: "message",
+						id: message.id
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 546,
+						S: this
+					});
+					unseenWriteIds.delete(message.id);
+					unseenWriteWakes = 0;
+					if (isUserPrompt(message) && selfWakes > 0) {
+						selfWakes = 0;
+						yield* SelfWakesCell.set(selfWakes);
+					}
+					dequeued = message;
+					prompt = [...message.blocks];
+				} else if (dueAlarm !== void 0) {
+					unseenAlarms.delete(dueAlarm.id);
+					if (selfWakes >= Alarm.MAX_SELF_WAKES) {
+						log.warn("agent self-wake budget spent, dropping alarm", { wakes: selfWakes }, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$1,
+							L: 559,
+							S: this
+						});
+						yield* sessionStore.ack(feed, dueAlarm);
+						ackedEntries = [...ackedEntries, dueAlarm.id];
+						yield* AckedEntriesCell.set(ackedEntries);
+						const after = yield* sessionStore.loadPending(feed);
+						yield* reconcileAlarmWith(after);
+						yield* maybeCompleteWith(after);
+						return;
+					}
+					selfWakes++;
+					yield* SelfWakesCell.set(selfWakes);
+					log("agent onAlarm self-wake", {
+						firedAt: dueAlarm.wakeAt,
+						wakes: selfWakes
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 570,
+						S: this
+					});
+					dequeued = dueAlarm;
+					prompt = [ContentBlock.Text.make({
+						text: wakeUpPrompt(dueAlarm.wakeAt, dueAlarm.message ?? null, {
+							wake: selfWakes,
+							max: Alarm.MAX_SELF_WAKES
+						}),
+						disposition: "synthetic"
+					})];
+				} else if (unseenWriteIds.size > 0 && unseenWriteWakes < MAX_UNSEEN_WRITE_WAKES) {
+					unseenWriteWakes++;
+					markWork("agent.unseen-write-retry");
+					log("agent onAlarm empty queue with an unread write, waking again", {
+						unseenWrites: unseenWriteIds.size,
+						attempt: unseenWriteWakes
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 588,
+						S: this
+					});
+					yield* ctx.setAlarm(UNSEEN_WRITE_RETRY_MS);
+					return;
+				} else if (unseenWriteIds.size > 0) {
+					log.warn("agent giving up on an unread write, staying resident", {
+						unseenWrites: unseenWriteIds.size,
+						wakes: unseenWriteWakes
+					}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 599,
+						S: this
+					});
+					yield* reconcileAlarmWith(state);
+					return;
+				} else {
+					log("agent onAlarm empty queue", {}, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 606,
+						S: this
+					});
+					yield* reconcileAlarmWith(state);
+					yield* maybeCompleteWith(state);
+					return;
+				}
 			}
-			for (const pid of dropReportedToolResults(inputQueue, (pid) => toolCallManager.isReported(pid))) log.info("skip tool result that was reported synchronously", { pid }, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 251,
-				S: this
-			});
-			const item = inputQueue.shift();
-			if (!item) {
-				log("agent onAlarm empty queue", {}, {
+			if (!announced) yield* Trace.emitRequestPhase("preparing");
+			const [mcpServers] = yield* Effect.all([loadSpaceMcpServers(), Effect.gen(function* () {
+				if (dequeued !== void 0) yield* sessionStore.markInFlight(feed, dequeued);
+				log("begin request", { prompt }, {
 					"~LogMeta": "~LogMeta",
 					F: __dxlog_file$1,
-					L: 256,
+					L: 629,
 					S: this
 				});
-				alarmManager.reconcile(false);
-				yield* AgentEventsCell.set(inputQueue);
-				yield* maybeComplete;
-				return;
-			}
-			log("agent onAlarm handling", { tag: item._tag }, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 263,
-				S: this
-			});
-			const prompt = agentEventToPrompt(item);
-			log("begin request", { prompt }, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 267,
-				S: this
-			});
-			log("trace agent request begin", void 0, {
-				"~LogMeta": "~LogMeta",
-				F: __dxlog_file$1,
-				L: 268,
-				S: this
-			});
-			yield* Trace.write(AgentRequestBegin, {});
+				log("trace agent request begin", void 0, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 630,
+					S: this
+				});
+				yield* Trace.write(Trace.AgentRequestBegin, {});
+			})], { concurrency: "unbounded" });
+			markWork("agent.turn-begin");
 			yield* session.runTurn({
 				prompt,
+				sender: dequeued !== void 0 && Obj.instanceOf(Message.Message, dequeued) ? dequeued.sender : void 0,
 				system: options.systemPrompt,
-				mcpServers: options.getMcpServers?.()
-			}).pipe(Effect.onExit((exit) => Trace.write(AgentRequestEnd, {
-				status: Exit.isSuccess(exit) ? "success" : Exit.hasInterrupts(exit) ? "interrupted" : "error",
-				error: Exit.isFailure(exit) ? Cause.pretty(exit.cause) : void 0
+				mcpServers
+			}).pipe(Effect.onExit((exit) => Effect.gen(function* () {
+				yield* Trace.write(Trace.AgentRequestEnd, {
+					status: Exit.isSuccess(exit) ? "success" : Exit.hasInterrupts(exit) ? "interrupted" : "error",
+					error: Exit.isFailure(exit) ? Cause.pretty(exit.cause) : void 0
+				});
+				const onTurnFailed = Option.isSome(strategy) ? strategy.value.onTurnFailed : void 0;
+				if (onTurnFailed && Exit.isFailure(exit) && !Cause.hasInterrupts(exit.cause)) yield* onTurnFailed(chat, exit.cause);
 			})));
 			log("end request", void 0, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 288,
+				L: 664,
 				S: this
 			});
-			yield* AgentEventsCell.set(inputQueue);
+			turnRan = true;
+			endHooksFired = false;
+			yield* ToolResultsCell.set(toolResults);
+			if (dequeued !== void 0) {
+				yield* sessionStore.ack(feed, dequeued);
+				ackedEntries = [...ackedEntries, dequeued.id];
+				yield* AckedEntriesCell.set(ackedEntries);
+			}
+			const after = yield* sessionStore.loadPending(feed);
 			if (Option.isSome(strategy)) {
 				const activeIds = new Set(delegations.map((delegation) => delegation.id));
-				const pending = yield* strategy.value.reconcile(feed, activeIds);
+				const pending = yield* strategy.value.reconcile(chat, activeIds);
 				for (const delegation of pending) {
 					const pid = yield* delegation.spawn;
 					delegations.push({
@@ -287,14 +590,18 @@ var AgentProcess = (options) => Process.make({
 					}, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 299,
+						L: 686,
 						S: this
 					});
+					yield* Trace.write(Trace.DelegationSpawned, {
+						taskId: delegation.id,
+						pid: String(pid)
+					});
 				}
 				if (pending.length > 0) yield* DelegationsCell.set(delegations);
 			}
-			alarmManager.reconcile(inputQueue.length > 0);
-			yield* maybeComplete;
+			yield* reconcileAlarmWith(after);
+			yield* maybeCompleteWith(after);
 		}, Effect.orDie, Effect.provide(Layer.mergeAll(makeToolResolverFromOperations(), ToolExecutionService({
 			toolCallManager,
 			feed,
@@ -304,19 +611,40 @@ var AgentProcess = (options) => Process.make({
 			log("childEvent", { event }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file$1,
-				L: 325,
+				L: 713,
 				S: this
 			});
+			if (event._tag === "exited" && asyncHooks.includes(event.pid)) {
+				asyncHooks = asyncHooks.filter((pid) => pid !== event.pid);
+				yield* AsyncHooksCell.set(asyncHooks);
+				const exit = yield* (yield* Process.ManagerService).attach(event.pid).pipe(Effect.flatMap(Process.awaitOutput), Effect.exit);
+				if (Exit.isFailure(exit)) log.warn("background end-request hook failed", { pid: event.pid }, {
+					"~LogMeta": "~LogMeta",
+					F: __dxlog_file$1,
+					L: 721,
+					S: this
+				});
+				yield* maybeComplete;
+				return;
+			}
 			if (event._tag === "exited") {
 				const delegation = delegations.find((delegation) => delegation.pid === event.pid);
 				if (delegation) {
 					delegations = delegations.filter((other) => other.pid !== event.pid);
 					yield* DelegationsCell.set(delegations);
-					const exit = yield* (yield* (yield* ProcessManager.ProcessOperationInvoker.Service).attachFiber(event.pid).pipe(Effect.orDie)).await;
+					const child = yield* (yield* Process.ManagerService).attach(event.pid);
+					const exit = yield* Process.awaitOutput(child).pipe(Effect.exit);
+					const result = Exit.isSuccess(exit) ? resultPreview(exit.value) : void 0;
+					yield* Trace.write(Trace.DelegationCompleted, {
+						taskId: delegation.id,
+						pid: String(event.pid),
+						status: Exit.isSuccess(exit) ? "success" : "failure",
+						...result === void 0 ? {} : { result }
+					});
 					if (Option.isSome(strategy)) {
-						yield* strategy.value.onComplete(feed, delegation.id, exit);
+						yield* strategy.value.onComplete(chat, delegation.id, exit);
 						const activeIds = new Set(delegations.map((delegation) => delegation.id));
-						const pending = yield* strategy.value.reconcile(feed, activeIds);
+						const pending = yield* strategy.value.reconcile(chat, activeIds);
 						for (const next of pending) {
 							const pid = yield* next.spawn;
 							delegations.push({
@@ -329,9 +657,13 @@ var AgentProcess = (options) => Process.make({
 							}, {
 								"~LogMeta": "~LogMeta",
 								F: __dxlog_file$1,
-								L: 347,
+								L: 757,
 								S: this
 							});
+							yield* Trace.write(Trace.DelegationSpawned, {
+								taskId: next.id,
+								pid: String(pid)
+							});
 						}
 						if (pending.length > 0) yield* DelegationsCell.set(delegations);
 					}
@@ -342,25 +674,22 @@ var AgentProcess = (options) => Process.make({
 					}, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 353,
+						L: 764,
 						S: this
 					});
 					yield* maybeComplete;
 				} else if (toolCallManager.isToolCall(event.pid)) {
-					const attachExit = yield* (yield* ProcessManager.ProcessOperationInvoker.Service).attachFiber(event.pid).pipe(Effect.exit);
-					if (Exit.isFailure(attachExit)) {
-						if (toolCallManager.isToolCall(event.pid) || inputQueue.some((item) => item._tag === "tool_result" && item.pid === event.pid) || toolCallManager.isReported(event.pid)) {
-							log.verbose("childEvent skipped (process gone, result already handled)", { pid: event.pid }, {
-								"~LogMeta": "~LogMeta",
-								F: __dxlog_file$1,
-								L: 366,
-								S: this
-							});
-							return;
-						}
-						return yield* Effect.failCause(attachExit.cause).pipe(Effect.orDie);
+					const attachExit = yield* (yield* Process.ManagerService).attach(event.pid).pipe(Effect.exit);
+					if (Exit.isFailure(attachExit) && isToolResultHandled(toolResults, event.pid, (pid) => toolCallManager.isReported(pid))) {
+						log.verbose("childEvent skipped (process gone, result already handled)", { pid: event.pid }, {
+							"~LogMeta": "~LogMeta",
+							F: __dxlog_file$1,
+							L: 775,
+							S: this
+						});
+						return;
 					}
-					const result = yield* attachExit.value.await.pipe(Effect.orDie).pipe(Effect.map(Exit.match({
+					const result = yield* (Exit.isFailure(attachExit) ? Effect.failCause(attachExit.cause) : Process.awaitOutput(attachExit.value)).pipe(Effect.exit, Effect.map(Exit.match({
 						onSuccess: (value) => ({
 							_tag: "tool_result",
 							pid: event.pid,
@@ -374,47 +703,43 @@ var AgentProcess = (options) => Process.make({
 							isError: true
 						})
 					})));
-					inputQueue.push(result);
+					toolResults.push(result);
 					log("agent onChildEvent persisted tool result", {
-						depth: inputQueue.length,
+						depth: toolResults.length,
 						childPid: event.pid
 					}, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 391,
+						L: 803,
 						S: this
 					});
-					yield* AgentEventsCell.set(inputQueue);
-					alarmManager.reconcile(true);
-					log("agent onChildEvent alarm scheduled", { depth: inputQueue.length }, {
+					yield* ToolResultsCell.set(toolResults);
+					yield* ctx.setAlarm(0);
+					log("agent onChildEvent alarm scheduled", { depth: toolResults.length }, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 394,
+						L: 806,
 						S: this
 					});
-				} else log.verbose("childEvent ignored non-tool call and not a delegation", { pid: event.pid }, {
-					"~LogMeta": "~LogMeta",
-					F: __dxlog_file$1,
-					L: 396,
-					S: this
-				});
+				} else {
+					log.verbose("childEvent ignored non-tool call and not a delegation", { pid: event.pid }, {
+						"~LogMeta": "~LogMeta",
+						F: __dxlog_file$1,
+						L: 808,
+						S: this
+					});
+					untrackedExits.add(event.pid);
+				}
 			}
 		})
 	};
-}));
-var AgentEvent = Schema.Union([
-	Schema.TaggedStruct("prompt", { content: Schema.Array(ContentBlock.Any) }),
-	Schema.TaggedStruct("tool_result", {
-		pid: Process.ID,
-		result: Schema.Unknown,
-		isError: Schema.Boolean
-	}),
-	Schema.TaggedStruct("alarm", {
-		firedAt: Schema.Number,
-		message: Schema.NullOr(Schema.String)
-	})
-]);
-var AgentEventsCell = StorageService.cell(Schema.fromJsonString(Schema.Array(AgentEvent).pipe(Schema.mutable)), "inputQueue").pipe(StorageService.withDefault(() => []));
+})));
+var ToolResultEvent = Schema.TaggedStruct("tool_result", {
+	pid: Process.ID,
+	result: Schema.Unknown,
+	isError: Schema.Boolean
+});
+var ToolResultsCell = StorageService.cell(Schema.fromJsonString(Schema.Array(ToolResultEvent).pipe(Schema.mutable)), "toolResults").pipe(StorageService.withDefault(() => []));
 /**
 * Tracks delegated sub-agent child processes (pid -> correlation id) so that, after a hibernation,
 * a delegated child's exit can be matched back to the work it was fulfilling.
@@ -424,6 +749,27 @@ var Delegation = Schema.Struct({
 	id: Schema.String
 }).mapFields(Struct.map(Schema.mutableKey));
 var DelegationsCell = StorageService.cell(Schema.fromJsonString(Schema.Array(Delegation).pipe(Schema.mutable)), "delegations").pipe(StorageService.withDefault(() => []));
+/** Pids of background ({@link Skill.Hook.async}) end-request hooks the process is waiting on. */
+var AsyncHooksCell = StorageService.cell(Schema.fromJsonString(Schema.Array(Process.ID).pipe(Schema.mutable)), "asyncHooks").pipe(StorageService.withDefault(() => []));
+/**
+* Ids of queue entries this process has ACKED, held until the ack is visible in the feed read.
+*
+* The ack is a feed append and a hosted process reads the feed back through the eventually
+* consistent space index, so `loadPending` keeps returning an entry whose ack has not landed yet —
+* and `loadPending` deliberately includes in-flight entries, so that an interrupted turn is
+* redelivered. Without this the two combine into a redelivery loop: the agent re-runs the same turn
+* on every wake, forever. Durable rather than in-memory because the isolate does not survive
+* between turns, and pruned as soon as the entry leaves the pending set, so it cannot grow
+* unbounded.
+*
+* This does NOT weaken at-least-once delivery: an entry is recorded only after its turn ran, which
+* is the same point the ack is written, so a crash before that still redelivers.
+*/
+var AckedEntriesCell = StorageService.cell(Schema.fromJsonString(Schema.Array(Schema.String).pipe(Schema.mutable)), "ackedEntries").pipe(StorageService.withDefault(() => []));
+/** Alarms that have woken the agent since the last user prompt; bounded by {@link Alarm.MAX_SELF_WAKES}. */
+var SelfWakesCell = StorageService.cell(Schema.fromJsonString(Schema.Number), "selfWakes").pipe(StorageService.withDefault(() => 0));
+/** A prompt someone typed, as opposed to one the system wrote (a report, a tool result). */
+var isUserPrompt = (message) => message.sender.role === "user" && message.blocks.some((block) => block._tag === "text" && block.disposition !== "synthetic");
 var ToolCallState = Schema.Struct({ activeCalls: Schema.Array(Schema.Struct({
 	pid: Process.ID,
 	reported: Schema.Boolean
@@ -475,7 +821,6 @@ var ToolCallManager = class {
 		return Effect.gen({ self: this }, function* () {
 			let changed = false;
 			for (const item of queue) {
-				if (item._tag !== "tool_result") continue;
 				const call = this.#state.activeCalls.find((entry) => entry.pid === item.pid);
 				if (call?.reported) {
 					call.reported = false;
@@ -483,7 +828,7 @@ var ToolCallManager = class {
 					log("reconcile queued tool result", { pid: item.pid }, {
 						"~LogMeta": "~LogMeta",
 						F: __dxlog_file$1,
-						L: 535,
+						L: 971,
 						S: this
 					});
 				}
@@ -492,8 +837,13 @@ var ToolCallManager = class {
 		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
 	}
 };
-/** True while the agent still has queued work, a self-wake, subprocesses, or undelivered tool results. */
-var isAgentWorkPending = ({ inputQueue, alarmManager, delegations, toolCallManager }) => inputQueue.length > 0 || alarmManager.wakeAt != null || delegations.length > 0 || toolCallManager.hasPendingToolResults();
+/** True while the agent still has queued work, a pending alarm, subprocesses, or undelivered tool results. */
+var isAgentWorkPending = ({ toolResults, pendingMessages, pendingAlarms, delegations, toolCallManager }) => toolResults.length > 0 || pendingMessages.length > 0 || pendingAlarms.length > 0 || delegations.length > 0 || toolCallManager.hasPendingToolResults();
+/**
+* Whether a tool call's result is already accounted for — queued for the next turn or delivered to the
+* agent — so a finished child that can no longer be reattached needs no answer of its own.
+*/
+var isToolResultHandled = (queue, pid, isReported) => queue.some((item) => item.pid === pid) || isReported(pid);
 /**
 * Discards tool results at the head of the queue whose values already reached the agent.
 *
@@ -507,37 +857,24 @@ var dropReportedToolResults = (queue, isReported) => {
 	const dropped = [];
 	while (queue.length > 0) {
 		const head = queue[0];
-		if (head._tag !== "tool_result" || !isReported(head.pid)) break;
+		if (!isReported(head.pid)) break;
 		queue.shift();
 		dropped.push(head.pid);
 	}
 	return dropped;
 };
 /**
-* Renders a queued event as the next turn's prompt.
-*
-* A tool result recovered across a reload is redelivered as a synthetic `<result pid=N>` TEXT block
+* Renders a recovered tool result as the next turn's prompt: a synthetic `<result pid=N>` TEXT block
 * rather than a tool-result part, because the request it belonged to is gone and its tool-call id
 * cannot be answered. `disposition: 'synthetic'` keeps it out of the user-visible transcript.
 */
-var agentEventToPrompt = (event) => Match.value(event).pipe(Match.tag("prompt", (event) => [...event.content]), Match.tag("tool_result", (event) => [ContentBlock.Text.make({
-	text: event.isError ? toolErrorResponse(event.pid, event.result) : toolResultResponse(event.pid, event.result),
-	disposition: "synthetic"
-})]), Match.tag("alarm", (event) => [ContentBlock.Text.make({
-	text: wakeUpPrompt(event.firedAt, event.message),
+var toolResultPrompt = (event) => [ContentBlock.Text.make({
+	text: event.isError ? toolErrorResponse(event.pid, String(event.result)) : toolResultResponse(event.pid, event.result),
 	disposition: "synthetic"
-})]), Match.exhaustive);
+})];
 /**
-* Persisted next agent-scheduled self-wake: the UNIX timestamp (ms) and an optional reminder
-* message delivered when it fires, or `null` when no self-wake is set.
-*/
-var AgentAlarmCell = StorageService.cell(Schema.fromJsonString(Schema.NullOr(Schema.Struct({
-	wakeAt: Schema.Number,
-	message: Schema.NullOr(Schema.String)
-}))), "agentAlarm").pipe(StorageService.withDefault(() => null));
-/**
-* Computes the timeout to pass to `ctx.setAlarm`, reconciling pending queue work with the agent's
-* self-wake alarm. Returns `null` when no alarm should be scheduled (process can go idle).
+* Computes the timeout to pass to `ctx.setAlarm`, reconciling pending queue work with the earliest
+* pending feed alarm. Returns `null` when no alarm should be scheduled (process can go idle).
 */
 var computeAlarmDelay = ({ hasPendingWork, wakeAt, now }) => {
 	if (hasPendingWork) return 0;
@@ -545,96 +882,19 @@ var computeAlarmDelay = ({ hasPendingWork, wakeAt, now }) => {
 	return null;
 };
 /**
-* Tracks the next agent-scheduled self-wake and keeps it in sync with the process alarm
-* (`ctx.setAlarm`). The agent sets alarms via the alarm blueprint, which dispatches to this manager
-* through the `HarnessControl` RPC surface; the process reconciles the underlying single-shot alarm
-* timer to fire at the earliest of pending work or the self-wake.
-*/
-var AlarmManager = class {
-	#storageService;
-	#setAlarm;
-	#now;
-	#wakeAt = null;
-	#message = null;
-	constructor({ storageService, setAlarm, now = () => Date.now() }) {
-		this.#storageService = storageService;
-		this.#setAlarm = setAlarm;
-		this.#now = now;
-	}
-	/** Currently scheduled self-wake timestamp (ms), or `null` when none is set. */
-	get wakeAt() {
-		return this.#wakeAt;
-	}
-	/** Reminder message delivered when the current self-wake fires, or `null` when none is set. */
-	get message() {
-		return this.#message;
-	}
-	now() {
-		return this.#now();
-	}
-	/** Restores the persisted alarm state. */
-	load() {
-		return Effect.gen({ self: this }, function* () {
-			const persisted = yield* AgentAlarmCell.get;
-			this.#wakeAt = persisted?.wakeAt ?? null;
-			this.#message = persisted?.message ?? null;
-		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
-	}
-	/** Records a new self-wake target (with an optional reminder message) and persists it. */
-	setWakeAt(wakeAt, message = null) {
-		return Effect.gen({ self: this }, function* () {
-			this.#wakeAt = wakeAt;
-			this.#message = message;
-			yield* AgentAlarmCell.set({
-				wakeAt,
-				message
-			});
-		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
-	}
-	/**
-	* Clears the self-wake alarm if it is due, returning the timestamp it was scheduled for and the
-	* reminder message it carried (or `null` if no alarm was due).
-	*/
-	takeFiredAlarm() {
-		return Effect.gen({ self: this }, function* () {
-			if (this.#wakeAt == null || this.#now() < this.#wakeAt) return null;
-			const firedAt = this.#wakeAt;
-			const message = this.#message;
-			this.#wakeAt = null;
-			this.#message = null;
-			yield* AgentAlarmCell.set(null);
-			return {
-				firedAt,
-				message
-			};
-		}).pipe(Effect.provideService(StorageService.StorageService, this.#storageService));
-	}
-	/**
-	* Reconciles the process alarm timer with pending work and the tracked self-wake, scheduling the
-	* earliest of the two. Does nothing when there is neither pending work nor a self-wake.
-	*/
-	reconcile(hasPendingWork) {
-		const delay = computeAlarmDelay({
-			hasPendingWork,
-			wakeAt: this.#wakeAt,
-			now: this.#now()
-		});
-		if (delay != null) this.#setAlarm(delay);
-	}
-};
-/**
 * Prompt delivered to the agent when a self-scheduled alarm fires. When the alarm carried a
 * reminder message it is surfaced verbatim, otherwise a generic continuation prompt is used.
+* Exported so the prompt shape stays pinned by tests without spawning an agent.
 */
-var wakeUpPrompt = (firedAt, message) => message != null ? trim`
-      Your scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).
-      ${message}
-    ` : trim`
-      Your scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).
-      Continue with whatever you intended to do when you scheduled this wake-up.
-    `;
+var wakeUpPrompt = (firedAt, message, budget) => {
+	return [
+		`Scheduled alarm fired (it was set for ${new Date(firedAt).toISOString()}).`,
+		message ?? "Continue with whatever you intended to do when you scheduled this wake-up.",
+		budget == null ? void 0 : budget.wake >= budget.max ? `This is self-wake ${budget.wake} of ${budget.max}: further alarms will not wake you until the user writes again, so finish or report where you are now.` : `This is self-wake ${budget.wake} of ${budget.max} before the user must write again.`
+	].filter((line) => line != null).join("\n");
+};
 var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duration.seconds(1), toolCallManager, feed }) => Layer.unwrap(Effect.gen(function* () {
-	const operationInvoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+	const childServices = yield* Effect.context();
 	return makeToolExecutionService({ invoke: (tool, input) => Effect.gen(function* () {
 		const operationDef = getOperationFromTool(tool).pipe(Option.getOrThrow);
 		log("invoking operation", {
@@ -643,34 +903,37 @@ var ToolExecutionService = ({ enableBackgrounding, backgroundThreshold = Duratio
 		}, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 770,
+			L: 1117,
 			S: this
 		});
-		const fiber = yield* operationInvoker.invokeFiber(operationDef, input, {
+		const handle = yield* Process.spawn(OperationProcess.make(operationDef), input, {
 			environment: { conversation: Obj.getURI(feed) },
 			traceMeta: { conversation: Ref.make(feed) }
 		});
-		yield* toolCallManager.beginCall(fiber.pid);
+		markWork("tool.spawned");
+		yield* toolCallManager.beginCall(handle.pid);
+		markWork("tool.call-recorded");
 		log("invoked operation", {
 			operationDef,
 			input,
-			fiber
+			pid: handle.pid
 		}, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 780,
+			L: 1129,
 			S: this
 		});
-		const awaitWithReport = fiber.await.pipe(Effect.tap(() => toolCallManager.markAsReported(fiber.pid)));
-		const result = enableBackgrounding ? yield* awaitWithReport.pipe(Effect.timeout(backgroundThreshold), Effect.catchTag("TimeoutError", () => Effect.succeed(Exit.succeed(toolIsRunningInBackgroundResponse(fiber.pid))))) : yield* awaitWithReport;
+		const awaitWithReport = Process.awaitOutput(handle).pipe(Effect.exit, Effect.tap(() => toolCallManager.markAsReported(handle.pid)));
+		const result = enableBackgrounding ? yield* awaitWithReport.pipe(Effect.timeout(backgroundThreshold), Effect.catchTag("TimeoutError", () => Effect.succeed(Exit.succeed(toolIsRunningInBackgroundResponse(handle.pid))))) : yield* awaitWithReport;
+		markWork("tool.settled");
 		log("result", { result }, {
 			"~LogMeta": "~LogMeta",
 			F: __dxlog_file$1,
-			L: 791,
+			L: 1144,
 			S: this
 		});
 		return yield* result;
-	}) });
+	}).pipe(Effect.provide(childServices)) });
 }));
 var AsynchronousExectionToolkit = class extends Toolkit.make(Tool.make("poll-tools", {
 	description: trim`
@@ -693,12 +956,16 @@ var AsynchronousExectionToolkit = class extends Toolkit.make(Tool.make("poll-too
 	})
 })) {};
 var AsynchronousExectionToolkitLayer = AsynchronousExectionToolkit.toLayer(Effect.gen(function* () {
-	const invoker = yield* ProcessManager.ProcessOperationInvoker.Service;
+	const manager = yield* Process.ManagerService;
 	return { "poll-tools": ({ ids, wait, timeout = 1e4 }) => Effect.gen(function* () {
-		return yield* Effect.forEach(ids, (pid) => invoker.attachFiber(Process.ID.make(pid)).pipe(Effect.flatMap((_) => _.await), Effect.timeout(Duration.millis(timeout)), Effect.flatMap(Exit.match({
-			onSuccess: (value) => Effect.succeed(toolResultResponse(pid, value)),
-			onFailure: (cause) => Effect.succeed(toolErrorResponse(pid, Cause.pretty(cause)))
-		})), Effect.catchTag("ProcessNotFoundError", () => Effect.succeed(`Process not found: ${pid}`)), Effect.catchTag("TimeoutError", () => Effect.succeed(`Process still running: ${pid}`))));
+		return yield* Effect.forEach(ids, (pid) => Effect.gen(function* () {
+			const attached = yield* manager.attach(Process.ID.make(pid)).pipe(Effect.exit);
+			if (Exit.isFailure(attached)) return `Process not found: ${pid}`;
+			return yield* Process.awaitOutput(attached.value).pipe(Effect.exit, Effect.timeout(Duration.millis(timeout)), Effect.map(Exit.match({
+				onSuccess: (value) => toolResultResponse(pid, value),
+				onFailure: (cause) => toolErrorResponse(pid, Cause.pretty(cause))
+			})), Effect.catchTag("TimeoutError", () => Effect.succeed(`Process still running: ${pid}`)));
+		}));
 	}) };
 }));
 /**
@@ -714,9 +981,11 @@ var AgentService_exports = /* @__PURE__ */ __exportAll({
 	layer: () => layer
 });
 var __dxlog_file = "/__w/dxos/dxos/packages/core/compute/agent-runtime/src/agent-service/AgentService.ts";
-var isTerminalProcess = (state) => state === Process.State.SUCCEEDED || state === Process.State.FAILED || state === Process.State.TERMINATED;
+/**
+* Creates a session on a fresh feed and chat, with `opts.skills` and `opts.context` bound to it.
+*/
 var createSession = Effect.fn("createSession")(function* (opts) {
-	const skills = yield* Effect.forEach(opts?.skills ?? [], (skill) => Skill.upsert(Skill.getKey(skill)).pipe(Effect.map(Ref.make)));
+	const skills = (opts?.skills ?? []).map(Skill.makeRef);
 	const feed = yield* Database.add(Feed.make());
 	const runtime = yield* Effect.context();
 	const binder = yield* EffectEx.acquireReleaseResource(() => new AiContext.Binder({
@@ -727,101 +996,182 @@ var createSession = Effect.fn("createSession")(function* (opts) {
 		skills,
 		objects: opts?.context ?? []
 	}));
-	return yield* getSession(feed, {
-		model: opts?.model,
-		provider: opts?.provider
-	});
+	const chat = yield* Database.add(Chat.make({
+		feed: Ref.make(feed),
+		...opts?.model ? { session: { model: opts.model } } : {}
+	}));
+	return yield* AgentService.getSession(chat, { provider: opts?.provider });
 }, Effect.scoped);
-var layer = (opts) => Layer.effect(AgentService, Effect.gen(function* () {
-	const processManager = yield* ProcessManager.Service;
+/**
+* The `AgentService` layer.
+*
+* Requires {@link Process.ManagerService}, which runs a session locally or, for `location: 'edge'`,
+* on the remote runtime. A host without EDGE satisfies its remote half with
+* `RemoteProcessManager.layerNoop`, so an edge session fails at spawn rather than silently running
+* locally.
+*/
+var layer = (opts) => Layer.effect(AgentService.AgentService, Effect.gen(function* () {
+	const processManager = yield* Process.ManagerService;
+	const remoteSpaces = /* @__PURE__ */ new Set();
+	/**
+	* Where a session's agent runs. `edge` needs the space, since one remote runtime spans them,
+	* and a chat with no space cannot name where its agent would run.
+	*/
+	const locationFor = (location, spaceId) => {
+		if (location !== "edge") return { kind: "local" };
+		if (!spaceId) throw new Error("Agent requested on edge, but its conversation has no space.");
+		remoteSpaces.add(spaceId);
+		return {
+			kind: "edge",
+			space: spaceId
+		};
+	};
 	const sessionCache = /* @__PURE__ */ new Map();
-	const makeExecutable = (model, provider) => AgentProcess({
+	const sessionLocks = /* @__PURE__ */ new Map();
+	const lockFor = (chatId) => {
+		const existing = sessionLocks.get(chatId);
+		if (existing) return existing;
+		const lock = Effect.runSync(Semaphore.make(1));
+		sessionLocks.set(chatId, lock);
+		return lock;
+	};
+	const makeExecutable = (provider) => AgentProcess({
 		systemPrompt: opts?.systemPrompt,
 		makeTurnProducer: opts?.makeTurnProducer,
-		model: model ?? opts?.model,
+		defaultModel: opts?.defaultModel,
 		provider: provider ?? opts?.provider,
-		getMcpServers: opts?.getMcpServers,
 		enableToolBackgrounding: opts?.enableToolBackgrounding,
-		delegationStrategy: opts?.delegationStrategy
+		delegationStrategy: opts?.delegationStrategy,
+		resident: opts?.resident
 	});
-	return {
-		getSession: (feed, options) => Effect.gen(function* () {
-			const model = options?.model ?? opts?.model;
+	/**
+	* The process a chat runs on: the one its session names, or ours. A name nothing contributed
+	* (its plugin was removed) falls back to ours rather than leaving the chat unable to run.
+	*/
+	const executableFor = (chat, provider) => {
+		const key = chat.session?.process;
+		if (key === void 0 || key === "org.dxos.testing.process.agent") return makeExecutable(provider);
+		const definition = opts?.processes?.().find((candidate) => candidate.key === key);
+		if (!definition) {
+			log.warn("agent process not contributed; running the default", { key }, {
+				"~LogMeta": "~LogMeta",
+				F: __dxlog_file,
+				L: 201,
+				S: this
+			});
+			return makeExecutable(provider);
+		}
+		return definition;
+	};
+	const service = {
+		getSession: (chat, options) => Effect.suspend(() => lockFor(chat.id).withPermits(1)(Effect.gen(function* () {
 			const provider = options?.provider ?? opts?.provider;
-			const instructions = options?.instructions?.uri;
-			const cached = sessionCache.get(feed.id);
+			const model = chat.session?.model;
+			const instructions = chat.instructions?.uri;
+			const location = options?.location ?? "local";
+			const executable = executableFor(chat, provider);
+			if (location === "edge" && executable.key !== "org.dxos.testing.process.agent") return yield* Effect.die(/* @__PURE__ */ new Error(`Agent process ${executable.key} runs only locally, but the chat asked for edge.`));
+			const cached = sessionCache.get(chat.id);
 			if (cached) {
-				if (cached.model === model && cached.provider === provider && cached.instructions === instructions && !isTerminalProcess(cached.handle.status.state)) return cached.session;
-				if (!isTerminalProcess(cached.handle.status.state)) yield* cached.handle.terminate();
-				sessionCache.delete(feed.id);
+				if (cached.model === model && cached.provider === provider && cached.instructions === instructions && cached.location === location && cached.process === executable.key && !Process.isTerminal(cached.handle.status.state)) return cached.session;
+				if (!Process.isTerminal(cached.handle.status.state)) yield* cached.handle.terminate();
+				sessionCache.delete(chat.id);
 			}
-			const target = Obj.getURI(feed);
+			const feed = yield* Database.load(chat.feed).pipe(Effect.orDie);
+			const target = Obj.getURI(chat);
 			const parsedEchoUri = EID.tryParse(target);
 			const spaceId = parsedEchoUri ? EID.getSpaceId(parsedEchoUri) : void 0;
-			const executable = makeExecutable(model, provider);
-			let activeProcess = (yield* processManager.list({
+			const processLocation = locationFor(options?.location, spaceId);
+			let activeProcess = (yield* processManager.handles({
 				target,
-				key: executable.key
-			})).find((process) => !isTerminalProcess(process.status.state));
-			if (activeProcess) {
-				if (Option.getOrUndefined(Annotation.getDictionary(activeProcess.params.annotations, Process.InstructionsAnnotation)) !== instructions) {
-					yield* activeProcess.terminate();
-					activeProcess = void 0;
-				}
-			}
+				key: executable.key,
+				location: processLocation
+			})).find((process) => !Process.isTerminal(process.status.state));
 			let handle;
-			if (activeProcess) {
-				yield* activeProcess.hydrate(executable);
-				handle = activeProcess;
-			} else handle = yield* processManager.spawn(executable, {
+			if (activeProcess) handle = yield* activeProcess.hydrate(executable);
+			else handle = yield* processManager.spawn(executable, {
+				location: processLocation,
 				name: "Agent",
 				target,
 				annotations: Annotation.buildDictionary((dictionary) => {
 					Annotation.setDictionary(dictionary, Process.HarnessHostAnnotation, true);
-					if (options?.instructions) Annotation.setDictionary(dictionary, Process.InstructionsAnnotation, options.instructions.uri);
 				}),
 				environment: {
 					...spaceId !== void 0 ? { space: spaceId } : {},
-					conversation: target
+					conversation: Obj.getURI(feed)
 				},
 				traceMeta: { conversation: Ref.make(feed) }
 			});
 			const releaseSession = () => {
-				sessionCache.delete(feed.id);
+				sessionCache.delete(chat.id);
 			};
-			const session = makeSession(handle, feed, releaseSession);
-			sessionCache.set(feed.id, {
+			const databaseContext = yield* Effect.context();
+			const isFinished = Effect.suspend(() => Process.isTerminal(handle.status.state) || location !== "edge" ? Effect.succeed(Process.isTerminal(handle.status.state)) : processManager.handles({
+				target,
+				key: executable.key,
+				location: processLocation
+			}).pipe(Effect.map((live) => {
+				const current = live.find((process) => process.pid === handle.pid);
+				return current === void 0 || Process.isTerminal(current.status.state);
+			}), Effect.orElseSucceed(() => false)));
+			const resubmit = (prompt, submitOptions) => Effect.sync(releaseSession).pipe(Effect.andThen(service.getSession(chat, options)), Effect.flatMap((next) => next.submitPrompt(prompt, submitOptions)), Effect.provide(databaseContext));
+			const session = makeSession(handle, chat, feed, releaseSession, isFinished, resubmit);
+			sessionCache.set(chat.id, {
 				model,
 				provider,
 				instructions,
+				location,
+				process: executable.key,
 				handle,
 				session
 			});
 			return session;
-		}),
+		}))),
 		hydrate: Effect.fnUntraced(function* () {
 			sessionCache.clear();
+			const contributed = (opts?.processes?.() ?? []).filter(({ key }) => key !== AGENT_PROCESS_KEY);
 			const executable = makeExecutable();
-			const agents = yield* processManager.list({ key: AGENT_PROCESS_KEY });
+			const agents = [
+				...(yield* processManager.handles({ key: AGENT_PROCESS_KEY })).map((agent) => ({
+					agent,
+					executable
+				})),
+				...(yield* Effect.forEach(contributed, (definition) => processManager.handles({ key: definition.key }).pipe(Effect.map((agents) => agents.map((agent) => ({
+					agent,
+					executable: definition
+				})))))).flat(),
+				...(yield* Effect.forEach([...remoteSpaces], (space) => processManager.handles({
+					key: AGENT_PROCESS_KEY,
+					location: {
+						kind: "edge",
+						space
+					}
+				}))).flat().map((agent) => ({
+					agent,
+					executable
+				}))
+			];
 			log("agent hydrate", { count: agents.length }, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file,
-				L: 150,
+				L: 231,
 				S: this
 			});
-			for (const agent of agents) yield* agent.hydrate(executable).pipe(Effect.catchCause((cause) => Effect.sync(() => log.warn("agent hydrate skipped", {
+			for (const { agent, executable } of agents) yield* agent.hydrate(executable).pipe(Effect.catchCause((cause) => Effect.sync(() => log.warn("agent hydrate skipped", {
 				pid: agent.pid,
 				cause: Cause.pretty(cause)
 			}, {
 				"~LogMeta": "~LogMeta",
 				F: __dxlog_file,
-				L: 156,
+				L: 237,
 				S: this
 			}))));
 		})
 	};
+	return service;
 }));
-var makeSession = (process, feed, releaseSession) => ({
+var makeSession = (process, chat, feed, releaseSession, isFinished, resubmit) => ({
+	chat,
 	feed,
 	getContext: () => Effect.gen(function* () {
 		const runtime = yield* Effect.context();
@@ -841,12 +1191,16 @@ var makeSession = (process, feed, releaseSession) => ({
 			objects: context
 		}));
 	}).pipe(Effect.scoped),
-	submitPrompt: (prompt) => process.submitInput(prompt),
+	submitPrompt: (prompt, options) => Effect.flatMap(isFinished, (finished) => finished ? resubmit(prompt, options) : process.submitInput(options?.sender ? {
+		prompt,
+		sender: options.sender
+	} : prompt)),
+	running: Atom.make((get) => get(process.statusAtom).state === Process.State.RUNNING || get(process.statusAtom).state === Process.State.HYBERNATING),
 	waitForCompletion: () => process.runUntilSettled(),
 	terminate: () => process.terminate().pipe(Effect.tap(() => Effect.sync(releaseSession))),
-	subscribeEphemeral: () => process.subscribeEphemeral()
+	subscribeEphemeral: (options) => process.subscribeEphemeral(options)
 });
 //#endregion
-export { __exportAll as a, makeAiSessionTurnProducer as i, layer as n, AGENT_PROCESS_KEY as r, AgentService_exports as t };
+export { AgentProcess as a, __exportAll as c, AgentInput as i, layer as n, makeInputMessage as o, AGENT_PROCESS_KEY as r, makeAiSessionTurnProducer as s, AgentService_exports as t };
 
 //# sourceMappingURL=chunk-AgentService.mjs.map