@junejs/server 1.0.0-dev.12 → 1.0.0-dev.14

package/dist/agent-durable.d.ts

@@ -39,6 +39,7 @@ declare class DoSessionStore implements SessionStore {
   getSessionKey(): string | undefined;
   setSessionKey(key: string): void;
   tx<T>(fn: () => T): T;
+  reset(): number;
   unwrap<H = unknown>(): H;
 }
 type DoAgentDef = {
@@ -88,6 +89,12 @@ declare class AgentDurableObject {
   }): Promise<{
     turnId: string;
   }>;
+  reset(opts?: {
+    session?: string;
+  }): Promise<{
+    previousSession: string;
+    generation: number;
+  }>;
   transcript(): import("@junejs/core/agent-runtime").Turn[];
   fetch(req: Request): Promise<Response>;
 }

package/dist/agent-durable.js

@@ -52,6 +52,22 @@ var DoSessionStore = class {
 	tx(fn) {
 		return this.storage.transactionSync(fn);
 	}
+	reset() {
+		return this.storage.transactionSync(() => {
+			const sql = this.sql;
+			sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
+			sql.exec(`CREATE TABLE IF NOT EXISTS agent_steps_archive (generation INTEGER, id TEXT, output TEXT)`);
+			const rows = this.sql.exec("SELECT v FROM agent_meta WHERE k = 'generation'").toArray();
+			const generation = rows.length ? Number(rows[0].v) : 0;
+			sql.exec("INSERT INTO agent_messages_archive (generation, seq, body) SELECT ?, seq, body FROM agent_messages", generation);
+			sql.exec("DELETE FROM agent_messages");
+			sql.exec("INSERT INTO agent_steps_archive (generation, id, output) SELECT ?, id, output FROM agent_steps", generation);
+			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));
+			return generation;
+		});
+	}
 	unwrap() {
 		return this.sql;
 	}
@@ -160,6 +176,9 @@ var AgentDurableObject = class {
 			services: this.services
 		}, () => session.start(input));
 	}
