dsh-loop-engine 1.0.0-rc6 → 1.0.0-rc7

package/lib/index.js

@@ -46,10 +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 { mkdir, readFile as readFile5, 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 { dirname as dirname5, join as join10 } from "node:path";
+import z6 from "@deepseek-ai/schemastery";
 import { installSettingsSection } from "@deepseek-ai/dsh-settings";
 import { resolveDshHome } from "@deepseek-ai/dsh-home-paths";
 
@@ -1478,8 +1478,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 +1530,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 +1604,7 @@ var AppServerThread = class _AppServerThread {
       }
       if (event) {
         queue.push(event);
-        resolve4?.();
+        resolve5?.();
       }
     };
     this.client.onNotification(notificationHandler);
@@ -1630,7 +1630,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 +1640,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;
@@ -2591,8 +2591,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 +2637,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 +2655,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;
     }
@@ -2763,13 +2763,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, {
@@ -3316,8 +3316,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 +3350,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" });
   }
@@ -3640,230 +3640,1094 @@ var PiLoop = class extends Service3 {
   }
 };
 
-// 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 { 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 { CallId as CallId6, 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 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");
+  }
+  return {
+    stdin,
+    stdout,
+    stderr,
+    done: handle.done,
+    terminate: () => handle.terminate()
+  };
 }
-function seedEmptyArray(text) {
-  const head = text.replace(/\n+$/, "");
-  return head === "" ? "[]\n" : `${head}
-[]
-`;
+
+// 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 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}`;
-  }
-  if (block !== "") return dropSeedPlaceholder(result);
-  if (text.trim() === "") return result;
-  return hasRootEntry(result) ? result : seedEmptyArray(result);
+function isPermissionRequestFrame(frame2) {
+  return frame2.method === "session/request_permission" && typeof frame2.id === "number";
 }
 
-// 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
+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 builtin(name2, description) {
-  return { name: name2, description, handler: forwardClaudeCodeCommand(name2) };
+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 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 [];
+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;
-    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) });
+  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;
   }
