@junejs/server 1.0.0-dev.13 → 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 });
@@ -258,6 +279,19 @@ var AgentDurableObject = class {
 			}
 			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() });
@@ -266,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 = {
@@ -292,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();
 				}
@@ -309,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]() {
@@ -366,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;
 	}
@@ -451,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)
 			})));
@@ -459,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)
 			}));
@@ -472,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)
 			}));
@@ -486,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)
 			})));
@@ -512,6 +547,16 @@ function durableChannelSurface(getNamespace, opts) {
 				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();
 		}
 	});
 }

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.13",
+  "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.30",
+    "@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

@@ -137,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;
   }
@@ -358,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
@@ -378,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
@@ -405,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
@@ -516,6 +548,25 @@ export class AgentDurableObject {
       }
       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().
@@ -528,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 });
   }
 }
 
@@ -556,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(); },
@@ -578,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 {
@@ -627,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;
   }
@@ -827,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);
@@ -843,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);
@@ -864,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"}`);
@@ -883,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);
     },
@@ -924,6 +976,24 @@ export function durableChannelSurface(
       }
       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);
 }

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> => {