@junejs/server 1.0.0-dev.36 → 1.0.0-dev.42

package/dist/agent-durable.d.ts

@@ -1,5 +1,5 @@
 import { Channel, ChannelFactory } from "@junejs/core/agent-config";
-import { AuthorizeAnswer, ChannelPolicy, InboundEvent, Model, Msg, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
+import { AuthorizeAnswer, ChannelPolicy, InboundEvent, InputAnnouncement, Model, Msg, NoteKind, ProactiveTrigger, SessionStore, Tool, TurnError, TurnEvent, TurnFailurePhase } from "@junejs/core/agent-runtime";
 import { Connection } from "@junejs/core/connections";
 import { Resources } from "@junejs/core/resources";
 //#region src/agent-durable.d.ts
@@ -14,6 +14,7 @@ export interface SqlStorage {
 export interface DurableStorage {
   sql: SqlStorage;
   transactionSync<T>(fn: () => T): T;
+  setAlarm?(scheduledTime: number): unknown;
 }
 export interface DurableObjectState {
   storage: DurableStorage;
@@ -40,7 +41,7 @@ export declare class DoSessionStore implements SessionStore {
   getSessionKey(): string | undefined;
   setSessionKey(key: string): void;
   tx<T>(fn: () => T): T;
-  reset(): number;
+  reset(inTx?: () => void): number;
   unwrap<H = unknown>(): H;
 }
 export type DoAgentDef = {
@@ -61,6 +62,7 @@ export type DoAgentDef = {
     step?: string;
   }) => void | Promise<void>;
   authorizeAnswer?: AuthorizeAnswer;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
 export declare class AgentDurableObject {
   private session;
@@ -79,11 +81,18 @@ export declare class AgentDurableObject {
   private readonly doEnv;
   private readonly services;
   private readonly authorizeAnswer?;
+  private readonly onInputAnnouncement?;
+  private readonly storage;
+  private announceFailures;
   private resolveResources;
   private resolveConnections;
   private ready;
   constructor(state: DurableObjectState, def: DoAgentDef);
   private resolveSession;
+  alarm(): Promise<void>;
+  private armWatchdog;
+  private scheduleAlarm;
+  private deliverHeld;
   turn(input: {
     turnId?: string;
     userText: string;
@@ -100,6 +109,14 @@ export declare class AgentDurableObject {
   }): Promise<{
     turnId: string;
   }>;
+  note(input: {
+    by: string;
+    kind: NoteKind;
+    text: string;
+    session?: string;
+  }): Promise<{
+    noteId: string;
+  }>;
   reset(opts?: {
     session?: string;
   }): Promise<{

package/dist/agent-durable.js

@@ -54,7 +54,7 @@ var DoSessionStore = class {
 	tx(fn) {
 		return this.storage.transactionSync(fn);
 	}
-	reset() {
+	reset(inTx) {
 		return this.storage.transactionSync(() => {
 			const sql = this.sql;
 			sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
@@ -67,6 +67,7 @@ var DoSessionStore = class {
 			sql.exec("DELETE FROM agent_steps");
 			this.setStatus("new");
 			sql.exec("INSERT INTO agent_meta (k, v) VALUES ('generation', ?) ON CONFLICT(k) DO UPDATE SET v = ?", String(generation + 1), String(generation + 1));
+			inTx?.();
 			return generation;
 		});
 	}
@@ -108,6 +109,9 @@ var AgentDurableObject = class {
 	doEnv;
 	services;
 	authorizeAnswer;
+	onInputAnnouncement;
+	storage;
+	announceFailures = 0;
 	resolveResources() {
 		return this.resourcesOpened ??= Promise.resolve(typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : this.resourcesInput ?? {});
 	}
@@ -138,8 +142,13 @@ var AgentDurableObject = class {
 		this.doEnv = def.env;
 		this.services = def.services;
 		this.authorizeAnswer = def.authorizeAnswer;
+		this.onInputAnnouncement = def.onInputAnnouncement;
+		this.storage = state.storage;
 		const name = def.name ?? "agent";
 		const sink = new InProcEventSink();
+		sink.subscribe((e) => {
+			if (e.type === "turn.started") this.armWatchdog();
+		});
 		sink.subscribe((e) => {
 			if (e.type !== "turn.failed") return;
 			const defaultLog = () => console.error(`[june] agent "${name}" turn ${e.turnId} failed${e.step ? ` at ${e.step}` : ""}: ${e.error.stack ?? e.error.message}${e.error.causeChain?.length ? `\ncaused by: ${e.error.causeChain.join(" ← ")}` : ""}`);
@@ -193,8 +202,71 @@ var AgentDurableObject = class {
 		if (key !== void 0 && key !== "self" && stored === void 0) this.store.setSessionKey(key);
 		this.sessionKey = resolved;
 		this.session = new AgentSession(this.name, resolved, this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions);
+		this.session.onDequeue = (heldTurnId, held) => {
+			if (held.hostContext?.deliver && held.event) this.deliverHeld(this.session, heldTurnId, held.event);
+		};
+		const announce = this.onInputAnnouncement;
+		if (announce) {
+			this.session.onAnnounce = async (a) => {
+				await ensureScope();
+				const resources = await this.ready();
+				try {
+					await runInScope({
+						resources,
+						services: this.services
+					}, () => announce(a));
+				} catch (err) {
+					this.scheduleAlarm(Math.min(5e3 * 2 ** this.announceFailures, 3e5));
+					this.announceFailures++;
+					throw err;
+				}
+				this.announceFailures = 0;
+			};
+			this.session.flushAnnouncements();
+		}
 		return this.session;
 	}
+	async alarm() {
+		if (!this.onInputAnnouncement) return;
+		await this.resolveSession().flushAnnouncements();
+	}
+	armWatchdog() {
+		if (this.onInputAnnouncement) this.scheduleAlarm(6e4);
+	}
+	scheduleAlarm(inMs) {
+		const failed = (err) => console.error(`[june] agent "${this.name}": could not schedule the announcement alarm — delivery waits for the next announcement, turn or rebuild:`, err);
+		try {
+			Promise.resolve(this.storage.setAlarm?.(Date.now() + inMs)).catch(failed);
+		} catch (err) {
+			failed(err);
+		}
+	}
+	deliverHeld(session, turnId, event) {
+		const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for held turn ${turnId} failed:`, err);
+		try {
+			const channel = this.channels.find((c) => c.name === event.source);
+			if (!channel?.deliver) {
+				logRenderFailure(/* @__PURE__ */ new Error(`no deliver()-capable channel named "${event.source}" is wired into this DO — the held turn runs, but its reply is not rendered`));
+				return;
+			}
+			const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+			const events = { [Symbol.asyncIterator]: () => it };
+			const target = {
+				channelId: event.channelId,
+				threadId: event.threadId,
+				recipientUserId: event.user?.id,
+				recipientTeamId: event.teamId
+			};
+			this.ready().then((resources) => runInScope({
+				resources,
+				services: this.services
+			}, () => channel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
+				it.return?.();
+			});
+		} catch (err) {
+			logRenderFailure(err);
+		}
+	}
 	async turn(input) {
 		await ensureScope();
 		const resources = await this.ready();
@@ -213,8 +285,14 @@ var AgentDurableObject = class {
 			services: this.services
 		}, () => session.start(input));
 	}
+	note(input) {
+		const { session, ...note } = input;
+		return this.resolveSession(session).note(note);
+	}
 	reset(opts) {
-		return this.resolveSession(opts?.session).reset();
+		const session = this.resolveSession(opts?.session);
+		this.armWatchdog();
+		return session.reset();
 	}
 	transcript() {
 		if (this.session) return this.session.transcript();
@@ -225,10 +303,13 @@ var AgentDurableObject = class {
 		const url = new URL(req.url);
 		const key = req.headers.get("x-june-session") ?? void 0;
 		if (req.method === "POST" && url.pathname.endsWith("/turn")) {
-			const { userText, turnId, event, trigger } = await req.json();
+			const { userText, turnId, event, trigger, ifSuspended } = await req.json();
 			await ensureScope();
 			const replace = url.searchParams.get("replace") === "1";
 			const wantsDeliver = url.searchParams.get("deliver") === "1";
+			const detached = url.searchParams.get("detach") === "1";
+			if (ifSuspended === "queue" && !wantsDeliver && !detached) return Response.json({ error: `ifSuspended "queue" needs deliver=1 or detach=1: a held turn runs later, when no one is streaming it` }, { status: 400 });
+			if (ifSuspended === "queue" && replace) return Response.json({ error: `ifSuspended "queue" and replace=1 cannot be combined — replacing would drop held turns that were accepted` }, { status: 400 });
 			let deliverChannel;
 			if (wantsDeliver) {
 				if (!event?.channelId) return Response.json({ error: "deliver=1 needs an inbound event (event.channelId names the reply target)" }, { status: 400 });
@@ -240,6 +321,7 @@ var AgentDurableObject = class {
 			let started;
 			try {
 				session = this.resolveSession(key);
+				this.armWatchdog();
 				started = runInScope({
 					resources,
 					services: this.services
@@ -248,11 +330,17 @@ var AgentDurableObject = class {
 					turnId,
 					event,
 					trigger,
-					replace
+					replace,
+					ifSuspended,
+					hostContext: wantsDeliver ? { deliver: true } : void 0
 				}));
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
+			if (started.queued) return Response.json({
+				turnId: started.turnId,
+				queued: true
+			}, { status: 202 });
 			if (wantsDeliver) {
 				const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for turn ${started.turnId} failed:`, err);
 				try {
@@ -275,7 +363,7 @@ var AgentDurableObject = class {
 				}
 				return Response.json({ turnId: started.turnId }, { status: 202 });
 			}
-			if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
+			if (detached) return Response.json({ turnId: started.turnId }, { status: 202 });
 			return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
 		}
 		if (req.method === "POST" && url.pathname.endsWith("/resume")) {
@@ -310,6 +398,7 @@ var AgentDurableObject = class {
 				console.error(`[june] agent "${this.name}": authorizeAnswer failed for input "${inputId}" of turn ${turnId}:`, err);
 				return Response.json({ error: `authorizeAnswer failed: ${err instanceof Error ? err.message : String(err)} — the answer was NOT applied` }, { status: 500 });
 			}
+			this.armWatchdog();
 			try {
 				runInScope({
 					resources,
@@ -347,12 +436,33 @@ var AgentDurableObject = class {
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
+			this.armWatchdog();
 			try {
 				return Response.json(await session.reset());
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
 			}
 		}
+		if (req.method === "POST" && url.pathname.endsWith("/note")) {
+			let input;
+			try {
+				input = await req.json();
+			} catch {
+				return Response.json({ error: "note: the body must be JSON { by, kind, text }" }, { status: 400 });
+			}
+			let session;
+			try {
+				session = this.resolveSession(key);
+			} catch (err) {
+				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+			}
+			try {
+				return Response.json(await session.note(input));
+			} catch (err) {
+				if (err instanceof TypeError) return Response.json({ error: err.message }, { status: 400 });
+				throw err;
+			}
+		}
 		if (url.pathname.endsWith("/transcript")) {
 			if (key !== void 0) try {
 				return Response.json({ transcript: this.resolveSession(key).transcript() });
@@ -361,7 +471,7 @@ var AgentDurableObject = class {
 			}
 			return Response.json({ transcript: this.transcript() });
 		}
-		return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
+		return new Response("agent DO — POST /turn, POST /resume, POST /reset, POST /note, or GET /transcript", { status: 404 });
 	}
 };
 const SSE_HEADERS = {
@@ -608,7 +718,8 @@ function serializeTurn(userText, o) {
 		userText,
 		turnId: o?.turnId,
 		event: o?.event,
-		trigger: o?.trigger
+		trigger: o?.trigger,
+		ifSuspended: o?.ifSuspended
 	};
 	try {
 		return JSON.stringify(payload);

package/dist/agent-native.d.ts

@@ -1,12 +1,13 @@
 import { SyncSqlite } from "./sqlite-driver.js";
 import { AgentDefinition, ChannelContext } from "@junejs/core/agent-config";
-import { AgentSession, ChannelPolicy, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
+import { AgentSession, ChannelPolicy, InputAnnouncement, Model, Runtime, Tool } from "@junejs/core/agent-runtime";
 //#region src/agent-native.d.ts
 export type AgentDef = {
   model: Model;
   tools: Tool[];
   instructions?: string;
   channelInstructions?: Record<string, string | ChannelPolicy>;
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
 export declare function toAgentDef(agent: AgentDefinition, model: Model): AgentDef;
 export type NativeRuntimeOptions = {
@@ -16,11 +17,13 @@ export declare class NativeRuntime implements Runtime {
   private actors;
   private readonly agents;
   private readonly db;
+  private readonly announceRetry;
   private readonly maxSessions;
   constructor(agents: Record<string, AgentDef>, db: SyncSqlite, opts?: NativeRuntimeOptions);
   agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;
   get sessionCount(): number;
+  recoverAnnouncements(): void;
   private evictIdle;
 }
 export declare function createNativeRuntime(agents: Record<string, AgentDef>, path?: string, opts?: NativeRuntimeOptions): Promise<NativeRuntime>;
@@ -28,6 +31,7 @@ export declare class MemoryRuntime implements Runtime {
   private actors;
   private stores;
   private readonly agents;
+  private readonly announceRetry;
   constructor(agents: Record<string, AgentDef>);
   agentDef(name: string): AgentDef | undefined;
   session(agent: string, id: string): AgentSession;

package/dist/agent-native.js

@@ -53,7 +53,7 @@ var SqliteSessionStore = class {
 			throw e;
 		}
 	}
-	reset() {
+	reset(inTx) {
 		return this.tx(() => {
 			this.db.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (session_id TEXT, generation INTEGER, seq INTEGER, body TEXT)`);
 			this.db.exec(`CREATE TABLE IF NOT EXISTS agent_steps_archive (session_id TEXT, generation INTEGER, id TEXT, output TEXT)`);
@@ -65,6 +65,7 @@ var SqliteSessionStore = class {
 			this.db.query("DELETE FROM agent_steps WHERE session_id = ?").run(this.sid);
 			this.db.query("INSERT INTO agent_sessions (session_id, status) VALUES (?, 'new') ON CONFLICT(session_id) DO UPDATE SET status = 'new'").run(this.sid);
 			this.db.query("INSERT INTO agent_session_generations (session_id, generation) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET generation = ?").run(this.sid, generation + 1, generation + 1);
+			inTx?.();
 			return generation;
 		});
 	}
@@ -89,18 +90,64 @@ var InProcEventSink = class {
 		return this.subs.size;
 	}
 };
+var AnnouncementRetry = class {
+	flush;
+	state = /* @__PURE__ */ new Map();
+	constructor(flush) {
+		this.flush = flush;
+	}
+	delivered(key) {
+		const s = this.state.get(key);
+		if (s?.timer) clearTimeout(s.timer);
+		this.state.delete(key);
+	}
+	failed(key, agent, id) {
+		const s = this.state.get(key) ?? { failures: 0 };
+		this.state.set(key, s);
+		if (s.timer) return;
+		const delay = Math.min(5e3 * 2 ** s.failures, 3e5);
+		s.failures++;
+		s.timer = setTimeout(() => {
+			s.timer = void 0;
+			this.flush(agent, id);
+		}, delay);
+		s.timer.unref?.();
+	}
+};
+function wireAnnouncements(session, def, retry) {
+	const hook = def.onInputAnnouncement;
+	if (hook) {
+		const key = `${session.agent}:${session.id}`;
+		session.onAnnounce = async (a) => {
+			try {
+				await hook(a);
+			} catch (err) {
+				retry.failed(key, session.agent, session.id);
+				throw err;
+			}
+			retry.delivered(key);
+		};
+		session.flushAnnouncements();
+	}
+	return session;
+}
+const ANNOUNCE_OUTBOX_STEP = "announce-outbox";
 function toAgentDef(agent, model) {
 	return {
 		model,
 		tools: agent.tools,
 		instructions: buildSystemPrompt(agent),
-		...agent.channelInstructions ? { channelInstructions: agent.channelInstructions } : {}
+		...agent.channelInstructions ? { channelInstructions: agent.channelInstructions } : {},
+		...agent.onInputAnnouncement ? { onInputAnnouncement: agent.onInputAnnouncement } : {}
 	};
 }
 var NativeRuntime = class {
 	actors = /* @__PURE__ */ new Map();
 	agents;
 	db;
+	announceRetry = new AnnouncementRetry((agent, id) => {
+		this.session(agent, id).flushAnnouncements();
+	});
 	maxSessions;
 	constructor(agents, db, opts = {}) {
 		assertCoreRuntimeVersion("NativeRuntime");
@@ -126,7 +173,7 @@ var NativeRuntime = class {
 		if (!def) throw new Error(`unknown agent: ${agent}`);
 		const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
 		const sink = new InProcEventSink();
-		const session = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions);
+		const session = wireAnnouncements(new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions), def, this.announceRetry);
 		this.evictIdle();
 		this.actors.set(key, {
 			session,
@@ -137,6 +184,13 @@ var NativeRuntime = class {
 	get sessionCount() {
 		return this.actors.size;
 	}
+	recoverAnnouncements() {
+		const rows = this.db.query("SELECT output FROM agent_steps WHERE id = ?").all(ANNOUNCE_OUTBOX_STEP);
+		for (const { output } of rows) {
+			const [first] = JSON.parse(output);
+			if (first && this.agents[first.agent]?.onInputAnnouncement) this.session(first.agent, first.session);
+		}
+	}
 	evictIdle() {
 		if (this.actors.size < this.maxSessions) return;
 		for (const [key, a] of this.actors) {
@@ -146,7 +200,9 @@ var NativeRuntime = class {
 	}
 };
 async function createNativeRuntime(agents, path = ":memory:", opts = {}) {
-	return new NativeRuntime(agents, await openLocalSqliteSync(path), opts);
+	const runtime = new NativeRuntime(agents, await openLocalSqliteSync(path), opts);
+	runtime.recoverAnnouncements();
+	return runtime;
 }
 var MemorySessionStore = class {
 	msgs = [];
@@ -181,7 +237,7 @@ var MemorySessionStore = class {
 	tx(fn) {
 		return fn();
 	}
-	reset() {
+	reset(inTx) {
 		const generation = this.generation++;
 		this.archives.push({
 			generation,
@@ -191,6 +247,7 @@ var MemorySessionStore = class {
 		this.msgs = [];
 		this.steps = /* @__PURE__ */ new Map();
 		this.status = "new";
+		inTx?.();
 		return generation;
 	}
 	unwrap() {}
@@ -199,6 +256,9 @@ var MemoryRuntime = class {
 	actors = /* @__PURE__ */ new Map();
 	stores = /* @__PURE__ */ new Map();
 	agents;
+	announceRetry = new AnnouncementRetry((agent, id) => {
+		this.session(agent, id).flushAnnouncements();
+	});
 	constructor(agents) {
 		assertCoreRuntimeVersion("MemoryRuntime");
 		this.agents = agents;
@@ -215,7 +275,7 @@ var MemoryRuntime = class {
 			const store = new MemorySessionStore();
 			this.stores.set(key, store);
 			const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-			a = new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions);
+			a = wireAnnouncements(new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions), def, this.announceRetry);
 			this.actors.set(key, a);
 		}
 		return a;

package/dist/build.js

@@ -208,6 +208,10 @@ export class JuneAgentDO extends DurableObject {
   fetch(req: Request): Promise<Response> {
     return this.#agent.fetch(req);
   }
+  // Delivers input announcements left undelivered — a failed hook's retry, or the watchdog (#260).
+  alarm(): Promise<void> {
+    return this.#agent.alarm();
+  }
 }
 ` : "";
 	const entry = `// AUTO-GENERATED by \`june build\` — do not edit. Regenerate: june build .

package/dist/core-version.js

@@ -1,6 +1,6 @@
 import * as coreRuntime from "@junejs/core/agent-runtime";
 //#region src/core-version.ts
-const EXPECTED_CORE_RUNTIME_API = 2;
+const EXPECTED_CORE_RUNTIME_API = 6;
 function assertCoreRuntimeVersion(surface) {
 	checkCoreRuntimeVersion(surface, coreRuntime.RUNTIME_API_VERSION);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@junejs/server",
-  "version": "1.0.0-dev.36",
+  "version": "1.0.0-dev.42",
   "description": "June host adapters + dev server. Host-coupled; depends on the pure @junejs/core contract layer.",
   "type": "module",
   "license": "MIT",
@@ -140,7 +140,7 @@
     "rolldown": "^1.1.0"
   },
   "peerDependencies": {
-    "@junejs/core": ">=0.2.0-dev.57",
+    "@junejs/core": ">=0.2.0-dev.63",
     "react": "^19.2.0",
     "react-dom": "^19.2.0",
     "react-server-dom-webpack": "19.3.0",

package/src/agent-durable.ts

@@ -22,6 +22,8 @@ import {
   withSystem,
   type Answerers,
   type AuthorizeAnswer,
+  type InputAnnouncement,
+  type NoteKind,
   type ChannelPolicy,
   type EventSink,
   type TurnEvent,
@@ -76,6 +78,10 @@ export interface SqlStorage {
 export interface DurableStorage {
   sql: SqlStorage;
   transactionSync<T>(fn: () => T): T;
+  // Schedules the object's alarm() — the watchdog and retry for input-announcement delivery
+  // (#260). Optional so a storage without alarms (a test double) still works; delivery then
+  // waits for the next announcement, settled turn or rebuild.
+  setAlarm?(scheduledTime: number): unknown;
 }
 export interface DurableObjectState {
   storage: DurableStorage;
@@ -151,7 +157,7 @@ export class DoSessionStore implements SessionStore {
   // tables + the generation counter are created lazily, so existing objects stay
   // untouched until their first reset. seq keeps counting across generations (DELETE
   // doesn't reset AUTOINCREMENT), so an archived (generation, seq) stays unique.
-  reset(): number {
+  reset(inTx?: () => void): number {
     return this.storage.transactionSync(() => {
       const sql = this.sql;
       sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
@@ -164,6 +170,7 @@ export class DoSessionStore implements SessionStore {
       sql.exec("DELETE FROM agent_steps");
       this.setStatus("new");
       sql.exec("INSERT INTO agent_meta (k, v) VALUES ('generation', ?) ON CONFLICT(k) DO UPDATE SET v = ?", String(generation + 1), String(generation + 1));
+      inTx?.(); // writes into the fresh generation, committed with the archive (#260)
       return generation;
     });
   }
@@ -245,6 +252,9 @@ export type DoAgentDef = {
   // Decides a { policy } answerer of a parked requestInput at /resume (#261) — the same hook
   // an AgentDefinition carries natively; assembleDurable passes agent.ts's through.
   authorizeAnswer?: AuthorizeAnswer;
+  // Receives this session's input announcements (#260) — run inside the request scope, so it
+  // can write the app's cross-session index with the ambient db.
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
 };
 
 // The agent runtime INSIDE a Durable Object. A plain class (constructor takes the
@@ -288,6 +298,10 @@ export class AgentDurableObject {
   private readonly doEnv: unknown;
   private readonly services: unknown;
   private readonly authorizeAnswer?: AuthorizeAnswer;
+  private readonly onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
+  private readonly storage: DurableStorage;
+  // Consecutive failed announcement deliveries (#260) — sets the alarm retry's backoff.
+  private announceFailures = 0;
   private resolveResources(): Promise<Resources> {
     return (this.resourcesOpened ??= Promise.resolve(
       typeof this.resourcesInput === "function" ? this.resourcesInput(this.doEnv) : (this.resourcesInput ?? {}),
@@ -330,6 +344,8 @@ export class AgentDurableObject {
     this.doEnv = def.env;
     this.services = def.services;
     this.authorizeAnswer = def.authorizeAnswer;
+    this.onInputAnnouncement = def.onInputAnnouncement;
+    this.storage = state.storage;
     const name = def.name ?? "agent";
     // Failure observability (#76): a turn that dies after the fast-ACK has no other
     // observable surface on the edge — the webhook already 200'd and runBackground
@@ -339,6 +355,13 @@ export class AgentDurableObject {
     // over reporting; if IT throws, fall back to the default so nothing goes silent.
     // (InProcEventSink already guards emit against a throwing subscriber.)
     const sink = new InProcEventSink();
+    // Announcement watchdog (#260): a park is committed inside a turn, after turn.started, so
+    // arming here comes before its announcement can commit — whichever path started the turn,
+    // a held turn drained later included. Resume, reset and a held inbound turn arm at their
+    // call sites (armWatchdog).
+    sink.subscribe((e) => {
+      if (e.type === "turn.started") this.armWatchdog();
+    });
     sink.subscribe((e) => {
       if (e.type !== "turn.failed") return;
       // The stack already opens with the message; log it INSTEAD of the message line
@@ -436,8 +459,91 @@ export class AgentDurableObject {
     if (key !== undefined && key !== "self" && stored === undefined) this.store.setSessionKey(key);
     this.sessionKey = resolved;
     this.session = new AgentSession(this.name, resolved, this.store, this.sink, this.model, this.tools, crossDoUnsupported, this.channelInstructions);
+    // A held turn (#263) that asked for delivery is rendered through its source channel when
+    // it finally runs — possibly in a later life of this object, which is why the ask rides
+    // in the turn's hostContext and this hook is installed on every rebuild.
+    this.session.onDequeue = (heldTurnId, held) => {
+      if ((held.hostContext as { deliver?: boolean } | undefined)?.deliver && held.event) this.deliverHeld(this.session!, heldTurnId, held.event);
+    };
+    // Input announcements (#260): delivered in the request scope (the hook writes the app's
+    // index), and flushed on every rebuild — an earlier life may have committed a park and
+    // died before delivering it.
+    const announce = this.onInputAnnouncement;
+    if (announce) {
+      // ensureScope() here, not only in the request handlers: a session can first be rebuilt by
+      // a path that never wires async scope (/reset, /transcript, the direct API), and without it
+      // runInScope is a pass-through and the hook would see no ambient db.
+      this.session.onAnnounce = async (a) => {
+        await ensureScope();
+        const resources = await this.ready();
+        try {
+          await runInScope({ resources, services: this.services }, () => announce(a));
+        } catch (err) {
+          // The engine keeps the announcement and logs; retry it on the alarm, 5 s doubling
+          // to 5 min — a quiet session would otherwise hold it until its next activity.
+          this.scheduleAlarm(Math.min(5_000 * 2 ** this.announceFailures, 300_000));
+          this.announceFailures++;
+          throw err;
+        }
+        this.announceFailures = 0;
+      };
+      void this.session.flushAnnouncements();
+    }
     return this.session;
   }
+
+  // The Durable Object alarm (#260): delivers input announcements left undelivered — a hook
+  // that failed (its retry), or an object that died between committing one and delivering
+  // it (the watchdog). The shell forwards it — `alarm() { return this.agent.alarm(); }`;
+  // june build's does. Resolves the session like any key-less path (the persisted key),
+  // which rebuilds it after an eviction and flushes. Never rejects: a failed delivery
+  // reschedules itself through onAnnounce.
+  async alarm(): Promise<void> {
+    if (!this.onInputAnnouncement) return;
+    await this.resolveSession().flushAnnouncements();
+  }
+  // A watchdog alarm a minute out, armed BEFORE anything can commit an announcement (a
+  // turn starting, a resume, a reset, a held inbound turn): arming after the commit would
+  // leave exactly the window it exists for. A delivery that succeeds leaves it to find
+  // nothing.
+  private armWatchdog(): void {
+    if (this.onInputAnnouncement) this.scheduleAlarm(60_000);
+  }
+  // One alarm per object: the latest schedule wins.
+  private scheduleAlarm(inMs: number): void {
+    const failed = (err: unknown) => console.error(`[june] agent "${this.name}": could not schedule the announcement alarm — delivery waits for the next announcement, turn or rebuild:`, err);
+    try {
+      Promise.resolve(this.storage.setAlarm?.(Date.now() + inMs)).catch(failed);
+    } catch (err) {
+      failed(err);
+    }
+  }
+
+  // Render a held turn's reply through its source channel (#263), like /turn?deliver=1 does
+  // for a turn started now. Called from onDequeue, synchronously as the turn starts: the
+  // event subscription is taken HERE, before any event can emit, and buffers until the
+  // (async) resources are ready. Nothing may escape — there is no caller to report to; the
+  // log is the only surfacing path, as for any delivered render.
+  private deliverHeld(session: AgentSession, turnId: string, event: InboundEvent): void {
+    const logRenderFailure = (err: unknown) =>
+      console.error(`[june] agent "${this.name}": delivered render for held turn ${turnId} failed:`, err);
+    try {
+      const channel = this.channels.find((c) => c.name === event.source);
+      if (!channel?.deliver) {
+        logRenderFailure(new Error(`no deliver()-capable channel named "${event.source}" is wired into this DO — the held turn runs, but its reply is not rendered`));
+        return;
+      }
+      const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+      const events: AsyncIterable<TurnEvent> = { [Symbol.asyncIterator]: () => it };
+      const target = { channelId: event.channelId, threadId: event.threadId, recipientUserId: event.user?.id, recipientTeamId: event.teamId };
+      this.ready()
+        .then((resources) => runInScope({ resources, services: this.services }, () => channel.deliver!(target, events, { session: this.sessionKey })))
+        .catch(logRenderFailure)
+        .finally(() => { void it.return?.(); });
+    } catch (err) {
+      logRenderFailure(err);
+    }
+  }
   // Run the whole turn inside a request scope seeded from this DO's env, so ambient
   // `db`/`kv`/`blob` and `currentServices()` resolve inside a tool exactly as in a
   // route loader. `locals` is intentionally NOT set here: a fresh scope object per
@@ -461,10 +567,18 @@ export class AgentDurableObject {
     const session = this.resolveSession(input.session);
     return runInScope({ resources, services: this.services }, () => session.start(input));
   }
+  // An attributed note (#262) for custom shells — the direct sibling of the /note route. No
+  // scope needed: a note touches only the store.
+  note(input: { by: string; kind: NoteKind; text: string; session?: string }): Promise<{ noteId: string }> {
+    const { session, ...note } = input;
+    return this.resolveSession(session).note(note);
+  }
   // Session reset (#129) for custom shells — the direct sibling of the /reset route. No
   // scope needed: reset touches only the store (no tools run).
   reset(opts?: { session?: string }): Promise<{ previousSession: string; generation: number }> {
-    return this.resolveSession(opts?.session).reset();
+    const session = this.resolveSession(opts?.session);
+    this.armWatchdog(); // a reset can retire a park (#260)
+    return session.reset();
   }
   // Read-only: folds the durable log. When an identity exists (live, or persisted from a
   // prior life) the session resolves and caches like any other path. Only a read on a
@@ -484,7 +598,7 @@ export class AgentDurableObject {
     // hand-rolled fetch → the pre-#75 "self" fallback keeps old callers working.
     const key = req.headers.get(SESSION_HEADER) ?? undefined;
     if (req.method === "POST" && url.pathname.endsWith("/turn")) {
-      const { userText, turnId, event, trigger } = (await req.json()) as { userText: string; turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger };
+      const { userText, turnId, event, trigger, ifSuspended } = (await req.json()) as { userText: string; turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger; ifSuspended?: "reject" | "queue" };
       await ensureScope();
       // CANCEL-AND-REPLACE (#129): supersede every unfinished turn on this session before
       // queuing this one (debounce). A mode flag like deliver/detach, so it rides the query
@@ -498,6 +612,15 @@ export class AgentDurableObject {
       // surface: on a pre-start rejection the caller may fall back to consumer-side rendering
       // without double-running the turn.
       const wantsDeliver = url.searchParams.get("deliver") === "1";
+      const detached = url.searchParams.get("detach") === "1";
+      // HOLD (#263): only a caller with no live consumer may ask to be held — a streaming
+      // caller wants the reply now, and a held turn's reply comes after the park resolves.
+      if (ifSuspended === "queue" && !wantsDeliver && !detached) {
+        return Response.json({ error: `ifSuspended "queue" needs deliver=1 or detach=1: a held turn runs later, when no one is streaming it` }, { status: 400 });
+      }
+      if (ifSuspended === "queue" && replace) {
+        return Response.json({ error: `ifSuspended "queue" and replace=1 cannot be combined — replacing would drop held turns that were accepted` }, { status: 400 });
+      }
       let deliverChannel: Channel | undefined;
       if (wantsDeliver) {
         if (!event?.channelId) {
@@ -517,15 +640,21 @@ export class AgentDurableObject {
       // BEFORE this block — the section from start() to the subscription stays synchronous.
       const resources = await this.ready();
       let session: AgentSession;
-      let started: { turnId: string };
+      let started: { turnId: string; queued?: true };
       try {
         session = this.resolveSession(key);
-        started = runInScope({ resources, services: this.services }, () => session.start({ userText, turnId, event, trigger, replace }));
+        // `hostContext` tells onDequeue how to finish a held turn (#263): a delivered one is
+        // rendered through its source channel when it runs, exactly as it would be now.
+        // start() itself runs turns a restart left held ahead of this one.
+        this.armWatchdog(); // a held turn commits a "held" announcement without starting (#260)
+        started = runInScope({ resources, services: this.services }, () =>
+          session.start({ userText, turnId, event, trigger, replace, ifSuspended, hostContext: wantsDeliver ? { deliver: true } : undefined }));
       } catch (err) {
         // e.g. the session is suspended awaiting input, or the key mis-matches this
         // object's identity — a client-resolvable conflict, not a crash
         return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
       }
+      if (started.queued) return Response.json({ turnId: started.turnId, queued: true }, { status: 202 });
       if (wantsDeliver) {
         // Subscribe synchronously (same guarantee sseTurnStream relies on: start() scheduled
         // the turn, no event can have emitted yet), then render under THIS DO's lifetime —
@@ -565,7 +694,7 @@ export class AgentDurableObject {
       // this DO's lifetime (alive while work is pending), so its duration is no longer
       // bounded by however long the CALLER can hold a connection (the edge waitUntil
       // ceiling). Nobody consumes the result; failures surface via the #76 log/hook.
-      if (url.searchParams.get("detach") === "1") return Response.json({ turnId: started.turnId }, { status: 202 });
+      if (detached) return Response.json({ turnId: started.turnId }, { status: 202 });
       return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
     }
     // Provide the input a suspended turn is waiting on and stream its continuation as SSE.
@@ -619,6 +748,7 @@ export class AgentDurableObject {
         console.error(`[june] agent "${this.name}": authorizeAnswer failed for input "${inputId}" of turn ${turnId}:`, err);
         return Response.json({ error: `authorizeAnswer failed: ${err instanceof Error ? err.message : String(err)} — the answer was NOT applied` }, { status: 500 });
       }
+      this.armWatchdog(); // the answer commits a "resolved" announcement (#260)
       try {
         runInScope({ resources, services: this.services }, () => session.resume(turnId, inputId, input, { by, granted }));
       } catch (err) {
@@ -662,6 +792,7 @@ export class AgentDurableObject {
       } catch (err) {
         return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
       }
+      this.armWatchdog(); // a reset can retire a park (#260)
       try {
         return Response.json(await session.reset());
       } catch (err) {
@@ -669,6 +800,28 @@ export class AgentDurableObject {
         return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
       }
     }
+    // An attributed note (#262): body { by, kind, text } → { noteId }. A malformed body is a
+    // 400; a session-key conflict is a 409, like every other route.
+    if (req.method === "POST" && url.pathname.endsWith("/note")) {
+      let input: { by?: unknown; kind?: unknown; text?: unknown };
+      try {
+        input = (await req.json()) as typeof input;
+      } catch {
+        return Response.json({ error: "note: the body must be JSON { by, kind, text }" }, { status: 400 });
+      }
+      let session: AgentSession;
+      try {
+        session = this.resolveSession(key);
+      } catch (err) {
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+      }
+      try {
+        return Response.json(await session.note(input as { by: string; kind: string; text: string }));
+      } catch (err) {
+        if (err instanceof TypeError) return Response.json({ error: err.message }, { status: 400 });
+        throw err;
+      }
+    }
     if (url.pathname.endsWith("/transcript")) {
       // A keyed read still conflict-checks (and may commit the key — it is authentic,
       // idFromName routed it here); a key-less read stays non-committal via transcript().
@@ -681,7 +834,7 @@ export class AgentDurableObject {
       }
       return Response.json({ transcript: this.transcript() });
     }
-    return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
+    return new Response("agent DO — POST /turn, POST /resume, POST /reset, POST /note, or GET /transcript", { status: 404 });
   }
 }
 
@@ -964,7 +1117,7 @@ export function durableChannelSurface(
         const detail = (await res.text()).slice(0, 200);
         throw new Error(`runDetached: turn was not accepted (status ${res.status}): ${detail}`);
       }
-      return (await res.json()) as { turnId: string };
+      return (await res.json()) as { turnId: string; queued?: true };
     },
     // DELIVERED: runDetached's reply-bearing sibling — the DO runs the turn AND renders its
     // reply through the source channel's deliver() under its OWN lifetime, so a reply-bearing
@@ -988,7 +1141,7 @@ export function durableChannelSurface(
         const detail = (await res.text()).slice(0, 200);
         throw new Error(`runDelivered: delivered turn was not accepted (status ${res.status}): ${detail}`);
       }
-      return (await res.json()) as { turnId: string };
+      return (await res.json()) as { turnId: string; queued?: true };
     },
     // The LIVE path: hand the channel the TurnEvent stream so it can render as the turn runs.
     runStream: async function* (message, o) {
@@ -1086,8 +1239,8 @@ function serializeResume(o: { turnId: string; inputId: string; input: unknown; b
 
 // `trigger` is ProactiveTrigger — plain strings by construction — so only event.raw can make
 // the stringify throw; the fallback that strips it stays sufficient.
-function serializeTurn(userText: string, o?: { turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger }): string {
-  const payload = { userText, turnId: o?.turnId, event: o?.event, trigger: o?.trigger };
+function serializeTurn(userText: string, o?: { turnId?: string; event?: InboundEvent; trigger?: ProactiveTrigger; ifSuspended?: "reject" | "queue" }): string {
+  const payload = { userText, turnId: o?.turnId, event: o?.event, trigger: o?.trigger, ifSuspended: o?.ifSuspended };
   try {
     return JSON.stringify(payload);
   } catch {

package/src/agent-native.ts

@@ -13,6 +13,7 @@ import {
   withSystem,
   type ChannelPolicy,
   type EventSink,
+  type InputAnnouncement,
   type TurnEvent,
   type Model,
   type Msg,
@@ -92,7 +93,7 @@ class SqliteSessionStore implements SessionStore {
   // generation (audit trail — never deleted), clear the live rows, status → "new".
   // Archive tables + the generation counter are created lazily here, so existing
   // databases stay untouched until the first reset.
-  reset(): number {
+  reset(inTx?: () => void): number {
     return this.tx(() => {
       this.db.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (session_id TEXT, generation INTEGER, seq INTEGER, body TEXT)`);
       this.db.exec(`CREATE TABLE IF NOT EXISTS agent_steps_archive (session_id TEXT, generation INTEGER, id TEXT, output TEXT)`);
@@ -105,6 +106,7 @@ class SqliteSessionStore implements SessionStore {
       this.db.query("DELETE FROM agent_steps WHERE session_id = ?").run(this.sid);
       this.db.query("INSERT INTO agent_sessions (session_id, status) VALUES (?, 'new') ON CONFLICT(session_id) DO UPDATE SET status = 'new'").run(this.sid);
       this.db.query("INSERT INTO agent_session_generations (session_id, generation) VALUES (?, ?) ON CONFLICT(session_id) DO UPDATE SET generation = ?").run(this.sid, generation + 1, generation + 1);
+      inTx?.(); // writes into the fresh generation, committed with the archive (#260)
       return generation;
     });
   }
@@ -120,7 +122,68 @@ class InProcEventSink implements EventSink {
 
 // `instructions` (the agent's system prompt) is injected into the model per turn
 // by the runtime (withSystem) — single-sourced on the def, not baked into `model`.
-export type AgentDef = { model: Model; tools: Tool[]; instructions?: string; channelInstructions?: Record<string, string | ChannelPolicy> };
+export type AgentDef = {
+  model: Model;
+  tools: Tool[];
+  instructions?: string;
+  channelInstructions?: Record<string, string | ChannelPolicy>;
+  // The app's receiver for input announcements (#260), installed on every session this
+  // runtime builds; undelivered announcements from an earlier process are flushed then.
+  onInputAnnouncement?: (a: InputAnnouncement) => void | Promise<void>;
+};
+
+// Retries a failed announcement delivery on a timer (#260): the engine keeps an undelivered
+// announcement and flushes again on the next announcement, settled turn or rebuild — but a
+// session that goes quiet would hold it until then. 5 s doubling to 5 min, per session;
+// unref'd, so a pending retry never holds the process open. Owned by the runtime, so the
+// backoff survives an evicted-and-rebuilt actor.
+class AnnouncementRetry {
+  // Explicit fields (not parameter properties) — keep the shipped source erasable.
+  private readonly flush: (agent: string, id: string) => void;
+  private readonly state = new Map<string, { failures: number; timer?: ReturnType<typeof setTimeout> }>();
+  constructor(flush: (agent: string, id: string) => void) {
+    this.flush = flush;
+  }
+  delivered(key: string) {
+    const s = this.state.get(key);
+    if (s?.timer) clearTimeout(s.timer);
+    this.state.delete(key);
+  }
+  failed(key: string, agent: string, id: string) {
+    const s = this.state.get(key) ?? { failures: 0 };
+    this.state.set(key, s);
+    if (s.timer) return; // one retry pending at a time
+    const delay = Math.min(5_000 * 2 ** s.failures, 300_000);
+    s.failures++;
+    s.timer = setTimeout(() => { s.timer = undefined; this.flush(agent, id); }, delay);
+    (s.timer as { unref?: () => void }).unref?.();
+  }
+}
+
+// Install the announcement hook on a freshly built session and deliver what an earlier life
+// of it recorded but never delivered (#260). The flush never rejects; it logs — and a
+// failure schedules a retry.
+function wireAnnouncements(session: AgentSession, def: AgentDef, retry: AnnouncementRetry): AgentSession {
+  const hook = def.onInputAnnouncement;
+  if (hook) {
+    const key = `${session.agent}:${session.id}`;
+    session.onAnnounce = async (a) => {
+      try {
+        await hook(a);
+      } catch (err) {
+        retry.failed(key, session.agent, session.id);
+        throw err; // the engine keeps the announcement and logs
+      }
+      retry.delivered(key);
+    };
+    void session.flushAnnouncements();
+  }
+  return session;
+}
+
+// The step the engine keeps its announcement outbox under (#260) — read by the native
+// runtime's startup scan. Mirrors ANNOUNCE_OUTBOX in @junejs/core/agent-runtime.
+const ANNOUNCE_OUTBOX_STEP = "announce-outbox";
 
 // The runtime-side def for an assembled AgentDefinition (#173): the tools (channel
 // capability tools and read_skill included), the system prompt (instructions + the
@@ -134,6 +197,7 @@ export function toAgentDef(agent: AgentDefinition, model: Model): AgentDef {
     tools: agent.tools,
     instructions: buildSystemPrompt(agent),
     ...(agent.channelInstructions ? { channelInstructions: agent.channelInstructions } : {}),
+    ...(agent.onInputAnnouncement ? { onInputAnnouncement: agent.onInputAnnouncement } : {}),
   };
 }
 
@@ -156,6 +220,8 @@ export class NativeRuntime implements Runtime {
   private actors = new Map<string, { session: AgentSession; sink: InProcEventSink }>();
   private readonly agents: Record<string, AgentDef>;
   private readonly db: SyncSqlite;
+  // Retries failed announcement deliveries (#260), across actor rebuilds.
+  private readonly announceRetry = new AnnouncementRetry((agent, id) => { void this.session(agent, id).flushAnnouncements(); });
   private readonly maxSessions: number;
 
   constructor(agents: Record<string, AgentDef>, db: SyncSqlite, opts: NativeRuntimeOptions = {}) {
@@ -188,7 +254,7 @@ export class NativeRuntime implements Runtime {
     if (!def) throw new Error(`unknown agent: ${agent}`);
     const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
     const sink = new InProcEventSink();
-    const session = new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions);
+    const session = wireAnnouncements(new AgentSession(agent, id, new SqliteSessionStore(this.db, key), sink, model, def.tools, this, def.channelInstructions), def, this.announceRetry);
     this.evictIdle();
     this.actors.set(key, { session, sink });
     return session;
@@ -197,6 +263,19 @@ export class NativeRuntime implements Runtime {
   // Number of memoized actors (observability / tests).
   get sessionCount(): number { return this.actors.size; }
 
+  // Deliver announcements an earlier process recorded but never delivered (#260), without
+  // waiting for their sessions to be used again: build every session whose outbox is not
+  // empty — building one flushes it. The agent and session come from the announcement
+  // itself, not from splitting the store key (an agent name may contain ":"). Called once
+  // by createNativeRuntime; safe to call again.
+  recoverAnnouncements(): void {
+    const rows = this.db.query("SELECT output FROM agent_steps WHERE id = ?").all(ANNOUNCE_OUTBOX_STEP) as { output: string }[];
+    for (const { output } of rows) {
+      const [first] = JSON.parse(output) as InputAnnouncement[];
+      if (first && this.agents[first.agent]?.onInputAnnouncement) this.session(first.agent, first.session);
+    }
+  }
+
   // Drop least recently used idle actors until one more fits under the cap. Runs before
   // the new actor is inserted, so the actor being handed out is never a candidate.
   private evictIdle() {
@@ -216,7 +295,9 @@ export async function createNativeRuntime(
   path = ":memory:",
   opts: NativeRuntimeOptions = {},
 ): Promise<NativeRuntime> {
-  return new NativeRuntime(agents, await openLocalSqliteSync(path), opts);
+  const runtime = new NativeRuntime(agents, await openLocalSqliteSync(path), opts);
+  runtime.recoverAnnouncements(); // #260
+  return runtime;
 }
 
 // ── memory backend — in-process, ephemeral (no DB, no disk) ───────────────────
@@ -242,12 +323,13 @@ class MemorySessionStore implements SessionStore {
   getStatus(): string { return this.status; }
   setStatus(s: string) { this.status = s; }
   tx<T>(fn: () => T): T { return fn(); } // no rollback: an in-memory store is not a durability tier
-  reset(): number {
+  reset(inTx?: () => void): number {
     const generation = this.generation++;
     this.archives.push({ generation, msgs: this.msgs, steps: this.steps });
     this.msgs = [];
     this.steps = new Map();
     this.status = "new";
+    inTx?.(); // writes into the fresh generation (#260)
     return generation;
   }
   unwrap<H = unknown>(): H { return undefined as unknown as H; }
@@ -257,6 +339,7 @@ export class MemoryRuntime implements Runtime {
   private actors = new Map<string, AgentSession>();
   private stores = new Map<string, MemorySessionStore>();
   private readonly agents: Record<string, AgentDef>;
+  private readonly announceRetry = new AnnouncementRetry((agent, id) => { void this.session(agent, id).flushAnnouncements(); }); // #260
   constructor(agents: Record<string, AgentDef>) {
     assertCoreRuntimeVersion("MemoryRuntime"); // #94: fail power-on, not mid-turn
     this.agents = agents;
@@ -272,7 +355,7 @@ export class MemoryRuntime implements Runtime {
       this.stores.set(key, store);
       // Same def handling as NativeRuntime: switching backend must not change behavior.
       const model = def.instructions ? withSystem(def.model, def.instructions) : def.model;
-      a = new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions);
+      a = wireAnnouncements(new AgentSession(agent, id, store, new InProcEventSink(), model, def.tools, this, def.channelInstructions), def, this.announceRetry);
       this.actors.set(key, a);
     }
     return a;

package/src/build.ts

@@ -417,6 +417,10 @@ export class JuneAgentDO extends DurableObject {
   fetch(req: Request): Promise<Response> {
     return this.#agent.fetch(req);
   }
+  // Delivers input announcements left undelivered — a failed hook's retry, or the watchdog (#260).
+  alarm(): Promise<void> {
+    return this.#agent.alarm();
+  }
 }
 `
     : "";

package/src/core-version.ts

@@ -15,7 +15,7 @@ import * as coreRuntime from "@junejs/core/agent-runtime";
 
 // The contract number this server tree is built against. Bump in lockstep with
 // core's RUNTIME_API_VERSION whenever the server↔core runtime contract changes.
-const EXPECTED_CORE_RUNTIME_API = 2;
+const EXPECTED_CORE_RUNTIME_API = 6;
 
 export function assertCoreRuntimeVersion(surface: string): void {
   checkCoreRuntimeVersion(surface, (coreRuntime as { RUNTIME_API_VERSION?: number }).RUNTIME_API_VERSION);