-  return definitions;
-}
-function userCommandsDir() {
-  return join3(homedir(), ".claude", "commands");
-}
-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;
+  /**
+   * 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");
     }
-    body = trimmed.slice(closing + 4);
+    return sessionId;
   }
-  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;
+  /** 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 }] });
   }
-  return void 0;
-}
-
-// src/skills.ts
-import { readFile, readdir, stat } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { join as join4, resolve } from "node:path";
-var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-var PROVIDER_NAME = "claude-code";
-var CLAUDE_CODE_RANK = 150;
-var CLAUDE_CODE_USER_RANK = 160;
-function parseFrontmatter(raw) {
-  const firstLineEnd = raw.indexOf("\n");
-  if (firstLineEnd < 0) return void 0;
-  const firstLine = raw.slice(0, firstLineEnd).replace(/\r$/, "");
-  if (firstLine !== "---") return void 0;
-  const start = firstLineEnd + 1;
-  const closing = findClosingFrontmatter(raw, start);
-  if (closing === void 0) return void 0;
-  const yaml = raw.slice(start, closing.start);
-  const data = {};
-  const lines = yaml.split("\n");
-  for (let index = 0; index < lines.length; index += 1) {
-    const line = lines[index] ?? "";
-    const trimmed = line.trim();
-    if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
-    const colon = trimmed.indexOf(":");
-    if (colon < 0) continue;
-    const key = trimmed.slice(0, colon).trim();
-    const value = trimmed.slice(colon + 1).trim();
-    if (key.length === 0) continue;
-    if (value === ">" || value === ">-" || value === "|" || value === "|-") {
-      const block = [];
-      while (index + 1 < lines.length) {
-        const next = lines[index + 1] ?? "";
-        if (next.trim().length > 0 && !/^[\s]/.test(next)) break;
-        index += 1;
-        if (next.trim().length > 0) block.push(next.trim());
+  /** 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;
       }
-      data[key] = value.startsWith("|") ? block.join("\n") : block.join(" ");
-      continue;
+      if (this.sealed) return;
+      await new Promise((resolve5) => {
+        this.updateWake = resolve5;
+      });
+      this.updateWake = void 0;
     }
-    data[key] = unquote(value);
   }
-  return { data, body: raw.slice(closing.bodyStart) };
-}
-function unquote(value) {
-  if (value.length >= 2) {
-    const first = value[0];
-    const last = value[value.length - 1];
-    if (first === '"' && last === '"' || first === "'" && last === "'") {
-      return value.slice(1, -1);
+  /** 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);
     }
   }
-  return value;
-}
-function findClosingFrontmatter(raw, start) {
-  let lineStart = start;
+  /** 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 {
+      frame2 = JSON.parse(line);
+    } catch {
+      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" } })}
+`);
+    }
+  }
+  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 { CallId as CallId5, createToolResultMessage as createToolResultMessage4 } from "@deepseek-ai/dsh-llm";
+function isTextChunk(update) {
+  return update.sessionUpdate === "agent_message_chunk";
+}
+function isThoughtChunk(update) {
+  return update.sessionUpdate === "agent_thought_chunk";
+}
+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: CallId5(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.events.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 });
+    }
+  }
+  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);
+  }
+  /**
+   * 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.events));
+    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: CallId6(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) {
+    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 {
+          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) {
+    var _stack = [];
+    try {
+      const ownedPreparation = __using(_stack, preparation);
+      const session = ownedPreparation.session;
+      const prepared = this.prepare(ownerCtx, id, agentOptions, session, signal);
+      try {
+        const setupCommit = await raceAbort(setup?.(prepared.agent.ctx), prepared.signal, id);
+        setupCommit?.commit();
+        return prepared.publish(source);
+      } catch (error) {
+        await prepared.dispose();
+        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.
+   * @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 }
+    }));
+    const published = this.setupAndPublish(
+      ownerCtx,
+      options.sessionId,
+      preparation,
+      options.agentOptions ?? {},
+      options.setup,
+      options.signal,
+      "startup"
+    );
+    this.ownership.trackWrapper(published);
+    return published;
+  }
+  /**
+   * 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 handle. */
+  async resumeWith(ownerCtx, persistence, options) {
+    const id = options.resumeSessionId;
+    let preparation;
+    try {
+      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
+      ]);
+      try {
+        preparation = await raceAbortCall(
+          () => persistence.prepare(id, fused),
+          fused,
+          id,
+          (abandoned) => {
+            abandoned[Symbol.dispose]();
+          }
+        );
+      } finally {
+        await unfollowOwner();
+      }
+      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]();
+    }
+  }
+};
+
+// 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";
+import { homedir as homedir2 } from "node:os";
+import { join as join4, resolve } from "node:path";
+var SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PROVIDER_NAME = "claude-code";
+var CLAUDE_CODE_RANK = 150;
+var CLAUDE_CODE_USER_RANK = 160;
+function parseFrontmatter(raw) {
+  const firstLineEnd = raw.indexOf("\n");
+  if (firstLineEnd < 0) return void 0;
+  const firstLine = raw.slice(0, firstLineEnd).replace(/\r$/, "");
+  if (firstLine !== "---") return void 0;
+  const start = firstLineEnd + 1;
+  const closing = findClosingFrontmatter(raw, start);
+  if (closing === void 0) return void 0;
+  const yaml = raw.slice(start, closing.start);
+  const data = {};
+  const lines = yaml.split("\n");
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    const trimmed = line.trim();
+    if (trimmed.length === 0 || trimmed.startsWith("#")) continue;
+    const colon = trimmed.indexOf(":");
+    if (colon < 0) continue;
+    const key = trimmed.slice(0, colon).trim();
+    const value = trimmed.slice(colon + 1).trim();
+    if (key.length === 0) continue;
+    if (value === ">" || value === ">-" || value === "|" || value === "|-") {
+      const block = [];
+      while (index + 1 < lines.length) {
+        const next = lines[index + 1] ?? "";
+        if (next.trim().length > 0 && !/^[\s]/.test(next)) break;
+        index += 1;
+        if (next.trim().length > 0) block.push(next.trim());
+      }
+      data[key] = value.startsWith("|") ? block.join("\n") : block.join(" ");
+      continue;
+    }
+    data[key] = unquote(value);
+  }
+  return { data, body: raw.slice(closing.bodyStart) };
+}
+function unquote(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === '"' && last === '"' || first === "'" && last === "'") {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+function findClosingFrontmatter(raw, start) {
+  let lineStart = start;
   while (lineStart <= raw.length) {
     const nextNewline = raw.indexOf("\n", lineStart);
     const lineEnd = nextNewline < 0 ? raw.length : nextNewline;
@@ -4008,94 +4872,417 @@ async function tryParseSkill(path) {
   } catch {
     return void 0;
   }
-}
-async function findProjectRoot(cwd) {
-  let current = cwd;
-  while (true) {
+}
+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 {
-      await stat(join4(current, ".git"));
-      return current;
+      const raw = await readFile3(path, { encoding: "utf8" });
+      return parseSkillFile(raw);
     } catch {
+      return void 0;
     }
-    const parent = resolve(current, "..");
-    if (parent === current) return cwd;
-    current = parent;
   }
+};
+
+// 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("model", "Switch the LLM model used in the current session"),
+  builtin("plan", "Toggle plan (read-only exploration) mode"),
+  builtin("auto", "Toggle auto permission mode"),
+  builtin("usage", "Show token usage, context, and quota information"),
+  builtin("version", "Display the Kimi Code CLI version number"),
+  builtin("goal", "Start or manage an autonomous goal")
+];
 
