dsh-loop-engine 1.0.0-rc6 → 1.0.0-rc8

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 readFile4, rename, writeFile } from "node:fs/promises";
-import { randomUUID } from "node:crypto";
-import { dirname as dirname4, join as join8 } from "node:path";
-import z5 from "@deepseek-ai/schemastery";
-import { installSettingsSection } from "@deepseek-ai/dsh-settings";
+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 { 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");
@@ -1162,7 +1161,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 +1195,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 +1253,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 +1284,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 +1293,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 +1373,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 +1386,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 +1443,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 +1530,7 @@ var AppServerClient = class _AppServerClient {
       clientInfo: {
         name: "dsh-loop-engine",
         title: null,
-        version: "0.1.1-rc.2"
+        version: "1.0.0-rc8"
       },
       capabilities: { experimentalApi: true, requestAttestation: false }
     };
@@ -1478,8 +1567,8 @@ var AppServerClient = class _AppServerClient {
     }
     const id = this.reqId++;
     const msg = { jsonrpc: "2.0", id, method, params };
-    return new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+    return new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
       this.process.stdin.write(JSON.stringify(msg) + "\n");
     });
   }
@@ -1530,7 +1619,7 @@ var AppServerThread = class _AppServerThread {
     const { signal, params } = options;
     const queue = [];
     const earlyNotifications = [];
-    let resolve4;
+    let resolve5;
     let done = false;
     let turnError;
     let turnId;
@@ -1604,7 +1693,7 @@ var AppServerThread = class _AppServerThread {
       }
       if (event) {
         queue.push(event);
-        resolve4?.();
+        resolve5?.();
       }
     };
     this.client.onNotification(notificationHandler);
@@ -1630,7 +1719,7 @@ var AppServerThread = class _AppServerThread {
         void this.client.turnInterrupt({ threadId: this.threadId, turnId }).catch(() => {
         });
       }
-      resolve4?.();
+      resolve5?.();
     };
     signal?.addEventListener("abort", abortHandler, { once: true });
     try {
@@ -1640,9 +1729,9 @@ var AppServerThread = class _AppServerThread {
           yield queue.shift();
         } else {
           await new Promise((r) => {
-            resolve4 = r;
+            resolve5 = r;
           });
-          resolve4 = void 0;
+          resolve5 = void 0;
         }
       }
       if (turnError) throw turnError;
@@ -1656,7 +1745,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 +1757,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 +1771,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 +1787,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 +1821,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 +2034,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 +2387,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 +2421,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 +2479,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 +2510,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 +2519,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 +2599,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 +2612,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 +2672,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";
 