+	reset(opts) {
+		return this.resolveSession(opts?.session).reset();
+	}
 	transcript() {
 		if (this.session) return this.session.transcript();
 		if (this.store.getSessionKey() !== void 0) return this.resolveSession().transcript();
@@ -171,6 +190,7 @@ var AgentDurableObject = class {
 		if (req.method === "POST" && url.pathname.endsWith("/turn")) {
 			const { userText, turnId, event, trigger } = await req.json();
 			await ensureScope();
+			const replace = url.searchParams.get("replace") === "1";
 			const wantsDeliver = url.searchParams.get("deliver") === "1";
 			let deliverChannel;
 			if (wantsDeliver) {
@@ -189,7 +209,8 @@ var AgentDurableObject = class {
 					userText,
 					turnId,
 					event,
-					trigger
+					trigger,
+					replace
 				}));
 			} catch (err) {
 				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
@@ -197,7 +218,8 @@ var AgentDurableObject = class {
 			if (wantsDeliver) {
 				const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered render for turn ${started.turnId} failed:`, err);
 				try {
-					const events = observeTurnEvents(session, started.turnId);
+					const it = observeTurnEvents(session, started.turnId)[Symbol.asyncIterator]();
+					const events = { [Symbol.asyncIterator]: () => it };
 					const target = {
 						channelId: event.channelId,
 						threadId: event.threadId,
@@ -207,7 +229,9 @@ var AgentDurableObject = class {
 					Promise.resolve().then(() => runInScope({
 						resources: this.resources,
 						services: this.services
-					}, () => deliverChannel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure);
+					}, () => deliverChannel.deliver(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
+						it.return?.();
+					});
 				} catch (err) {
 					logRenderFailure(err);
 				}
@@ -217,8 +241,15 @@ var AgentDurableObject = class {
 			return new Response(sseTurnStream(session, started.turnId), { headers: SSE_HEADERS });
 		}
 		if (req.method === "POST" && url.pathname.endsWith("/resume")) {
-			const { turnId, inputId, input, by } = await req.json();
+			const { turnId, inputId, input, by, source, target } = await req.json();
 			await ensureScope();
+			const wantsDeliver = url.searchParams.get("deliver") === "1";
+			let resumeChannel;
+			if (wantsDeliver) {
+				if (!source || !target?.channelId || !target.messageTs) return Response.json({ error: "resume deliver=1 needs `source` (the channel name) and `target` (channelId + messageTs of the prompt message)" }, { status: 400 });
+				resumeChannel = this.channels.find((c) => c.name === source);
+				if (!resumeChannel?.deliverResume) return Response.json({ error: `agent "${this.name}": no deliverResume()-capable channel named "${source}" is wired into this DO (DoAgentDef.channels) — the answer was NOT applied` }, { status: 501 });
+			}
 			let session;
 			try {
 				session = this.resolveSession(key);
@@ -230,8 +261,37 @@ var AgentDurableObject = class {
 				const message = err instanceof Error ? err.message : String(err);
 				return Response.json({ error: message }, { status: err instanceof ResumeAuthorizationError ? 403 : 409 });
 			}
+			if (wantsDeliver) {
+				const logRenderFailure = (err) => console.error(`[june] agent "${this.name}": delivered resume render for turn ${turnId} failed:`, err);
+				try {
+					const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+					const events = { [Symbol.asyncIterator]: () => it };
+					Promise.resolve().then(() => runInScope({
+						resources: this.resources,
+						services: this.services
+					}, () => resumeChannel.deliverResume(target, events, { session: this.sessionKey }))).catch(logRenderFailure).finally(() => {
+						it.return?.();
+					});
+				} catch (err) {
+					logRenderFailure(err);
+				}
+				return Response.json({ turnId }, { status: 202 });
+			}
 			return new Response(sseTurnStream(session, turnId), { headers: SSE_HEADERS });
 		}
+		if (req.method === "POST" && url.pathname.endsWith("/reset")) {
+			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.reset());
+			} catch (err) {
+				return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+			}
+		}
 		if (url.pathname.endsWith("/transcript")) {
 			if (key !== void 0) try {
 				return Response.json({ transcript: this.resolveSession(key).transcript() });
@@ -240,7 +300,7 @@ var AgentDurableObject = class {
 			}
 			return Response.json({ transcript: this.transcript() });
 		}
-		return new Response("agent DO — POST /turn, POST /resume, or GET /transcript", { status: 404 });
+		return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
 	}
 };
 const SSE_HEADERS = {
@@ -266,7 +326,7 @@ function sseTurnStream(session, turnId) {
 			}, 2e4);
 			unsub = session.observe((e) => {
 				controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
-				if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "input.requested") {
+				if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "turn.cancelled" || e.type === "input.requested") {
 					stop();
 					controller.close();
 				}
@@ -283,7 +343,7 @@ function observeTurnEvents(session, turnId) {
 	let notify;
 	const unsub = session.observe((e) => {
 		queue.push(e);
-		if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "input.requested") terminal = true;
+		if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "turn.cancelled" || e.type === "input.requested") terminal = true;
 		notify?.();
 	}, { turnId });
 	return { [Symbol.asyncIterator]() {
@@ -340,6 +400,7 @@ async function sseTurnFinalText(res) {
 			const e = JSON.parse(line.slice(5).trim());
 			if (e.type === "turn.completed") return e.text;
 			if (e.type === "turn.failed") throw new Error(e.error.message, { cause: e.error });
+			if (e.type === "turn.cancelled") throw new Error(`turn ${e.turnId} was cancelled (${e.reason})`);
 		}
 		if (done) break;
 	}
@@ -425,7 +486,7 @@ function durableChannelSurface(getNamespace, opts) {
 		run: async (message, o) => {
 			const namespace = getNamespace();
 			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			return sseTurnFinalText(await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn", {
+			return sseTurnFinalText(await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request(`https://do/turn${o?.replace ? "?replace=1" : ""}`, {
 				method: "POST",
 				body: serializeTurn(message, o)
 			})));
