@workerdeck/server 0.19.0 → 0.21.0

package/build/index.mjs

@@ -2016,6 +2016,10 @@ async function handleCommand(ctx, frame, runner) {
 		case "interrupt":
 			await runner.interrupt();
 			return;
+		case "clear_context":
+			if (!runner.clearContext) throw new Error(`the ${runner.info().engine ?? "claude"} engine cannot clear a conversation`);
+			await runner.clearContext();
+			return;
 		case "set_permission_mode":
 			if (frame.mode === "bypassPermissions" && ctx.options.disableBypassPermissions) throw new Error("bypassPermissions is disabled on this server (disableBypassPermissions)");
 			await runner.setPermissionMode(frame.mode);
@@ -2632,6 +2636,17 @@ var SessionParkManager = class {
 	* one thing a runner doesn't carry on its public surface. */
 	#configs = /* @__PURE__ */ new Map();
 	/**
+	* Sessions this process has written a dormant record for. Its only job is to
+	* tell "the engine has not named its session *yet*" apart from "the engine
+	* had named it and no longer has one" (a `conversation_reset` on an engine
+	* whose fresh id is not known until its next turn) — the first is the normal
+	* startup window and must cost no store write, the second must delete a
+	* record that has gone stale. It is accurate for exactly the sessions that
+	* matter: a woken session's runner is rebuilt with `resume` set, so it names
+	* its engine session immediately and re-enters the set on its first save.
+	*/
+	#remembered = /* @__PURE__ */ new Set();
+	/**
 	* In-flight store work per session, so operations on one record run in order.
 	*
 	* Load-bearing with any store whose writes are real I/O. `#park` must evict the
@@ -2721,6 +2736,10 @@ var SessionParkManager = class {
 				case "system_init":
 					this.#rememberDormant(runner);
 					return;
+				case "conversation_reset":
+					this.#rememberDormant(runner);
+					this.#persistLive(runner);
+					return;
 				case "session_closed":
 					if (this.#closed) return;
 					this.discard(runner.id);
@@ -2797,6 +2816,7 @@ var SessionParkManager = class {
 		clearTimeout(this.#detachTimers.get(sessionId));
 		this.#detachTimers.delete(sessionId);
 		this.#configs.delete(sessionId);
+		this.#remembered.delete(sessionId);
 		for (const [executionId, owner] of this.#owners) if (owner === sessionId) this.#forget(executionId);
 		for (const [executionId, owner] of this.#settled) if (owner === sessionId) this.#settled.delete(executionId);
 		await this.#queue(sessionId, () => this.#options.store.delete(sessionId));
@@ -2826,12 +2846,15 @@ var SessionParkManager = class {
 	async #rememberDormant(runner) {
 		if (this.#closed) return;
 		const info = runner.info();
-		const sdkSessionId = info.sdkSessionId;
-		if (sdkSessionId === void 0) return;
 		if (!(info.capabilities ?? ENGINE_CAPABILITIES[info.engine ?? "claude"]).resume) return;
 		const config = this.#configs.get(runner.id);
 		if (!config) return;
 		if (this.#options.registry.get(runner.id) !== runner) return;
+		const sdkSessionId = info.sdkSessionId;
+		if (sdkSessionId === void 0) {
+			if (this.#remembered.has(runner.id)) await this.#forgetDormant(runner.id);
+			return;
+		}
 		const record = {
 			kind: "dormant",
 			id: runner.id,
@@ -2848,6 +2871,7 @@ var SessionParkManager = class {
 			savedAt: Date.now()
 		};
 		try {
+			this.#remembered.add(runner.id);
 			await this.#queue(runner.id, () => this.#options.store.save(record));
 		} catch (error) {
 			this.#options.onError?.(error, {
@@ -2857,6 +2881,28 @@ var SessionParkManager = class {
 		}
 	}
 	/**
+	* Drop a dormant record that has stopped being true, leaving the live session
+	* alone — the narrow counterpart to {@link ParkingService.discard}, which also
+	* forgets the config and the session's executions and would therefore make a
+	* clear cost the session its ability to go dormant ever again.
+	*
+	* Only ever called behind {@link ParkingService.#rememberDormant}'s guards,
+	* which is what keeps it off a parked record: a park evicts the runner from
+	* the registry before it saves, and the ownership guard turns a late event
+	* from an evicted runner into a no-op.
+	*/
+	async #forgetDormant(sessionId) {
+		this.#remembered.delete(sessionId);
+		try {
+			await this.#queue(sessionId, () => this.#options.store.delete(sessionId));
+		} catch (error) {
+			this.#options.onError?.(error, {
+				sessionId,
+				phase: "remember"
+			});
+		}
+	}
+	/**
 	* Write a live session's snapshot through to the store, so a restart can
 	* rebuild it. The counterpart to {@link #rememberDormant} for the engine that
 	* has no engine-side session to resume from — same discipline, different