-// src/engine-codex/skills.ts
-import { homedir as homedir3 } from "node:os";
-import { join as join6 } from "node:path";
+// src/settings.ts
+import z5 from "@deepseek-ai/schemastery";
+import { settingsNamespace } from "@deepseek-ai/dsh-settings";
 
-// 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/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 settingsNamespace(LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL);
 }
-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;
+
+// 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");
 }
-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;
+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";
 }
-async function pathExists(path) {
-  try {
-    await stat2(path);
-    return true;
-  } catch {
-    return false;
+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}
+`;
+}
+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}`;
   }
+  if (block !== "") return dropSeedPlaceholder(result);
+  if (text.trim() === "") return result;
+  return hasRootEntry(result) ? result : seedEmptyArray(result);
 }
-async function readOptionalFile(path) {
+
+// src/commands.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join7 } from "node:path";
+import { 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 = join7(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 join7(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 join8 } 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 +5291,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 +5299,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 = join8(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 +5338,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 readFile4, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir6 } from "node:os";
+import { dirname as dirname4, join as join9, resolve as resolve4 } from "node:path";
+var PROVIDER_NAME4 = "pi";
 var PI_AGENTS_PROJECT_RANK = 140;
 var PI_SKILL_PROJECT_RANK = 150;
 var PI_AGENTS_USER_RANK = 160;
@@ -4165,15 +5352,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 join9(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 +5369,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(join9(dir, ".pi", "skills"), PI_SKILL_PROJECT_RANK, candidates);
       }
     }
     const userAgentDir = piAgentDir();
-    const userContext = join7(userAgentDir, "AGENTS.md");
+    const userContext = join9(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(join9(userAgentDir, "skills"), PI_SKILL_USER_RANK, candidates);
     if (this.control.signal.aborted) return [];
     return candidates;
   }
@@ -4206,7 +5393,7 @@ var PiSkillProvider = class {
         provider: this.name,
         content: parsed.content,
         path: locator.path,
-        resourceBase: { kind: "directory", path: dirname3(locator.path) }
+        resourceBase: { kind: "directory", path: dirname4(locator.path) }
       };
     }
     const content = await readSources(locator.paths);
@@ -4242,16 +5429,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 = join9(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 = join9(entryPath, "SKILL.md");
         const parsed2 = await this.tryParse(path);
         if (parsed2 === void 0) continue;
         candidates.push(this.skillCandidate(parsed2, path, rank, entryPath));
@@ -4281,7 +5468,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 readFile4(path, { encoding: "utf8" });
       return parseSkillFile(raw);
     } catch {
       return void 0;
@@ -4294,23 +5481,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 join10(
     resolveDshHome(),
     "profiles",
     config.profile ?? "web",
@@ -4322,20 +5510,20 @@ function isMissing(error) {
 }
 async function readPatchOrUndefined(path) {
   try {
-    return await readFile4(path, "utf8");
+    return await readFile5(path, "utf8");
   } catch (error) {
     if (isMissing(error)) return void 0;
     throw error;
   }
 }
 async function writePatchFile(path, text) {
-  await mkdir(dirname4(path), { recursive: true });
+  await mkdir(dirname5(path), { recursive: true });
   const tmp = `${path}.tmp-${randomUUID()}`;
   await writeFile(tmp, text, "utf8");
   await rename(tmp, path);
 }
 function writePatchFileSync(path, text) {
-  mkdirSync(dirname4(path), { recursive: true });
+  mkdirSync(dirname5(path), { recursive: true });
   const tmp = `${path}.tmp-${randomUUID()}`;
   writeFileSync(tmp, text, "utf8");
   renameSync(tmp, path);
@@ -4381,6 +5569,13 @@ 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));
@@ -4459,10 +5654,30 @@ 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) => {
     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;
@@ -4501,7 +5716,7 @@ function apply(ctx, config) {
   });
 }
 export {
-  Config4 as Config,
+  Config5 as Config,
   apply,
   inject,
   name,