@@ -433,7 +494,7 @@ function durableChannelSurface(getNamespace, opts) {
 		runDetached: async (message, o) => {
 			const namespace = getNamespace();
 			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			const res = await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn?detach=1", {
+			const res = await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request(`https://do/turn?detach=1${o?.replace ? "&replace=1" : ""}`, {
 				method: "POST",
 				body: serializeTurn(message, o)
 			}));
@@ -446,7 +507,7 @@ function durableChannelSurface(getNamespace, opts) {
 		runDelivered: async (message, o) => {
 			const namespace = getNamespace();
 			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			const res = await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn?deliver=1", {
+			const res = await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request(`https://do/turn?deliver=1${o?.replace ? "&replace=1" : ""}`, {
 				method: "POST",
 				body: serializeTurn(message, o)
 			}));
@@ -460,7 +521,7 @@ function durableChannelSurface(getNamespace, opts) {
 		runStream: async function* (message, o) {
 			const namespace = getNamespace();
 			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
-			yield* sseTurnEvents(await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/turn", {
+			yield* sseTurnEvents(await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request(`https://do/turn${o?.replace ? "?replace=1" : ""}`, {
 				method: "POST",
 				body: serializeTurn(message, o)
 			})));
@@ -472,6 +533,30 @@ function durableChannelSurface(getNamespace, opts) {
 				method: "POST",
 				body: serializeResume(o)
 			})));
+		},
+		resumeDelivered: async (o) => {
+			const namespace = getNamespace();
+			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
+			const res = await durableFetch(namespace, opts.agentName, o.session ?? "default", new Request("https://do/resume?deliver=1", {
+				method: "POST",
+				body: serializeResume(o)
+			}));
+			if (res.status === 501) throw new DeliverUnsupportedError(`resumeDelivered: ${(await res.json().catch(() => void 0))?.error ?? "the turn host cannot deliver this continuation"}`);
+			if (res.status !== 202) {
+				const detail = (await res.text()).slice(0, 200);
+				throw new Error(`resumeDelivered: resume was not accepted (status ${res.status}): ${detail}`);
+			}
+			return await res.json();
+		},
+		resetSession: async (o) => {
+			const namespace = getNamespace();
+			if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
+			const res = await durableFetch(namespace, opts.agentName, o?.session ?? "default", new Request("https://do/reset", { method: "POST" }));
+			if (!res.ok) {
+				const detail = (await res.text()).slice(0, 200);
+				throw new Error(`resetSession: reset was not accepted (status ${res.status}): ${detail}`);
+			}
+			return await res.json();
 		}
 	});
 }
@@ -481,10 +566,12 @@ function serializeResume(o) {
 			turnId: o.turnId,
 			inputId: o.inputId,
 			input: o.input,
-			by: o.by
+			by: o.by,
+			source: o.source,
+			target: o.target
 		});
 	} catch (err) {
-		throw new Error(`resumeStream: input is not JSON-serializable (${err.message}) — a resume answer must round-trip to the DO`);
+		throw new Error(`resume: input is not JSON-serializable (${err.message}) — a resume answer must round-trip to the DO`);
 	}
 }
 function serializeTurn(userText, o) {

package/dist/agent-native.js

@@ -51,6 +51,21 @@ var SqliteSessionStore = class {
 			throw e;
 		}
 	}