@@ -2591,8 +2770,8 @@ var PiRpcClient = class _PiRpcClient {
    *   absent falls back to the plain node child spawn.
    * @returns the connected client.
    */
-  static create(spec, spawn3) {
-    const process2 = spawn3 === void 0 ? defaultSpawn(spec) : spawn3(spec);
+  static create(spec, spawn4) {
+    const process2 = spawn4 === void 0 ? defaultSpawn(spec) : spawn4(spec);
     return new _PiRpcClient(process2);
   }
   /** Register the event dispatch handler. */
@@ -2637,8 +2816,8 @@ var PiRpcClient = class _PiRpcClient {
     if (this.disposed) throw new Error("pi RPC client is disposed");
     const id = command.id ?? this.reqId++;
     const wire = { ...command, id };
-    return new Promise((resolve4, reject) => {
-      this.pending.set(id, { resolve: resolve4, reject });
+    return new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
       this.process.stdin.write(`${JSON.stringify(wire)}
 `);
     });
@@ -2655,8 +2834,8 @@ var PiRpcClient = class _PiRpcClient {
         continue;
       }
       if (this.disposed) return;
-      await new Promise((resolve4) => {
-        this.eventWake = resolve4;
+      await new Promise((resolve5) => {
+        this.eventWake = resolve5;
       });
       this.eventWake = void 0;
     }
@@ -2717,7 +2896,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 +2927,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
   });
@@ -2763,13 +2942,13 @@ function specsEqual(a, b) {
   return a.cwd === b.cwd && a.env === b.env && a.argv.length === b.argv.length && a.argv.every((value, index) => value === b.argv[index]);
 }
 var PiAgent = class {
-  constructor(loopCtx, id, options, session, config, spawn3, bin) {
+  constructor(loopCtx, id, options, session, config, spawn4, bin) {
     this.loopCtx = loopCtx;
     this.id = id;
     this.options = options;
     this.session = session;
     this.config = config;
-    this.spawn = spawn3;
+    this.spawn = spawn4;
     this.bin = bin;
     this.dispatch = agentEvents3(loopCtx, this);
     this.inbox = new Inbox3(session, {
@@ -2783,7 +2962,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 +3183,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,
@@ -3215,7 +3394,7 @@ var PiAgent = class {
         this.session.append("tool/call", {
           turn,
           step,
-          callId: CallId4(callId),
+          callId: ToolCallId4(callId),
           name: name2,
           arguments: argumentsValue
         });
@@ -3316,8 +3495,8 @@ var PiAgent = class {
               held = { content: contentOf(event.message), refs: [...chunkSeqs] };
               chunkSeqs.length = 0;
             }
-            for (const toolResult of event.toolResults ?? []) {
-              this.appendToolResult(turn, step, toolResult);
+            for (const toolResult2 of event.toolResults ?? []) {
+              this.appendToolResult(turn, step, toolResult2);
             }
             flushHeld(lastUsage);
             finished = true;
@@ -3350,15 +3529,15 @@ var PiAgent = class {
     }
   }
   /** Append one Pi tool result to the durable log as a `tool/result` message. */
-  appendToolResult(turn, step, toolResult) {
-    const text = typeof toolResult.content === "string" ? toolResult.content : toolResult.content.map((block) => block.type === "text" ? block.text : "").filter((segment) => segment !== "").join("\n\n");
+  appendToolResult(turn, step, toolResult2) {
+    const text = typeof toolResult2.content === "string" ? toolResult2.content : toolResult2.content.map((block) => block.type === "text" ? block.text : "").filter((segment) => segment !== "").join("\n\n");
     this.session.append("tool/result", {
       turn,
       step,
       message: mapToolResult({
-        toolCallId: toolResult.toolCallId,
+        toolCallId: toolResult2.toolCallId,
         result: { content: [{ type: "text", text }] },
-        isError: toolResult.isError === true
+        isError: toolResult2.isError === true
       })
     }, { surfaceOp: "append" });
   }
@@ -3452,7 +3631,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 +3665,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 +3723,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 +3754,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 +3763,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 +3843,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,203 +3856,1181 @@ 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;
   }
 };
 
-// src/settings.ts
+// src/engine-kimi/loop.ts
+import { Service as Service4 } from "@deepseek-ai/cordis";
 import z4 from "@deepseek-ai/schemastery";
-import { settingsNamespace } from "@deepseek-ai/dsh-settings";
+import { emitAgentEvent as emitAgentEvent4 } from "@deepseek-ai/dsh-agent";
+import { interruptedTurnClosers as interruptedTurnClosers4, SessionLogOffset as SessionLogOffset4, SessionPreparation as SessionPreparation4 } from "@deepseek-ai/dsh-session";
 
-// src/namespace.ts
-var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
+// src/engine-kimi/agent.ts
+import { Inbox as Inbox4, agentEvents as agentEvents4 } from "@deepseek-ai/dsh-agent";
+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";
 
-// src/settings.ts
-var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi"];
-var LOOP_ENGINE_SETTINGS_SCHEMA = z4.object({
-  engine: z4.union([z4.const("in-process"), z4.const("claude-code"), z4.const("codex"), z4.const("pi")]).default("in-process"),
-  showInComposer: z4.boolean().default(true)
-});
-function loopEngineSettingsNamespace() {
-  return settingsNamespace(LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL);
+// src/engine-kimi/process.ts
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { join as join3 } from "node:path";
+function kimiHomeDir() {
+  const envHome = process.env.KIMI_CODE_HOME;
+  return envHome !== void 0 && envHome !== "" ? envHome : join3(homedir(), ".kimi-code");
 }
-
-// src/patch-manager.ts
-var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block: ";
-var MANAGED_BLOCK_END = "# -- /dsh-loop-engine managed block --";
-var END_MARKER_LINE = `${MANAGED_BLOCK_END}
-`;
-function renderManagedBlock(engine) {
-  if (engine === "in-process") return "";
-  return [
-    `${MANAGED_BLOCK_BEGIN}${engine} --`,
-    "- id: agent-loop",
-    "  disabled: true",
-    END_MARKER_LINE
-  ].join("\n");
+function kimiBinResolver(configBin) {
+  if (configBin !== void 0 && configBin !== "") return configBin;
+  const executable = process.platform === "win32" ? "kimi.exe" : "kimi";
+  const candidate = join3(kimiHomeDir(), "bin", executable);
+  return existsSync(candidate) ? candidate : "kimi";
 }
-var BEGIN_MARKER_RE = /^# -- dsh-loop-engine managed block: (\S+) --$/m;
-function currentEngineOf(text) {
-  const engine = BEGIN_MARKER_RE.exec(text)?.[1];
-  return LOOP_ENGINE_IDS.includes(engine ?? "") ? engine : "in-process";
+function kimiAcpArgv(bin) {
+  return [bin, "acp"];
 }
-function managedSpan(text) {
-  const begin = text.indexOf(MANAGED_BLOCK_BEGIN);
-  if (begin === -1) return { head: text, tail: "", present: false, blankBefore: false };
-  const afterBegin = begin + MANAGED_BLOCK_BEGIN.length;
-  const endAt = text.indexOf(MANAGED_BLOCK_END, afterBegin);
-  const spanEnd = endAt === -1 ? text.length : endAt + END_MARKER_LINE.length;
-  const before = text.slice(0, begin);
-  const blankBefore = before.endsWith("\n\n");
+function kimiSubprocessSpec(spec, graceMs) {
   return {
-    head: blankBefore ? before.slice(0, -1) : before,
-    tail: text.slice(spanEnd),
-    present: true,
-    blankBefore
+    argv: [...spec.argv],
+    cwd: spec.cwd,
+    stdio: { stdin: "pipe", stdout: "pipe", stderr: "pipe" },
+    graceMs,
+    env: spec.env,
+    ...spec.signal === void 0 ? {} : { signal: spec.signal }
   };
 }
-function ensureTrailingNewline(text) {
-  return text.endsWith("\n") ? text : `${text}
-`;
-}
-function hasRootEntry(text) {
-  return /^(?:- |\[)/m.test(text);
-}
-function dropSeedPlaceholder(text) {
-  return text.replace(/^\[\]\n/m, "");
-}
-function seedEmptyArray(text) {
-  const head = text.replace(/\n+$/, "");
-  return head === "" ? "[]\n" : `${head}
-[]
-`;
-}
-function applyManagedBlock(text, engine) {
-  const block = renderManagedBlock(engine);
-  const span = managedSpan(text);
-  let result;
-  if (!span.present) {
-    if (block === "") {
-      result = text;
-    } else {
-      const base = ensureTrailingNewline(text);
-      result = `${base}
-${block}`;
-    }
-  } else if (block === "") {
-    result = span.tail.startsWith("\n") ? `${span.head}${span.tail.slice(1)}` : `${span.head}${span.tail}`;
-  } else {
-    result = `${span.head}${span.blankBefore ? "\n" : ""}${block}${span.tail}`;
+function fromSubprocess2(handle) {
+  const { stdin, stdout, stderr } = handle;
+  if (stdin === void 0 || stdout === void 0 || stderr === void 0) {
+    throw new Error("agent-loop-kimi: spawned child must pipe stdin/stdout/stderr");
   }
-  if (block !== "") return dropSeedPlaceholder(result);
-  if (text.trim() === "") return result;
-  return hasRootEntry(result) ? result : seedEmptyArray(result);
+  return {
+    stdin,
+    stdout,
+    stderr,
+    done: handle.done,
+    terminate: () => handle.terminate()
+  };
 }
 
-// src/commands.ts
-import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
-import { homedir } from "node:os";
-import { join as join3 } from "node:path";
-import { createUserMessage as createUserMessage4 } from "@deepseek-ai/dsh-llm";
-var COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
-function forwardClaudeCodeCommand(name2) {
-  return (invocation) => {
-    invocation.agent.followup(createUserMessage4({
-      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
-      source: { kind: "user" }
-    }));
-    return { kind: "success" };
-  };
+// src/engine-kimi/acp/client.ts
+import { spawn as spawn3 } from "node:child_process";
+import { StringDecoder as StringDecoder2 } from "node:string_decoder";
+
+// src/engine-kimi/acp/types.ts
+function isUpdateFrame(frame2) {
+  return frame2.method === "session/update" && typeof frame2.params === "object" && frame2.params !== null && typeof frame2.params.update === "object" && frame2.params.update !== null;
 }
-function builtin(name2, description) {
-  return { name: name2, description, handler: forwardClaudeCodeCommand(name2) };
+function isPermissionRequestFrame(frame2) {
+  return frame2.method === "session/request_permission" && typeof frame2.id === "number";
 }
-var CLAUDE_CODE_COMMANDS = [
-  builtin("help", "Show help about Claude Code commands"),
-  builtin("compact", "Compact the conversation to reduce context usage"),
-  builtin("clear", "Clear the conversation and start fresh"),
-  builtin("review", "Review recent changes (git diff)"),
-  builtin("explain", "Explain the selected code"),
-  builtin("fix", "Fix issues in the code"),
-  builtin("tests", "Add tests for the selected code")
-];
-function discoverUserSlashCommands() {
-  let entries;
-  try {
-    entries = readdirSync(userCommandsDir(), { encoding: "utf8" });
-  } catch {
-    return [];
+
+// src/engine-kimi/acp/client.ts
+function defaultSpawn2(spec) {
+  const child = spawn3(spec.argv[0], spec.argv.slice(1), {
+    cwd: spec.cwd,
+    env: spec.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  return fromNativeChild(child);
+}
+function fromNativeChild(child) {
+  const done = Promise.withResolvers();
+  child.once("exit", () => done.resolve(void 0));
+  child.once("error", done.reject);
+  return {
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    done: done.promise,
+    terminate: () => child.kill()
+  };
+}
+var AcpClient = class _AcpClient {
+  /** Mount a client over an already-spawned `kimi acp` process. */
+  constructor(process2) {
+    this.process = process2;
+    this.process.stdout.on("data", (chunk) => this.feed(chunk));
+    this.process.stderr.on("data", () => {
+    });
+    this.process.done.then(() => {
+      this.sealed = true;
+      const error = new Error("kimi acp process exited unexpectedly");
+      for (const { reject } of this.pending.values()) reject(error);
+      this.pending.clear();
+      this.updateWake?.();
+    }, () => {
+      this.sealed = true;
+      this.updateWake?.();
+    });
   }
-  const definitions = [];
-  const seen = new Set(CLAUDE_CODE_COMMANDS.map((command) => command.name));
-  for (const entry of entries.sort()) {
-    if (!entry.endsWith(".md")) continue;
-    const name2 = entry.slice(0, -".md".length);
-    if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
-    const path = join3(userCommandsDir(), entry);
-    let raw;
+  process;
+  pending = /* @__PURE__ */ new Map();
+  updateBuffer = [];
+  updateWake;
+  updateHandler;
+  permissionHandler;
+  sealed = false;
+  nextId = 1;
+  decoder = new StringDecoder2("utf8");
+  buffer = "";
+  /** Whether this client was sealed or its process exited. */
+  get closed() {
+    return this.sealed;
+  }
+  /**
+   * Create a client, spawning the `kimi acp` child through the supplied
+   * capability (or the default node spawn when none is given).
+   * @param spec - the `kimi acp` argv/cwd/env the child should run with.
+   * @param spawn - optional process-spawn capability (the subprocess seam).
+   * @returns the connected client.
+   */
+  static create(spec, spawn4) {
+    const process2 = spawn4 === void 0 ? defaultSpawn2(spec) : spawn4(spec);
+    return new _AcpClient(process2);
+  }
+  /** Register the event dispatch handler. */
+  onUpdate(handler) {
+    this.updateHandler = handler;
+  }
+  /** Register the permission-approval handler (reverse-RPC answers). */
+  onPermission(handler) {
+    this.permissionHandler = handler;
+  }
+  /** Send one request and await the correlated response. */
+  request(method, params) {
+    if (this.sealed) return Promise.reject(new Error("kimi acp client is sealed"));
+    const id = this.nextId++;
+    return new Promise((resolve5, reject) => {
+      this.pending.set(id, { resolve: resolve5, reject });
+      this.process.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, method, params })}
+`);
+    });
+  }
+  /** Send a notification (no correlated response awaited). */
+  notify(method, params) {
+    if (this.sealed) return;
+    this.process.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", method, params })}
+`);
+  }
+  /** Open the protocol handshake. */
+  initialize() {
+    return this.request("initialize", { protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: "dsh-loop-engine", version: "1.0.0" } });
+  }
+  /** Start a fresh ACP session and resolve to its session id. */
+  async newSession(cwd) {
+    const result = await this.request("session/new", { cwd, mcpServers: [] });
+    const sessionId = result?.sessionId;
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+      throw new Error("kimi acp session/new returned no session id");
+    }
+    return sessionId;
+  }
+  /** Prompt the agent in a session and resolve when the turn completes. */
+  prompt(sessionId, text) {
+    return this.request("session/prompt", { sessionId, prompt: [{ type: "text", text }] });
+  }
+  /** Cancel the active turn in a session (fire-and-forget). */
+  cancel(sessionId) {
+    this.request("session/cancel", { sessionId }).catch(() => void 0);
+  }
+  /** Answer a pending `session/request_permission`. */
+  respondPermission(id, approved) {
+    this.process.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id, result: { approved } })}
+`);
+  }
+  /** Consume every buffered update as an async generator. */
+  async *updates() {
+    while (true) {
+      if (this.updateBuffer.length > 0) {
+        yield this.updateBuffer.shift();
+        continue;
+      }
+      if (this.sealed) return;
+      await new Promise((resolve5) => {
+        this.updateWake = resolve5;
+      });
+      this.updateWake = void 0;
+    }
+  }
+  /** Seal the client and request child termination. */
+  dispose() {
+    if (this.sealed) return;
+    this.sealed = true;
+    this.process.terminate();
+    const error = new Error("kimi acp client is sealed");
+    for (const { reject } of this.pending.values()) reject(error);
+    this.pending.clear();
+    this.updateWake?.();
+  }
+  feed(chunk) {
+    if (this.sealed) return;
+    const text = typeof chunk === "string" ? this.buffer + chunk : this.buffer + this.decoder.write(chunk);
+    this.buffer = text;
+    while (true) {
+      const newline = this.buffer.indexOf("\n");
+      if (newline === -1) break;
+      let line = this.buffer.slice(0, newline);
+      this.buffer = this.buffer.slice(newline + 1);
+      if (line.endsWith("\r")) line = line.slice(0, -1);
+      this.dispatch(line);
+    }
+  }
+  /** Dispatch one parsed line: a response, an update notification, or a reverse-RPC request. */
+  dispatch(line) {
+    if (line.trim().length === 0) return;
+    let frame2;
     try {
-      raw = readFileSync2(path, "utf8");
+      frame2 = JSON.parse(line);
     } catch {
-      continue;
+      return;
+    }
+    if (isPermissionRequestFrame(frame2)) {
+      void this.handlePermission(frame2.id, frame2);
+      return;
+    }
+    if (typeof frame2.id === "number" && frame2.method === void 0) {
+      this.settle(frame2);
+      return;
+    }
+    if (isUpdateFrame(frame2)) {
+      const update = frame2.params.update;
+      this.updateHandler?.(update);
+      this.updateBuffer.push(update);
+      this.updateWake?.();
+      return;
+    }
+    if (typeof frame2.id === "number" && typeof frame2.method === "string") {
+      this.process.stdin.write(`${JSON.stringify({ jsonrpc: "2.0", id: frame2.id, error: { code: -32601, message: "Method not found" } })}
+`);
     }
-    const description = commandDescription(raw);
-    if (description === void 0) continue;
-    seen.add(name2);
-    definitions.push({ name: name2, description, handler: forwardClaudeCodeCommand(name2) });
   }
-  return definitions;
+  settle(frame2) {
+    const id = frame2.id;
+    const pending = this.pending.get(id);
+    if (pending === void 0) return;
+    this.pending.delete(id);
+    if (frame2.error !== void 0) {
+      pending.reject(new Error(frame2.error.message ?? "kimi acp request failed"));
+    } else {
+      pending.resolve(frame2.result);
+    }
+  }
+  async handlePermission(id, frame2) {
+    const approved = this.permissionHandler === void 0 ? false : await this.permissionHandler(frame2);
+    this.respondPermission(id, approved);
+  }
+};
+
+// src/engine-kimi/acp/mapping.ts
+import { ToolCallId as ToolCallId5, createToolResultMessage as createToolResultMessage4 } from "@deepseek-ai/dsh-llm";
+function isTextChunk(update) {
+  return update.sessionUpdate === "agent_message_chunk";
 }
-function userCommandsDir() {
-  return join3(homedir(), ".claude", "commands");
+function isThoughtChunk(update) {
+  return update.sessionUpdate === "agent_thought_chunk";
 }
-function commandDescription(raw) {
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) return void 0;
-  let body = trimmed;
-  if (trimmed.startsWith("---\n")) {
-    const closing = trimmed.indexOf("\n---");
-    if (closing <= 0) return void 0;
-    for (const line of trimmed.slice(4, closing).split("\n")) {
-      const colon = line.indexOf(":");
-      if (colon < 0 || line.slice(0, colon).trim() !== "description") continue;
-      const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
-      if (value.length > 0) return value;
+function isToolCall(update) {
+  return update.sessionUpdate === "tool_call";
+}
+function isToolCallUpdate(update) {
+  return update.sessionUpdate === "tool_call_update";
+}
+function chunkDelta(update) {
+  const content = update.content;
+  if (content === void 0) return "";
+  const text = content.text;
+  return typeof text === "string" ? text : "";
+}
+function toolCallIdOf(update) {
+  return update.toolCallId;
+}
+function toolCallName(update) {
+  return update.title;
+}
+function isToolSettledStatus(status) {
+  return status !== "pending" && status !== "queued" && status !== "running" && status !== "in_progress";
+}
+function isToolErrorStatus(status) {
+  return status === "failed" || status === "error" || status === "denied";
+}
+function toolContentText(update) {
+  const blocks = update.content ?? [];
+  return blocks.map((block) => block.type === "content" && block.content.type === "text" ? block.content.text : "").join("");
+}
+function toolResult(callId, text, isError) {
+  return createToolResultMessage4({
+    callId: ToolCallId5(callId),
+    content: [{ type: "text", text: text.length > 0 ? text : "(no content)" }],
+    isError
+  });
+}
+
+// src/engine-kimi/permission.ts
+function resolveToolApproval(events) {
+  return sessionApprovalPolicy(events) !== "ask";
+}
+
+// src/engine-kimi/agent.ts
+var PROVIDER4 = "kimi";
+var NATIVE_MODEL_LABEL4 = "kimi-native";
+var KimiAgent = class {
+  constructor(loopCtx, id, options, session, config, spawn4, bin) {
+    this.loopCtx = loopCtx;
+    this.id = id;
+    this.options = options;
+    this.session = session;
+    this.config = config;
+    this.spawn = spawn4;
+    this.bin = bin;
+    this.dispatch = agentEvents4(loopCtx, this);
+    this.inbox = new Inbox4(session, {
+      inserted: (message) => {
+        this.dispatch.emit("agent/inbox/inserted", { message });
+      },
+      discarded: (message) => {
+        this.dispatch.emit("agent/inbox/discarded", { message });
+      },
+      claimed: (message, turn) => {
+        this.dispatch.emit("agent/inbox/claimed", { message, turn });
+      }
+    });
+    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 });
+    this.scope.ctx.effect(() => () => {
+      this.acp?.dispose();
+      this.acp = void 0;
+    }, "kimi.acpClient()");
+  }
+  loopCtx;
+  id;
+  options;
+  session;
+  config;
+  spawn;
+  bin;
+  inbox;
+  phase;
+  activityDone = Promise.resolve();
+  /** The agent-scoped registration boundary; the lifecycle owner unwinds it after the driver exits. */
+  scope;
+  ctx;
+  /** Fused dispatcher, built once in the constructor so hot-path dispatches never allocate. */
+  dispatch;
+  /** Whether this loop instance has appended its initial/resume request anchor. */
+  requestHeaderLogged = false;
+  /** Lazily created ACP client, reused across steps and released on scope teardown. */
+  acp;
+  /** The spawn spec the cached client was built from; a change forces a respawn. */
+  lastSpec;
+  get status() {
+    return this.phase.kind === "idle" || this.phase.kind === "maintenance" ? "idle" : "running";
+  }
+  /** Commit a phase and publish its externally visible status transition. */
+  setPhase(next) {
+    const previousStatus = this.status;
+    this.phase = next;
+    const status = this.status;
+    if (status !== previousStatus) {
+      this.dispatch.emit("agent/status", { status });
     }
-    body = trimmed.slice(closing + 4);
   }
-  for (const line of body.split("\n")) {
-    const candidate = line.trim();
-    if (candidate.length === 0 || candidate.startsWith("#")) continue;
-    return candidate.length > 120 ? `${candidate.slice(0, 119)}\u2026` : candidate;
+  send(message, target, wakeup) {
+    const wakingAfterAbort = wakeup && this.phase.kind !== "idle" && this.phase.abort.signal.aborted;
+    const resolvedTarget = wakingAfterAbort ? "next-turn" : target;
+    this.inbox.splice(resolvedTarget, Infinity, 0, [message]);
+    if (wakeup) this.wakeDriver(wakingAfterAbort);
   }
-  return void 0;
-}
+  /**
+   * Queue a message for the next turn and wake the driver.
+   * @param input - the user message to deliver.
+   */
+  followup(input) {
+    this.send(input, "next-turn", true);
+  }
+  /**
+   * Queue a message for the running step and wake the driver.
+   * @param input - the user message to deliver.
+   */
+  steer(input) {
+    this.send(input, "next-step", true);
+  }
+  /**
+   * Queue a message for the running step without waking the driver.
+   * @param input - the user message to deliver.
+   */
+  inject(input) {
+    this.send(input, "next-step", false);
+  }
+  cancel(cause, options = {}) {
+    if (!options.keepInbox) {
+      this.inbox.clear();
+      if (this.phase.kind !== "idle") this.phase.wakeRequested = false;
+    }
+    if (this.phase.kind !== "idle") this.phase.abort.abort(cause);
+  }
+  /**
+   * Run a maintenance job while the agent is idle.
+   * @param job - the maintenance operation, receiving the phase abort signal.
+   * @returns the maintenance result.
+   */
+  runMaintenance(job) {
+    if (this.phase.kind !== "idle") throw new Error(`agent "${this.id}" already has active work`);
+    const done = Promise.withResolvers();
+    const maintenance = {
+      kind: "maintenance",
+      abort: new AbortController(),
+      lastTurn: this.phase.lastTurn,
+      wakeRequested: false
+    };
+    this.setPhase(maintenance);
+    this.activityDone = done.promise;
+    return (async () => {
+      try {
+        return await job(maintenance.abort.signal);
+      } finally {
+        this.setPhase({ kind: "idle", lastTurn: maintenance.lastTurn });
+        if (maintenance.wakeRequested && this.inbox.hasPending) this.wakeDriver();
+        done.resolve();
+      }
+    })();
+  }
+  /**
+   * Start one driver, or latch its wake behind maintenance or an aborted
+   * activity. A wake sent while idle always opens its turn boundary, even
+   * when its message was cleared; only a latched replay is suppressed when
+   * the queue no longer holds the wake.
+   * @param wakeAfterAbort - the {@link send} classification, captured before
+   *   the inbox insertion so a reentrant cancel cannot reclassify it.
+   */
+  wakeDriver(wakeAfterAbort = false) {
+    if (this.phase.kind !== "idle") {
+      const reason = this.phase.abort.signal.reason;
+      if (reason?.kind !== "disposed" && (this.phase.kind === "maintenance" || wakeAfterAbort)) {
+        this.phase.wakeRequested = true;
+      }
+      return;
+    }
+    const driver = Promise.withResolvers();
+    this.activityDone = driver.promise;
+    this.setPhase({
+      kind: "running",
+      abort: new AbortController(),
+      turn: this.phase.lastTurn,
+      step: 0,
+      wakeRequested: false
+    });
+    this.loopCtx.agents.withInitiator(this, () => this.kick()).then(driver.resolve, driver.reject);
+  }
+  async whenIdle() {
+    let activity;
+    do {
+      await (activity = this.activityDone);
+    } while (activity !== this.activityDone);
+  }
+  /** Report one failure at its live boundary, then preserve it for driver containment. */
+  throwError(error) {
+    const turn = this.phase.kind === "running" ? this.phase.turn : this.phase.lastTurn;
+    const step = this.phase.kind === "running" ? this.phase.step : 0;
+    this.dispatch.emit("agent/error", { turn, step, error });
+    throw error;
+  }
+  async kick() {
+    try {
+      while (await this.turn()) {
+      }
+    } catch (_error) {
+    } finally {
+      if (this.phase.kind === "running") {
+        const { turn, wakeRequested } = this.phase;
+        this.setPhase({ kind: "idle", lastTurn: turn });
+        if (wakeRequested && this.inbox.hasPending) this.wakeDriver();
+      }
+    }
+  }
+  async preStep(target, position) {
+    if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": pre-step outside running phase`);
+    const signal = this.phase.abort.signal;
+    const claimed = this.inbox.claim(target, position.turn);
+    const decision = await this.dispatch.waterfall(
+      "agent/pre-step",
+      { messages: claimed, ...position, signal },
+      () => Promise.resolve({ kind: "enter", messages: claimed })
+    );
+    signal.throwIfAborted();
+    if (decision.kind === "reject") return decision;
+    const injected = await this.injectSkills(decision.messages, signal);
+    signal.throwIfAborted();
+    return injected !== decision.messages ? { kind: "enter", messages: [...injected] } : { ...decision };
+  }
+  /**
+   * Scan the step's user messages for `/name` skill gestures, load each
+   * matching skill, and inject the rendered skill content into the message
+   * batch. This mirrors what dsh-tool-skill does for the in-process engine.
+   * @param messages - the current step's message batch.
+   * @param signal - cancellation signal (aborted loads are silently dropped).
+   * @returns the original batch when no skill was invoked, or an extended
+   *   batch with injected skill-content messages appended.
+   */
+  async injectSkills(messages, signal) {
+    const names = invokedSkillNames(messages);
+    if (names.length === 0) return messages;
+    const skills = this.loopCtx.get("skills");
+    if (skills === void 0) return messages;
+    const cwd = this.session.header.cwd;
+    const injections = [];
+    for (const name2 of names) {
+      if (!isSkillName(name2)) continue;
+      let skill;
+      try {
+        skill = await skills.get(name2, { signal, scope: this, ...cwd === void 0 ? {} : { cwd } });
+      } catch {
+        continue;
+      }
+      if (skill === void 0 || !skill.invocation.userInvocable) continue;
+      if (signal.aborted) return messages;
+      injections.push(createUserMessage4({
+        content: [{ type: "text", text: renderSkillContent(skill) }],
+        source: { kind: "skill-invocation", name: name2, form: "instructions" }
+      }));
+    }
+    return injections.length > 0 ? [...messages, ...injections] : messages;
+  }
+  /** Open one turn before claiming its first proposed step. */
+  async turn() {
+    if (this.phase.kind !== "running") {
+      this.throwError(new Error(`agent "${this.id}": turn without driver reservation`));
+    }
+    const phase = this.phase;
+    const { signal } = phase.abort;
+    signal.throwIfAborted();
+    const turn = phase.turn + 1;
+    try {
+      this.session.append("turn/start", { turn });
+    } catch (error) {
+      this.throwError(error);
+    }
+    phase.turn = turn;
+    let turnEnds = null;
+    let target = "next-turn";
+    try {
+      while (true) {
+        signal.throwIfAborted();
+        const step = phase.step + 1;
+        const decision = await this.preStep(target, { turn, step });
+        if (decision.kind === "reject") {
+          turnEnds = { kind: "blocked" };
+          return false;
+        }
+        if (turnEnds && decision.messages.length === 0) break;
+        if (phase.step === 0 && decision.messages.length === 0) {
+          turnEnds = { kind: "completed" };
+          return false;
+        }
+        signal.throwIfAborted();
+        this.session.append("step/start", { turn, step });
+        phase.step = step;
+        try {
+          for (const message of decision.messages) {
+            this.session.append("user/message", message, { surfaceOp: "append" });
+          }
+          const stepEnd = await this.step();
+          if (turnEnds === null) turnEnds = stepEnd;
+        } finally {
+          this.session.append("step/end", { turn, step });
+        }
+        signal.throwIfAborted();
+        if (turnEnds && this.inbox.nextStep.length === 0) {
+          await this.dispatch.serial("agent/turn-stopping", { turn, signal });
+          signal.throwIfAborted();
+        }
+        if (turnEnds && this.inbox.nextStep.length === 0) break;
+        target = "next-step";
+      }
+    } catch (error) {
+      if (signal.aborted) {
+        turnEnds = { kind: "aborted", reason: signal.reason };
+        throw error;
+      }
+      turnEnds = {
+        kind: "error",
+        error: error instanceof LlmError4 ? error.failure : { message: errorChain4(error), code: "UNKNOWN" }
+      };
+      this.throwError(error);
+    } finally {
+      try {
+        this.session.append("turn/end", { turn, reason: turnEnds });
+      } catch (error) {
+        this.throwError(error);
+      }
+    }
+    if (!this.inbox.hasPending) return false;
+    phase.abort = new AbortController();
+    phase.wakeRequested = false;
+    phase.step = 0;
+    return true;
+  }
+  /** Model label recorded in the request header for one lifecycle. */
+  modelLabel() {
+    return this.config.model ?? NATIVE_MODEL_LABEL4;
+  }
+  /** Append the request header snapshot once per loop instance. */
+  assertRequestHeader() {
+    if (this.requestHeaderLogged) return;
+    const header = canonicalHeader4({
+      config: { provider: PROVIDER4, model: this.modelLabel() }
+    });
+    const baseline = this.session.requestHeader();
+    this.session.append("request/header", {
+      header,
+      reason: baseline === void 0 ? "initial" : "resume"
+    });
+    this.requestHeaderLogged = true;
+  }
+  /** Whether two spawn specs describe the same `kimi acp` child. */
+  specsEqual(a, b) {
+    if (a === void 0) return false;
+    return a.cwd === b.cwd && a.env === b.env && a.argv.length === b.argv.length && a.argv.every((value, index) => value === b.argv[index]);
+  }
+  /** Return the cached ACP client, respawning when the spec or process changed. */
+  async acpClient(cwd) {
+    const spec = this.spawnSpec(cwd);
+    if (this.acp !== void 0 && !this.acp.closed && this.specsEqual(this.lastSpec, spec)) return this.acp;
+    this.acp?.dispose();
+    const client = AcpClient.create(spec, this.spawn);
+    this.acp = client;
+    this.lastSpec = spec;
+    try {
+      await client.initialize();
+    } catch (error) {
+      this.acp = void 0;
+      this.lastSpec = void 0;
+      client.dispose();
+      throw error;
+    }
+    return client;
+  }
+  /** Build the `kimi acp` argv/cwd/env for the persistent child. */
+  spawnSpec(cwd) {
+    return {
+      argv: kimiAcpArgv(this.bin),
+      cwd,
+      env: this.config.env
+    };
+  }
+  /** Run one `kimi acp` step for the current session history and map the streamed updates. */
+  async step() {
+    if (this.phase.kind !== "running") throw new Error(`agent "${this.id}": step outside running phase`);
+    const { turn, step, abort: { signal } } = this.phase;
+    signal.throwIfAborted();
+    this.blocks = [];
+    this.emittedToolCalls = /* @__PURE__ */ new Set();
+    this.toolText = /* @__PURE__ */ new Map();
+    const cwd = this.session.header.cwd;
+    if (cwd === void 0 || cwd.length === 0) {
+      throw new Error(`agent "${this.id}": no working directory \u2014 start the session with cwd metadata`);
+    }
+    const history = this.session.deriveMessages();
+    const prompt = serializeHistory(history);
+    if (prompt.length === 0) {
+      throw new Error(`agent "${this.id}": cannot derive a prompt from an empty session log`);
+    }
+    this.assertRequestHeader();
+    signal.throwIfAborted();
+    const client = await this.acpClient(cwd);
+    signal.throwIfAborted();
+    client.onPermission(() => resolveToolApproval(this.session.snapshotEvents()));
+    const acpSessionId = await client.newSession(cwd);
+    signal.throwIfAborted();
+    client.onUpdate((update) => this.applyUpdate(turn, step, update));
+    const cancel = () => {
+      client.cancel(acpSessionId);
+    };
+    signal.addEventListener("abort", cancel, { once: true });
+    try {
+      await raceAbort(client.prompt(acpSessionId, prompt), signal, this.id);
+    } finally {
+      signal.removeEventListener("abort", cancel);
+    }
+    this.flushAssistant(turn, step);
+    if (this.blocks.length === 0 && this.emittedToolCalls.size === 0) {
+      throw new LlmError4(
+        `agent "${this.id}": kimi query produced no assistant output`,
+        "KIMI_NO_RESULT"
+      );
+    }
+    return { kind: "completed" };
+  }
+  /** Per-step accumulation state for streamed assistant blocks and tool calls. */
+  blocks = [];
+  emittedToolCalls = /* @__PURE__ */ new Set();
+  toolText = /* @__PURE__ */ new Map();
+  blockRef(type) {
+    return this.blocks.find((block) => block.type === type);
+  }
+  ensureBlock(type) {
+    const existing = this.blockRef(type);
+    if (existing !== void 0) return existing;
+    const index = this.blocks.length;
+    const block = { index, type, text: "", refs: [] };
+    this.blocks.push(block);
+    return block;
+  }
+  /** Append one streamed update's durable effect for the current step. */
+  applyUpdate(turn, step, update) {
+    if (isThoughtChunk(update)) {
+      const delta = chunkDelta(update);
+      if (delta === "") return;
+      const block = this.ensureBlock("reasoning");
+      const started = block.refs.length === 0;
+      if (started) block.refs.push(this.appendChunk(turn, step, { type: "block-start", index: block.index, blockType: "reasoning" }));
+      block.refs.push(this.appendChunk(turn, step, { type: "reasoning-delta", index: block.index, text: delta }));
+      block.text += delta;
+      return;
+    }
+    if (isTextChunk(update)) {
+      const delta = chunkDelta(update);
+      if (delta === "") return;
+      const block = this.ensureBlock("text");
+      const started = block.refs.length === 0;
+      if (started) block.refs.push(this.appendChunk(turn, step, { type: "block-start", index: block.index, blockType: "text" }));
+      block.refs.push(this.appendChunk(turn, step, { type: "text-delta", index: block.index, text: delta }));
+      block.text += delta;
+      return;
+    }
+    if (isToolCall(update)) {
+      const callId = toolCallIdOf(update);
+      if (callId === "" || this.emittedToolCalls.has(callId)) return;
+      this.emittedToolCalls.add(callId);
+      const name2 = toolCallName(update);
+      this.session.append("tool/call", { turn, step, callId: ToolCallId6(callId), name: name2, arguments: "{}" });
+      this.toolText.set(callId, "");
+      return;
+    }
+    if (isToolCallUpdate(update)) {
+      const callId = toolCallIdOf(update);
+      if (callId === "" || !this.toolText.has(callId)) return;
+      const delta = toolContentText(update);
+      const accumulated = `${this.toolText.get(callId)}${delta}`;
+      this.toolText.set(callId, accumulated);
+      const status = update.status;
+      if (isToolSettledStatus(status)) {
+        const message = toolResult(callId, accumulated, isToolErrorStatus(status));
+        this.session.append("tool/result", { turn, step, message }, { surfaceOp: "append" });
+        this.toolText.delete(callId);
+      }
+      return;
+    }
+  }
+  /** Append one live chunk and return its durable seq. */
+  appendChunk(turn, step, chunk) {
+    return this.session.append("assistant/chunk", { turn, step, chunk }).seq;
+  }
+  /** Flush the accumulated assistant blocks into one durable assistant/message. */
+  flushAssistant(turn, step) {
+    if (this.blocks.length === 0 && this.emittedToolCalls.size === 0) return;
+    const content = [];
+    const refs = [];
+    for (const block of this.blocks) {
+      const delta = block.text;
+      content.push(block.type === "text" ? { type: "text", text: delta } : { type: "reasoning", text: delta });
+      block.refs.push(this.appendChunk(turn, step, { type: "block-end", index: block.index, block: block.type === "text" ? { type: "text", text: delta } : { type: "reasoning", text: delta } }));
+      refs.push(...block.refs);
+    }
+    this.session.append("assistant/message", {
+      turn,
+      step,
+      message: createAssistantMessage4({
+        content,
+        source: { provider: PROVIDER4, model: this.modelLabel() }
+      })
+    }, {
+      surfaceOp: "append",
+      sourceEventSeqs: refs
+    });
+  }
+};
+
+// src/engine-kimi/loop.ts
+var KIMI_DISPOSE_GRACE_MS = 3e3;
+var Config4 = z4.object({
+  model: z4.string(),
+  env: z4.dict(z4.string()).default({}),
+  bin: z4.string()
+});
+function resolveConfig4(config) {
+  return {
+    model: config.model,
+    env: config.env ?? {},
+    bin: kimiBinResolver(config.bin)
+  };
+}
+var KimiLoop = class extends Service4 {
+  /** Services the loop resolves through its own fiber; blessed identically to the package-level entry inject. */
+  static inject = ["agents", "sessions", "systemPrompt", "subprocess"];
+  /** Validated configuration owned by the loop plugin. */
+  config;
+  ownership;
+  /** Plain holder prevents Cordis from re-tracing the factory's dependency context through a caller shadow. */
+  runtime;
+  /** One-shot spawn capability handed to every agent, sandboxed by the subprocess seam. */
+  spawn;
+  constructor(ctx, config) {
+    super(ctx, "agentLoopKimi");
+    this.config = resolveConfig4(config);
+    this.ownership = new FactoryOwnership(ctx.fiber);
+    this.runtime = { ctx };
+    this.spawn = (spec) => fromSubprocess2(this.runtime.ctx.subprocess.spawn(kimiSubprocessSpec(spec, KIMI_DISPOSE_GRACE_MS)));
+    ctx.effect(() => () => this.ownership.dispose(), "agentLoopKimi.transactions()");
+    ctx.effect(() => ctx.agents.setFactory(this), "agentLoopKimi.setFactory()");
+    ctx.systemPrompt.variable("provider", (context) => context.agent?.options.provider);
+    ctx.systemPrompt.variable("model", (context) => context.agent?.options.model);
+    ctx.systemPrompt.variable("cwd", (context) => context.agent?.session.header.cwd);
+  }
+  /**
+   * Construct the driver, scope, and one memoized reverse teardown for a new
+   * agent. The teardown is registered with the factory and the owner fiber
+   * BEFORE publication, so a mid-setup unload rolls everything back; `signal`
+   * 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, handle) {
+    ownerCtx.fiber.assertActive();
+    if (!this.ownership.isActive()) throw new Error("agent loop is not active");
+    if (callerSignal?.aborted) {
+      throw callerSignal.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal.reason });
+    }
+    const loopCtx = this.runtime.ctx;
+    const abort = new AbortController();
+    const onCallerAbort = () => {
+      abort.abort(callerSignal?.reason instanceof Error ? callerSignal.reason : new Error(`agent "${id}" creation aborted`, { cause: callerSignal?.reason }));
+    };
+    const onFactoryTeardown = () => {
+      abort.abort(this.ownership.signal.reason);
+    };
+    callerSignal?.addEventListener("abort", onCallerAbort, { once: true });
+    this.ownership.signal.addEventListener("abort", onFactoryTeardown, { once: true });
+    let machine;
+    let detachSession;
+    let detachAgent;
+    let disposing;
+    const machineReady = Promise.withResolvers();
+    const dispose = (ownerTriggered = false) => disposing ??= (async () => {
+      abort.abort(new Error(`agent "${id}" lifecycle disposed`));
+      callerSignal?.removeEventListener("abort", onCallerAbort);
+      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
+      try {
+        if (machine === void 0) await machineReady.promise;
+        if (machine !== void 0) {
+          machine.cancel({ kind: "disposed" });
+          await machine.whenIdle();
+          await machine.scope.dispose();
+        }
+      } finally {
+        try {
+          await handle?.close();
+        } finally {
+          try {
+            detachAgent?.();
+            detachSession?.();
+          } finally {
+            untrack();
+            if (!ownerTriggered) await unfollowOwner();
+          }
+        }
+      }
+    })();
+    const untrack = this.ownership.track(dispose);
+    let unfollowOwner;
+    try {
+      unfollowOwner = ownerCtx.effect(() => () => {
+        if (disposing !== void 0) return;
+        abort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
+        return dispose(true);
+      }, `agentLoopKimi.lifecycle(${id})`);
+    } catch (error) {
+      untrack();
+      callerSignal?.removeEventListener("abort", onCallerAbort);
+      this.ownership.signal.removeEventListener("abort", onFactoryTeardown);
+      throw error;
+    }
+    const assertLive = () => {
+      if (!abort.signal.aborted) return;
+      throw abort.signal.reason instanceof Error ? abort.signal.reason : new Error(String(abort.signal.reason));
+    };
+    try {
+      const agent = machine = new KimiAgent(loopCtx, id, options, session, this.config, this.spawn, this.config.bin);
+      machineReady.resolve();
+      assertLive();
+      return {
+        agent,
+        signal: abort.signal,
+        publish: (source) => {
+          assertLive();
+          detachSession = agent.ctx.sessions.enter(session);
+          detachAgent = loopCtx.agents.enter(agent, ownerCtx.agent);
+          agent.ctx.sessions.announce(session);
+          assertLive();
+          loopCtx.agents.announce(agent);
+          assertLive();
+          emitAgentEvent4(loopCtx, agent, "agent/session-start", { source });
+          assertLive();
+          return { agent, dispose };
+        },
+        dispose
+      };
+    } catch (error) {
+      machineReady.resolve();
+      void dispose();
+      throw error;
+    }
+  }
+  /** Prepare one Agent around an acquired Session, run setup, and publish it. */
+  async setupAndPublish(ownerCtx, id, preparation, agentOptions, setup, signal, source, stored) {
+    var _stack = [];
+    try {
+      const ownedPreparation = __using(_stack, preparation);
+      const session = ownedPreparation.session;
+      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().catch(() => {
+        });
+        throw error;
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      __callDispose(_stack, _error, _hasError);
+    }
+  }
+  /**
+   * Create an agent and session under one caller-supplied identity, owned by
+   * 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.
+   */
+  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.inheritedEventCount === void 0 ? {} : { inheritedEventCount: options.inheritedEventCount }
+    }));
+    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.
+   * @param options - persisted identity, loop options, setup, and cancellation.
+   * @returns the published handle.
+   */
+  async resume(ownerCtx, options) {
+    const persistence = this.runtime.ctx.get("sessionPersistence");
+    if (persistence === void 0) {
+      throw new Error("cannot resume: session persistence is not configured (load a dsh-session-persistence backend)");
+    }
+    return this.resumeWith(ownerCtx, persistence, options);
+  }
+  /** Resume through an explicit persistence service. */
+  resumeWith(ownerCtx, persistence, options) {
+    const id = options.resumeSessionId;
+    const published = (async () => {
+      const ownerAbort = new AbortController();
+      const unfollowOwner = ownerCtx.effect(() => () => {
+        ownerAbort.abort(new Error(`agent "${id}" setup aborted: owner disposed during setup`));
+      }, `agentLoopKimi.resume-load(${id})`);
+      const fused = AbortSignal.any([
+        ...options.signal === void 0 ? [] : [options.signal],
+        ownerAbort.signal,
+        this.ownership.signal
+      ]);
+      let handle;
+      let stored;
+      let preparation;
+      try {
+        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,
+          preparation,
+          options.agentOptions ?? {},
+          options.setup,
+          options.signal,
+          "resume",
+          owned
+        );
+      } finally {
+        preparation?.[Symbol.dispose]();
+        await handle?.close().catch(() => {
+        });
+      }
+    })();
+    this.ownership.trackWrapper(published);
+    return published;
+  }
+};
+
+// src/engine-kimi/skills.ts
+import { readdir as readdir2, readFile as readFile3, stat as stat3 } from "node:fs/promises";
+import { homedir as homedir3 } from "node:os";
+import { dirname as dirname3, join as join6, resolve as resolve3 } from "node:path";
+
+// src/driver-core/context-files.ts
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
+import { join as join5, resolve as resolve2 } from "node:path";
 
 // src/skills.ts
 import { readFile, readdir, stat } from "node:fs/promises";
@@ -4001,101 +5224,526 @@ function toCandidate(skill, path, rank, resourceBaseDir) {
     resourceBase: { kind: "directory", path: resourceBaseDir }
   };
 }
-async function tryParseSkill(path) {
-  try {
-    const raw = await readFile(path, { encoding: "utf8" });
-    return parseSkillFile(raw);
-  } catch {
-    return void 0;
-  }
+async function tryParseSkill(path) {
+  try {
+    const raw = await readFile(path, { encoding: "utf8" });
+    return parseSkillFile(raw);
+  } catch {
+    return void 0;
+  }
+}
+async function findProjectRoot(cwd) {
+  let current = cwd;
+  while (true) {
+    try {
+      await stat(join4(current, ".git"));
+      return current;
+    } catch {
+    }
+    const parent = resolve(current, "..");
+    if (parent === current) return cwd;
+    current = parent;
+  }
+}
+
+// src/driver-core/context-files.ts
+async function projectAncestors(cwd) {
+  const root = await findProjectRoot(resolve2(cwd));
+  const dirs = [];
+  let current = resolve2(cwd);
+  while (true) {
+    dirs.push(current);
+    if (current === root) return dirs;
+    current = resolve2(current, "..");
+  }
+}
+async function collectProjectContextFiles(cwd, policy) {
+  const files = [];
+  for (const dir of await projectAncestors(cwd)) {
+    const chosen = await dirContextFile(dir, policy);
+    if (chosen !== void 0) files.push(chosen);
+  }
+  return files;
+}
+async function dirContextFile(dir, policy) {
+  if (policy.override !== void 0) {
+    const override = join5(dir, policy.override);
+    if (await pathExists(override)) return override;
+  }
+  for (const name2 of policy.primary) {
+    const candidate = join5(dir, name2);
+    if (await pathExists(candidate)) return candidate;
+  }
+  return void 0;
+}
+async function pathExists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readOptionalFile(path) {
+  try {
+    return await readFile2(path, { encoding: "utf8" });
+  } catch {
+    return void 0;
+  }
+}
+async function anySourceNonEmpty(paths) {
+  for (const path of paths) {
+    const raw = await readOptionalFile(path);
+    if (raw !== void 0 && raw.trim().length > 0) return true;
+  }
+  return false;
+}
+async function fileNonEmpty(path) {
+  const raw = await readOptionalFile(path);
+  return raw !== void 0 && raw.trim().length > 0;
+}
+async function readSources(paths) {
+  const parts = [];
+  for (const path of paths) {
+    const raw = await readOptionalFile(path);
+    if (raw !== void 0 && raw.trim().length > 0) parts.push(raw);
+  }
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+
+// src/engine-kimi/skills.ts
+var PROVIDER_NAME2 = "kimi";
+var KIMI_AGENTS_PROJECT_RANK = 140;
+var KIMI_SKILL_PROJECT_RANK = 150;
+var KIMI_SKILL_USER_RANK = 160;
+var KIMI_CONTEXT_POLICY = {
+  primary: ["AGENTS.md"]
+};
+function kimiAgentDir() {
+  const override = process.env.KIMI_CODE_HOME;
+  if (override !== void 0 && override.length > 0) return resolve3(override);
+  return join6(homedir3(), ".kimi-code");
+}
+var KimiSkillProvider = class {
+  constructor(control) {
+    this.control = control;
+  }
+  control;
+  name = PROVIDER_NAME2;
+  async list(options) {
+    const candidates = [];
+    const cwd = options.cwd;
+    if (cwd !== void 0) {
+      const projectDirs = await projectAncestors(cwd);
+      const contextPaths = await collectProjectContextFiles(cwd, KIMI_CONTEXT_POLICY);
+      if (await anySourceNonEmpty(contextPaths)) candidates.push(this.agentsCandidate(contextPaths, KIMI_AGENTS_PROJECT_RANK));
+      for (const dir of projectDirs) {
+        await this.collectSkillsDir(join6(dir, ".kimi-code", "skills"), KIMI_SKILL_PROJECT_RANK, candidates);
+      }
+    }
+    await this.collectSkillsDir(join6(kimiAgentDir(), "skills"), KIMI_SKILL_USER_RANK, candidates);
+    if (this.control.signal.aborted) return [];
+    return candidates;
+  }
+  async get(candidate, _options) {
+    const locator = candidate.locator;
+    if (locator.kind === "skill-file") {
+      const parsed = await this.tryParse(locator.path);
+      if (parsed === void 0) return void 0;
+      return {
+        name: parsed.name,
+        description: parsed.description,
+        ...parsed.whenToUse === void 0 ? {} : { whenToUse: parsed.whenToUse },
+        invocation: parsed.invocation,
+        source: candidate.source,
+        provider: this.name,
+        content: parsed.content,
+        path: locator.path,
+        resourceBase: { kind: "directory", path: dirname3(locator.path) }
+      };
+    }
+    const content = await readSources(locator.paths);
+    if (content === void 0) return void 0;
+    const first = locator.paths[0];
+    return {
+      name: candidate.name,
+      description: candidate.description,
+      invocation: candidate.invocation,
+      source: candidate.source,
+      provider: this.name,
+      content,
+      path: first,
+      resourceBase: { kind: "file", path: first }
+    };
+  }
+  /** One merged `agents-md` candidate for a ranked file set. */
+  agentsCandidate(paths, rank) {
+    const first = paths[0];
+    return {
+      name: "agents-md",
+      description: "Kimi project instructions (AGENTS.md)",
+      invocation: { modelInvocable: true, userInvocable: true },
+      source: "custom",
+      provider: this.name,
+      rank,
+      locator: { kind: "agents-md", paths },
+      path: first,
+      resourceBase: { kind: "file", path: first }
+    };
+  }
+  /** Collect every skill in one skills directory, both kimi layouts. */
+  async collectSkillsDir(skillsDir, rank, candidates) {
+    let entries;
+    try {
+      entries = await readdir2(skillsDir, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const entryPath = join6(skillsDir, entry.name);
+      const info = await stat3(entryPath).catch(() => void 0);
+      if (info === void 0) continue;
+      if (info.isDirectory()) {
+        const path = join6(entryPath, "SKILL.md");
+        const parsed2 = await this.tryParse(path);
+        if (parsed2 === void 0) continue;
+        candidates.push(this.skillCandidate(parsed2, path, rank, entryPath));
+        continue;
+      }
+      if (!entry.name.endsWith(".md")) continue;
+      const parsed = await this.tryParse(entryPath);
+      if (parsed === void 0) continue;
+      candidates.push(this.skillCandidate(parsed, entryPath, rank, skillsDir));
+    }
+  }
+  /** One parsed skill as a ranked candidate. */
+  skillCandidate(skill, path, rank, resourceDir) {
+    return {
+      name: skill.name,
+      description: skill.description,
+      ...skill.whenToUse === void 0 ? {} : { whenToUse: skill.whenToUse },
+      invocation: skill.invocation,
+      source: "custom",
+      provider: this.name,
+      rank,
+      locator: { kind: "skill-file", path },
+      path,
+      resourceBase: { kind: "directory", path: resourceDir }
+    };
+  }
+  /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
+  async tryParse(path) {
+    try {
+      const raw = await readFile3(path, { encoding: "utf8" });
+      return parseSkillFile(raw);
+    } catch {
+      return void 0;
+    }
+  }
+};
+
+// src/engine-kimi/commands.ts
+import { createUserMessage as createUserMessage5 } from "@deepseek-ai/dsh-llm";
+function forwardKimiCommand(name2) {
+  return (invocation) => {
+    invocation.agent.followup(createUserMessage5({
+      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
+      source: { kind: "user" }
+    }));
+    return { kind: "success" };
+  };
+}
+function builtin(name2, description) {
+  return { name: name2, description, handler: forwardKimiCommand(name2) };
+}
+var KIMI_COMMANDS = [
+  builtin("help", "Show available Kimi Code 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("plan", "Toggle plan (read-only exploration) mode"),
+  builtin("auto", "Toggle auto permission mode"),
+  builtin("usage", "Show token usage, context, and quota information"),
+  builtin("version", "Display the Kimi Code CLI version number"),
+  builtin("goal", "Start or manage an autonomous goal")
+];
+
+// src/settings.ts
+import z5 from "@deepseek-ai/schemastery";
+
+// src/namespace.ts
+var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
+
+// src/settings.ts
+var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi", "kimi"];
+var LOOP_ENGINE_SETTINGS_SCHEMA = z5.object({
+  engine: z5.union([z5.const("in-process"), z5.const("claude-code"), z5.const("codex"), z5.const("pi"), z5.const("kimi")]).default("in-process"),
+  showInComposer: z5.boolean().default(true)
+});
+function loopEngineSettingsNamespace() {
+  return LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL;
+}
+
+// src/patch-manager.ts
+var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block: ";
+var MANAGED_BLOCK_END = "# -- /dsh-loop-engine managed block --";
+var END_MARKER_LINE = `${MANAGED_BLOCK_END}
+`;
+function renderManagedBlock(engine) {
+  if (engine === "in-process") return "";
+  return [
+    `${MANAGED_BLOCK_BEGIN}${engine} --`,
+    "- id: agent-loop",
+    "  disabled: true",
+    "- id: command-goal",
+    "  disabled: true",
+    END_MARKER_LINE
+  ].join("\n");
+}
+var BEGIN_MARKER_RE = /^# -- dsh-loop-engine managed block: (\S+) --$/m;
+function currentEngineOf(text) {
+  const engine = BEGIN_MARKER_RE.exec(text)?.[1];
+  return LOOP_ENGINE_IDS.includes(engine ?? "") ? engine : "in-process";
+}
+function managedSpan(text) {
+  const begin = text.indexOf(MANAGED_BLOCK_BEGIN);
+  if (begin === -1) return { head: text, tail: "", present: false, blankBefore: false };
+  const afterBegin = begin + MANAGED_BLOCK_BEGIN.length;
+  const endAt = text.indexOf(MANAGED_BLOCK_END, afterBegin);
+  const spanEnd = endAt === -1 ? text.length : endAt + END_MARKER_LINE.length;
+  const before = text.slice(0, begin);
+  const blankBefore = before.endsWith("\n\n");
+  return {
+    head: blankBefore ? before.slice(0, -1) : before,
+    tail: text.slice(spanEnd),
+    present: true,
+    blankBefore
+  };
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
 }
-async function findProjectRoot(cwd) {
-  let current = cwd;
-  while (true) {
-    try {
-      await stat(join4(current, ".git"));
-      return current;
-    } catch {
+function hasRootEntry(text) {
+  return /^(?:- |\[)/m.test(text);
+}
+function dropSeedPlaceholder(text) {
+  return text.replace(/^\[\]\n/m, "");
+}
+function seedEmptyArray(text) {
+  const head = text.replace(/\n+$/, "");
+  return head === "" ? "[]\n" : `${head}
+[]
+`;
+}
+function applyManagedBlock(text, engine) {
+  const block = renderManagedBlock(engine);
+  const span = managedSpan(text);
+  let result;
+  if (!span.present) {
+    if (block === "") {
+      result = text;
+    } else {
+      const base = ensureTrailingNewline(text);
+      result = `${base}
+${block}`;
     }
-    const parent = resolve(current, "..");
-    if (parent === current) return cwd;
-    current = parent;
+  } else if (block === "") {
+    result = span.tail.startsWith("\n") ? `${span.head}${span.tail.slice(1)}` : `${span.head}${span.tail}`;
+  } else {
+    result = `${span.head}${span.blankBefore ? "\n" : ""}${block}${span.tail}`;
   }
+  if (block !== "") return dropSeedPlaceholder(result);
+  if (text.trim() === "") return result;
+  return hasRootEntry(result) ? result : seedEmptyArray(result);
 }
 
-// src/engine-codex/skills.ts
-import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
-
-// src/driver-core/context-files.ts
-import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { join as join5, resolve as resolve2 } from "node:path";
-async function projectAncestors(cwd) {
-  const root = await findProjectRoot(resolve2(cwd));
-  const dirs = [];
-  let current = resolve2(cwd);
-  while (true) {
-    dirs.push(current);
-    if (current === root) return dirs;
-    current = resolve2(current, "..");
-  }
+// 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("- ");
 }
-async function collectProjectContextFiles(cwd, policy) {
-  const files = [];
-  for (const dir of await projectAncestors(cwd)) {
-    const chosen = await dirContextFile(dir, policy);
-    if (chosen !== void 0) files.push(chosen);
-  }
-  return files;
+function entryId(line) {
+  return /^- id:\s*(\S+)\s*$/.exec(line)?.[1];
 }
-async function dirContextFile(dir, policy) {
-  if (policy.override !== void 0) {
-    const override = join5(dir, policy.override);
-    if (await pathExists(override)) return override;
-  }
-  for (const name2 of policy.primary) {
-    const candidate = join5(dir, name2);
-    if (await pathExists(candidate)) return candidate;
-  }
-  return void 0;
+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 pathExists(path) {
+async function writeIfDifferent(path, text) {
   try {
-    await stat2(path);
-    return true;
+    if (await readFile4(path, "utf8") === text) return false;
   } catch {
-    return false;
   }
+  await mkdir(dirname4(path), { recursive: true });
+  const tmp = `${path}.tmp-${randomUUID()}`;
+  await writeFile(tmp, text, "utf8");
+  await rename(tmp, path);
+  return true;
 }
-async function readOptionalFile(path) {
+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.
+   */
+  constructor(label) {
+    super();
+    this.label = label;
+  }
+  label;
+  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 join8 } from "node:path";
+import { createUserMessage as createUserMessage6 } from "@deepseek-ai/dsh-llm";
+var COMMAND_NAME = /^[a-z][a-z0-9_-]*$/;
+function forwardClaudeCodeCommand(name2) {
+  return (invocation) => {
+    invocation.agent.followup(createUserMessage6({
+      content: [{ type: "text", text: `/${name2}${invocation.rawInput}` }],
+      source: { kind: "user" }
+    }));
+    return { kind: "success" };
+  };
+}
+function builtin2(name2, description) {
+  return { name: name2, description, handler: forwardClaudeCodeCommand(name2) };
+}
+var CLAUDE_CODE_COMMANDS = [
+  builtin2("help", "Show help about Claude Code commands"),
+  builtin2("compact", "Compact the conversation to reduce context usage"),
+  builtin2("clear", "Clear the conversation and start fresh"),
+  builtin2("review", "Review recent changes (git diff)"),
+  builtin2("explain", "Explain the selected code"),
+  builtin2("fix", "Fix issues in the code"),
+  builtin2("tests", "Add tests for the selected code")
+];
+function discoverUserSlashCommands() {
+  let entries;
   try {
-    return await readFile2(path, { encoding: "utf8" });
+    entries = readdirSync(userCommandsDir(), { encoding: "utf8" });
   } catch {
-    return void 0;
+    return [];
   }
-}
-async function anySourceNonEmpty(paths) {
-  for (const path of paths) {
-    const raw = await readOptionalFile(path);
-    if (raw !== void 0 && raw.trim().length > 0) return true;
+  const definitions = [];
+  const seen = new Set(CLAUDE_CODE_COMMANDS.map((command) => command.name));
+  for (const entry of entries.sort()) {
+    if (!entry.endsWith(".md")) continue;
+    const name2 = entry.slice(0, -".md".length);
+    if (!COMMAND_NAME.test(name2) || seen.has(name2)) continue;
+    const path = join8(userCommandsDir(), entry);
+    let raw;
+    try {
+      raw = readFileSync2(path, "utf8");
+    } catch {
+      continue;
+    }
+    const description = commandDescription(raw);
+    if (description === void 0) continue;
+    seen.add(name2);
+    definitions.push({ name: name2, description, handler: forwardClaudeCodeCommand(name2) });
   }
-  return false;
+  return definitions;
 }
-async function fileNonEmpty(path) {
-  const raw = await readOptionalFile(path);
-  return raw !== void 0 && raw.trim().length > 0;
+function userCommandsDir() {
+  return join8(homedir4(), ".claude", "commands");
 }
-async function readSources(paths) {
-  const parts = [];
-  for (const path of paths) {
-    const raw = await readOptionalFile(path);
-    if (raw !== void 0 && raw.trim().length > 0) parts.push(raw);
+function commandDescription(raw) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) return void 0;
+  let body = trimmed;
+  if (trimmed.startsWith("---\n")) {
+    const closing = trimmed.indexOf("\n---");
+    if (closing <= 0) return void 0;
+    for (const line of trimmed.slice(4, closing).split("\n")) {
+      const colon = line.indexOf(":");
+      if (colon < 0 || line.slice(0, colon).trim() !== "description") continue;
+      const value = line.slice(colon + 1).trim().replace(/^["']|["']$/g, "");
+      if (value.length > 0) return value;
+    }
+    body = trimmed.slice(closing + 4);
   }
-  return parts.length > 0 ? parts.join("\n\n") : void 0;
+  for (const line of body.split("\n")) {
+    const candidate = line.trim();
+    if (candidate.length === 0 || candidate.startsWith("#")) continue;
+    return candidate.length > 120 ? `${candidate.slice(0, 119)}\u2026` : candidate;
+  }
+  return void 0;
 }
 
 // src/engine-codex/skills.ts
-var PROVIDER_NAME2 = "codex";
+import { homedir as homedir5 } from "node:os";
+import { join as join9 } from "node:path";
+var PROVIDER_NAME3 = "codex";
 var CODEX_PROJECT_RANK = 140;
 var CODEX_USER_RANK = 160;
 var CODEX_CONTEXT_POLICY = { primary: ["AGENTS.md"] };
@@ -4104,7 +5752,7 @@ var CodexSkillProvider = class {
     this.control = control;
   }
   control;
-  name = PROVIDER_NAME2;
+  name = PROVIDER_NAME3;
   async list(options) {
     const candidates = [];
     const cwd = options.cwd;
@@ -4112,7 +5760,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 = join6(homedir3(), ".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;
@@ -4151,10 +5799,10 @@ var CodexSkillProvider = class {
 };
 
 // src/engine-pi/skills.ts
-import { readdir as readdir2, readFile as readFile3, stat as stat3 } from "node:fs/promises";
-import { homedir as homedir4 } from "node:os";
-import { dirname as dirname3, join as join7, resolve as resolve3 } from "node:path";
-var PROVIDER_NAME3 = "pi";
+import { readdir as readdir3, readFile as readFile5, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+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;
 var PI_AGENTS_USER_RANK = 160;
@@ -4165,15 +5813,15 @@ var PI_CONTEXT_POLICY = {
 };
 function piAgentDir() {
   const override = process.env.PI_CODING_AGENT_DIR;
-  if (override !== void 0 && override.length > 0) return resolve3(override);
-  return join7(homedir4(), ".pi", "agent");
+  if (override !== void 0 && override.length > 0) return resolve4(override);
+  return join10(homedir6(), ".pi", "agent");
 }
 var PiSkillProvider = class {
   constructor(control) {
     this.control = control;
   }
   control;
-  name = PROVIDER_NAME3;
+  name = PROVIDER_NAME4;
   async list(options) {
     const candidates = [];
     const cwd = options.cwd;
@@ -4182,13 +5830,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(join7(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 = join7(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(join7(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;
   }
@@ -4206,7 +5854,7 @@ var PiSkillProvider = class {
         provider: this.name,
         content: parsed.content,
         path: locator.path,
-        resourceBase: { kind: "directory", path: dirname3(locator.path) }
+        resourceBase: { kind: "directory", path: dirname5(locator.path) }
       };
     }
     const content = await readSources(locator.paths);
@@ -4242,16 +5890,16 @@ var PiSkillProvider = class {
   async collectSkillsDir(skillsDir, rank, candidates) {
     let entries;
     try {
-      entries = await readdir2(skillsDir, { withFileTypes: true, encoding: "utf8" });
+      entries = await readdir3(skillsDir, { withFileTypes: true, encoding: "utf8" });
     } catch {
       return;
     }
     for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
-      const entryPath = join7(skillsDir, entry.name);
-      const info = await stat3(entryPath).catch(() => void 0);
+      const entryPath = join10(skillsDir, entry.name);
+      const info = await stat4(entryPath).catch(() => void 0);
       if (info === void 0) continue;
       if (info.isDirectory()) {
-        const path = join7(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));
@@ -4281,7 +5929,7 @@ var PiSkillProvider = class {
   /** Parse one SKILL.md file, or `undefined` when it is unreadable or invalid. */
   async tryParse(path) {
     try {
-      const raw = await readFile3(path, { encoding: "utf8" });
+      const raw = await readFile5(path, { encoding: "utf8" });
       return parseSkillFile(raw);
     } catch {
       return void 0;
@@ -4294,23 +5942,24 @@ var name = "loop-engine";
 var inject = [];
 var MAX_MOUNT_ATTEMPTS = 40;
 var MOUNT_RETRY_MS = 50;
-var Config4 = z5.object({
-  profile: z5.string(),
-  patchFilename: z5.string(),
-  patchPath: z5.string(),
-  permissionMode: z5.union(CLAUDE_CODE_PERMISSION_MODES.map((mode) => z5.const(mode))),
-  env: z5.dict(z5.string()),
-  model: z5.string(),
-  disposeGraceMs: z5.number(),
-  maxTurns: z5.number(),
-  sandboxMode: z5.union(CODEX_SANDBOX_MODES.map((mode) => z5.const(mode))),
-  approvalPolicy: z5.union(CODEX_APPROVAL_POLICIES.map((policy) => z5.const(policy))),
-  piProvider: z5.string(),
-  piThinking: z5.string()
+var Config5 = z6.object({
+  profile: z6.string(),
+  patchFilename: z6.string(),
+  patchPath: z6.string(),
+  permissionMode: z6.union(CLAUDE_CODE_PERMISSION_MODES.map((mode) => z6.const(mode))),
+  env: z6.dict(z6.string()),
+  model: z6.string(),
+  disposeGraceMs: z6.number(),
+  maxTurns: z6.number(),
+  sandboxMode: z6.union(CODEX_SANDBOX_MODES.map((mode) => z6.const(mode))),
+  approvalPolicy: z6.union(CODEX_APPROVAL_POLICIES.map((policy) => z6.const(policy))),
+  piProvider: z6.string(),
+  piThinking: z6.string(),
+  kimiBin: z6.string()
 });
 function resolvePatchPath(config) {
   if (config.patchPath !== void 0 && config.patchPath !== "") return config.patchPath;
-  return join8(
+  return join11(
     resolveDshHome(),
     "profiles",
     config.profile ?? "web",
@@ -4322,21 +5971,21 @@ function isMissing(error) {
 }
 async function readPatchOrUndefined(path) {
   try {
-    return await readFile4(path, "utf8");
+    return await readFile6(path, "utf8");
   } catch (error) {
     if (isMissing(error)) return void 0;
     throw error;
   }
 }
 async function writePatchFile(path, text) {
-  await mkdir(dirname4(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(dirname4(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);
 }
@@ -4381,9 +6030,19 @@ function piConfig(config) {
     ...config.sandboxMode === void 0 ? {} : { sandboxMode: config.sandboxMode }
   };
 }
+function kimiConfig(config) {
+  return {
+    ...config.model === void 0 ? {} : { model: config.model },
+    ...config.env === void 0 ? {} : { env: config.env },
+    ...config.kimiBin === void 0 ? {} : { bin: config.kimiBin }
+  };
+}
 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;
@@ -4396,6 +6055,105 @@ 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 {
+      routeHandle = llm.registerAdapter([label], new HostedEngineRouteAdapter(label));
+      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();
@@ -4459,15 +6217,37 @@ function apply(ctx, config) {
     }
     hostFactory("pi", () => ctx.plugin(PiLoop, piConfig(config)));
   };
+  const mountKimi = () => {
+    const commands = ctx.get("commands");
+    if (commands !== void 0) {
+      const disposers = [];
+      for (const command of KIMI_COMMANDS) {
+        try {
+          disposers.push(commands.register(command));
+        } catch (error) {
+          ctx.logger.warn(`loop-engine: skip kimi command /${command.name}: ${String(error)}`);
+        }
+      }
+      commandDisposers = disposers;
+    }
+    const skills = ctx.get("skills");
+    if (skills !== void 0) {
+      skillDisposer = skills.registerProvider((control) => new KimiSkillProvider(control));
+    }
+    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();
+    else if (engine === "kimi") mountKimi();
   };
   const unmountEngine = () => {
     const fiber = engineFiber;
     mountAttempts = 0;
     CLEAR_RETRY();
+    releaseRoute();
     cleanupEngineRegistrations();
     mountedEngine = void 0;
     if (fiber === void 0) return;
@@ -4477,31 +6257,40 @@ 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 {
-  Config4 as Config,
+  Config5 as Config,
   apply,
   inject,
   name,