dsh-run2skill 0.3.1 → 0.5.0-alpha.2

package/lib/index.js

@@ -1,8 +1,11 @@
+import { r as routeRun2skillEndpoint } from "./contract-vZz7H2_H.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import { z } from "zod";
 import { basename, dirname, isAbsolute, join, normalize, posix, relative, resolve, sep, win32 } from "node:path";
+import { RemoteError, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
 import { access, link, lstat, mkdir, open, opendir, readFile, readdir, realpath, rename, rmdir, stat, unlink } from "node:fs/promises";
 import { homedir } from "node:os";
+import { livePresetMounts, standingMountFor } from "@deepseek-ai/dsh-agent-preset-registry";
 import z$1 from "@deepseek-ai/schemastery";
 import { createReadStream } from "node:fs";
 //#region src/adapters/dsh-session/gap-reader.ts
@@ -40,7 +43,7 @@ var DshSessionGapReader = class {
 	}
 	async listSnapshots(signal) {
 		try {
-			const snapshots = await this.persistence.listSnapshots(signal);
+			const snapshots = "list" in this.persistence ? await this.persistence.list(signal === void 0 ? void 0 : { signal }) : await this.persistence.listSnapshots(signal);
 			if (!Array.isArray(snapshots) || snapshots.some((snapshot) => !validSnapshot(snapshot))) return {
 				status: "UNAVAILABLE",
 				healthCode: "SESSION_SNAPSHOTS_UNAVAILABLE"
@@ -67,17 +70,55 @@ var DshSessionGapReader = class {
 			fromSeq
 		};
 		if (!Number.isSafeInteger(fromSeq) || fromSeq < 0) return unavailable;
+		let handle;
+		let result = unavailable;
 		try {
-			const result = await this.persistence.readFrom(sessionId, fromSeq, signal);
-			if (!isRecord$5(result) || !validHeader(result["meta"]) || result.meta.id !== sessionId || !validEvents(result.events)) return unavailable;
-			return {
+			if (!("open" in this.persistence)) {
+				const legacy = await this.persistence.readFrom(sessionId, fromSeq, signal);
+				if (isRecord$5(legacy) && validHeader(legacy["meta"]) && legacy.meta.id === sessionId && validEvents(legacy.events)) return {
+					status: "AVAILABLE",
+					header: cloneHeader(legacy.meta),
+					events: cloneEvents(legacy.events)
+				};
+				return unavailable;
+			}
+			handle = await this.persistence.open(sessionId, "read", signal === void 0 ? void 0 : { signal });
+			const read = await handle.read(fromSeq, void 0, signal === void 0 ? void 0 : { signal });
+			if (!validHeader(handle.header) || handle.header.id !== sessionId || !isRecord$5(read) || read["eventState"] !== "detached" && read["eventState"] !== "shared-frozen" || !validEvents(read["events"])) result = unavailable;
+			else result = {
 				status: "AVAILABLE",
-				header: cloneHeader(result.meta),
-				events: cloneEvents(result.events)
+				header: cloneHeader(handle.header),
+				events: cloneEvents(read.events)
 			};
+		} catch {
+			result = unavailable;
+		}
+		if (handle !== void 0) try {
+			await handle.close();
 		} catch {
 			return unavailable;
 		}
+		return result;
+	}
+};
+/** Converts the lifecycle-owned DSH service into run2skill's detached reader port. */
+var DshSessionPersistenceAdapter = class {
+	#reader;
+	constructor(persistence) {
+		this.#reader = new DshSessionGapReader(persistence);
+	}
+	async listSnapshots(signal) {
+		const result = await this.#reader.listSnapshots(signal);
+		if (result.status === "UNAVAILABLE") throw new Error(result.healthCode);
+		return result.snapshots;
+	}
+	async readFrom(sessionId, fromSeq, signal) {
+		const result = await this.#reader.readFrom(sessionId, fromSeq, signal);
+		if (result.status === "UNAVAILABLE") throw new Error(result.healthCode);
+		return {
+			meta: result.header,
+			events: result.events
+		};
 	}
 };
 //#endregion
@@ -3637,9 +3678,6 @@ const ObserveSummaryV1Schema = z.object({
 	lastRecoveryProgressAt: z.string().datetime({ offset: true }).optional(),
 	lastHealthCode: z.string().regex(/^[A-Z][A-Z0-9_]{0,63}$/).optional()
 }).strict();
-//#endregion
-//#region src/adapters/dsh-connection/observe-summary-rpc.ts
-const RUN2SKILL_RPC_CHANNEL = "/run2skill";
 const ObserveSummaryRequestV1Schema = z.object({ apiVersion: z.literal(1) }).strict();
 function badRequest() {
 	return {
@@ -3651,8 +3689,8 @@ function badRequest() {
 		}
 	};
 }
-function registerObserveSummaryRpc(connection, readSummary, fallback) {
-	return connection.rpc.handle(RUN2SKILL_RPC_CHANNEL, async (endpoint, payload, signal) => {
+function createObserveSummaryRpcHandler(readSummary, fallback) {
+	return async (endpoint, payload, signal) => {
 		if (endpoint !== "observe-summary") return fallback === void 0 ? badRequest() : await fallback(endpoint, payload, signal);
 		if (!ObserveSummaryRequestV1Schema.safeParse(payload).success) return badRequest();
 		if (signal.aborted) return {
@@ -3678,8 +3716,34 @@ function registerObserveSummaryRpc(connection, readSummary, fallback) {
 				}
 			};
 		}
-	}, { authority: "loopback" });
+	};
+}
+//#endregion
+//#region src/adapters/dsh-remote/service.ts
+function assertRoute(endpoint, expected) {
+	let actual;
+	try {
+		actual = routeRun2skillEndpoint(endpoint);
+	} catch (cause) {
+		throw new RemoteError("gateway/bad-request", `unknown run2skill endpoint: ${endpoint}`, {}, { cause });
+	}
+	if (actual !== expected) throw new RemoteError("gateway/bad-request", `run2skill endpoint ${endpoint} must use ${actual}`, {});
 }
+var Run2skillRemoteService = class extends TypertRemoteService {
+	handler;
+	constructor(ctx, handler) {
+		super(ctx, "run2skillRemote", { namespace: "run2skill" });
+		this.handler = handler;
+	}
+	async query(request, signal) {
+		assertRoute(request.endpoint, "query");
+		return await this.handler(request.endpoint, request.payload, signal);
+	}
+	async command(request, signal) {
+		assertRoute(request.endpoint, "command");
+		return await this.handler(request.endpoint, request.payload, signal);
+	}
+};
 //#endregion
 //#region src/adapters/dsh-storage/global-store.ts
 var Run2skillGlobalStore = class Run2skillGlobalStore {
@@ -15693,42 +15757,26 @@ var DshPublicationReadbackAdapter = class {
 };
 //#endregion
 //#region src/adapters/dsh-skills/stock-root-contract.ts
-const STOCK_DSH_BASELINE_COMMIT = "b150a551b8d465e31e418e1b2eaf5e79bbb7d28e";
+const STOCK_DSH_BASELINE_COMMIT = "477b4f420553e8a52c2fbccc464d7561b239c443";
 const STOCK_ROOT_CONTRACT_VERSION = ROOT_CONTRACT_VERSION_V2;
 const STOCK_ROOT_RESOLVER_VERSION = ROOT_RESOLVER_VERSION_V2;
-const SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["standard", "code"]);
-const STOCK_PRESET_COMPOSITION_DIGESTS = Object.freeze({
-	standard: Object.freeze(["fa14feb98daef20b810fef30bb7239a89a786de3c45c602b37743f7100d9a5af"]),
-	code: Object.freeze(["bdecfe0b26a9d56a2ffcb79694fc123bc395247969e135c62945a1ec8fb92e87"])
-});
-function contextUsesFileSystem(context) {
-	if (!("get" in context) || typeof context.get !== "function") return false;
+const SUPPORTED_PRESETS = /* @__PURE__ */ new Set(["standard"]);
+const STOCK_PRESET_COMPOSITION_DIGESTS = Object.freeze({ standard: Object.freeze(["ad344050d18ed7bc2582c1ce691b5f56334b84a85ee67a928895f7b0e0b3b5ff"]) });
+function hasStockPresetComposition(mount, expectedDigest) {
+	if (mount.presetId !== "standard") return false;
 	try {
-		return context.get("fs") !== void 0;
+		const rows = mount.tree?.root.data;
+		return Array.isArray(rows) && sha256Utf8(canonicalJson(JSON.parse(JSON.stringify(rows)))) === expectedDigest;
 	} catch {
-		return true;
+		return false;
 	}
 }
-async function resolvePinnedStockPresetConfiguration(presets, agent, expectedDigests = STOCK_PRESET_COMPOSITION_DIGESTS) {
-	return resolvePinnedStockPresetConfigurationById(presets, presets.composedPreset(agent.ctx), contextUsesFileSystem(agent.ctx), expectedDigests);
-}
-async function resolvePinnedStockPresetConfigurationById(presets, presetId, usesContextFileSystem, expectedDigests = STOCK_PRESET_COMPOSITION_DIGESTS) {
-	if (presetId !== "standard" && presetId !== "code") return void 0;
+function contextUsesFileSystem(context) {
+	if (!("get" in context) || typeof context.get !== "function") return false;
 	try {
-		const preset = await presets.resolve(presetId);
-		if (preset.id !== presetId || preset.trust !== "system") return void 0;
-		const content = await presets.read(presetId);
-		if (!expectedDigests[presetId].includes(sha256Utf8(content))) return void 0;
-		return {
-			profile: "web",
-			presetId,
-			providerName: "filesystem",
-			includeDefaultRoots: true,
-			customSkillDirs: [],
-			...usesContextFileSystem ? { usesContextFileSystem: true } : {}
-		};
+		return context.get("fs") !== void 0;
 	} catch {
-		return;
+		return true;
 	}
 }
 var StockSkillRuntimeConfigurationCache = class {
@@ -15770,9 +15818,12 @@ function isWithinFiber(candidate, root) {
 	}
 }
 /** Reads the exact stock filesystem fiber mounted for one Agent's joined generation. */
-async function resolveStockSkillRuntimeConfiguration(mounts, agent) {
+async function resolveStockSkillRuntimeConfiguration(mounts, agent, expectedDigest) {
 	const mount = await mounts.standingMountFor(agent.ctx);
-	if (mount === void 0) return void 0;
+	if (mount === void 0 || expectedDigest !== void 0 && !hasStockPresetComposition(mount, expectedDigest)) return void 0;
+	return resolveMountedStockSkillRuntimeConfiguration(mount, agent);
+}
+function resolveMountedStockSkillRuntimeConfiguration(mount, agent) {
 	const fibers = [...agent.ctx.registry.values()].filter((runtime) => runtime.name === "skill-filesystem").flatMap((runtime) => [...runtime.fibers]).filter((fiber) => isWithinFiber(fiber, mount.fiber));
 	if (fibers.length !== 1) return void 0;
 	const raw = fibers[0].config;
@@ -15899,22 +15950,71 @@ function deriveStockResolutionContractDigest(resolution, scopeIdentity) {
 //#endregion
 //#region src/adapters/dsh-skills/stock-preset-mount.ts
 /** Stock DSH's exact mounted-generation locator, kept behind a narrow production port. */
-const stockPresetMounts = { async standingMountFor(agentContext) {
-	const { standingMountFor } = await import("@deepseek-ai/dsh-agent-presets");
+const stockPresetMounts = { standingMountFor(agentContext) {
 	return standingMountFor(agentContext);
 } };
+const stockColdPresetMounts = { liveMounts(hostContext) {
+	const root = "root" in hostContext ? hostContext.root : void 0;
+	if (typeof root !== "object" || root === null || !("fiber" in root)) return [];
+	return livePresetMounts(root.fiber);
+} };
 //#endregion
-//#region src/adapters/dsh-settings/automatic-learning.ts
-const RUN2SKILL_SETTINGS_NAMESPACE = "run2skill";
-const AutomaticLearningSettingsSchema = z$1.object({ automaticLearning: z$1.boolean().default(true) });
-function registerAutomaticLearningSettings(settings) {
-	const scope = settings.register(RUN2SKILL_SETTINGS_NAMESPACE, AutomaticLearningSettingsSchema, { applies: "live" });
-	const freeze = (value) => Object.freeze({ automaticLearning: value.automaticLearning });
+//#region src/adapters/dsh-skills/stock-cold-preset.ts
+/** A retained generation remains usable only while it is the sole standard mount in this Host. */
+function currentStockPresetMount(mounts, hostContext, key, expectedDigest = STOCK_PRESET_COMPOSITION_DIGESTS.standard[0]) {
+	const standard = mounts.liveMounts(hostContext).filter((mount) => mount.presetId === "standard");
+	if (standard.length !== 1 || standard[0]?.key !== key) return void 0;
+	const mount = standard[0];
+	return mount !== void 0 && expectedDigest !== void 0 && hasStockPresetComposition(mount, expectedDigest) ? mount : void 0;
+}
+async function acquireStockColdPreset(presets, mounts, hostContext, id, expectedDigest = STOCK_PRESET_COMPOSITION_DIGESTS.standard[0]) {
+	if (id !== "standard") return void 0;
+	let lease;
+	try {
+		lease = await presets.acquireScope(id);
+	} catch {
+		return;
+	}
+	let accepted = false;
+	try {
+		const mount = currentStockPresetMount(mounts, hostContext, lease.key, expectedDigest);
+		if (mount === void 0) return void 0;
+		const configuration = resolveMountedStockSkillRuntimeConfiguration(mount, { ctx: {
+			registry: mount.fiber.ctx.registry,
+			get: (name) => name === "fs" ? hostContext.fs : void 0
+		} });
+		if (configuration === void 0) return void 0;
+		accepted = true;
+		return {
+			lease,
+			configuration
+		};
+	} finally {
+		if (!accepted) await lease[Symbol.asyncDispose]();
+	}
+}
+const AutomaticLearningSettingsSchema = z$1.object({ automaticLearning: z$1.boolean().default(true).volatile() });
+function createAutomaticLearningSettings(context) {
+	const listeners = /* @__PURE__ */ new Set();
+	let previous = context.config.automaticLearning.get();
+	const freeze = (value) => Object.freeze({ automaticLearning: value });
+	context.on("loader/volatile-update", (paths) => {
+		if (!paths.some((path) => path.length === 1 && path[0] === "automaticLearning")) return;
+		const next = context.config.automaticLearning.get();
+		if (next === previous) return;
+		const before = freeze(previous);
+		previous = next;
+		const after = freeze(next);
+		for (const listener of listeners) listener(after, before);
+	});
 	return {
-		snapshot: () => freeze(scope.get()),
-		watch: (callback) => scope.watch(async (next, previous) => {
-			await callback(freeze(next), freeze(previous));
-		})
+		snapshot: () => freeze(context.config.automaticLearning.get()),
+		watch: (callback) => {
+			listeners.add(callback);
+			return () => {
+				listeners.delete(callback);
+			};
+		}
 	};
 }
 //#endregion
@@ -15991,6 +16091,7 @@ const SUPPORTED_TURN_EVENT_TYPES = /* @__PURE__ */ new Set([
 	"step/end",
 	"user/message",
 	"assistant/chunk",
+	"assistant/attempt",
 	"assistant/message",
 	"tool/call",
 	"tool/result",
@@ -16157,12 +16258,24 @@ function parseToolCall(event, turn) {
 function parseToolResult(event, turn) {
 	if (!isRecord$1(event.data) || event.data["turn"] !== turn || !isSafeCoordinate(event.data["step"])) return void 0;
 	const message = event.data["message"];
-	if (!isRecord$1(message) || message["role"] !== "user" || !isRecord$1(message["source"]) || message["source"]["kind"] !== "tool") return void 0;
+	if (!isRecord$1(message) || !isRecord$1(message["source"]) || message["source"]["kind"] !== "tool") return void 0;
 	const callId = message["source"]["callId"];
-	const content = message["content"];
-	if (!isCoordinateIdentity(callId) || !Array.isArray(content) || content.length !== 1 || !isRecord$1(content[0])) return void 0;
-	const block = content[0];
-	if (block["type"] !== "tool-result" || block["toolCallId"] !== callId || !Array.isArray(block["content"]) || block["isError"] !== void 0 && typeof block["isError"] !== "boolean") return void 0;
+	if (!isCoordinateIdentity(callId)) return void 0;
+	let content;
+	let isError;
+	if (message["role"] === "tool") {
+		if (message["toolCallId"] !== callId || !Array.isArray(message["content"])) return void 0;
+		content = message["content"];
+		isError = message["isError"];
+	} else if (message["role"] === "user") {
+		const blocks = message["content"];
+		if (!Array.isArray(blocks) || blocks.length !== 1 || !isRecord$1(blocks[0])) return void 0;
+		const block = blocks[0];
+		if (block["type"] !== "tool-result" || block["toolCallId"] !== callId || !Array.isArray(block["content"])) return void 0;
+		content = block["content"];
+		isError = block["isError"];
+	} else return void 0;
+	if (isError !== void 0 && typeof isError !== "boolean") return void 0;
 	const error = event.data["error"];
 	if (error !== void 0 && (!isRecord$1(error) || !isIdentity(error["name"]) || !isIdentity(error["code"]))) return void 0;
 	try {
@@ -16170,10 +16283,10 @@ function parseToolResult(event, turn) {
 			seq: event.seq,
 			step: event.data["step"],
 			callId,
-			failed: block["isError"] === true || error !== void 0,
+			failed: isError === true || error !== void 0,
 			contentDigest: sha256Utf8(canonicalJson({
-				content: block["content"],
-				isError: block["isError"] === true,
+				content,
+				isError: isError === true,
 				error: error ?? null
 			}))
 		};
@@ -16913,12 +17026,13 @@ var DshSessionActivityAdapter = class {
 	}
 	#sampleLive(sessionId, sessionLifecycleKey, durableEvents) {
 		const live = this.#sessions.get(sessionId);
-		if (live !== void 0 && (lifecycleKey(live.header) !== sessionLifecycleKey || !sameSessionPrefix(live.events, durableEvents))) return void 0;
+		const liveEvents = live?.snapshotEvents();
+		if (live !== void 0 && (lifecycleKey(live.header) !== sessionLifecycleKey || liveEvents === void 0 || !sameSessionPrefix(liveEvents, durableEvents))) return void 0;
 		const agent = this.#agents.get(sessionId);
 		if (agent !== void 0 && (live === void 0 || agent.id !== sessionId || agent.session !== live || lifecycleKey(agent.session.header) !== sessionLifecycleKey || agent.status !== "idle" && agent.status !== "running" || typeof agent.whenIdle !== "function")) return void 0;
 		return {
 			live,
-			liveCoordinates: canonicalJson(eventCoordinates(live?.events ?? [])),
+			liveCoordinates: canonicalJson(eventCoordinates(liveEvents ?? [])),
 			agent,
 			agentStatus: agent?.status ?? "absent"
 		};
@@ -18629,6 +18743,7 @@ const SUPPORTED_TURN_EVENTS = /* @__PURE__ */ new Set([
 	"step/end",
 	"user/message",
 	"assistant/chunk",
+	"assistant/attempt",
 	"assistant/message",
 	"tool/call",
 	"tool/result",
@@ -19449,7 +19564,7 @@ var DshV2RootManifestAdapter = class {
 		}
 	}
 	async #rootManifest(cwd, configuration, budget, filesystem) {
-		if (configuration.profile !== "web" || configuration.presetId !== "standard" && configuration.presetId !== "code" || configuration.providerName.trim().length === 0 || configuration.usesContextFileSystem === true && filesystem === void 0) return void 0;
+		if (configuration.profile !== "web" || configuration.presetId !== "standard" || configuration.providerName.trim().length === 0 || configuration.usesContextFileSystem === true && filesystem === void 0) return void 0;
 		const home = this.#homeDirectory();
 		const current = this.#currentEnvironment();
 		if (configuration.configuredDshHome === void 0 && resolveDshHomeCompatible(void 0, current.DSH_HOME, home) !== resolveDshHomeCompatible(void 0, this.#initialEnvironment.DSH_HOME, home)) return void 0;
@@ -25351,16 +25466,15 @@ var DshV2ProductionRuntime = class {
 //#endregion
 //#region src/host/index.ts
 const name = "run2skill";
+const Config = AutomaticLearningSettingsSchema;
 const inject = [
 	"agents",
 	"sessions",
 	"sessionPersistence",
 	"storageDomain",
 	"workspaceRegistry",
-	"connection",
 	"llm",
 	"skills",
-	"settings",
 	"agentPresets",
 	"fs"
 ];
@@ -25399,7 +25513,7 @@ var Run2skillRuntimeFactory = class {
 		this.scopes = scopes;
 		this.automaticLearning = automaticLearning;
 		this.mutationGate = mutationGate;
-		this.#stockConfigurations = new StockSkillRuntimeConfigurationCache(async (agent) => await resolveStockSkillRuntimeConfiguration(stockPresetMounts, agent) ?? await resolvePinnedStockPresetConfiguration(this.context.agentPresets, agent));
+		this.#stockConfigurations = new StockSkillRuntimeConfigurationCache(async (agent) => await resolveStockSkillRuntimeConfiguration(stockPresetMounts, agent, STOCK_PRESET_COMPOSITION_DIGESTS.standard[0]));
 	}
 	wakeLearning() {
 		this.currentScheduler?.wake();
@@ -25785,7 +25899,7 @@ var Run2skillV2RuntimeFactory = class {
 		this.notices = notices;
 		this.scopes = scopes;
 		this.automaticLearning = automaticLearning;
-		this.#stockConfigurations = new StockSkillRuntimeConfigurationCache(async (agent) => await resolveStockSkillRuntimeConfiguration(stockPresetMounts, agent) ?? await resolvePinnedStockPresetConfiguration(this.context.agentPresets, agent));
+		this.#stockConfigurations = new StockSkillRuntimeConfigurationCache(async (agent) => await resolveStockSkillRuntimeConfiguration(stockPresetMounts, agent, STOCK_PRESET_COMPOSITION_DIGESTS.standard[0]));
 	}
 	wakeLearning() {
 		this.currentV2Runtime?.pipeline.wake();
@@ -25801,8 +25915,14 @@ var Run2skillV2RuntimeFactory = class {
 		else this.#workspaceBindings.set(agent, workspaceBinding);
 		const presetId = configuration.presetId ?? header.agentPreset;
 		if (presetId === void 0) throw new Error("V2_SESSION_PRESET_UNAVAILABLE");
-		const scope = await this.context.agentPresets.standingKeyFor(presetId);
-		this.#rememberDormantSession(header, scope, configuration, workspaceBinding);
+		const retained = await acquireStockColdPreset(this.context.agentPresets, stockColdPresetMounts, this.context, presetId);
+		if (retained === void 0) throw new Error("V2_SESSION_PRESET_GENERATION_UNAVAILABLE");
+		try {
+			if ((await stockPresetMounts.standingMountFor(agent.ctx))?.key !== retained.lease.key) throw new Error("V2_SESSION_PRESET_GENERATION_UNAVAILABLE");
+			this.#rememberDormantSession(header, retained.lease.key, retained.configuration, workspaceBinding);
+		} finally {
+			await retained.lease[Symbol.asyncDispose]();
+		}
 	}
 	releaseRootConfiguration(agent) {
 		this.#workspaceBindings.delete(agent);
@@ -25838,27 +25958,35 @@ var Run2skillV2RuntimeFactory = class {
 			...workspaceBinding === void 0 ? {} : { workspaceBinding }
 		});
 	}
+	#currentDormant(session) {
+		return currentStockPresetMount(stockColdPresetMounts, this.context, session.scope) !== void 0;
+	}
 	async #hydrateDormantSessions() {
 		let snapshots;
 		try {
-			snapshots = await this.context.sessionPersistence.listSnapshots();
+			const listed = await new DshSessionGapReader(this.context.sessionPersistence).listSnapshots();
+			if (listed.status === "UNAVAILABLE") return;
+			snapshots = listed.snapshots;
 		} catch {
 			return;
 		}
 		for (const { header } of snapshots) {
 			if (classifySessionRoot(header).status !== "ROOT") continue;
 			try {
-				const configuration = await resolvePinnedStockPresetConfigurationById(this.context.agentPresets, header.agentPreset, true);
-				if (configuration === void 0) continue;
-				const scope = await this.context.agentPresets.standingKeyFor(configuration.presetId);
-				const workspaceBinding = await this.#workspaceBinding(header.cwd);
-				this.#rememberDormantSession(header, scope, configuration, workspaceBinding);
+				const retained = await acquireStockColdPreset(this.context.agentPresets, stockColdPresetMounts, this.context, header.agentPreset);
+				if (retained === void 0) continue;
+				try {
+					const workspaceBinding = await this.#workspaceBinding(header.cwd);
+					this.#rememberDormantSession(header, retained.lease.key, retained.configuration, workspaceBinding);
+				} finally {
+					await retained.lease[Symbol.asyncDispose]();
+				}
 			} catch {}
 		}
 	}
 	#dormantForView(view) {
 		const cwdDigest = deriveSessionCwdDigest(view.cwd);
-		return [...this.#dormantSessions.values()].find((session) => session.scope === view.scope && deriveSessionCwdDigest(session.header.cwd) === cwdDigest);
+		return [...this.#dormantSessions.values()].find((session) => this.#currentDormant(session) && session.scope === view.scope && deriveSessionCwdDigest(session.header.cwd) === cwdDigest);
 	}
 	async open() {
 		let domain;
@@ -25889,7 +26017,7 @@ var Run2skillV2RuntimeFactory = class {
 					}
 				}
 				const dormant = this.#dormantSessions.get(lifecycleKey);
-				if (dormant === void 0) return void 0;
+				if (dormant === void 0 || !this.#currentDormant(dormant)) return void 0;
 				return {
 					header: dormant.header,
 					view: {
@@ -25906,6 +26034,7 @@ var Run2skillV2RuntimeFactory = class {
 				const dormant = this.#dormantForView(view);
 				const configuration = this.#stockConfigurations.get(view.scope) ?? dormant?.configuration;
 				if (configuration === void 0) return void 0;
+				if (dormant === void 0 && !("session" in view.scope)) return void 0;
 				const workspaceBinding = this.#workspaceBindings.get(view.scope) ?? dormant?.workspaceBinding;
 				const filesystem = exactAgentFileSystem(view.scope) ?? dormant?.filesystem;
 				return {
@@ -25919,7 +26048,7 @@ var Run2skillV2RuntimeFactory = class {
 			const sessions = typeof this.context.sessions === "object" && this.context.sessions !== null && "get" in this.context.sessions && typeof this.context.sessions.get === "function" ? this.context.sessions : { get: (_id) => void 0 };
 			const agents = typeof this.context.agents === "object" && this.context.agents !== null && "get" in this.context.agents && typeof this.context.agents.get === "function" ? this.context.agents : { get: (_id) => void 0 };
 			runtime = new DshV2ProductionRuntime(domain, {
-				persistence: this.context.sessionPersistence,
+				persistence: new DshSessionPersistenceAdapter(this.context.sessionPersistence),
 				sessions,
 				agents,
 				llm: this.context.llm,
@@ -25955,12 +26084,17 @@ var Run2skillV2RuntimeFactory = class {
 					publicationAbort.abort();
 					if (this.currentV2Runtime === activeRuntime) this.currentV2Runtime = void 0;
 					if (this.currentV2Domain === domain) this.currentV2Domain = void 0;
-					await activeRuntime.close();
+					try {
+						await activeRuntime.close();
+					} finally {
+						this.#dormantSessions.clear();
+					}
 				}
 			};
 		} catch (error) {
 			if (runtime !== void 0) await runtime.close().catch(() => void 0);
 			else if (domain !== void 0) await domain.close().catch(() => void 0);
+			this.#dormantSessions.clear();
 			throw error;
 		}
 	}
@@ -26009,8 +26143,11 @@ function v2Summary(domain, lifecycle, notices) {
 		...latest === void 0 ? {} : { lastHealthCode: latest.healthCode }
 	});
 }
-async function apply(context) {
-	const automaticLearning = registerAutomaticLearningSettings(context.settings);
+async function apply(context, config) {
+	const automaticLearning = createAutomaticLearningSettings({
+		config,
+		on: context.on.bind(context)
+	});
 	const notices = new RuntimeNotices();
 	const scopes = new ExactAgentScopeRegistry();
 	const scopeDisposers = /* @__PURE__ */ new WeakMap();
@@ -26117,7 +26254,7 @@ async function apply(context) {
 		runtimeAttention: (sessionId) => projectRuntimeAttention(notices, sessionId),
 		learningActions: async (currentScope) => await (factory.currentV2Runtime?.attention.project(currentScope) ?? [])
 	}, v2LearningRpc);
-	const v2Rpc = createV2RecentSkillActivityRpcHandler(() => factory.currentV2Domain, resolveCurrentWorkspace, createV2LearningStatusRpcHandler(() => factory.currentV2Domain, {
+	new Run2skillRemoteService(context, createObserveSummaryRpcHandler(readSummary, createV2RecentSkillActivityRpcHandler(() => factory.currentV2Domain, resolveCurrentWorkspace, createV2LearningStatusRpcHandler(() => factory.currentV2Domain, {
 		resolveSession: (lifecycleKey) => factory.currentV2Runtime?.learningStatusSession(lifecycleKey),
 		resolveWorkspace: resolveCurrentWorkspace,
 		requestSynthesis: async (lifecycleKey) => {
@@ -26125,8 +26262,7 @@ async function apply(context) {
 			if (runtime === void 0) throw new Error("V2_RUNTIME_UNAVAILABLE");
 			return await runtime.requestSynthesis(lifecycleKey);
 		}
-	}, createPurgeRpcHandler(() => factory.currentV2Runtime?.purge, v2ProposalRpc, { runMutation: (operation) => mutationGate.run(operation) })));
-	const disposeRpc = registerObserveSummaryRpc(context.connection, readSummary, v2Rpc);
+	}, createPurgeRpcHandler(() => factory.currentV2Runtime?.purge, v2ProposalRpc, { runMutation: (operation) => mutationGate.run(operation) })))));
 	try {
 		await lifecycle.start();
 	} catch (error) {
@@ -26137,15 +26273,11 @@ async function apply(context) {
 		accepting = false;
 		stopWatchingSettings();
 		try {
-			await disposeRpc();
+			await lifecycle.dispose();
 		} finally {
-			try {
-				await lifecycle.dispose();
-			} finally {
-				scopes.clear();
-			}
+			scopes.clear();
 		}
 	};
 }
 //#endregion
-export { ApprovalPublicationSaga, ApprovedProposalRevalidator, PublicationConflict, PublicationScheduler, PublicationTargetSingleFlight, Run2skillRuntimeFactory, V2ProposalPublicationCoordinator, V2ProposalPublicationError, apply, createBundle, finalizeTransaction, inject, mergeBundle, name, preparePublicationRoot, recoverTransaction };
+export { ApprovalPublicationSaga, ApprovedProposalRevalidator, Config, PublicationConflict, PublicationScheduler, PublicationTargetSingleFlight, Run2skillRuntimeFactory, V2ProposalPublicationCoordinator, V2ProposalPublicationError, apply, createBundle, finalizeTransaction, inject, mergeBundle, name, preparePublicationRoot, recoverTransaction };

package/lib/typert.host.d.ts

@@ -0,0 +1,25 @@
+//#region src/adapters/dsh-remote/typert.d.ts
+declare const TYPERT: Readonly<{
+  package: "dsh-run2skill";
+  face: "host";
+  schemas: never[];
+  invocations: readonly import("@deepseek-ai/dsh-typert-protocol").InvocationDescriptor[];
+  model: {
+    services: {
+      key: string;
+      exportName: string;
+      summary: string;
+      tags: never[];
+      members: {
+        kind: string;
+        name: string;
+        signature: string;
+      }[];
+      types: never[];
+    }[];
+    events: never[];
+    objects: never[];
+  };
+}>;
+//#endregion
+export { TYPERT, TYPERT as default };

package/lib/typert.host.js

@@ -0,0 +1,30 @@
+import { n as RUN2SKILL_REMOTE_DESCRIPTORS } from "./contract-vZz7H2_H.js";
+//#region src/adapters/dsh-remote/typert.ts
+const TYPERT = Object.freeze({
+	package: "dsh-run2skill",
+	face: "host",
+	schemas: [],
+	invocations: RUN2SKILL_REMOTE_DESCRIPTORS,
+	model: {
+		services: [{
+			key: "run2skillRemote",
+			exportName: "Run2skillRemoteService",
+			summary: "Run2Skill read and mutation boundary for the DSH Web client.",
+			tags: [],
+			members: [{
+				kind: "method",
+				name: "query",
+				signature: "query(request: Run2skillQueryRequest, signal: AbortSignal): Promise<Run2skillRpcResult>"
+			}, {
+				kind: "method",
+				name: "command",
+				signature: "command(request: Run2skillCommandRequest, signal: AbortSignal): Promise<Run2skillRpcResult>"
+			}],
+			types: []
+		}],
+		events: [],
+		objects: []
+	}
+});
+//#endregion
+export { TYPERT, TYPERT as default };

package/lib/typert.remote-client.d.ts

@@ -0,0 +1,38 @@
+import { z } from "zod";
+import { RemoteResult, TypertRemoteContribution } from "@deepseek-ai/dsh-typert-protocol";
+//#region src/adapters/dsh-connection/observe-summary-rpc.d.ts
+type ObserveRpcError = {
+  readonly code: string;
+  readonly message: string;
+  readonly details: Record<string, unknown>;
+};
+type ObserveRpcResult<T> = {
+  readonly ok: true;
+  readonly value: T;
+} | {
+  readonly ok: false;
+  readonly error: ObserveRpcError;
+};
+//#endregion
+//#region src/adapters/dsh-remote/contract.d.ts
+declare const RUN2SKILL_QUERY_ENDPOINTS: readonly ["observe-summary", "attention", "proposals/list", "summary", "proposals/get", "recent-activity/list", "learning/status", "learning/issues/list", "purge/preview", "purge/status"];
+declare const RUN2SKILL_COMMAND_ENDPOINTS: readonly ["proposals/approve", "proposals/reject", "proposals/retry", "proposals/refresh", "proposals/revise", "coverage/confirm-discard", "learning/request", "learning/issues/retry", "learning/issues/dismiss", "purge/confirm", "purge/retry"];
+type Run2skillQueryEndpoint = typeof RUN2SKILL_QUERY_ENDPOINTS[number];
+type Run2skillCommandEndpoint = typeof RUN2SKILL_COMMAND_ENDPOINTS[number];
+type Run2skillEndpoint = Run2skillQueryEndpoint | Run2skillCommandEndpoint;
+declare const RUN2SKILL_REMOTE: TypertRemoteContribution;
+interface Run2skillRemoteRequest<Endpoint extends Run2skillEndpoint = Run2skillEndpoint> {
+  readonly endpoint: Endpoint;
+  readonly payload: unknown;
+}
+interface Run2skillRemoteNamespace {
+  query(request: Run2skillRemoteRequest<Run2skillQueryEndpoint>, signal?: AbortSignal): Promise<RemoteResult<ObserveRpcResult<unknown>>>;
+  command(request: Run2skillRemoteRequest<Run2skillCommandEndpoint>, signal?: AbortSignal): Promise<RemoteResult<ObserveRpcResult<unknown>>>;
+}
+declare module '@deepseek-ai/dsh-typert-protocol' {
+  interface TypertRemoteNamespaceMap {
+    run2skill: Run2skillRemoteNamespace;
+  }
+}
+//#endregion
+export { RUN2SKILL_REMOTE as TYPERT_REMOTE, RUN2SKILL_REMOTE as default };