+	reset() {
+		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)`);
+			this.db.exec(`CREATE TABLE IF NOT EXISTS agent_session_generations (session_id TEXT PRIMARY KEY, generation INTEGER)`);
+			const generation = this.db.query("SELECT generation FROM agent_session_generations WHERE session_id = ?").get(this.sid)?.generation ?? 0;
+			this.db.query("INSERT INTO agent_messages_archive (session_id, generation, seq, body) SELECT session_id, ?, seq, body FROM agent_messages WHERE session_id = ?").run(generation, this.sid);
+			this.db.query("DELETE FROM agent_messages WHERE session_id = ?").run(this.sid);
+			this.db.query("INSERT INTO agent_steps_archive (session_id, generation, id, output) SELECT session_id, ?, id, output FROM agent_steps WHERE session_id = ?").run(generation, this.sid);
+			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);
+			return generation;
+		});
+	}
 	unwrap() {
 		return this.db;
 	}
@@ -99,6 +114,8 @@ var MemorySessionStore = class {
 	msgs = [];
 	steps = /* @__PURE__ */ new Map();
 	status = "new";
+	generation = 0;
+	archives = [];
 	appendMessage(m) {
 		this.msgs.push(m);
 	}
@@ -126,6 +143,18 @@ var MemorySessionStore = class {
 	tx(fn) {
 		return fn();
 	}
+	reset() {
+		const generation = this.generation++;
+		this.archives.push({
+			generation,
+			msgs: this.msgs,
+			steps: this.steps
+		});
+		this.msgs = [];
+		this.steps = /* @__PURE__ */ new Map();
+		this.status = "new";
+		return generation;
+	}
 	unwrap() {}
 };
 var MemoryRuntime = class {
@@ -166,14 +195,17 @@ function mountAgent(agent, runtime, opts = {}) {
 			turnId: o?.turnId,
 			userText: message,
 			event: o?.event,
-			trigger: o?.trigger
+			trigger: o?.trigger,
+			replace: o?.replace
 		}),
 		runDetached: async (message, o) => runtime.session(agent.name, o?.session ?? "default").start({
 			turnId: o?.turnId,
 			userText: message,
 			event: o?.event,
-			trigger: o?.trigger
-		})
+			trigger: o?.trigger,
+			replace: o?.replace
+		}),
+		resetSession: (o) => runtime.session(agent.name, o?.session ?? "default").reset()
 	};
 	const channels = channelFetch(agent, ctx);
 	const surface = async (req) => {

package/package.json

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

package/src/agent-durable.ts

@@ -40,6 +40,7 @@ import {
   type Channel,
   type ChannelContext,
   type ChannelFactory,
+  type ResumeDeliveryTarget,
 } from "@junejs/core/agent-config";
 import { ensureScope, runInScope } from "@junejs/db";
 import { isolateLocal } from "./isolate-local";
@@ -136,6 +137,28 @@ export class DoSessionStore implements SessionStore {
   tx<T>(fn: () => T): T {
     return this.storage.transactionSync(fn);
   }
+  // Session reset (#129): ARCHIVE messages/steps under the current generation (the audit
+  // trail — never deleted), clear the live tables, status → "new". The session key in
+  // agent_meta is deliberately untouched: the DO's identity survives its history. Archive
+  // 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 {
+    return this.storage.transactionSync(() => {
+      const sql = this.sql;
+      sql.exec(`CREATE TABLE IF NOT EXISTS agent_messages_archive (generation INTEGER, seq INTEGER, body TEXT)`);
+      sql.exec(`CREATE TABLE IF NOT EXISTS agent_steps_archive (generation INTEGER, id TEXT, output TEXT)`);
+      const rows = this.sql.exec<{ v: string }>("SELECT v FROM agent_meta WHERE k = 'generation'").toArray();
+      const generation = rows.length ? Number(rows[0]!.v) : 0;
+      sql.exec("INSERT INTO agent_messages_archive (generation, seq, body) SELECT ?, seq, body FROM agent_messages", generation);
+      sql.exec("DELETE FROM agent_messages");
+      sql.exec("INSERT INTO agent_steps_archive (generation, id, output) SELECT ?, id, output FROM agent_steps", generation);
+      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));
+      return generation;
+    });
+  }
   unwrap<H = unknown>(): H {
     return this.sql as unknown as H;
   }
@@ -357,6 +380,11 @@ export class AgentDurableObject {
     const session = this.resolveSession(input.session);
     return runInScope({ resources: this.resources, services: this.services }, () => session.start(input));
   }
+  // 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();
+  }
   // 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
   // NEVER-keyed object stays non-committal — caching there would bake "self" in as the
@@ -377,6 +405,11 @@ export class AgentDurableObject {
     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 };
       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
+      // string and composes with both. A suspended session still 409s below — replace
+      // never cancels a parked approval.
+      const replace = url.searchParams.get("replace") === "1";
       // DELIVERED: like detach=1, the caller gets a 202 and goes away — but the reply is NOT
       // dropped: this DO renders the turn's event stream through the source channel's own
       // deliver() (the inbound renderer), under the DO's lifetime. Capability is checked
@@ -404,7 +437,7 @@ export class AgentDurableObject {
       let started: { turnId: string };
       try {
         session = this.resolveSession(key);
-        started = runInScope({ resources: this.resources, services: this.services }, () => session.start({ userText, turnId, event, trigger }));
+        started = runInScope({ resources: this.resources, services: this.services }, () => session.start({ userText, turnId, event, trigger, replace }));
       } 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
@@ -429,11 +462,17 @@ export class AgentDurableObject {
         const logRenderFailure = (err: unknown) =>
           console.error(`[june] agent "${this.name}": delivered render for turn ${started.turnId} failed:`, err);
         try {
-          const events = observeTurnEvents(session, started.turnId);
+          // Own the iterator here: observeTurnEvents subscribes EAGERLY, and a deliver()
+          // that throws before ever iterating would otherwise leave that subscription
+          // attached, buffering this turn's events forever. return() is idempotent, so
+          // closing in finally is safe whether deliver consumed the stream or died early.
+          const it = observeTurnEvents(session, started.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 };
           Promise.resolve()
             .then(() => runInScope({ resources: this.resources, services: this.services }, () => deliverChannel!.deliver!(target, events, { session: this.sessionKey })))
-            .catch(logRenderFailure);
+            .catch(logRenderFailure)
+            .finally(() => { void it.return?.(); });
         } catch (err) {
           logRenderFailure(err);
         }
@@ -451,8 +490,31 @@ export class AgentDurableObject {
     // VERIFIED identity, so the app must authenticate it upstream (e.g. take the user id from a
     // signature-checked Slack interaction payload), never expose this endpoint raw to clients.
     if (req.method === "POST" && url.pathname.endsWith("/resume")) {
-      const { turnId, inputId, input, by } = (await req.json()) as { turnId: string; inputId: string; input: unknown; by?: string };
+      const { turnId, inputId, input, by, source, target } = (await req.json()) as {
+        turnId: string; inputId: string; input: unknown; by?: string;
+        source?: string; target?: ResumeDeliveryTarget;
+      };
       await ensureScope();
+      // DELIVERED resume: like /turn?deliver=1, the caller 202s away and THIS DO renders the
+      // continuation through the source channel's deliverResume() — a long continuation no
+      // longer dies with the webhook isolate. Capability is checked BEFORE resume() applies
+      // the answer — the DeliverUnsupportedError contract at the surface: on a pre-effect
+      // refusal the caller may fall back to consumer-side rendering without double-answering
+      // (a second resume of an already-applied input would 409).
+      const wantsDeliver = url.searchParams.get("deliver") === "1";
+      let resumeChannel: Channel | undefined;
+      if (wantsDeliver) {
+        if (!source || !target?.channelId || !target.messageTs) {
+          return Response.json({ error: "resume deliver=1 needs `source` (the channel name) and `target` (channelId + messageTs of the prompt message)" }, { status: 400 });
+        }
+        resumeChannel = this.channels.find((c) => c.name === source);
+        if (!resumeChannel?.deliverResume) {
+          return Response.json(
+            { error: `agent "${this.name}": no deliverResume()-capable channel named "${source}" is wired into this DO (DoAgentDef.channels) — the answer was NOT applied` },
+            { status: 501 },
+          );
+        }
+      }
       let session: AgentSession;
       try {
         session = this.resolveSession(key);
@@ -462,8 +524,49 @@ export class AgentDurableObject {
         // 403: the resumer may not answer; 409: not suspended / wrong turn / wrong input id / key mismatch
         return Response.json({ error: message }, { status: err instanceof ResumeAuthorizationError ? 403 : 409 });
       }
+      if (wantsDeliver) {
+        // Same post-acceptance discipline as delivered turns: subscribe synchronously, render
+        // under this DO's lifetime, and let NOTHING escape past the accepted resume — the log
+        // is the render failure's only surfacing path (the TURN's own failures surface via
+        // the #76 sink subscription).
+        const logRenderFailure = (err: unknown) =>
+          console.error(`[june] agent "${this.name}": delivered resume render for turn ${turnId} failed:`, err);
+        try {
+          // Own the iterator (same rationale as the delivered-turn path): the eager
+          // subscription must be released even when deliverResume throws before
+          // iterating — e.g. its very first message update fails.
+          const it = observeTurnEvents(session, turnId)[Symbol.asyncIterator]();
+          const events: AsyncIterable<TurnEvent> = { [Symbol.asyncIterator]: () => it };
+          Promise.resolve()
+            .then(() => runInScope({ resources: this.resources, services: this.services }, () => resumeChannel!.deliverResume!(target!, events, { session: this.sessionKey })))
+            .catch(logRenderFailure)
+            .finally(() => { void it.return?.(); });
+        } catch (err) {
+          logRenderFailure(err);
+        }
+        return Response.json({ turnId }, { status: 202 });
+      }
       return new Response(sseTurnStream(session, turnId), { headers: SSE_HEADERS });
     }
+    // SESSION RESET (#129): terminally retire this session's history — supersede unfinished
+    // turns, archive messages/steps under the current generation (the audit trail), and
+    // answer with the audit handle. The response waits for in-flight turns to unwind at
+    // their next checkpoint boundary (the reset op runs on the turn chain), which is fine:
+    // a DO stays alive while it has pending work.
+    if (req.method === "POST" && url.pathname.endsWith("/reset")) {
+      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.reset());
+      } catch (err) {
+        // e.g. a store without reset() — a caller-resolvable refusal, not a crash
+        return Response.json({ error: err instanceof Error ? err.message : String(err) }, { status: 409 });
+      }
+    }
     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().
@@ -476,7 +579,7 @@ export class AgentDurableObject {
       }
       return Response.json({ transcript: this.transcript() });
     }
-    return new Response("agent DO — POST /turn, POST /resume, or GET /transcript", { status: 404 });
+    return new Response("agent DO — POST /turn, POST /resume, POST /reset, or GET /transcript", { status: 404 });
   }
 }
 
@@ -504,9 +607,9 @@ function sseTurnStream(session: AgentSession, turnId: string): ReadableStream<Ui
       }, 20_000);
       unsub = session.observe((e) => {
         controller.enqueue(enc.encode(`data: ${JSON.stringify(e)}\n\n`));
-        // terminal for the STREAM: completed, failed, OR suspended (input.requested → the turn
-        // parked; the stream ends and a later /resume opens a fresh continuation stream).
-        if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "input.requested") { stop(); controller.close(); }
+        // terminal for the STREAM: completed, failed, cancelled, OR suspended (input.requested
+        // → the turn parked; the stream ends and a later /resume opens a fresh continuation stream).
+        if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "turn.cancelled" || e.type === "input.requested") { stop(); controller.close(); }
       }, { turnId });
     },
     cancel() { stop(); },
@@ -526,7 +629,7 @@ function observeTurnEvents(session: AgentSession, turnId: string): AsyncIterable
   let notify: (() => void) | undefined;
   const unsub = session.observe((e) => {
     queue.push(e);
-    if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "input.requested") terminal = true;
+    if (e.type === "turn.completed" || e.type === "turn.failed" || e.type === "turn.cancelled" || e.type === "input.requested") terminal = true;
     notify?.();
   }, { turnId });
   return {
@@ -575,6 +678,7 @@ export async function sseTurnFinalText(res: Response): Promise<string> {
       const e = JSON.parse(line.slice(5).trim()) as TurnEvent;
       if (e.type === "turn.completed") return e.text;
       if (e.type === "turn.failed") throw new Error(e.error.message, { cause: e.error }); // full TurnError rides along
+      if (e.type === "turn.cancelled") throw new Error(`turn ${e.turnId} was cancelled (${e.reason})`);
     }
     if (done) break;
   }
@@ -775,7 +879,7 @@ export function durableChannelSurface(
         namespace,
         opts.agentName,
         o?.session ?? "default",
-        new Request("https://do/turn", { method: "POST", body: serializeTurn(message, o) }),
+        new Request(`https://do/turn${o?.replace ? "?replace=1" : ""}`, { method: "POST", body: serializeTurn(message, o) }),
       );
       // /turn streams SSE; the simple path collapses it to the final text.
       return sseTurnFinalText(res);
