dsh-loop-engine 1.0.0-rc7 → 1.0.0-rc9

package/lib/index.js

@@ -46,11 +46,10 @@ var __callDispose = (stack, error, hasError) => {
 
 // src/index.ts
 import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "node:fs";
-import { mkdir, readFile as readFile5, rename, writeFile } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { dirname as dirname5, join as join10 } from "node:path";
+import { mkdir as mkdir2, readFile as readFile6, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { dirname as dirname6, join as join11 } from "node:path";
 import z6 from "@deepseek-ai/schemastery";
-import { installSettingsSection } from "@deepseek-ai/dsh-settings";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 
 // src/engine-claude/loop.ts
@@ -58,7 +57,7 @@ import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 import { emitAgentEvent } from "@deepseek-ai/dsh-agent";
 import { MAX_TIMER_DELAY_MS } from "@deepseek-ai/dsh-timeout";
-import { SessionPreparation } from "@deepseek-ai/dsh-session";
+import { interruptedTurnClosers, SessionLogOffset, SessionPreparation } from "@deepseek-ai/dsh-session";
 
 // src/engine-claude/agent.ts
 import { Inbox, agentEvents } from "@deepseek-ai/dsh-agent";
@@ -69,7 +68,7 @@ import { query as officialQuery } from "@anthropic-ai/claude-agent-sdk";
 
 // src/engine-claude/mapping.ts
 import {
-  CallId,
+  ToolCallId,
   createToolResultMessage
 } from "@deepseek-ai/dsh-llm";
 function stringifyToolInput(input) {
@@ -88,7 +87,7 @@ function mapAssistantMessage(message) {
         content.push({ type: "text", text: block.text });
         break;
       case "tool_use": {
-        const callId = CallId(block.id);
+        const callId = ToolCallId(block.id);
         content.push({
           type: "tool-call",
           id: callId,
@@ -123,7 +122,7 @@ function mapToolResults(message) {
   for (const block of content) {
     if (block.type !== "tool_result") continue;
     results.push(createToolResultMessage({
-      callId: CallId(block.tool_use_id),
+      callId: ToolCallId(block.tool_use_id),
       content: toolResultContent(block.content),
       isError: block.is_error === true
     }));
@@ -166,7 +165,7 @@ function mapStreamEvent(event, toolCalls) {
         return [{ type: "block-start", index: event.index, blockType: "reasoning" }];
       }
       if (block.type === "tool_use") {
-        toolCalls.set(event.index, { callId: CallId(block.id), name: block.name });
+        toolCalls.set(event.index, { callId: ToolCallId(block.id), name: block.name });
         return [{ type: "block-start", index: event.index, blockType: "tool-call" }];
       }
       return [];
@@ -184,7 +183,7 @@ function mapStreamEvent(event, toolCalls) {
         return [{
           type: "tool-call-delta",
           index: event.index,
-          id: call?.callId ?? CallId(`call-${event.index}`),
+          id: call?.callId ?? ToolCallId(`call-${event.index}`),
           ...call === void 0 ? {} : { name: call.name },
           argumentsDelta: delta.partial_json
         }];
@@ -552,7 +551,7 @@ var ClaudeCodeAgent = class {
         this.dispatch.emit("agent/inbox/claimed", { message, turn });
       }
     });
-    const lastTurn = session.events.findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+    const lastTurn = session.snapshotEvents().findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
     this.phase = { kind: "idle", lastTurn };
     this.scope = createScope(loopCtx, this);
     this.ctx = this.scope.ctx.extend({ agent: this });
@@ -756,7 +755,7 @@ var ClaudeCodeAgent = class {
    */
   queryPermission() {
     if (this.config.permissionMode !== void 0) return { permissionMode: this.config.permissionMode };
-    const permission = resolveSessionPermission(this.session.events);
+    const permission = resolveSessionPermission(this.session.snapshotEvents());
     if (permission.kind === "bypass") return { permissionMode: "bypassPermissions" };
     if (permission.kind === "ask") {
       const approval = this.loopCtx.get("approval");
@@ -1020,11 +1019,15 @@ var ClaudeCodeAgent = class {
 };
 
 // src/driver-core/ownership.ts
-import { FiberState } from "@deepseek-ai/cordis";
+var INACTIVE_FIBER_VALUES = {
+  FAILED: 3,
+  DISPOSED: 4,
+  UNLOADING: 5
+};
 var INACTIVE_STATES = /* @__PURE__ */ new Set([
-  FiberState.UNLOADING,
-  FiberState.DISPOSED,
-  FiberState.FAILED
+  INACTIVE_FIBER_VALUES.UNLOADING,
+  INACTIVE_FIBER_VALUES.DISPOSED,
+  INACTIVE_FIBER_VALUES.FAILED
 ]);
 var FactoryOwnership = class {
   constructor(fiber) {
@@ -1162,7 +1165,7 @@ var ClaudeCodeLoop = class extends Service {
    * fuses caller cancellation with lifecycle teardown for setup awaits.
    */
   /* jscpd:ignore-start -- ownership/transaction machinery mirrors the default agent-loop factory; depending on agent-loop is forbidden. */
-  prepare(ownerCtx, id, options, session, callerSignal) {
+  prepare(ownerCtx, id, options, session, callerSignal, handle) {
     ownerCtx.fiber.assertActive();
     if (!this.ownership.isActive()) throw new Error("agent loop is not active");
     if (callerSignal?.aborted) {
@@ -1196,11 +1199,15 @@ var ClaudeCodeLoop = class extends Service {
         }
       } finally {
         try {
-          detachAgent?.();
-          detachSession?.();
+          await handle?.close();
         } finally {
-          untrack();
-          if (!ownerTriggered) await unfollowOwner();
+          try {
+            detachAgent?.();
+            detachSession?.();
+          } finally {
+            untrack();
+            if (!ownerTriggered) await unfollowOwner();
+          }
         }
       }
     })();
@@ -1250,18 +1257,27 @@ var ClaudeCodeLoop = class extends Service {
     }
   }
   /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source) {
+  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored) {
     var _stack = [];
     try {
       const ownedPreparation = __using(_stack, preparation);
       const session = ownedPreparation.session;
-      const prepared = this.prepare(ownerCtx, id, agentOptions, session, signal);
+      let prepared;
+      try {
+        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle);
+      } catch (error) {
+        await stored?.handle.close().catch(() => {
+        });
+        throw error;
+      }
       try {
         const setupCommit = await raceAbort(setup?.(prepared.agent.ctx), prepared.signal, id);
         setupCommit?.commit();
+        await this.appendUnstoredSuffix(stored, session);
         return prepared.publish(source);
       } catch (error) {
-        await prepared.dispose();
+        await prepared.dispose().catch(() => {
+        });
         throw error;
       }
     } catch (_) {
@@ -1272,7 +1288,8 @@ var ClaudeCodeLoop = class extends Service {
   }
   /**
    * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber.
+   * the accessing fiber. When a persistence backend is mounted, the session's
+   * durable identity is stored before publication.
    * @param ownerCtx - caller context that structurally owns the lifecycle.
    * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
    * @returns the published handle.
@@ -1280,20 +1297,73 @@ var ClaudeCodeLoop = class extends Service {
   async createAgent(ownerCtx, options) {
     const preparation = SessionPreparation.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
       ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta }
+      ...options.meta === void 0 ? {} : { meta: options.meta },
+      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
     }));
-    const published = this.setupAndPublish(
-      ownerCtx,
-      options.sessionId,
-      preparation,
-      options.agentOptions ?? {},
-      options.setup,
-      options.signal,
-      "startup"
-    );
+    const published = (async () => {
+      let stored;
+      try {
+        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
+          () => this.createStoredSession(preparation.session, options.signal),
+          options.signal,
+          options.sessionId,
+          (abandoned) => {
+            void abandoned?.handle.close().catch(() => {
+            });
+          }
+        );
+      } catch (error) {
+        preparation[Symbol.dispose]();
+        throw error;
+      }
+      return this.setupAndPublish(
+        ownerCtx,
+        options.sessionId,
+        preparation,
+        options.agentOptions ?? {},
+        options.setup,
+        options.signal,
+        "startup",
+        stored
+      );
+    })();
     this.ownership.trackWrapper(published);
     return published;
   }
+  /**
+   * Take a fresh session's write ownership when persistence is mounted.
+   * Nothing is appended here: the constructor seed (which never re-emits
+   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+   * publication commit point, so a failed or cancelled setup closes an
+   * unmaterialized handle and leaves no stored residue — the same id can be
+   * created again.
+   * @param session - the unpublished session to store.
+   * @param signal - optional cancellation forwarded to the backend create.
+   * @returns the owned handle and stored cursor, or `undefined` without a backend.
+   */
+  async createStoredSession(session, signal) {
+    const persistence = this.runtime.ctx.get("sessionPersistence");
+    if (persistence === void 0) return void 0;
+    const handle = await persistence.create(session.header, {
+      inheritedEventCount: session.inheritedEventCount,
+      ...signal === void 0 ? {} : { signal }
+    });
+    return { handle, storedCount: 0 };
+  }
+  /**
+   * Durably store the session events appended since the last stored cursor.
+   * Pre-publication appends (constructor seed markers, setup-window events)
+   * never re-emit through `session/event`, so publication must flush them
+   * through the handle before live events start routing into it.
+   * @param stored - the session's owned handle and stored cursor, if any.
+   * @param session - the unpublished session whose suffix is stored.
+   */
+  async appendUnstoredSuffix(stored, session) {
+    if (stored === void 0) return;
+    const suffix = session.snapshotEvents(SessionLogOffset(stored.storedCount));
+    if (suffix.length > 0) await stored.handle.append(suffix);
+    stored.storedCount += suffix.length;
+  }
   /**
    * Resume an owned agent from the configured persistence service.
    * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -1307,11 +1377,10 @@ var ClaudeCodeLoop = class extends Service {
     }
     return this.resumeWith(ownerCtx, persistence, options);
   }
-  /** Resume through an explicit persistence handle. */
-  async resumeWith(ownerCtx, persistence, options) {
+  /** Resume through an explicit persistence service. */
+  resumeWith(ownerCtx, persistence, options) {
     const id = options.resumeSessionId;
-    let preparation;
-    try {
+    const published = (async () => {
       const ownerAbort = new AbortController();
       const unfollowOwner = ownerCtx.effect(() => () => {
         ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
@@ -1321,32 +1390,56 @@ var ClaudeCodeLoop = class extends Service {
         ownerAbort.signal,
         this.ownership.signal
       ]);
+      let handle;
+      let stored;
+      let preparation;
       try {
-        preparation = await raceAbortCall(
-          () => persistence.prepare(id, fused),
-          fused,
+        try {
+          handle = await raceAbortCall(
+            () => persistence.open(id, "write", { signal: fused }),
+            fused,
+            id,
+            (abandoned) => {
+              void abandoned.close();
+            }
+          );
+          const persisted = await handle.read(0, void 0, { signal: fused });
+          fused.throwIfAborted();
+          const closers = interruptedTurnClosers(persisted);
+          if (closers.length > 0) await handle.append(closers);
+          preparation = SessionPreparation.create(this.runtime.ctx.sessions.prepare(id, {
+            seed: [...persisted, ...closers],
+            meta: structuredClone(handle.header),
+            inheritedEventCount: handle.inheritedEventCount,
+            seedSource: "persistence"
+          }));
+          stored = { handle, storedCount: persisted.length + closers.length };
+          await this.appendUnstoredSuffix(stored, preparation.session);
+        } finally {
+          await unfollowOwner();
+        }
+        ownerCtx.fiber.assertActive();
+        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+        const owned = stored;
+        handle = void 0;
+        return await this.setupAndPublish(
+          ownerCtx,
           id,
-          (abandoned) => {
-            abandoned[Symbol.dispose]();
-          }
+          preparation,
+          options.agentOptions ?? {},
+          options.setup,
+          options.signal,
+          "resume",
+          owned
         );
       } finally {
-        await unfollowOwner();
+        preparation?.[Symbol.dispose]();
+        await handle?.close().catch(() => {
+        });
       }
-      ownerCtx.fiber.assertActive();
-      if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-      return await this.setupAndPublish(
-        ownerCtx,
-        id,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "resume"
-      );
-    } finally {
-      preparation?.[Symbol.dispose]();
-    }
+    })();
+    this.ownership.trackWrapper(published);
+    return published;
   }
 };
 
@@ -1354,7 +1447,7 @@ var ClaudeCodeLoop = class extends Service {
 import { Service as Service2 } from "@deepseek-ai/cordis";
 import z2 from "@deepseek-ai/schemastery";
 import { emitAgentEvent as emitAgentEvent2 } from "@deepseek-ai/dsh-agent";
-import { SessionPreparation as SessionPreparation2 } from "@deepseek-ai/dsh-session";
+import { interruptedTurnClosers as interruptedTurnClosers2, SessionLogOffset as SessionLogOffset2, SessionPreparation as SessionPreparation2 } from "@deepseek-ai/dsh-session";
 
 // src/engine-codex/agent.ts
 import { Inbox as Inbox2, agentEvents as agentEvents2 } from "@deepseek-ai/dsh-agent";
@@ -1441,7 +1534,7 @@ var AppServerClient = class _AppServerClient {
       clientInfo: {
         name: "dsh-loop-engine",
         title: null,
-        version: "0.1.1-rc.2"
+        version: "1.0.0-rc9"
       },
       capabilities: { experimentalApi: true, requestAttestation: false }
     };
@@ -1656,7 +1749,7 @@ function noopNotificationHandler() {
 }
 
 // src/engine-codex/appserver/mapping.ts
-import { CallId as CallId2, createToolResultMessage as createToolResultMessage2 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId2, createToolResultMessage as createToolResultMessage2 } from "@deepseek-ai/dsh-llm";
 function mapUsage2(usage) {
   return {
     inputTokens: usage.inputTokens,
@@ -1668,12 +1761,12 @@ function mapUsage2(usage) {
 function mapCommandExecution(item) {
   return {
     call: {
-      callId: CallId2(item.id),
+      callId: ToolCallId2(item.id),
       name: "command_execution",
       arguments: JSON.stringify({ command: item.command ?? "" })
     },
     result: createToolResultMessage2({
-      callId: CallId2(item.id),
+      callId: ToolCallId2(item.id),
       content: [{ type: "text", text: item.aggregatedOutput ?? "" }],
       isError: (item.exitCode ?? 0) !== 0 || item.status === "failed"
     })
@@ -1682,12 +1775,12 @@ function mapCommandExecution(item) {
 function mapFileChange(item) {
   return {
     call: {
-      callId: CallId2(item.id),
+      callId: ToolCallId2(item.id),
       name: "apply_patch",
       arguments: JSON.stringify(item.changes ?? [])
     },
     result: createToolResultMessage2({
-      callId: CallId2(item.id),
+      callId: ToolCallId2(item.id),
       content: [{ type: "text", text: `patch ${item.status ?? "completed"}` }],
       isError: item.status === "failed"
     })
@@ -1698,12 +1791,12 @@ function mapMcpToolCall(item) {
   const isError = item.error !== void 0 && item.error !== null;
   return {
     call: {
-      callId: CallId2(item.id),
+      callId: ToolCallId2(item.id),
       name: name2,
       arguments: JSON.stringify(item.arguments ?? {})
     },
     result: createToolResultMessage2({
-      callId: CallId2(item.id),
+      callId: ToolCallId2(item.id),
       content: isError ? [{ type: "text", text: item.error?.message ?? "tool call failed" }] : [{ type: "text", text: JSON.stringify(item.result?.content ?? []) }],
       isError
     })
@@ -1732,7 +1825,7 @@ var CodexAgent = class {
         this.dispatch.emit("agent/inbox/claimed", { message, turn });
       }
     });
-    const lastTurn = session.events.findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+    const lastTurn = session.snapshotEvents().findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
     this.phase = { kind: "idle", lastTurn };
     this.scope = createScope2(loopCtx, this);
     this.ctx = this.scope.ctx.extend({ agent: this });
@@ -1945,7 +2038,7 @@ var CodexAgent = class {
    * @returns the permission fields of the query spec.
    */
   queryPermission() {
-    const fold = resolveSessionPermission2(this.session.events);
+    const fold = resolveSessionPermission2(this.session.snapshotEvents());
     return {
       sandboxMode: this.config.sandboxMode ?? fold.sandboxMode,
       approvalPolicy: this.config.approvalPolicy ?? fold.approvalPolicy
@@ -2298,7 +2391,7 @@ var CodexLoop = class extends Service2 {
    * fuses caller cancellation with lifecycle teardown for setup awaits.
    */
   /* jscpd:ignore-start -- ownership/transaction machinery mirrors the Claude Code loop factory. */
-  prepare(ownerCtx, id, options, session, callerSignal) {
+  prepare(ownerCtx, id, options, session, callerSignal, handle) {
     ownerCtx.fiber.assertActive();
     if (!this.ownership.isActive()) throw new Error("agent loop is not active");
     if (callerSignal?.aborted) {
@@ -2332,11 +2425,15 @@ var CodexLoop = class extends Service2 {
         }
       } finally {
         try {
-          detachAgent?.();
-          detachSession?.();
+          await handle?.close();
         } finally {
-          untrack();
-          if (!ownerTriggered) await unfollowOwner();
+          try {
+            detachAgent?.();
+            detachSession?.();
+          } finally {
+            untrack();
+            if (!ownerTriggered) await unfollowOwner();
+          }
         }
       }
     })();
@@ -2386,18 +2483,27 @@ var CodexLoop = class extends Service2 {
     }
   }
   /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source) {
+  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored) {
     var _stack = [];
     try {
       const ownedPreparation = __using(_stack, preparation);
       const session = ownedPreparation.session;
-      const prepared = this.prepare(ownerCtx, id, agentOptions, session, signal);
+      let prepared;
+      try {
+        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle);
+      } catch (error) {
+        await stored?.handle.close().catch(() => {
+        });
+        throw error;
+      }
       try {
         const setupCommit = await raceAbort(setup?.(prepared.agent.ctx), prepared.signal, id);
         setupCommit?.commit();
+        await this.appendUnstoredSuffix(stored, session);
         return prepared.publish(source);
       } catch (error) {
-        await prepared.dispose();
+        await prepared.dispose().catch(() => {
+        });
         throw error;
       }
     } catch (_) {
@@ -2408,7 +2514,8 @@ var CodexLoop = class extends Service2 {
   }
   /**
    * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber.
+   * the accessing fiber. When a persistence backend is mounted, the session's
+   * durable identity is stored before publication.
    * @param ownerCtx - caller context that structurally owns the lifecycle.
    * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
    * @returns the published handle.
@@ -2416,20 +2523,73 @@ var CodexLoop = class extends Service2 {
   async createAgent(ownerCtx, options) {
     const preparation = SessionPreparation2.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
       ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta }
+      ...options.meta === void 0 ? {} : { meta: options.meta },
+      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
     }));
-    const published = this.setupAndPublish(
-      ownerCtx,
-      options.sessionId,
-      preparation,
-      options.agentOptions ?? {},
-      options.setup,
-      options.signal,
-      "startup"
-    );
+    const published = (async () => {
+      let stored;
+      try {
+        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
+          () => this.createStoredSession(preparation.session, options.signal),
+          options.signal,
+          options.sessionId,
+          (abandoned) => {
+            void abandoned?.handle.close().catch(() => {
+            });
+          }
+        );
+      } catch (error) {
+        preparation[Symbol.dispose]();
+        throw error;
+      }
+      return this.setupAndPublish(
+        ownerCtx,
+        options.sessionId,
+        preparation,
+        options.agentOptions ?? {},
+        options.setup,
+        options.signal,
+        "startup",
+        stored
+      );
+    })();
     this.ownership.trackWrapper(published);
     return published;
   }
+  /**
+   * Take a fresh session's write ownership when persistence is mounted.
+   * Nothing is appended here: the constructor seed (which never re-emits
+   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+   * publication commit point, so a failed or cancelled setup closes an
+   * unmaterialized handle and leaves no stored residue — the same id can be
+   * created again.
+   * @param session - the unpublished session to store.
+   * @param signal - optional cancellation forwarded to the backend create.
+   * @returns the owned handle and stored cursor, or `undefined` without a backend.
+   */
+  async createStoredSession(session, signal) {
+    const persistence = this.runtime.ctx.get("sessionPersistence");
+    if (persistence === void 0) return void 0;
+    const handle = await persistence.create(session.header, {
+      inheritedEventCount: session.inheritedEventCount,
+      ...signal === void 0 ? {} : { signal }
+    });
+    return { handle, storedCount: 0 };
+  }
+  /**
+   * Durably store the session events appended since the last stored cursor.
+   * Pre-publication appends (constructor seed markers, setup-window events)
+   * never re-emit through `session/event`, so publication must flush them
+   * through the handle before live events start routing into it.
+   * @param stored - the session's owned handle and stored cursor, if any.
+   * @param session - the unpublished session whose suffix is stored.
+   */
+  async appendUnstoredSuffix(stored, session) {
+    if (stored === void 0) return;
+    const suffix = session.snapshotEvents(SessionLogOffset2(stored.storedCount));
+    if (suffix.length > 0) await stored.handle.append(suffix);
+    stored.storedCount += suffix.length;
+  }
   /**
    * Resume an owned agent from the configured persistence service.
    * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -2443,11 +2603,10 @@ var CodexLoop = class extends Service2 {
     }
     return this.resumeWith(ownerCtx, persistence, options);
   }
-  /** Resume through an explicit persistence handle. */
-  async resumeWith(ownerCtx, persistence, options) {
+  /** Resume through an explicit persistence service. */
+  resumeWith(ownerCtx, persistence, options) {
     const id = options.resumeSessionId;
-    let preparation;
-    try {
+    const published = (async () => {
       const ownerAbort = new AbortController();
       const unfollowOwner = ownerCtx.effect(() => () => {
         ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
@@ -2457,32 +2616,56 @@ var CodexLoop = class extends Service2 {
         ownerAbort.signal,
         this.ownership.signal
       ]);
+      let handle;
+      let stored;
+      let preparation;
       try {
-        preparation = await raceAbortCall(
-          () => persistence.prepare(id, fused),
-          fused,
+        try {
+          handle = await raceAbortCall(
+            () => persistence.open(id, "write", { signal: fused }),
+            fused,
+            id,
+            (abandoned) => {
+              void abandoned.close();
+            }
+          );
+          const persisted = await handle.read(0, void 0, { signal: fused });
+          fused.throwIfAborted();
+          const closers = interruptedTurnClosers2(persisted);
+          if (closers.length > 0) await handle.append(closers);
+          preparation = SessionPreparation2.create(this.runtime.ctx.sessions.prepare(id, {
+            seed: [...persisted, ...closers],
+            meta: structuredClone(handle.header),
+            inheritedEventCount: handle.inheritedEventCount,
+            seedSource: "persistence"
+          }));
+          stored = { handle, storedCount: persisted.length + closers.length };
+          await this.appendUnstoredSuffix(stored, preparation.session);
+        } finally {
+          await unfollowOwner();
+        }
+        ownerCtx.fiber.assertActive();
+        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+        const owned = stored;
+        handle = void 0;
+        return await this.setupAndPublish(
+          ownerCtx,
           id,
-          (abandoned) => {
-            abandoned[Symbol.dispose]();
-          }
+          preparation,
+          options.agentOptions ?? {},
+          options.setup,
+          options.signal,
+          "resume",
+          owned
         );
       } finally {
-        await unfollowOwner();
+        preparation?.[Symbol.dispose]();
+        await handle?.close().catch(() => {
+        });
       }
-      ownerCtx.fiber.assertActive();
-      if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-      return await this.setupAndPublish(
-        ownerCtx,
-        id,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "resume"
-      );
-    } finally {
-      preparation?.[Symbol.dispose]();
-    }
+    })();
+    this.ownership.trackWrapper(published);
+    return published;
   }
 };
 
@@ -2493,11 +2676,11 @@ import { fileURLToPath } from "node:url";
 import { Service as Service3 } from "@deepseek-ai/cordis";
 import z3 from "@deepseek-ai/schemastery";
 import { emitAgentEvent as emitAgentEvent3 } from "@deepseek-ai/dsh-agent";
-import { SessionPreparation as SessionPreparation3 } from "@deepseek-ai/dsh-session";
+import { interruptedTurnClosers as interruptedTurnClosers3, SessionLogOffset as SessionLogOffset3, SessionPreparation as SessionPreparation3 } from "@deepseek-ai/dsh-session";
 
 // src/engine-pi/agent.ts
 import { Inbox as Inbox3, agentEvents as agentEvents3 } from "@deepseek-ai/dsh-agent";
-import { CallId as CallId4, LlmError as LlmError3, createAssistantMessage as createAssistantMessage3, createUserMessage as createUserMessage3, errorChain as errorChain3 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId4, LlmError as LlmError3, createAssistantMessage as createAssistantMessage3, createUserMessage as createUserMessage3, errorChain as errorChain3 } from "@deepseek-ai/dsh-llm";
 import { createScope as createScope3 } from "@deepseek-ai/dsh-scope";
 import { canonicalHeader as canonicalHeader3 } from "@deepseek-ai/dsh-session";
 
@@ -2717,7 +2900,7 @@ var PiRpcClient = class _PiRpcClient {
 
 // src/engine-pi/rpc/mapping.ts
 import {
-  CallId as CallId3,
+  ToolCallId as ToolCallId3,
   createToolResultMessage as createToolResultMessage3
 } from "@deepseek-ai/dsh-llm";
 function mapUsage3(usage) {
@@ -2748,7 +2931,7 @@ function resultText(content) {
 }
 function mapToolResult(ev) {
   return createToolResultMessage3({
-    callId: CallId3(ev.toolCallId),
+    callId: ToolCallId3(ev.toolCallId),
     content: [{ type: "text", text: resultText(ev.result) || "(no content)" }],
     isError: ev.isError
   });
@@ -2783,7 +2966,7 @@ var PiAgent = class {
         this.dispatch.emit("agent/inbox/claimed", { message, turn });
       }
     });
-    const lastTurn = session.events.findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+    const lastTurn = session.snapshotEvents().findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
     this.phase = { kind: "idle", lastTurn };
     this.scope = createScope3(loopCtx, this);
     this.ctx = this.scope.ctx.extend({ agent: this });
@@ -3004,7 +3187,7 @@ var PiAgent = class {
    * @returns the permission fields of the query spec.
    */
   queryPermission() {
-    const fold = resolveSessionPermission3(this.session.events);
+    const fold = resolveSessionPermission3(this.session.snapshotEvents());
     const sandboxMode = this.config.sandboxMode ?? fold.sandboxMode;
     return {
       sandboxMode,
@@ -3102,14 +3285,32 @@ var PiAgent = class {
     });
     this.requestHeaderLogged = true;
   }
+  /**
+   * The harness Session's web-side model selection, if any was stored. The
+   * durable `model/selection` event carries `{ provider, model, ... }`; when a
+   * user picked a model via `/model`, this is the newest pick, and it overrides
+   * the deployment config (which stays the fallback). Returns `undefined` when
+   * no selection was stored, so the deployment config governs.
+   */
+  dynamicModel() {
+    for (const event of [...this.session.snapshotEvents()].reverse()) {
+      const type = event.type;
+      if (type !== "model/selection") continue;
+      const data = event.data;
+      const model = data?.model;
+      if (typeof model === "string" && model.length > 0) return model;
+    }
+    return void 0;
+  }
   /** Build the `pi --mode rpc` argv/cwd/env for one step's child process. */
   spawnSpec(cwd) {
     const argv = [];
+    const model = this.dynamicModel() ?? this.config.model;
     if (this.config.provider !== void 0) argv.push("--provider", this.config.provider);
-    if (this.config.model !== void 0 && this.config.thinkingLevel !== void 0) {
-      argv.push("--model", `${this.config.model}:${this.config.thinkingLevel}`);
-    } else if (this.config.model !== void 0) {
-      argv.push("--model", this.config.model);
+    if (model !== void 0 && this.config.thinkingLevel !== void 0) {
+      argv.push("--model", `${model}:${this.config.thinkingLevel}`);
+    } else if (model !== void 0) {
+      argv.push("--model", model);
     } else if (this.config.thinkingLevel !== void 0) {
       argv.push("--model", `:${this.config.thinkingLevel}`);
     }
@@ -3215,7 +3416,7 @@ var PiAgent = class {
         this.session.append("tool/call", {
           turn,
           step,
-          callId: CallId4(callId),
+          callId: ToolCallId4(callId),
           name: name2,
           arguments: argumentsValue
         });
@@ -3364,6 +3565,67 @@ var PiAgent = class {
   }
 };
 
+// src/engine-pi/probe.ts
+function waitForExit(child) {
+  return new Promise((resolve5) => {
+    ;
+    child.onExit(
+      (code) => resolve5(code ?? 0)
+    );
+  });
+}
+function collectStdout(child) {
+  return new Promise((resolve5) => {
+    let text = "";
+    if (child.stdout.on === void 0) {
+      resolve5("");
+      return;
+    }
+    const out = child.stdout;
+    out.setEncoding("utf8");
+    out.on("data", (data) => {
+      text += String(data);
+    });
+    out.on("end", () => {
+      resolve5(text);
+    });
+    out.on("close", () => {
+      resolve5(text);
+    });
+  });
+}
+function parsePiModelList(output) {
+  const entries = [];
+  for (const line of output.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) continue;
+    const match = /^(\S+)\s{2,}(\S+)/.exec(trimmed);
+    if (match === null) continue;
+    const provider = match[1];
+    if (provider === "provider") continue;
+    entries.push({ provider, model: match[2] });
+  }
+  return entries;
+}
+async function probePiModels(bin, spawn4) {
+  const spec = {
+    argv: [bin, "--mode", "rpc", "--list-models"],
+    cwd: process.cwd(),
+    env: {}
+  };
+  let child;
+  try {
+    child = spawn4(spec);
+  } catch {
+    return [];
+  }
+  const stdoutPromise = collectStdout(child);
+  const exitCode = await waitForExit(child);
+  if (exitCode !== 0) return [];
+  const stdout = await stdoutPromise;
+  return parsePiModelList(stdout);
+}
+
 // src/engine-pi/loop.ts
 var PI_SANDBOX_MODES = [
   "read-only",
@@ -3376,7 +3638,8 @@ var Config3 = z3.object({
   provider: z3.string(),
   model: z3.string(),
   thinkingLevel: z3.string(),
-  env: z3.dict(z3.string()).default({})
+  env: z3.dict(z3.string()).default({}),
+  piCatalogHolder: z3.any()
 });
 function resolveConfig3(config) {
   return {
@@ -3415,7 +3678,8 @@ function fromSubprocess(handle) {
     stdout,
     stderr,
     onExit: (handler) => {
-      void handle.done.then(handler, handler);
+      const onExit = handler;
+      void handle.done.then((outcome) => onExit(outcome.exitCode), handler);
     },
     terminate: () => handle.terminate()
   };
@@ -3439,6 +3703,14 @@ var PiLoop = class extends Service3 {
     this.runtime = { ctx };
     this.bin = piCliEntrypoint();
     this.spawn = (spec) => fromSubprocess(this.runtime.ctx.subprocess.spawn(piSubprocessSpec(spec, PI_DISPOSE_GRACE_MS)));
+    const holder = config.piCatalogHolder;
+    if (holder !== void 0) {
+      void probePiModels(this.bin, (spec) => this.spawn(spec)).then((models) => {
+        holder.entries = [...models];
+      }).catch(() => {
+        holder.entries = [];
+      });
+    }
     ctx.effect(() => () => this.ownership.dispose(), "agentLoopPi.transactions()");
     ctx.effect(() => ctx.agents.setFactory(this), "agentLoopPi.setFactory()");
     ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
@@ -3452,7 +3724,7 @@ var PiLoop = class extends Service3 {
    * fuses caller cancellation with lifecycle teardown for setup awaits.
    */
   /* jscpd:ignore-start -- ownership/transaction machinery mirrors the Claude Code loop factory. */
-  prepare(ownerCtx, id, options, session, callerSignal) {
+  prepare(ownerCtx, id, options, session, callerSignal, handle) {
     ownerCtx.fiber.assertActive();
     if (!this.ownership.isActive()) throw new Error("agent loop is not active");
     if (callerSignal?.aborted) {
@@ -3486,11 +3758,15 @@ var PiLoop = class extends Service3 {
         }
       } finally {
         try {
-          detachAgent?.();
-          detachSession?.();
+          await handle?.close();
         } finally {
-          untrack();
-          if (!ownerTriggered) await unfollowOwner();
+          try {
+            detachAgent?.();
+            detachSession?.();
+          } finally {
+            untrack();
+            if (!ownerTriggered) await unfollowOwner();
+          }
         }
       }
     })();
@@ -3540,18 +3816,27 @@ var PiLoop = class extends Service3 {
     }
   }
   /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source) {
+  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored) {
     var _stack = [];
     try {
       const ownedPreparation = __using(_stack, preparation);
       const session = ownedPreparation.session;
-      const prepared = this.prepare(ownerCtx, id, agentOptions, session, signal);
+      let prepared;
+      try {
+        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle);
+      } catch (error) {
+        await stored?.handle.close().catch(() => {
+        });
+        throw error;
+      }
       try {
         const setupCommit = await raceAbort(setup?.(prepared.agent.ctx), prepared.signal, id);
         setupCommit?.commit();
+        await this.appendUnstoredSuffix(stored, session);
         return prepared.publish(source);
       } catch (error) {
-        await prepared.dispose();
+        await prepared.dispose().catch(() => {
+        });
         throw error;
       }
     } catch (_) {
@@ -3562,7 +3847,8 @@ var PiLoop = class extends Service3 {
   }
   /**
    * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber.
+   * the accessing fiber. When a persistence backend is mounted, the session's
+   * durable identity is stored before publication.
    * @param ownerCtx - caller context that structurally owns the lifecycle.
    * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
    * @returns the published handle.
@@ -3570,20 +3856,73 @@ var PiLoop = class extends Service3 {
   async createAgent(ownerCtx, options) {
     const preparation = SessionPreparation3.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
       ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta }
+      ...options.meta === void 0 ? {} : { meta: options.meta },
+      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
     }));
-    const published = this.setupAndPublish(
-      ownerCtx,
-      options.sessionId,
-      preparation,
-      options.agentOptions ?? {},
-      options.setup,
-      options.signal,
-      "startup"
-    );
+    const published = (async () => {
+      let stored;
+      try {
+        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
+          () => this.createStoredSession(preparation.session, options.signal),
+          options.signal,
+          options.sessionId,
+          (abandoned) => {
+            void abandoned?.handle.close().catch(() => {
+            });
+          }
+        );
+      } catch (error) {
+        preparation[Symbol.dispose]();
+        throw error;
+      }
+      return this.setupAndPublish(
+        ownerCtx,
+        options.sessionId,
+        preparation,
+        options.agentOptions ?? {},
+        options.setup,
+        options.signal,
+        "startup",
+        stored
+      );
+    })();
     this.ownership.trackWrapper(published);
     return published;
   }
+  /**
+   * Take a fresh session's write ownership when persistence is mounted.
+   * Nothing is appended here: the constructor seed (which never re-emits
+   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+   * publication commit point, so a failed or cancelled setup closes an
+   * unmaterialized handle and leaves no stored residue — the same id can be
+   * created again.
+   * @param session - the unpublished session to store.
+   * @param signal - optional cancellation forwarded to the backend create.
+   * @returns the owned handle and stored cursor, or `undefined` without a backend.
+   */
+  async createStoredSession(session, signal) {
+    const persistence = this.runtime.ctx.get("sessionPersistence");
+    if (persistence === void 0) return void 0;
+    const handle = await persistence.create(session.header, {
+      inheritedEventCount: session.inheritedEventCount,
+      ...signal === void 0 ? {} : { signal }
+    });
+    return { handle, storedCount: 0 };
+  }
+  /**
+   * Durably store the session events appended since the last stored cursor.
+   * Pre-publication appends (constructor seed markers, setup-window events)
+   * never re-emit through `session/event`, so publication must flush them
+   * through the handle before live events start routing into it.
+   * @param stored - the session's owned handle and stored cursor, if any.
+   * @param session - the unpublished session whose suffix is stored.
+   */
+  async appendUnstoredSuffix(stored, session) {
+    if (stored === void 0) return;
+    const suffix = session.snapshotEvents(SessionLogOffset3(stored.storedCount));
+    if (suffix.length > 0) await stored.handle.append(suffix);
+    stored.storedCount += suffix.length;
+  }
   /**
    * Resume an owned agent from the configured persistence service.
    * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -3597,11 +3936,10 @@ var PiLoop = class extends Service3 {
     }
     return this.resumeWith(ownerCtx, persistence, options);
   }
-  /** Resume through an explicit persistence handle. */
-  async resumeWith(ownerCtx, persistence, options) {
+  /** Resume through an explicit persistence service. */
+  resumeWith(ownerCtx, persistence, options) {
     const id = options.resumeSessionId;
-    let preparation;
-    try {
+    const published = (async () => {
       const ownerAbort = new AbortController();
       const unfollowOwner = ownerCtx.effect(() => () => {
         ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
@@ -3611,32 +3949,56 @@ var PiLoop = class extends Service3 {
         ownerAbort.signal,
         this.ownership.signal
       ]);
+      let handle;
+      let stored;
+      let preparation;
       try {
-        preparation = await raceAbortCall(
-          () => persistence.prepare(id, fused),
-          fused,
+        try {
+          handle = await raceAbortCall(
+            () => persistence.open(id, "write", { signal: fused }),
+            fused,
+            id,
+            (abandoned) => {
+              void abandoned.close();
+            }
+          );
+          const persisted = await handle.read(0, void 0, { signal: fused });
+          fused.throwIfAborted();
+          const closers = interruptedTurnClosers3(persisted);
+          if (closers.length > 0) await handle.append(closers);
+          preparation = SessionPreparation3.create(this.runtime.ctx.sessions.prepare(id, {
+            seed: [...persisted, ...closers],
+            meta: structuredClone(handle.header),
+            inheritedEventCount: handle.inheritedEventCount,
+            seedSource: "persistence"
+          }));
+          stored = { handle, storedCount: persisted.length + closers.length };
+          await this.appendUnstoredSuffix(stored, preparation.session);
+        } finally {
+          await unfollowOwner();
+        }
+        ownerCtx.fiber.assertActive();
+        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+        const owned = stored;
+        handle = void 0;
+        return await this.setupAndPublish(
+          ownerCtx,
           id,
-          (abandoned) => {
-            abandoned[Symbol.dispose]();
-          }
+          preparation,
+          options.agentOptions ?? {},
+          options.setup,
+          options.signal,
+          "resume",
+          owned
         );
       } finally {
-        await unfollowOwner();
+        preparation?.[Symbol.dispose]();
+        await handle?.close().catch(() => {
+        });
       }
-      ownerCtx.fiber.assertActive();
-      if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-      return await this.setupAndPublish(
-        ownerCtx,
-        id,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "resume"
-      );
-    } finally {
-      preparation?.[Symbol.dispose]();
-    }
+    })();
+    this.ownership.trackWrapper(published);
+    return published;
   }
 };
 
@@ -3644,11 +4006,11 @@ var PiLoop = class extends Service3 {
 import { Service as Service4 } from "@deepseek-ai/cordis";
 import z4 from "@deepseek-ai/schemastery";
 import { emitAgentEvent as emitAgentEvent4 } from "@deepseek-ai/dsh-agent";
-import { SessionPreparation as SessionPreparation4 } from "@deepseek-ai/dsh-session";
+import { interruptedTurnClosers as interruptedTurnClosers4, SessionLogOffset as SessionLogOffset4, SessionPreparation as SessionPreparation4 } from "@deepseek-ai/dsh-session";
 
 // src/engine-kimi/agent.ts
 import { Inbox as Inbox4, agentEvents as agentEvents4 } from "@deepseek-ai/dsh-agent";
-import { CallId as CallId6, LlmError as LlmError4, createAssistantMessage as createAssistantMessage4, createUserMessage as createUserMessage4, errorChain as errorChain4 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId6, LlmError as LlmError4, createAssistantMessage as createAssistantMessage4, createUserMessage as createUserMessage4, errorChain as errorChain4 } from "@deepseek-ai/dsh-llm";
 import { createScope as createScope4 } from "@deepseek-ai/dsh-scope";
 import { canonicalHeader as canonicalHeader4 } from "@deepseek-ai/dsh-session";
 
@@ -3903,7 +4265,7 @@ var AcpClient = class _AcpClient {
 };
 
 // src/engine-kimi/acp/mapping.ts
-import { CallId as CallId5, createToolResultMessage as createToolResultMessage4 } from "@deepseek-ai/dsh-llm";
+import { ToolCallId as ToolCallId5, createToolResultMessage as createToolResultMessage4 } from "@deepseek-ai/dsh-llm";
 function isTextChunk(update) {
   return update.sessionUpdate === "agent_message_chunk";
 }
@@ -3940,7 +4302,7 @@ function toolContentText(update) {
 }
 function toolResult(callId, text, isError) {
   return createToolResultMessage4({
-    callId: CallId5(callId),
+    callId: ToolCallId5(callId),
     content: [{ type: "text", text: text.length > 0 ? text : "(no content)" }],
     isError
   });
@@ -3975,7 +4337,7 @@ var KimiAgent = class {
         this.dispatch.emit("agent/inbox/claimed", { message, turn });
       }
     });
-    const lastTurn = session.events.findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
+    const lastTurn = session.snapshotEvents().findLast((event) => event.type === "turn/start")?.data.turn ?? 0;
     this.phase = { kind: "idle", lastTurn };
     this.scope = createScope4(loopCtx, this);
     this.ctx = this.scope.ctx.extend({ agent: this });
@@ -4321,7 +4683,7 @@ var KimiAgent = class {
     signal.throwIfAborted();
     const client = await this.acpClient(cwd);
     signal.throwIfAborted();
-    client.onPermission(() => resolveToolApproval(this.session.events));
+    client.onPermission(() => resolveToolApproval(this.session.snapshotEvents()));
     const acpSessionId = await client.newSession(cwd);
     signal.throwIfAborted();
     client.onUpdate((update) => this.applyUpdate(turn, step, update));
@@ -4385,7 +4747,7 @@ var KimiAgent = class {
       if (callId === "" || this.emittedToolCalls.has(callId)) return;
       this.emittedToolCalls.add(callId);
       const name2 = toolCallName(update);
-      this.session.append("tool/call", { turn, step, callId: CallId6(callId), name: name2, arguments: "{}" });
+      this.session.append("tool/call", { turn, step, callId: ToolCallId6(callId), name: name2, arguments: "{}" });
       this.toolText.set(callId, "");
       return;
     }
@@ -4476,7 +4838,7 @@ var KimiLoop = class extends Service4 {
    * fuses caller cancellation with lifecycle teardown for setup awaits.
    */
   /* jscpd:ignore-start -- ownership/transaction machinery mirrors the Claude Code loop factory. */
-  prepare(ownerCtx, id, options, session, callerSignal) {
+  prepare(ownerCtx, id, options, session, callerSignal, handle) {
     ownerCtx.fiber.assertActive();
     if (!this.ownership.isActive()) throw new Error("agent loop is not active");
     if (callerSignal?.aborted) {
@@ -4510,11 +4872,15 @@ var KimiLoop = class extends Service4 {
         }
       } finally {
         try {
-          detachAgent?.();
-          detachSession?.();
+          await handle?.close();
         } finally {
-          untrack();
-          if (!ownerTriggered) await unfollowOwner();
+          try {
+            detachAgent?.();
+            detachSession?.();
+          } finally {
+            untrack();
+            if (!ownerTriggered) await unfollowOwner();
+          }
         }
       }
     })();
@@ -4564,18 +4930,27 @@ var KimiLoop = class extends Service4 {
     }
   }
   /** Prepare one Agent around an acquired Session, run setup, and publish it. */
-  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source) {
+  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored) {
     var _stack = [];
     try {
       const ownedPreparation = __using(_stack, preparation);
       const session = ownedPreparation.session;
-      const prepared = this.prepare(ownerCtx, id, agentOptions, session, signal);
+      let prepared;
+      try {
+        prepared = this.prepare(ownerCtx, id, agentOptions, session, signal, stored?.handle);
+      } catch (error) {
+        await stored?.handle.close().catch(() => {
+        });
+        throw error;
+      }
       try {
         const setupCommit = await raceAbort(setup?.(prepared.agent.ctx), prepared.signal, id);
         setupCommit?.commit();
+        await this.appendUnstoredSuffix(stored, session);
         return prepared.publish(source);
       } catch (error) {
-        await prepared.dispose();
+        await prepared.dispose().catch(() => {
+        });
         throw error;
       }
     } catch (_) {
@@ -4586,7 +4961,8 @@ var KimiLoop = class extends Service4 {
   }
   /**
    * Create an agent and session under one caller-supplied identity, owned by
-   * the accessing fiber.
+   * the accessing fiber. When a persistence backend is mounted, the session's
+   * durable identity is stored before publication.
    * @param ownerCtx - caller context that structurally owns the lifecycle.
    * @param options - identities, session seed/metadata, loop options, setup, and cancellation.
    * @returns the published handle.
@@ -4594,20 +4970,73 @@ var KimiLoop = class extends Service4 {
   async createAgent(ownerCtx, options) {
     const preparation = SessionPreparation4.create(this.runtime.ctx.sessions.prepare(options.sessionId, {
       ...options.seed === void 0 ? {} : { seed: options.seed },
-      ...options.meta === void 0 ? {} : { meta: options.meta }
+      ...options.meta === void 0 ? {} : { meta: options.meta },
+      ...options.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
     }));
-    const published = this.setupAndPublish(
-      ownerCtx,
-      options.sessionId,
-      preparation,
-      options.agentOptions ?? {},
-      options.setup,
-      options.signal,
-      "startup"
-    );
+    const published = (async () => {
+      let stored;
+      try {
+        stored = options.signal === void 0 ? await this.createStoredSession(preparation.session) : await raceAbortCall(
+          () => this.createStoredSession(preparation.session, options.signal),
+          options.signal,
+          options.sessionId,
+          (abandoned) => {
+            void abandoned?.handle.close().catch(() => {
+            });
+          }
+        );
+      } catch (error) {
+        preparation[Symbol.dispose]();
+        throw error;
+      }
+      return this.setupAndPublish(
+        ownerCtx,
+        options.sessionId,
+        preparation,
+        options.agentOptions ?? {},
+        options.setup,
+        options.signal,
+        "startup",
+        stored
+      );
+    })();
     this.ownership.trackWrapper(published);
     return published;
   }
+  /**
+   * Take a fresh session's write ownership when persistence is mounted.
+   * Nothing is appended here: the constructor seed (which never re-emits
+   * through `session/event`) is stored by {@link appendUnstoredSuffix} at the
+   * publication commit point, so a failed or cancelled setup closes an
+   * unmaterialized handle and leaves no stored residue — the same id can be
+   * created again.
+   * @param session - the unpublished session to store.
+   * @param signal - optional cancellation forwarded to the backend create.
+   * @returns the owned handle and stored cursor, or `undefined` without a backend.
+   */
+  async createStoredSession(session, signal) {
+    const persistence = this.runtime.ctx.get("sessionPersistence");
+    if (persistence === void 0) return void 0;
+    const handle = await persistence.create(session.header, {
+      inheritedEventCount: session.inheritedEventCount,
+      ...signal === void 0 ? {} : { signal }
+    });
+    return { handle, storedCount: 0 };
+  }
+  /**
+   * Durably store the session events appended since the last stored cursor.
+   * Pre-publication appends (constructor seed markers, setup-window events)
+   * never re-emit through `session/event`, so publication must flush them
+   * through the handle before live events start routing into it.
+   * @param stored - the session's owned handle and stored cursor, if any.
+   * @param session - the unpublished session whose suffix is stored.
+   */
+  async appendUnstoredSuffix(stored, session) {
+    if (stored === void 0) return;
+    const suffix = session.snapshotEvents(SessionLogOffset4(stored.storedCount));
+    if (suffix.length > 0) await stored.handle.append(suffix);
+    stored.storedCount += suffix.length;
+  }
   /**
    * Resume an owned agent from the configured persistence service.
    * @param ownerCtx - caller context that owns load, setup, and the live lifecycle.
@@ -4621,11 +5050,10 @@ var KimiLoop = class extends Service4 {
     }
     return this.resumeWith(ownerCtx, persistence, options);
   }
-  /** Resume through an explicit persistence handle. */
-  async resumeWith(ownerCtx, persistence, options) {
+  /** Resume through an explicit persistence service. */
+  resumeWith(ownerCtx, persistence, options) {
     const id = options.resumeSessionId;
-    let preparation;
-    try {
+    const published = (async () => {
       const ownerAbort = new AbortController();
       const unfollowOwner = ownerCtx.effect(() => () => {
         ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
@@ -4635,32 +5063,56 @@ var KimiLoop = class extends Service4 {
         ownerAbort.signal,
         this.ownership.signal
       ]);
+      let handle;
+      let stored;
+      let preparation;
       try {
-        preparation = await raceAbortCall(
-          () => persistence.prepare(id, fused),
-          fused,
+        try {
+          handle = await raceAbortCall(
+            () => persistence.open(id, "write", { signal: fused }),
+            fused,
+            id,
+            (abandoned) => {
+              void abandoned.close();
+            }
+          );
+          const persisted = await handle.read(0, void 0, { signal: fused });
+          fused.throwIfAborted();
+          const closers = interruptedTurnClosers4(persisted);
+          if (closers.length > 0) await handle.append(closers);
+          preparation = SessionPreparation4.create(this.runtime.ctx.sessions.prepare(id, {
+            seed: [...persisted, ...closers],
+            meta: structuredClone(handle.header),
+            inheritedEventCount: handle.inheritedEventCount,
+            seedSource: "persistence"
+          }));
+          stored = { handle, storedCount: persisted.length + closers.length };
+          await this.appendUnstoredSuffix(stored, preparation.session);
+        } finally {
+          await unfollowOwner();
+        }
+        ownerCtx.fiber.assertActive();
+        if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+        const owned = stored;
+        handle = void 0;
+        return await this.setupAndPublish(
+          ownerCtx,
           id,
-          (abandoned) => {
-            abandoned[Symbol.dispose]();
-          }
+          preparation,
+          options.agentOptions ?? {},
+          options.setup,
+          options.signal,
+          "resume",
+          owned
         );
       } finally {
-        await unfollowOwner();
+        preparation?.[Symbol.dispose]();
+        await handle?.close().catch(() => {
+        });
       }
-      ownerCtx.fiber.assertActive();
-      if (!this.ownership.isActive()) throw new Error("agent loop is not active");
-      return await this.setupAndPublish(
-        ownerCtx,
-        id,
-        preparation,
-        options.agentOptions ?? {},
-        options.setup,
-        options.signal,
-        "resume"
-      );
-    } finally {
-      preparation?.[Symbol.dispose]();
-    }
+    })();
+    this.ownership.trackWrapper(published);
+    return published;
   }
 };
 
@@ -5102,7 +5554,6 @@ var KIMI_COMMANDS = [
   builtin("status", "Show the current session runtime state"),
   builtin("compact", "Compact the conversation context to free token usage"),
   builtin("clear", "Start a fresh session, discarding the current context"),
-  builtin("model", "Switch the LLM model used in the current session"),
   builtin("plan", "Toggle plan (read-only exploration) mode"),
   builtin("auto", "Toggle auto permission mode"),
   builtin("usage", "Show token usage, context, and quota information"),
@@ -5112,7 +5563,6 @@ var KIMI_COMMANDS = [
 
 // src/settings.ts
 import z5 from "@deepseek-ai/schemastery";
-import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 
 // src/namespace.ts
 var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
@@ -5124,7 +5574,7 @@ var LOOP_ENGINE_SETTINGS_SCHEMA = z5.object({
   showInComposer: z5.boolean().default(true)
 });
 function loopEngineSettingsNamespace() {
-  return settingsNamespace(LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL);
+  return LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL;
 }
 
 // src/patch-manager.ts
@@ -5138,6 +5588,8 @@ function renderManagedBlock(engine) {
     `${MANAGED_BLOCK_BEGIN}${engine} --`,
     "- id: agent-loop",
     "  disabled: true",
+    "- id: command-goal",
+    "  disabled: true",
     END_MARKER_LINE
   ].join("\n");
 }
@@ -5199,10 +5651,124 @@ ${block}`;
   return hasRootEntry(result) ? result : seedEmptyArray(result);
 }
 
+// src/preset.ts
+import { mkdir, readFile as readFile4, rename, writeFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { dirname as dirname4, join as join7 } from "node:path";
+var HOSTED_PRESET_ID = "loop-engine";
+var USER_PRESET_DIR = ".agent-presets";
+var COMPOSITION_FILE = "agent.cordis.yml";
+var METADATA_FILE = "preset.yml";
+var SOURCE_PRESET_ID = "standard";
+var STRIPPED_ROWS = ["skill-filesystem", "tool-skill", "tool-goal", "planning", "compaction"];
+var MANAGED_HEADER = `# Managed by dsh-loop-engine: the deployment's "${SOURCE_PRESET_ID}" preset minus
+# the dsh-native command/skill rows a hosted loop engine replaces. Regenerated
+# from "${SOURCE_PRESET_ID}" on boot \u2014 hand edits are overwritten.
+`;
+var MANAGED_METADATA = "name: Hosted Engine\ndescription: Standard preset minus the dsh-native commands and skills a hosted loop engine replaces.\n";
+function isEntryStart(line) {
+  return line.startsWith("- ");
+}
+function entryId(line) {
+  return /^- id:\s*(\S+)\s*$/.exec(line)?.[1];
+}
+function stripPresetRows(text, ids = STRIPPED_ROWS) {
+  const lines = text.split("\n");
+  const starts = [];
+  for (const [index, line] of lines.entries()) {
+    if (isEntryStart(line)) starts.push(index);
+  }
+  if (starts.length === 0) return text;
+  const drop = new Set(ids);
+  const entries = [];
+  let heading = lines.slice(0, starts[0]);
+  for (const [index, start] of starts.entries()) {
+    const end = index + 1 < starts.length ? starts[index + 1] : lines.length;
+    const span = lines.slice(start, end);
+    let bodyEnd = span.length;
+    while (bodyEnd > 1) {
+      const line = span[bodyEnd - 1];
+      if (line.trim() !== "" && !line.trimStart().startsWith("#")) break;
+      bodyEnd -= 1;
+    }
+    entries.push({ id: entryId(span[0]), heading, body: span.slice(0, bodyEnd) });
+    heading = span.slice(bodyEnd);
+  }
+  const out = [];
+  out.push(...entries[0].heading);
+  let lastKept = -1;
+  for (const [index, entry] of entries.entries()) {
+    if (entry.id !== void 0 && drop.has(entry.id)) continue;
+    if (index > 0) out.push(...entry.heading);
+    out.push(...entry.body);
+    lastKept = index;
+  }
+  if (lastKept === entries.length - 1) out.push(...heading);
+  if (out.length > 0 && out[out.length - 1] !== "") out.push("");
+  return out.join("\n");
+}
+async function writeIfDifferent(path, text) {
+  try {
+    if (await readFile4(path, "utf8") === text) return false;
+  } catch {
+  }
+  await mkdir(dirname4(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID()}`;
+  await writeFile(tmp, text, "utf8");
+  await rename(tmp, path);
+  return true;
+}
+async function ensureHostedPreset(dshHome, source) {
+  const composition = await source.read(SOURCE_PRESET_ID);
+  const stripped = `${MANAGED_HEADER}
+${stripPresetRows(composition)}`;
+  const dir = join7(dshHome, USER_PRESET_DIR, HOSTED_PRESET_ID);
+  const compositionChanged = await writeIfDifferent(join7(dir, COMPOSITION_FILE), stripped);
+  const metadataChanged = await writeIfDifferent(join7(dir, METADATA_FILE), MANAGED_METADATA);
+  return compositionChanged || metadataChanged;
+}
+
+// src/provider-route.ts
+import { LlmAdapter, LlmError as LlmError5 } from "@deepseek-ai/dsh-llm";
+var HOSTED_PROVIDER_ROUTES = {
+  "claude-code": PROVIDER,
+  codex: PROVIDER2,
+  pi: PROVIDER3,
+  kimi: PROVIDER4
+};
+var HostedEngineRouteAdapter = class extends LlmAdapter {
+  /**
+   * @param label - the provider route label this placeholder serves.
+   * @param options - optional catalog source; omit for an empty catalog.
+   */
+  constructor(label, options = {}) {
+    super();
+    this.label = label;
+    this.options = options;
+  }
+  label;
+  options;
+  /** Advertise the injected Pi models (if any) under this route's provider label. */
+  async listModels(_provider) {
+    const catalog = this.options.listModels?.() ?? [];
+    return catalog.map((entry) => ({
+      provider: this.label,
+      id: `${entry.provider}/${entry.model}`,
+      name: `${entry.provider}/${entry.model}`
+    }));
+  }
+  stream(_options) {
+    throw new LlmError5(
+      `provider "${this.label}" is a hosted loop engine route, not a model endpoint`,
+      "HOSTED_ENGINE_ROUTE"
+    );
+  }
+};
+
 // src/commands.ts
 import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
 import { homedir as homedir4 } from "node:os";
-import { join as join7 } from "node:path";
+import { join as join8 } from "node:path";
 import { createUserMessage as createUserMessage6 } from "@deepseek-ai/dsh-llm";
 var COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
 function forwardClaudeCodeCommand(name2) {
@@ -5239,7 +5805,7 @@ function discoverUserSlashCommands() {
     if (!entry.endsWith(".md")) continue;
     const name2 = entry.slice(0, -".md".length);
     if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
-    const path = join7(userCommandsDir(), entry);
+    const path = join8(userCommandsDir(), entry);
     let raw;
     try {
       raw = readFileSync2(path, "utf8");
@@ -5254,7 +5820,7 @@ function discoverUserSlashCommands() {
   return definitions;
 }
 function userCommandsDir() {
-  return join7(homedir4(), ".claude", "commands");
+  return join8(homedir4(), ".claude", "commands");
 }
 function commandDescription(raw) {
   const trimmed = raw.trim();
@@ -5281,7 +5847,7 @@ function commandDescription(raw) {
 
 // src/engine-codex/skills.ts
 import { homedir as homedir5 } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 var PROVIDER_NAME3 = "codex";
 var CODEX_PROJECT_RANK = 140;
 var CODEX_USER_RANK = 160;
@@ -5299,7 +5865,7 @@ var CodexSkillProvider = class {
       const paths = await collectProjectContextFiles(cwd, CODEX_CONTEXT_POLICY);
       if (await anySourceNonEmpty(paths)) candidates.push(this.agentsCandidate(paths, CODEX_PROJECT_RANK));
     }
-    const userPath = join8(homedir5(), ".codex", "AGENTS.md");
+    const userPath = join9(homedir5(), ".codex", "AGENTS.md");
     if (await fileNonEmpty(userPath)) candidates.push(this.agentsCandidate([userPath], CODEX_USER_RANK));
     if (this.control.signal.aborted) return [];
     return candidates;
@@ -5338,9 +5904,9 @@ var CodexSkillProvider = class {
 };
 
 // src/engine-pi/skills.ts
-import { readdir as readdir3, readFile as readFile4, stat as stat4 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile5, stat as stat4 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
-import { dirname as dirname4, join as join9, resolve as resolve4 } from "node:path";
+import { dirname as dirname5, join as join10, resolve as resolve4 } from "node:path";
 var PROVIDER_NAME4 = "pi";
 var PI_AGENTS_PROJECT_RANK = 140;
 var PI_SKILL_PROJECT_RANK = 150;
@@ -5353,7 +5919,7 @@ var PI_CONTEXT_POLICY = {
 function piAgentDir() {
   const override = process.env.PI_CODING_AGENT_DIR;
   if (override !== void 0 && override.length > 0) return resolve4(override);
-  return join9(homedir6(), ".pi", "agent");
+  return join10(homedir6(), ".pi", "agent");
 }
 var PiSkillProvider = class {
   constructor(control) {
@@ -5369,13 +5935,13 @@ var PiSkillProvider = class {
       const contextPaths = await collectProjectContextFiles(cwd, PI_CONTEXT_POLICY);
       if (await anySourceNonEmpty(contextPaths)) candidates.push(this.agentsCandidate(contextPaths, PI_AGENTS_PROJECT_RANK));
       for (const dir of projectDirs) {
-        await this.collectSkillsDir(join9(dir, ".pi", "skills"), PI_SKILL_PROJECT_RANK, candidates);
+        await this.collectSkillsDir(join10(dir, ".pi", "skills"), PI_SKILL_PROJECT_RANK, candidates);
       }
     }
     const userAgentDir = piAgentDir();
-    const userContext = join9(userAgentDir, "AGENTS.md");
+    const userContext = join10(userAgentDir, "AGENTS.md");
     if (await fileNonEmpty(userContext)) candidates.push(this.agentsCandidate([userContext], PI_AGENTS_USER_RANK));
-    await this.collectSkillsDir(join9(userAgentDir, "skills"), PI_SKILL_USER_RANK, candidates);
+    await this.collectSkillsDir(join10(userAgentDir, "skills"), PI_SKILL_USER_RANK, candidates);
     if (this.control.signal.aborted) return [];
     return candidates;
   }
@@ -5393,7 +5959,7 @@ var PiSkillProvider = class {
         provider: this.name,
         content: parsed.content,
         path: locator.path,
-        resourceBase: { kind: "directory", path: dirname4(locator.path) }
+        resourceBase: { kind: "directory", path: dirname5(locator.path) }
       };
     }
     const content = await readSources(locator.paths);
@@ -5434,11 +6000,11 @@ var PiSkillProvider = class {
       return;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const entryPath = join9(skillsDir, entry.name);
+      const entryPath = join10(skillsDir, entry.name);
       const info = await stat4(entryPath).catch(() => void 0);
       if (info === void 0) continue;
       if (info.isDirectory()) {
-        const path = join9(entryPath, "SKILL.md");
+        const path = join10(entryPath, "SKILL.md");
         const parsed2 = await this.tryParse(path);
         if (parsed2 === void 0) continue;
         candidates.push(this.skillCandidate(parsed2, path, rank, entryPath));
@@ -5468,7 +6034,7 @@ var PiSkillProvider = class {
   /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
   async tryParse(path) {
     try {
-      const raw = await readFile4(path, { encoding: "utf8" });
+      const raw = await readFile5(path, { encoding: "utf8" });
       return parseSkillFile(raw);
     } catch {
       return void 0;
@@ -5498,7 +6064,7 @@ var Config5 = z6.object({
 });
 function resolvePatchPath(config) {
   if (config.patchPath !== void 0 && config.patchPath !== "") return config.patchPath;
-  return join10(
+  return join11(
     resolveDshHome(),
     "profiles",
     config.profile ?? "web",
@@ -5510,21 +6076,21 @@ function isMissing(error) {
 }
 async function readPatchOrUndefined(path) {
   try {
-    return await readFile5(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (error) {
     if (isMissing(error)) return void 0;
     throw error;
   }
 }
 async function writePatchFile(path, text) {
-  await mkdir(dirname5(path), { recursive: true });
-  const tmp = `${path}.tmp-${randomUUID()}`;
-  await writeFile(tmp, text, "utf8");
-  await rename(tmp, path);
+  await mkdir2(dirname6(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID2()}`;
+  await writeFile2(tmp, text, "utf8");
+  await rename2(tmp, path);
 }
 function writePatchFileSync(path, text) {
-  mkdirSync(dirname5(path), { recursive: true });
-  const tmp = `${path}.tmp-${randomUUID()}`;
+  mkdirSync(dirname6(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID2()}`;
   writeFileSync(tmp, text, "utf8");
   renameSync(tmp, path);
 }
@@ -5579,10 +6145,14 @@ function kimiConfig(config) {
 function apply(ctx, config) {
   const patchPath = resolvePatchPath(config);
   let fileEngine = currentEngineOf(readPatchFileSync(patchPath));
+  const AGENT_PRESETS_NS = "agent-presets";
+  const PRESET_DEFAULT_ATTEMPTS = 30;
+  const PRESET_DEFAULT_RETRY_MS = 100;
   let engineFiber;
   let mountedEngine;
   let commandDisposers;
   let skillDisposer;
+  const piCatalogHolder = { entries: [] };
   let mountAttempts = 0;
   let mountRetry;
   const CLEAR_RETRY = () => {
@@ -5591,6 +6161,106 @@ function apply(ctx, config) {
       mountRetry = void 0;
     }
   };
+  let savedPresetDefault;
+  let presetRetry;
+  const CLEAR_PRESET_RETRY = () => {
+    if (presetRetry !== void 0) {
+      clearTimeout(presetRetry);
+      presetRetry = void 0;
+    }
+  };
+  const ROUTE_ATTEMPTS = 30;
+  const ROUTE_RETRY_MS = 100;
+  let routeHandle;
+  let routeEngine;
+  let routeRetry;
+  const CLEAR_ROUTE_RETRY = () => {
+    if (routeRetry !== void 0) {
+      clearTimeout(routeRetry);
+      routeRetry = void 0;
+    }
+  };
+  const releaseRoute = () => {
+    CLEAR_ROUTE_RETRY();
+    const handle = routeHandle;
+    routeHandle = void 0;
+    routeEngine = void 0;
+    handle?.();
+  };
+  const mountProviderRoute = (engine, attempt = 0) => {
+    if (engine === "in-process") return;
+    if (routeEngine === engine && routeHandle !== void 0) return;
+    CLEAR_ROUTE_RETRY();
+    const label = HOSTED_PROVIDER_ROUTES[engine];
+    const llm = ctx.get("llm");
+    if (llm === void 0) {
+      if (attempt < ROUTE_ATTEMPTS) {
+        routeRetry = setTimeout(() => {
+          mountProviderRoute(engine, attempt + 1);
+        }, ROUTE_RETRY_MS);
+      }
+      return;
+    }
+    try {
+      const options = engine === "pi" ? { listModels: () => piCatalogHolder.entries } : void 0;
+      routeHandle = llm.registerAdapter([label], new HostedEngineRouteAdapter(label, options));
+      routeEngine = engine;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("already registered")) {
+        ctx.logger.warn(`loop-engine: provider route "${label}" is already served by another adapter`);
+        return;
+      }
+      ctx.logger.error(`loop-engine: provider route "${label}" registration failed: ${String(error)}`);
+    }
+  };
+  const mutatePresetDefault = (op, attempt = 0) => {
+    const settings = ctx.get("settings");
+    if (settings === void 0) return;
+    settings.mutate(AGENT_PRESETS_NS, [op]).then(() => void 0, (error) => {
+      if (error instanceof Error && error.message.includes("not registered") && attempt < PRESET_DEFAULT_ATTEMPTS) {
+        presetRetry = setTimeout(() => {
+          mutatePresetDefault(op, attempt + 1);
+        }, PRESET_DEFAULT_RETRY_MS);
+        return;
+      }
+      ctx.logger.error(`loop-engine: preset default switch failed: ${String(error)}`);
+    });
+  };
+  const restorePresetDefault = (attempt = 0) => {
+    const presets = ctx.get("agentPresets");
+    if (presets === void 0) return;
+    if (presets.defaultId === HOSTED_PRESET_ID) {
+      const saved = savedPresetDefault;
+      savedPresetDefault = void 0;
+      mutatePresetDefault(saved === void 0 ? { op: "unset", path: ["default"] } : { op: "set", path: ["default"], value: saved });
+      return;
+    }
+    if (attempt < PRESET_DEFAULT_ATTEMPTS) {
+      presetRetry = setTimeout(() => {
+        restorePresetDefault(attempt + 1);
+      }, PRESET_DEFAULT_RETRY_MS);
+    }
+  };
+  const steerPresetDefault = (engine) => {
+    const presets = ctx.get("agentPresets");
+    if (presets === void 0) return;
+    if (engine === "in-process") {
+      restorePresetDefault();
+      return;
+    }
+    void (async () => {
+      try {
+        await ensureHostedPreset(resolveDshHome(), presets);
+      } catch (error) {
+        ctx.logger.error(`loop-engine: hosted preset authoring failed: ${String(error)}`);
+        return;
+      }
+      const current = presets.defaultId;
+      if (current === HOSTED_PRESET_ID) return;
+      savedPresetDefault = current;
+      mutatePresetDefault({ op: "set", path: ["default"], value: HOSTED_PRESET_ID });
+    })();
+  };
   const cleanupEngineRegistrations = () => {
     if (commandDisposers !== void 0) {
       for (const dispose of commandDisposers) dispose();
@@ -5652,7 +6322,10 @@ function apply(ctx, config) {
     if (skills !== void 0) {
       skillDisposer = skills.registerProvider((control) => new PiSkillProvider(control));
     }
-    hostFactory("pi", () => ctx.plugin(PiLoop, piConfig(config)));
+    hostFactory("pi", () => ctx.plugin(PiLoop, {
+      ...piConfig(config),
+      piCatalogHolder
+    }));
   };
   const mountKimi = () => {
     const commands = ctx.get("commands");
@@ -5674,6 +6347,7 @@ function apply(ctx, config) {
     hostFactory("kimi", () => ctx.plugin(KimiLoop, kimiConfig(config)));
   };
   const mountEngine = (engine) => {
+    mountProviderRoute(engine);
     if (engine === "claude-code") mountClaude();
     else if (engine === "codex") mountCodex();
     else if (engine === "pi") mountPi();
@@ -5683,6 +6357,7 @@ function apply(ctx, config) {
     const fiber = engineFiber;
     mountAttempts = 0;
     CLEAR_RETRY();
+    releaseRoute();
     cleanupEngineRegistrations();
     mountedEngine = void 0;
     if (fiber === void 0) return;
@@ -5692,27 +6367,36 @@ function apply(ctx, config) {
     }, () => void 0);
   };
   mountEngine(fileEngine);
-  ctx.effect(() => () => CLEAR_RETRY(), "loop-engine: mount retry cleanup");
+  steerPresetDefault(fileEngine);
+  ctx.effect(() => () => {
+    CLEAR_RETRY();
+    CLEAR_PRESET_RETRY();
+    releaseRoute();
+  }, "loop-engine: retry cleanup");
   let source;
-  installSettingsSection(ctx, loopEngineSettingsNamespace(), LOOP_ENGINE_SETTINGS_SCHEMA, { engine: fileEngine, showInComposer: true }, {
-    setSource: (current) => {
-      source = current;
-    },
-    onChange: () => {
-      const next = source().engine;
-      if (next === fileEngine) return;
-      if (mountedEngine !== next) {
-        unmountEngine();
-        mountEngine(next);
-      }
-      try {
-        const updated = applyManagedBlock(readPatchFileSync(patchPath), next);
-        writePatchFileSync(patchPath, updated);
-        fileEngine = next;
-      } catch (error) {
-        ctx.logger.error(`loop-engine: managed block write failed: ${String(error)}`);
+  ctx.inject(["settings"], (settingsCtx) => {
+    settingsCtx.settings.installSection(ctx, loopEngineSettingsNamespace(), LOOP_ENGINE_SETTINGS_SCHEMA, { engine: fileEngine, showInComposer: true }, {
+      setSource: (current) => {
+        source = current;
+      },
+      onChange: () => {
+        const next = source().engine;
+        if (next === fileEngine) return;
+        if (mountedEngine !== next) {
+          unmountEngine();
+          mountEngine(next);
+        }
+        try {
+          const updated = applyManagedBlock(readPatchFileSync(patchPath), next);
+          writePatchFileSync(patchPath, updated);
+          fileEngine = next;
+        } catch (error) {
+          ctx.logger.error(`loop-engine: managed block write failed: ${String(error)}`);
+          return;
+        }
+        steerPresetDefault(next);
       }
-    }
+    });
   });
 }
 export {