@@ -791,7 +895,7 @@ export function durableChannelSurface(
         namespace,
         opts.agentName,
         o?.session ?? "default",
-        new Request("https://do/turn?detach=1", { method: "POST", body: serializeTurn(message, o) }),
+        new Request(`https://do/turn?detach=1${o?.replace ? "&replace=1" : ""}`, { method: "POST", body: serializeTurn(message, o) }),
       );
       if (res.status !== 202) {
         const detail = (await res.text()).slice(0, 200);
@@ -812,7 +916,7 @@ export function durableChannelSurface(
         namespace,
         opts.agentName,
         o?.session ?? "default",
-        new Request("https://do/turn?deliver=1", { method: "POST", body: serializeTurn(message, o) }),
+        new Request(`https://do/turn?deliver=1${o?.replace ? "&replace=1" : ""}`, { method: "POST", body: serializeTurn(message, o) }),
       );
       if (res.status === 501) {
         throw new DeliverUnsupportedError(`runDelivered: ${((await res.json().catch(() => undefined)) as { error?: string } | undefined)?.error ?? "the turn host cannot deliver this turn"}`);
@@ -831,7 +935,7 @@ export function durableChannelSurface(
         namespace,
         opts.agentName,
         o?.session ?? "default",
-        new Request("https://do/turn", { method: "POST", body: serializeTurn(message, o) }),
+        new Request(`https://do/turn${o?.replace ? "?replace=1" : ""}`, { method: "POST", body: serializeTurn(message, o) }),
       );
       yield* sseTurnEvents(res);
     },
@@ -847,6 +951,49 @@ export function durableChannelSurface(
       );
       yield* sseTurnEvents(res);
     },
+    // DELIVERED resume (runDelivered's sibling for the HITL leg): the DO applies the answer
+    // AND renders the continuation through the source channel's deliverResume() under its
+    // OWN lifetime. A 501 means the DO refused BEFORE applying the answer (channel not
+    // wired there / no deliverResume) — surfaced as DeliverUnsupportedError, the one
+    // rejection a channel may answer with a consumer-side fallback without double-answering.
+    // Engine rejections (403 unauthorized clicker / 409 stale-or-double click) throw as
+    // ordinary errors, mirroring what resumeStream's first pull would do.
+    resumeDelivered: async (o) => {
+      const namespace = getNamespace();
+      if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
+      const res = await durableFetch(
+        namespace,
+        opts.agentName,
+        o.session ?? "default",
+        new Request("https://do/resume?deliver=1", { method: "POST", body: serializeResume(o) }),
+      );
+      if (res.status === 501) {
+        throw new DeliverUnsupportedError(`resumeDelivered: ${((await res.json().catch(() => undefined)) as { error?: string } | undefined)?.error ?? "the turn host cannot deliver this continuation"}`);
+      }
+      if (res.status !== 202) {
+        const detail = (await res.text()).slice(0, 200);
+        throw new Error(`resumeDelivered: resume was not accepted (status ${res.status}): ${detail}`);
+      }
+      return (await res.json()) as { turnId: string };
+    },
+    // SESSION RESET (#129): retire the session's history on its DO. The response carries
+    // the audit handle ({ previousSession, generation }); a 409 (store without reset(),
+    // key mismatch) surfaces as an ordinary error — there is no fallback to invent.
+    resetSession: async (o) => {
+      const namespace = getNamespace();
+      if (!namespace) throw new Error("durableChannelSurface: no Durable Object namespace bound (env.AGENT)");
+      const res = await durableFetch(
+        namespace,
+        opts.agentName,
+        o?.session ?? "default",
+        new Request("https://do/reset", { method: "POST" }),
+      );
+      if (!res.ok) {
+        const detail = (await res.text()).slice(0, 200);
+        throw new Error(`resetSession: reset was not accepted (status ${res.status}): ${detail}`);
+      }
+      return (await res.json()) as { previousSession: string; generation: number };
+    },
   };
   return channelDispatch(resolved, ctx);
 }
@@ -861,11 +1008,12 @@ export function durableChannelSurface(
 // (third-party) host could hand us something JSON.stringify chokes on (BigInt, circular).
 // Unlike serializeTurn's `raw`, `input` is essential: silently dropping it would resume the
 // turn with the wrong answer. So fail loudly with a clear message rather than corrupt the resume.
-function serializeResume(o: { turnId: string; inputId: string; input: unknown; by?: string }): string {
+function serializeResume(o: { turnId: string; inputId: string; input: unknown; by?: string; source?: string; target?: ResumeDeliveryTarget }): string {
   try {
-    return JSON.stringify({ turnId: o.turnId, inputId: o.inputId, input: o.input, by: o.by });
+    return JSON.stringify({ turnId: o.turnId, inputId: o.inputId, input: o.input, by: o.by, source: o.source, target: o.target });
   } catch (err) {
-    throw new Error(`resumeStream: input is not JSON-serializable (${(err as Error).message}) — a resume answer must round-trip to the DO`);
+    // API-neutral prefix: this serializer backs both resumeStream and resumeDelivered.
+    throw new Error(`resume: input is not JSON-serializable (${(err as Error).message}) — a resume answer must round-trip to the DO`);
   }
 }
 

package/src/agent-native.ts

@@ -79,6 +79,26 @@ class SqliteSessionStore implements SessionStore {
       throw e;
     }
   }
+  // Session reset (#129): ARCHIVE this session's messages/steps under the current
+  // 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 {
+    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)`);
+      this.db.exec(`CREATE TABLE IF NOT EXISTS agent_session_generations (session_id TEXT PRIMARY KEY, generation INTEGER)`);
+      const r = this.db.query("SELECT generation FROM agent_session_generations WHERE session_id = ?").get(this.sid) as { generation: number } | undefined;
+      const generation = r?.generation ?? 0;
+      this.db.query("INSERT INTO agent_messages_archive (session_id, generation, seq, body) SELECT session_id, ?, seq, body FROM agent_messages WHERE session_id = ?").run(generation, this.sid);
+      this.db.query("DELETE FROM agent_messages WHERE session_id = ?").run(this.sid);
+      this.db.query("INSERT INTO agent_steps_archive (session_id, generation, id, output) SELECT session_id, ?, id, output FROM agent_steps WHERE session_id = ?").run(generation, this.sid);
+      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);
+      return generation;
+    });
+  }
   unwrap<H = unknown>(): H { return this.db as unknown as H; }
 }
 
@@ -139,6 +159,10 @@ class MemorySessionStore implements SessionStore {
   private msgs: Msg[] = [];
   private steps = new Map<string, unknown>();
   private status = "new";
+  private generation = 0;
+  // Retired generations (#129) — kept for the audit contract even in memory, so the
+  // backend behaves like the durable tiers within one process lifetime.
+  private readonly archives: { generation: number; msgs: Msg[]; steps: Map<string, unknown> }[] = [];
   appendMessage(m: Msg) { this.msgs.push(m); }
   messages(): Msg[] { return this.msgs.slice(); }
   hasOpeningMessage(turnId: string): boolean { return this.msgs.some((m) => (m.role === "user" || m.role === "trigger") && m.turnId === turnId); }
@@ -148,6 +172,14 @@ 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 {
+    const generation = this.generation++;
+    this.archives.push({ generation, msgs: this.msgs, steps: this.steps });
+    this.msgs = [];
+    this.steps = new Map();
+    this.status = "new";
+    return generation;
+  }
   unwrap<H = unknown>(): H { return undefined as unknown as H; }
 }
 
@@ -216,12 +248,16 @@ export function mountAgent(
     agent,
     services: opts.services, // same DI bag reachable from channel hooks (parity with durableChannelSurface)
     run: (message, o) =>
-      runtime.session(agent.name, o?.session ?? "default").turn({ turnId: o?.turnId, userText: message, event: o?.event, trigger: o?.trigger }),
+      runtime.session(agent.name, o?.session ?? "default").turn({ turnId: o?.turnId, userText: message, event: o?.event, trigger: o?.trigger, replace: o?.replace }),
     // FIRE-AND-FORGET (#77): start() without awaiting the result. Native has no waitUntil
     // ceiling (Node keeps floating promises alive), but the seam is the same so a channel
     // written against ctx.runDetached behaves identically on both targets.
     runDetached: async (message, o) =>
-      runtime.session(agent.name, o?.session ?? "default").start({ turnId: o?.turnId, userText: message, event: o?.event, trigger: o?.trigger }),
+      runtime.session(agent.name, o?.session ?? "default").start({ turnId: o?.turnId, userText: message, event: o?.event, trigger: o?.trigger, replace: o?.replace }),
+    // SESSION RESET (#129): same seam as durableChannelSurface — the in-process runtimes'
+    // stores implement archival, so a channel written against ctx.resetSession behaves
+    // identically on both targets.
+    resetSession: (o) => runtime.session(agent.name, o?.session ?? "default").reset(),
   };
   const channels = channelFetch(agent, ctx);
   const surface = async (req: Request): Promise<Response | null> => {