replicas-engine 0.1.664 → 0.1.666

package/dist/src/index.js

@@ -4,6 +4,7 @@ import {
   AGENT,
   AGENT_MESSAGE_DELTA_METHOD,
   AGENT_MODELS,
+  AI_GATEWAY_BASE_URL,
   ASTER_BASE_URL,
   ASTER_MODELS,
   ASTER_MODEL_LABELS,
@@ -41,6 +42,7 @@ import {
   DEFAULT_DEEPSEEK_MODEL,
   DEFAULT_FX_MODEL,
   DEFAULT_HOOK_OUTPUT_PREVIEW_CHARS,
+  DEFAULT_KIMI_MODEL,
   DEFAULT_OPENCODE_MODEL,
   DEFAULT_PI_MODEL,
   DEFAULT_START_HOOK_TIMEOUT_MS,
@@ -120,6 +122,7 @@ import {
   extractCommandProtectionCommandText,
   extractErrorText,
   extractToolResultText,
+  fetchAiGatewayModels,
   findGitCommitSignals,
   findPrMergeSignals,
   getChatHistoryPageSenders,
@@ -186,13 +189,13 @@ import {
   serializeCanvasContentResponse,
   shellQuotePosix,
   stripAgentDiagnosticErrors
-} from "./chunk-L4RE37PJ.js";
+} from "./chunk-3EPGH6IZ.js";
 
 // src/index.ts
 import { serve } from "@hono/node-server";
 import { Hono as Hono2 } from "hono";
 import { existsSync as existsSync11 } from "fs";
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { connect } from "net";
 
 // src/managers/github-token-manager.ts
@@ -1976,6 +1979,7 @@ function createDefaultDetails() {
     cursorAuthMethod: "none",
     deepseekAuthMethod: "none",
     fxAuthMethod: "none",
+    kimiAuthMethod: "none",
     opencodeAuthMethod: "none",
     piAuthMethod: "none",
     lastUpdatedAt: (/* @__PURE__ */ new Date()).toISOString()
@@ -2017,6 +2021,7 @@ var EnvironmentDetailsService = class {
     details.cursorAuthMethod = detectCursorAuthMethod();
     details.deepseekAuthMethod = detectDeepseekAuthMethod();
     details.fxAuthMethod = detectFxAuthMethod();
+    details.kimiAuthMethod = detectFxAuthMethod();
     details.opencodeAuthMethod = detectOpencodeAuthMethod();
     details.piAuthMethod = detectPiAuthMethod();
     details.credentialFallbacks = listCredentialFallbacks();
@@ -2772,10 +2777,10 @@ async function registerDesktopPreview() {
 
 // src/services/chat/chat-service.ts
 import { existsSync as existsSync8 } from "fs";
-import { appendFile as appendFile4, copyFile, mkdir as mkdir17, readFile as readFile16, rename as rename3, rm as rm2 } from "fs/promises";
+import { appendFile as appendFile4, copyFile, mkdir as mkdir17, readFile as readFile17, rename as rename3, rm as rm2 } from "fs/promises";
 import { homedir as homedir15 } from "os";
-import { join as join30 } from "path";
-import { randomUUID as randomUUID7 } from "crypto";
+import { join as join29 } from "path";
+import { randomUUID as randomUUID8 } from "crypto";
 
 // src/managers/claude-manager.ts
 import {
@@ -6356,6 +6361,7 @@ var OPENCODE_HISTORY_DIR = join18(ENGINE_DIR2, "opencode-histories");
 var PI_HISTORY_DIR = join18(ENGINE_DIR2, "pi-histories");
 var DEEPSEEK_HISTORY_DIR = join18(ENGINE_DIR2, "deepseek-histories");
 var FX_HISTORY_DIR = join18(ENGINE_DIR2, "fx-histories");
+var KIMI_HISTORY_DIR = join18(ENGINE_DIR2, "kimi-histories");
 var HISTORY_DIR_BY_PROVIDER = {
   claude: CLAUDE_HISTORY_DIR,
   relay: RELAY_HISTORY_DIR,
@@ -6363,6 +6369,7 @@ var HISTORY_DIR_BY_PROVIDER = {
   cursor: CURSOR_HISTORY_DIR,
   deepseek: DEEPSEEK_HISTORY_DIR,
   fx: FX_HISTORY_DIR,
+  kimi: KIMI_HISTORY_DIR,
   opencode: OPENCODE_HISTORY_DIR,
   pi: PI_HISTORY_DIR
 };
@@ -6482,15 +6489,9 @@ var CodexAspManager = class extends CodingAgentManager {
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
-    if (this.initialSessionId) {
-      this.currentThreadId = this.initialSessionId;
-      return;
-    }
     const replayed = await this.historyFile?.load();
-    if (replayed) {
-      if (replayed.transcript) {
-        this.mergeTranscriptSnapshot(replayed.transcript);
-      }
+    if (replayed?.transcript && (!this.initialSessionId || replayed.transcript.threadId === this.initialSessionId)) {
+      this.mergeTranscriptSnapshot(replayed.transcript);
     }
     this.currentThreadId = this.initialSessionId ?? replayed?.transcript?.threadId ?? null;
   }
@@ -6647,16 +6648,22 @@ var CodexAspManager = class extends CodingAgentManager {
         itemsView: "full"
       }
     );
-    const transcript = turnsToAspTranscript(
+    const nativeTranscript = turnsToAspTranscript(
       this.currentThreadId,
       (/* @__PURE__ */ new Date()).toISOString(),
       response.data
     );
-    if (cursor === void 0) {
-      this.codexAspTranscript = transcript;
-      this.syncTranscriptSequence(transcript);
-    }
-    return { transcript, before: response.nextCursor };
+    const mergedTranscript = mergeCodexAspTranscripts(this.codexAspTranscript, nativeTranscript) ?? nativeTranscript;
+    this.codexAspTranscript = mergedTranscript;
+    this.syncTranscriptSequence(mergedTranscript);
+    const turnIds = new Set(response.data.map((turn) => turn.id));
+    return {
+      transcript: {
+        ...mergedTranscript,
+        turns: mergedTranscript.turns.filter((turn) => turnIds.has(turn.id))
+      },
+      before: response.nextCursor
+    };
   }
   getGoal() {
     return this.currentGoal;
@@ -6723,6 +6730,7 @@ var CodexAspManager = class extends CodingAgentManager {
     this.recordCodexHistoryEvent("event_msg", {
       type: "user_message",
       message: request.message,
+      ...request.messageId ? { [USER_MESSAGE_ID_PAYLOAD_KEY]: request.messageId } : {},
       ...images ? { images } : {},
       ...extraPayload
     });
@@ -8551,9 +8559,14 @@ ${request.message}` : request.message;
 };
 
 // src/managers/fx-manager.ts
+import { readFile as readFile12 } from "fs/promises";
+import { spawn as spawn5 } from "child_process";
+
+// src/managers/acp-manager.ts
 import { spawn as spawn4 } from "child_process";
-import { mkdir as mkdir13, readFile as readFile11 } from "fs/promises";
-import { dirname as dirname7, join as join22 } from "path";
+import { randomUUID as randomUUID6 } from "crypto";
+import { mkdir as mkdir13, readFile as readFile11, writeFile as writeFile6 } from "fs/promises";
+import { dirname as dirname7 } from "path";
 import { Writable } from "stream";
 import {
   PROTOCOL_VERSION,
@@ -8561,21 +8574,12 @@ import {
   methods,
   ndJsonStream
 } from "@agentclientprotocol/sdk";
-async function ensureResolvableDnsConfig() {
-  const contents = await readFile11("/etc/resolv.conf");
-  if (contents.length === 0 || contents.at(-1) === 10) return;
-  await new Promise((resolve5, reject) => {
-    const child = spawn4("sudo", ["tee", "-a", "/etc/resolv.conf"], { stdio: ["pipe", "ignore", "pipe"] });
-    let stderr = "";
-    child.stderr.on("data", (chunk) => {
-      stderr += chunk;
-    });
-    child.on("error", reject);
-    child.on("exit", (code) => code === 0 ? resolve5() : reject(new Error(`Failed to normalize /etc/resolv.conf: ${stderr.trim()}`)));
-    child.stdin.end("\n");
-  });
+function selectOptions(option) {
+  if (option.type !== "select") return [];
+  return option.options.flatMap((entry) => "group" in entry ? entry.options : [entry]);
 }
-var FxManager = class extends CodingAgentManager {
+var AcpManager = class extends CodingAgentManager {
+  acp;
   historyFile;
   historyFilePath;
   process = null;
@@ -8583,42 +8587,90 @@ var FxManager = class extends CodingAgentManager {
   context = null;
   sessionId = null;
   activeModel = null;
+  activeThinkingLevel;
   planMode = false;
+  replaying = false;
   slashCommands = [];
+  configOptions = [];
+  modes = null;
+  capabilities = {};
+  interactiveTools = false;
+  pendingPermissions = /* @__PURE__ */ new Map();
+  terminals = /* @__PURE__ */ new Map();
   constructor(options) {
-    super(options);
-    this.historyFilePath = options.historyFilePath ?? join22(ENGINE_ENV.HOME_DIR, ".replicas", "fx", "history.jsonl");
+    super({ ...options, provider: options.acp.provider });
+    this.acp = options.acp;
+    this.historyFilePath = options.historyFilePath;
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
   async initialize() {
     await mkdir13(dirname7(this.historyFilePath), { recursive: true });
-    await ensureResolvableDnsConfig();
+    await this.acp.prepare?.();
   }
   getHistorySink() {
     return this.historyFile;
   }
-  async start(model) {
-    if (this.context && this.activeModel === model) return;
+  async start(model, thinkingLevel) {
+    if (this.context && this.activeModel === model && (!this.acp.restartOnThinkingChange || this.activeThinkingLevel === thinkingLevel)) return;
     this.dispose();
-    const child = spawn4("fx", ["acp", "--model", model], {
+    const agentEnv = await this.acp.env?.(model, thinkingLevel);
+    const child = spawn4(this.acp.command, this.acp.args(model), {
       cwd: this.workingDirectory,
-      env: { ...process.env, FX_AUTO_UPGRADE: "0", NO_COLOR: "1" },
+      env: { ...process.env, NO_COLOR: "1", ...agentEnv },
       stdio: ["pipe", "pipe", "pipe"]
     });
     this.process = child;
-    child.stderr.on("data", (chunk) => console.error("[FxManager]", chunk.toString().trimEnd()));
+    child.stderr.on("data", (chunk) => console.error(`[${this.acp.provider} ACP]`, chunk.toString().trimEnd()));
     child.on("exit", (code, signal) => {
       if (this.process !== child) return;
       this.process = null;
       this.context = null;
       this.connection = null;
       if (code !== 0 && signal !== "SIGTERM") {
-        this.recordHistoryEvent("fx-error", { message: `fx ACP exited with code ${code ?? signal}` }, this.historyFile);
+        this.recordHistoryEvent("acp-error", {
+          provider: this.acp.provider,
+          message: `${this.acp.command} ACP exited with code ${code ?? signal}`
+        }, this.historyFile);
       }
     });
-    const app2 = client({ name: "Replicas" }).onNotification(methods.client.session.update, ({ params }) => this.recordUpdate(params)).onRequest(methods.client.session.requestPermission, ({ params }) => {
-      const option = params.options.find((candidate) => candidate.kind === (this.planMode ? "reject_once" : "allow_always")) ?? params.options.find((candidate) => candidate.kind === (this.planMode ? "reject_always" : "allow_once"));
+    const app2 = client({ name: "Replicas" }).onNotification(methods.client.session.update, ({ params }) => this.recordUpdate(params)).onRequest(methods.client.fs.readTextFile, async ({ params }) => {
+      this.assertSession(params.sessionId);
+      const content = await readFile11(params.path, "utf8");
+      if (params.line === void 0 && params.limit === void 0) return { content };
+      const start = Math.max(0, (params.line ?? 1) - 1);
+      const end = params.limit === null || params.limit === void 0 ? void 0 : start + params.limit;
+      return { content: content.split("\n").slice(start, end).join("\n") };
+    }).onRequest(methods.client.fs.writeTextFile, async ({ params }) => {
+      this.assertSession(params.sessionId);
+      if (this.planMode) throw new Error("ACP file writes are disabled in plan mode.");
+      await writeFile6(params.path, params.content, "utf8");
+      return {};
+    }).onRequest(methods.client.terminal.create, ({ params }) => this.createTerminal(params)).onRequest(methods.client.terminal.output, ({ params }) => {
+      this.assertSession(params.sessionId);
+      const terminal = this.getTerminal(params.terminalId);
+      return {
+        output: terminal.output.toString("utf8"),
+        truncated: terminal.truncated,
+        exitStatus: terminal.exitStatus
+      };
+    }).onRequest(methods.client.terminal.waitForExit, async ({ params }) => {
+      this.assertSession(params.sessionId);
+      return this.getTerminal(params.terminalId).exited;
+    }).onRequest(methods.client.terminal.kill, ({ params }) => {
+      this.assertSession(params.sessionId);
+      this.getTerminal(params.terminalId).process.kill("SIGTERM");
+      return {};
+    }).onRequest(methods.client.terminal.release, ({ params }) => {
+      this.assertSession(params.sessionId);
+      const terminal = this.getTerminal(params.terminalId);
+      if (terminal.exitStatus === null) terminal.process.kill("SIGTERM");
+      this.terminals.delete(params.terminalId);
+      return {};
+    }).onRequest(methods.client.session.requestPermission, ({ params }) => {
+      if (params.toolCall.title === "AskUserQuestion") return this.requestUserInput(params);
+      const preferred = this.planMode ? ["reject_once", "reject_always"] : ["allow_always", "allow_once"];
+      const option = preferred.flatMap((kind) => params.options.filter((candidate) => candidate.kind === kind))[0];
       return option ? { outcome: { outcome: "selected", optionId: option.optionId } } : { outcome: { outcome: "cancelled" } };
     });
     const stdout = new ReadableStream({
@@ -8631,26 +8683,34 @@ var FxManager = class extends CodingAgentManager {
         child.stdout.destroy();
       }
     });
-    const stream = ndJsonStream(
-      Writable.toWeb(child.stdin),
-      stdout
-    );
-    this.connection = app2.connect(stream);
+    this.connection = app2.connect(ndJsonStream(Writable.toWeb(child.stdin), stdout));
     this.context = this.connection.agent;
-    await this.context.request(methods.agent.initialize, {
+    const initialized = await this.context.request(methods.agent.initialize, {
       protocolVersion: PROTOCOL_VERSION,
-      clientCapabilities: { plan: {} },
+      clientCapabilities: {
+        fs: { readTextFile: true, writeTextFile: true },
+        terminal: true,
+        plan: {}
+      },
       clientInfo: { name: "Replicas", version: "1" }
     });
+    this.capabilities = initialized.agentCapabilities ?? {};
     const additionalDirectories = await getAgentAdditionalDirectories();
     const sessionId = this.sessionId ?? this.initialSessionId;
-    if (sessionId) {
-      await this.context.request(methods.agent.session.load, {
-        sessionId,
-        cwd: this.workingDirectory,
-        additionalDirectories,
-        mcpServers: []
-      });
+    if (sessionId && this.capabilities.loadSession) {
+      this.replaying = true;
+      try {
+        const session = await this.context.request(methods.agent.session.load, {
+          sessionId,
+          cwd: this.workingDirectory,
+          additionalDirectories,
+          mcpServers: []
+        });
+        this.configOptions = session.configOptions ?? [];
+        this.modes = session.modes ?? null;
+      } finally {
+        this.replaying = false;
+      }
       this.sessionId = sessionId;
     } else {
       const session = await this.context.request(methods.agent.session.new, {
@@ -8659,21 +8719,84 @@ var FxManager = class extends CodingAgentManager {
         mcpServers: []
       });
       this.sessionId = session.sessionId;
+      this.configOptions = session.configOptions ?? [];
+      this.modes = session.modes ?? null;
       await this.onSaveSessionId(session.sessionId);
     }
     this.activeModel = model;
+    this.activeThinkingLevel = thinkingLevel;
+  }
+  assertSession(sessionId) {
+    if (sessionId !== this.sessionId) throw new Error(`Unknown ACP session: ${sessionId}`);
+  }
+  getTerminal(terminalId) {
+    const terminal = this.terminals.get(terminalId);
+    if (!terminal) throw new Error(`Unknown ACP terminal: ${terminalId}`);
+    return terminal;
+  }
+  createTerminal(params) {
+    this.assertSession(params.sessionId);
+    if (this.planMode) throw new Error("ACP terminals are disabled in plan mode.");
+    const terminalId = randomUUID6();
+    const outputByteLimit = Math.max(1, Math.min(params.outputByteLimit ?? 1048576, 10485760));
+    const child = spawn4(params.command, params.args ?? [], {
+      cwd: params.cwd ?? this.workingDirectory,
+      env: {
+        ...process.env,
+        ...Object.fromEntries(params.env?.map(({ name, value }) => [name, value]) ?? [])
+      },
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let resolveExit;
+    const terminal = {
+      process: child,
+      output: Buffer.alloc(0),
+      outputByteLimit,
+      truncated: false,
+      exitStatus: null,
+      exited: new Promise((resolve5) => {
+        resolveExit = resolve5;
+      })
+    };
+    const append = (chunk) => {
+      terminal.output = Buffer.concat([terminal.output, chunk]);
+      if (terminal.output.length <= outputByteLimit) return;
+      let start = terminal.output.length - outputByteLimit;
+      while (start < terminal.output.length && (terminal.output[start] & 192) === 128) start += 1;
+      terminal.output = terminal.output.subarray(start);
+      terminal.truncated = true;
+    };
+    child.stdout.on("data", append);
+    child.stderr.on("data", append);
+    child.on("error", () => {
+      const status = { exitCode: null, signal: null };
+      terminal.exitStatus = status;
+      resolveExit?.(status);
+    });
+    child.on("exit", (exitCode, signal) => {
+      const status = { exitCode, signal };
+      terminal.exitStatus = status;
+      resolveExit?.(status);
+    });
+    this.terminals.set(terminalId, terminal);
+    return { terminalId };
   }
   recordUpdate(notification) {
-    if (notification.sessionId !== this.sessionId) return;
-    if (notification.update.sessionUpdate === "available_commands_update") {
-      this.slashCommands = mergeSlashCommands(notification.update.availableCommands.flatMap((command) => {
-        const parsed = createProviderSlashCommand("fx", command.name, command.description, command.input?.hint);
+    if (notification.sessionId !== this.sessionId && this.sessionId !== null) return;
+    const update = notification.update;
+    if (update.sessionUpdate === "available_commands_update") {
+      this.slashCommands = mergeSlashCommands(update.availableCommands.flatMap((command) => {
+        const parsed = createProviderSlashCommand(this.acp.provider, command.name, command.description, command.input?.hint);
         return parsed ? [parsed] : [];
       }));
-    } else if (notification.update.sessionUpdate === "usage_update") {
-      const { used, size } = notification.update;
+    } else if (update.sessionUpdate === "config_option_update") {
+      this.configOptions = update.configOptions;
+    } else if (update.sessionUpdate === "current_mode_update" && this.modes) {
+      this.modes = { ...this.modes, currentModeId: update.currentModeId };
+    } else if (update.sessionUpdate === "usage_update" && !this.replaying) {
+      const { used, size } = update;
       this.historyFile.append(this.emitContextUsage({
-        provider: "fx",
+        provider: this.acp.provider,
         source: "provider_usage",
         model: this.activeModel,
         totalTokens: used,
@@ -8683,37 +8806,155 @@ var FxManager = class extends CodingAgentManager {
         updatedAt: (/* @__PURE__ */ new Date()).toISOString()
       }));
     }
-    this.recordHistoryEvent("fx-session-update", { update: notification.update }, this.historyFile);
+    if (!this.replaying) {
+      this.recordHistoryEvent("acp-session-update", {
+        provider: this.acp.provider,
+        update
+      }, this.historyFile);
+    }
+  }
+  async setConfig(category, value) {
+    const context = this.context;
+    const sessionId = this.sessionId;
+    const option = this.configOptions.find((candidate) => candidate.category === category || candidate.id === category);
+    if (!context || !sessionId || !option) return false;
+    if (option.type === "select" && !selectOptions(option).some((candidate) => candidate.value === value)) return false;
+    if (option.currentValue === value) return true;
+    const response = typeof value === "boolean" ? await context.request(methods.agent.session.setConfigOption, {
+      sessionId,
+      configId: option.id,
+      value,
+      type: "boolean"
+    }) : await context.request(methods.agent.session.setConfigOption, {
+      sessionId,
+      configId: option.id,
+      value
+    });
+    this.configOptions = response.configOptions;
+    return true;
+  }
+  async setMode(planMode) {
+    const context = this.context;
+    const sessionId = this.sessionId;
+    if (!context || !sessionId) return;
+    const candidates = planMode ? ["plan", "ask", "architect"] : ["code", "default", "auto", "yolo"];
+    const mode = this.modes?.availableModes.find((candidate) => candidates.includes(candidate.id.toLowerCase())) ?? this.modes?.availableModes.find((candidate) => candidates.some((name) => candidate.name.toLowerCase().includes(name)));
+    if (mode) {
+      await context.request(methods.agent.session.setMode, { sessionId, modeId: mode.id });
+      if (this.modes) this.modes = { ...this.modes, currentModeId: mode.id };
+      return;
+    }
+    const option = this.configOptions.find((candidate) => candidate.category === "mode" || candidate.id === "mode");
+    if (!option || option.type !== "select") return;
+    const selected = selectOptions(option).find((candidate) => candidates.includes(candidate.value.toLowerCase())) ?? selectOptions(option).find((candidate) => candidates.some((name) => candidate.name.toLowerCase().includes(name)));
+    if (selected) await this.setConfig("mode", selected.value);
+  }
+  async setThinking(level) {
+    if (!level) return;
+    const option = this.configOptions.find((candidate) => candidate.category === "thought_level" || candidate.id === "thinking");
+    if (!option || option.type !== "select") return;
+    const values = selectOptions(option).map((candidate) => candidate.value);
+    const aliases = {
+      low: ["low", "on"],
+      medium: ["medium", "on"],
+      high: ["high", "on"],
+      xhigh: ["xhigh", "high", "on"],
+      max: ["max", "xhigh", "high", "on"],
+      ultra: ["ultra", "max", "xhigh", "high", "on"],
+      ultracode: ["max", "xhigh", "high", "on"]
+    };
+    const value = aliases[level].find((candidate) => values.includes(candidate));
+    if (value) await this.setConfig("thought_level", value);
+  }
+  async requestUserInput(params) {
+    if (!this.interactiveTools) return { outcome: { outcome: "cancelled" } };
+    const requestId = randomUUID6();
+    const toolCallId = params.toolCall.toolCallId;
+    return new Promise((resolve5) => {
+      this.pendingPermissions.set(requestId, { toolCallId, options: params.options, resolve: resolve5 });
+      this.recordHistoryEvent("acp-session-update", {
+        provider: this.acp.provider,
+        update: { ...params.toolCall, sessionUpdate: "tool_call", status: "pending" }
+      }, this.historyFile);
+      this.recordHistoryEvent("replicas-tool-input-request", {
+        requestId,
+        toolUseId: toolCallId,
+        toolName: params.toolCall.title,
+        options: params.options.map((option) => ({
+          id: option.optionId,
+          label: option.name,
+          variant: option.kind.startsWith("reject") ? "secondary" : "primary"
+        })),
+        parent_tool_use_id: null
+      }, this.historyFile);
+    });
+  }
+  async respondToToolInput(requestId, selectionId) {
+    const pending = this.pendingPermissions.get(requestId);
+    if (!pending) return false;
+    const option = pending.options.find((candidate) => candidate.optionId === selectionId);
+    if (!option) return false;
+    this.pendingPermissions.delete(requestId);
+    pending.resolve({ outcome: { outcome: "selected", optionId: selectionId } });
+    this.recordHistoryEvent("replicas-tool-input-resolved", {
+      requestId,
+      toolUseId: pending.toolCallId,
+      toolName: "AskUserQuestion",
+      selectionId,
+      selectionSummary: option.name,
+      parent_tool_use_id: null
+    }, this.historyFile);
+    return true;
+  }
+  isAwaitingInput() {
+    return this.pendingPermissions.size > 0;
+  }
+  abortPendingPermissions() {
+    for (const [requestId, pending] of this.pendingPermissions) {
+      pending.resolve({ outcome: { outcome: "cancelled" } });
+      this.recordHistoryEvent("replicas-tool-input-resolved", {
+        requestId,
+        toolUseId: pending.toolCallId,
+        toolName: "AskUserQuestion",
+        selectionId: "aborted",
+        parent_tool_use_id: null
+      }, this.historyFile);
+    }
+    this.pendingPermissions.clear();
   }
   async processMessageInternal(request) {
     try {
-      if (request.images?.length) throw new Error("fx does not support image prompts over ACP yet.");
-      const model = request.model ?? DEFAULT_FX_MODEL;
-      await this.start(model);
+      const model = request.model ?? this.acp.defaultModel;
+      await this.start(model, request.thinkingLevel);
       const context = this.context;
       const sessionId = this.sessionId;
-      if (!context || !sessionId) throw new Error("fx ACP failed to initialize.");
+      if (!context || !sessionId) throw new Error(`${this.acp.command} ACP failed to initialize.`);
       this.recordHistoryEvent("event_msg", { type: "user_message", message: request.message }, this.historyFile);
       this.planMode = request.planMode ?? false;
-      await context.request(methods.agent.session.setMode, {
-        sessionId,
-        modeId: this.planMode ? "ask" : "code"
-      });
-      await context.request(methods.agent.session.prompt, {
-        sessionId,
-        prompt: [{
-          type: "text",
-          text: this.planMode ? `Plan the requested work without modifying files or executing mutating commands. Return a clear implementation plan only.
-
-${request.message}` : request.message
-        }]
-      });
-      this.recordHistoryEvent("fx-turn-complete", {}, this.historyFile);
+      this.interactiveTools = request.enableInteractiveTools ?? false;
+      await this.setConfig("model", model);
+      await this.setThinking(request.thinkingLevel);
+      await this.setMode(this.planMode);
+      const prompt = [{ type: "text", text: request.message }];
+      for (const image of request.images ?? []) {
+        if (!this.capabilities.promptCapabilities?.image) throw new Error(`${this.acp.provider} does not advertise ACP image support.`);
+        if (image.source.type !== "base64") throw new Error(`${this.acp.provider} requires uploaded images to be base64 encoded.`);
+        prompt.push({ type: "image", mimeType: image.source.media_type, data: image.source.data });
+      }
+      const response = await context.request(methods.agent.session.prompt, { sessionId, prompt });
+      this.recordHistoryEvent("acp-turn-complete", {
+        provider: this.acp.provider,
+        stopReason: response.stopReason
+      }, this.historyFile);
     } catch (error) {
-      this.recordHistoryEvent("fx-error", { message: error instanceof Error ? error.message : String(error) }, this.historyFile);
+      this.recordHistoryEvent("acp-error", {
+        provider: this.acp.provider,
+        message: error instanceof Error ? error.message : String(error)
+      }, this.historyFile);
       throw error;
     } finally {
       this.planMode = false;
+      this.interactiveTools = false;
       try {
         await this.historyFile.flush();
       } finally {
@@ -8723,8 +8964,17 @@ ${request.message}` : request.message
   }
   async interruptActiveTurn() {
     if (!this.context || !this.sessionId) return;
+    this.abortPendingPermissions();
     await this.context.notify(methods.agent.session.cancel, { sessionId: this.sessionId });
   }
+  keepSteeredMessageQueued() {
+    return true;
+  }
+  async steerRequest() {
+    if (!this.isProcessing() || !this.context || !this.sessionId) return false;
+    await this.interruptActiveTurn();
+    return true;
+  }
   async getHistory(page = {}) {
     await this.historyFile.flush();
     return {
@@ -8738,20 +8988,105 @@ ${request.message}` : request.message
     return this.slashCommands;
   }
   dispose() {
+    for (const terminal of this.terminals.values()) {
+      if (terminal.exitStatus === null) terminal.process.kill("SIGTERM");
+    }
+    this.terminals.clear();
     this.connection?.close();
     this.process?.kill("SIGTERM");
     this.connection = null;
     this.context = null;
     this.process = null;
     this.activeModel = null;
+    this.activeThinkingLevel = void 0;
+    this.configOptions = [];
+    this.modes = null;
+    this.capabilities = {};
     this.planMode = false;
+    this.interactiveTools = false;
+    this.abortPendingPermissions();
+  }
+};
+
+// src/managers/fx-manager.ts
+async function ensureResolvableDnsConfig() {
+  const contents = await readFile12("/etc/resolv.conf");
+  if (contents.length === 0 || contents.at(-1) === 10) return;
+  await new Promise((resolve5, reject) => {
+    const child = spawn5("sudo", ["tee", "-a", "/etc/resolv.conf"], { stdio: ["pipe", "ignore", "pipe"] });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.on("error", reject);
+    child.on("exit", (code) => code === 0 ? resolve5() : reject(new Error(`Failed to normalize /etc/resolv.conf: ${stderr.trim()}`)));
+    child.stdin.end("\n");
+  });
+}
+var FxManager = class extends AcpManager {
+  constructor(options) {
+    super({
+      ...options,
+      acp: {
+        provider: "fx",
+        command: "fx",
+        args: (model) => ["acp", "--model", model],
+        env: () => ({ FX_AUTO_UPGRADE: "0", AI_GATEWAY_API_KEY: ENGINE_ENV.AI_GATEWAY_API_KEY }),
+        defaultModel: DEFAULT_FX_MODEL,
+        prepare: ensureResolvableDnsConfig
+      }
+    });
+  }
+};
+
+// src/managers/kimi-manager.ts
+var KimiManager = class extends AcpManager {
+  constructor(options) {
+    super({
+      ...options,
+      acp: {
+        provider: "kimi",
+        command: "kimi",
+        args: () => ["acp"],
+        env: async (model, thinkingLevel) => {
+          let contextSize = "262144";
+          let capabilities = model.startsWith("moonshotai/kimi") ? "image_in,thinking,tool_use" : "tool_use";
+          try {
+            const entry = (await fetchAiGatewayModels()).find((candidate) => candidate.id === model);
+            if (entry) {
+              if (entry.contextWindow) contextSize = String(entry.contextWindow);
+              capabilities = [
+                entry.tags.includes("vision") ? "image_in" : null,
+                entry.tags.includes("reasoning") ? "thinking" : null,
+                entry.tags.includes("tool-use") ? "tool_use" : null
+              ].filter((value) => value !== null).join(",") || capabilities;
+            }
+          } catch {
+          }
+          return {
+            KIMI_DISABLE_TELEMETRY: "1",
+            KIMI_MODEL_NAME: model,
+            KIMI_MODEL_API_KEY: ENGINE_ENV.AI_GATEWAY_API_KEY,
+            KIMI_MODEL_PROVIDER_TYPE: "openai",
+            KIMI_MODEL_BASE_URL: AI_GATEWAY_BASE_URL,
+            KIMI_MODEL_MAX_CONTEXT_SIZE: contextSize,
+            KIMI_MODEL_CAPABILITIES: capabilities,
+            ...thinkingLevel ? {
+              KIMI_MODEL_THINKING_EFFORT: ["low", "medium", "high"].includes(thinkingLevel) ? thinkingLevel : "high"
+            } : {}
+          };
+        },
+        defaultModel: DEFAULT_KIMI_MODEL,
+        restartOnThinkingChange: true
+      }
+    });
   }
 };
 
 // src/managers/opencode-manager.ts
 import { existsSync as existsSync7 } from "fs";
-import { mkdir as mkdir14, readFile as readFile12 } from "fs/promises";
-import { delimiter, dirname as dirname8, join as join23 } from "path";
+import { mkdir as mkdir14, readFile as readFile13 } from "fs/promises";
+import { delimiter, dirname as dirname8, join as join22 } from "path";
 import { randomBytes as randomBytes2 } from "crypto";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { Agent } from "undici";
@@ -8798,7 +9133,7 @@ async function getAllowedOpenRouterModels() {
 
 // src/managers/opencode-manager.ts
 var OPENCODE_SHIM_DIR = dirname8(fileURLToPath2(new URL("../../scripts/opencode", import.meta.url)));
-var OPENCODE_CONFIG_PATH = join23(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
+var OPENCODE_CONFIG_PATH = join22(ENGINE_ENV.HOME_DIR, ".config", "opencode", "opencode.json");
 var OPENCODE_FETCH_DISPATCHER = new Agent({ headersTimeout: 0, bodyTimeout: 0 });
 var OPENCODE_SERVER_STARTUP_TIMEOUT_MS = 3e4;
 var OPENCODE_WORKSPACE_PERMISSION = {
@@ -8835,7 +9170,7 @@ var opencodeAuthSchema = z4.record(z4.string(), z4.object({
 async function hasOpencodeCredentials(provider) {
   if (!existsSync7(OPENCODE_AUTH_PATH)) return false;
   try {
-    const auth = opencodeAuthSchema.safeParse(JSON.parse(await readFile12(OPENCODE_AUTH_PATH, "utf8")));
+    const auth = opencodeAuthSchema.safeParse(JSON.parse(await readFile13(OPENCODE_AUTH_PATH, "utf8")));
     return auth.success && auth.data[provider]?.type === "api" && Boolean(auth.data[provider]?.key);
   } catch {
     return false;
@@ -8940,7 +9275,7 @@ function isOpencodeMcpEntry(value) {
 async function readProvisionedOpencodeMcpConfig() {
   let raw;
   try {
-    raw = await readFile12(OPENCODE_CONFIG_PATH, "utf8");
+    raw = await readFile13(OPENCODE_CONFIG_PATH, "utf8");
   } catch (error) {
     if (isRecord2(error) && error.code === "ENOENT") return void 0;
     console.error("[OpencodeManager] Failed to read Opencode config:", error);
@@ -9048,7 +9383,7 @@ var OpencodeManager = class extends CodingAgentManager {
   constructor(options) {
     super(options);
     this.sessionId = options.initialSessionId;
-    this.historyFilePath = options.historyFilePath ?? join23(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
+    this.historyFilePath = options.historyFilePath ?? join22(ENGINE_ENV.HOME_DIR, ".replicas", "opencode", "history.jsonl");
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
@@ -9558,7 +9893,7 @@ var OpencodeManager = class extends CodingAgentManager {
 
 // src/managers/pi-manager.ts
 import { mkdir as mkdir15 } from "fs/promises";
-import { dirname as dirname9, join as join24 } from "path";
+import { dirname as dirname9, join as join23 } from "path";
 import {
   AuthStorage,
   createAgentSession,
@@ -9641,7 +9976,7 @@ var PiManager = class extends CodingAgentManager {
   providerApiKey = null;
   constructor(options) {
     super(options);
-    this.historyFilePath = options.historyFilePath ?? join24(PI_HISTORY_DIR, `${Date.now()}.jsonl`);
+    this.historyFilePath = options.historyFilePath ?? join23(PI_HISTORY_DIR, `${Date.now()}.jsonl`);
     this.historyFile = new CodexHistoryFile(this.historyFilePath);
     this.initializeManager(this.processMessageInternal.bind(this));
   }
@@ -9741,7 +10076,7 @@ var PiManager = class extends CodingAgentManager {
     const sessionManager = this.initialSessionId ? SessionManager.open(this.initialSessionId, PI_HISTORY_DIR, this.workingDirectory) : SessionManager.create(this.workingDirectory, PI_HISTORY_DIR);
     const resourceLoader = new DefaultResourceLoader({
       cwd: this.workingDirectory,
-      agentDir: join24(ENGINE_ENV.HOME_DIR, ".pi", "agent"),
+      agentDir: join23(ENGINE_ENV.HOME_DIR, ".pi", "agent"),
       extensionFactories: [registerCommandProtection(
         this.workingDirectory,
         this.historyFile,
@@ -9818,6 +10153,7 @@ function getAvailableRelayProviders(availability) {
   const cursorAvailable = availability.cursorAvailable ?? false;
   const deepseekAvailable = availability.deepseekAvailable ?? false;
   const fxAvailable = availability.fxAvailable ?? false;
+  const kimiAvailable = availability.kimiAvailable ?? false;
   const opencodeAvailable = availability.opencodeAvailable ?? false;
   const piAvailable = availability.piAvailable ?? false;
   const providers = ["claude"];
@@ -9825,6 +10161,7 @@ function getAvailableRelayProviders(availability) {
   if (cursorAvailable) providers.push("cursor");
   if (deepseekAvailable) providers.push("deepseek");
   if (fxAvailable) providers.push("fx");
+  if (kimiAvailable) providers.push("kimi");
   if (opencodeAvailable) providers.push("opencode");
   if (piAvailable) providers.push("pi");
   providers.push("relay");
@@ -9914,7 +10251,7 @@ function extractFinalResponse(history) {
       const text = getDeepseekAssistantMessageText(payload.event, "text");
       if (text) return text;
     }
-    if (event.type === "fx-session-update") {
+    if (event.type === "fx-session-update" || event.type === "acp-session-update") {
       const text = getFxTextChunk(payload.update, "agent_message_chunk");
       if (text) return text;
     }
@@ -9957,11 +10294,12 @@ You will also receive the chatId so you can send follow-up messages or clean up
         `Cursor: ${AGENT_MODELS.cursor.join(", ")}.`,
         `DeepSeek Harness: ${AGENT_MODELS.deepseek.join(", ")}.`,
         `fx: ${AGENT_MODELS.fx.join(", ")}.`,
+        `Kimi Code: ${AGENT_MODELS.kimi.join(", ")}.`,
         `Opencode: ${AGENT_MODELS.opencode.join(", ")}.`,
         `Pi: ${AGENT_MODELS.pi.join(", ")}.`
       ].join(" ")),
       thinking_level: z5.enum(VALID_THINKING_LEVELS).optional().describe(
-        "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high; Codex, Cursor, DeepSeek Harness, fx, Opencode, and Pi = medium."
+        "Controls how much thinking/reasoning the subagent applies. low = light thinking, medium = moderate, high = deep reasoning, xhigh = extended effort, max = maximum effort, ultra = Codex ultra, ultracode = Claude Code dynamic workflows. Defaults: Claude = high; Codex, Cursor, DeepSeek Harness, fx, Kimi Code, Opencode, and Pi = medium."
       ),
       title: z5.string().optional().describe("Optional title for the subagent chat (for identification)."),
       timeout_minutes: z5.number().positive().optional().describe("Timeout in minutes for the subagent to complete (default: 10). Set higher for large tasks to avoid losing work.")
@@ -10213,14 +10551,15 @@ function getUsingToolsSection() {
   ];
   return [`# Using your tools`, ...prependBullets(items)].join("\n");
 }
-function getDelegationSection(codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, opencodeAvailable, piAvailable) {
-  const providerList = getAvailableRelayProviders({ codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, opencodeAvailable, piAvailable }).join(", ");
+function getDelegationSection(codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, kimiAvailable, opencodeAvailable, piAvailable) {
+  const providerList = getAvailableRelayProviders({ codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, kimiAvailable, opencodeAvailable, piAvailable }).join(", ");
   const spawnDesc = `Create a new subagent with a specific provider (${providerList}), send it a prompt, and wait for its response. Returns the chatId and the agent's final response. You can set a custom timeout via the timeout_minutes parameter (default: 10 minutes).`;
   const claudeModelList = AGENT_MODELS.claude.join(", ");
   const extraAgentLines = [
     codexAvailable ? `Use provider 'codex' for heavy code writing, implementation, and large refactors. Suggested models: ${AGENT_MODELS.codex.join(", ")} (${AGENT_MODELS.codex[0]} is the default).` : null,
     deepseekAvailable ? `Use provider 'deepseek' for tasks that benefit from the DeepSeek Harness tool loop. Suggested models: ${AGENT_MODELS.deepseek.join(", ")}.` : null,
     fxAvailable ? `Use provider 'fx' for tasks that benefit from fx's minimal native coding loop. Suggested models: ${AGENT_MODELS.fx.join(", ")}.` : null,
+    kimiAvailable ? `Use provider 'kimi' for tasks that benefit from Kimi Code's ACP coding loop. Suggested models: ${AGENT_MODELS.kimi.join(", ")}.` : null,
     opencodeAvailable ? `Use provider 'opencode' for cheaper routine implementation tasks through OpenRouter-backed open source models. Suggested models: ${AGENT_MODELS.opencode.join(", ")}.` : null,
     piAvailable ? `Use provider 'pi' for coding tasks through Pi's OpenRouter-backed coding agent. Suggested models: ${AGENT_MODELS.pi.join(", ")}.` : null,
     cursorAvailable ? `Use provider 'cursor' for fast iteration on code changes. Suggested models: ${AGENT_MODELS.cursor.join(", ")}.` : null
@@ -10345,14 +10684,14 @@ function getEnvironmentSection() {
   ].join("\n");
 }
 function buildRelaySystemPrompt(options) {
-  const { customInstructions, codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, opencodeAvailable, piAvailable } = options ?? {};
+  const { customInstructions, codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, kimiAvailable, opencodeAvailable, piAvailable } = options ?? {};
   const sections = [
     getIntroSection(),
     getSystemSection(),
     getDoingTasksSection(),
     getActionsSection(),
     getUsingToolsSection(),
-    getDelegationSection(codexAvailable ?? false, cursorAvailable ?? false, deepseekAvailable ?? false, fxAvailable ?? false, opencodeAvailable ?? false, piAvailable ?? false),
+    getDelegationSection(codexAvailable ?? false, cursorAvailable ?? false, deepseekAvailable ?? false, fxAvailable ?? false, kimiAvailable ?? false, opencodeAvailable ?? false, piAvailable ?? false),
     getToneAndStyleSection(),
     getOutputEfficiencySection(),
     getEnvironmentSection(),
@@ -10386,9 +10725,10 @@ var RelayManager = class {
     const cursorAvailable = options.cursorAvailable ?? false;
     const deepseekAvailable = options.deepseekAvailable ?? false;
     const fxAvailable = options.fxAvailable ?? false;
+    const kimiAvailable = options.kimiAvailable ?? false;
     const opencodeAvailable = options.opencodeAvailable ?? false;
     const piAvailable = options.piAvailable ?? false;
-    const availability = { codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, opencodeAvailable, piAvailable };
+    const availability = { codexAvailable, cursorAvailable, deepseekAvailable, fxAvailable, kimiAvailable, opencodeAvailable, piAvailable };
     const getProviderAvailability = options.getProviderAvailability ?? (() => availability);
     this.inner = new ClaudeManager({
       ...options,
@@ -10453,16 +10793,16 @@ var RelayManager = class {
 import {
   appendFile as appendFile3,
   mkdir as mkdir16,
-  readFile as readFile13,
+  readFile as readFile14,
   readdir as readdir6,
   rename as rename2,
   unlink as unlink3
 } from "fs/promises";
-import { join as join25 } from "path";
-import { randomUUID as randomUUID6 } from "crypto";
+import { join as join24 } from "path";
+import { randomUUID as randomUUID7 } from "crypto";
 
 // src/analytics/agent/activity/skill-mcp-call-extractor.ts
-var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "deepseek", "fx", "opencode", "pi", "custom", "dynamic"]);
+var NON_MCP_SERVERS = /* @__PURE__ */ new Set(["claude", "cursor", "deepseek", "fx", "kimi", "opencode", "pi", "custom", "dynamic"]);
 function mcpNameFromToolCall(message) {
   const parsedName = parseMcpToolName(message.tool);
   if (parsedName) return parsedName.server;
@@ -10509,7 +10849,7 @@ var AgentChatActivityBuffer = class {
       options.storageName,
       ...options.legacyStorageNames ?? []
     ];
-    this.liveFile = join25(ENGINE_DIR2, `${options.storageName}.jsonl`);
+    this.liveFile = join24(ENGINE_DIR2, `${options.storageName}.jsonl`);
     this.segmentFilePatterns = this.storageNames.map(
       (storageName) => new RegExp(`^${storageName}\\.(\\d+)\\.jsonl$`)
     );
@@ -10568,8 +10908,8 @@ var AgentChatActivityBuffer = class {
       await Promise.allSettled([...this.pendingAppends]);
     for (const storageName of this.storageNames) {
       await rename2(
-        join25(ENGINE_DIR2, `${storageName}.jsonl`),
-        join25(ENGINE_DIR2, `${storageName}.${Date.now()}.jsonl`)
+        join24(ENGINE_DIR2, `${storageName}.jsonl`),
+        join24(ENGINE_DIR2, `${storageName}.${Date.now()}.jsonl`)
       ).catch(() => {
       });
     }
@@ -10580,7 +10920,7 @@ var AgentChatActivityBuffer = class {
       if (!this.segmentFilePatterns.some((pattern) => pattern.test(entry)))
         continue;
       try {
-        await this.uploadSegment(join25(ENGINE_DIR2, entry));
+        await this.uploadSegment(join24(ENGINE_DIR2, entry));
         flushed++;
       } catch (error) {
         failed++;
@@ -10612,13 +10952,13 @@ var AgentChatActivityBuffer = class {
       ) && entry.endsWith(UPLOADED_SUFFIX)
     ).sort();
     for (const entry of uploaded.slice(0, -MAX_UPLOADED_SEGMENTS)) {
-      await unlink3(join25(ENGINE_DIR2, entry)).catch(() => {
+      await unlink3(join24(ENGINE_DIR2, entry)).catch(() => {
       });
     }
     return { flushed, failed };
   }
   async uploadSegment(filePath) {
-    const records = (await readFile13(filePath, "utf-8")).split("\n").flatMap((line) => {
+    const records = (await readFile14(filePath, "utf-8")).split("\n").flatMap((line) => {
       try {
         const parsed = JSON.parse(line);
         return this.options.validate(parsed) ? [parsed] : [];
@@ -10680,7 +11020,7 @@ var AgentChatTurnActivityTracker = class {
     const credential = ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[provider];
     this.pendingMessages.delete(messageId);
     this.activeTurns.set(chatId, {
-      turnId: randomUUID6(),
+      turnId: randomUUID7(),
       startedAtMs: Date.now(),
       provider,
       model: attributes.model ?? getDefaultAgentModel(provider),
@@ -10843,19 +11183,19 @@ var KeepAliveService = class _KeepAliveService {
 var keepAliveService = new KeepAliveService();
 
 // src/services/canvas-service.ts
-import { readdir as readdir7, readFile as readFile14, stat as stat3 } from "fs/promises";
+import { readdir as readdir7, readFile as readFile15, stat as stat3 } from "fs/promises";
 import { homedir as homedir14 } from "os";
-import { join as join26 } from "path";
+import { join as join25 } from "path";
 var GLOBAL_CANVAS_DIRECTORIES = [
-  join26(homedir14(), ".claude", "plans"),
-  join26(process.env.XDG_DATA_HOME ?? join26(homedir14(), ".local", "share"), "opencode", "plans"),
-  join26(homedir14(), ".replicas", "canvas")
+  join25(homedir14(), ".claude", "plans"),
+  join25(process.env.XDG_DATA_HOME ?? join25(homedir14(), ".local", "share"), "opencode", "plans"),
+  join25(homedir14(), ".replicas", "canvas")
 ];
 async function canvasDirectories() {
   const repositories = await gitService.listRepositories().catch(() => []);
   return [
     ...GLOBAL_CANVAS_DIRECTORIES,
-    ...repositories.map((repository) => join26(repository.path, ".opencode", "plans"))
+    ...repositories.map((repository) => join25(repository.path, ".opencode", "plans"))
   ];
 }
 var CanvasService = class {
@@ -10879,7 +11219,7 @@ var CanvasService = class {
         for (const entry of entries) {
           if (entry.name.startsWith(".")) continue;
           const filename = current.relativePath ? `${current.relativePath}/${entry.name}` : entry.name;
-          const filePath = join26(current.directory, entry.name);
+          const filePath = join25(current.directory, entry.name);
           if (entry.isDirectory()) {
             pending.push({ directory: filePath, relativePath: filename });
             continue;
@@ -10904,7 +11244,7 @@ var CanvasService = class {
     if (!safe) return null;
     const { kind, mimeType } = classifyCanvasFilename(safe);
     for (const directory of await this.directories()) {
-      const filePath = join26(directory, safe);
+      const filePath = join25(directory, safe);
       let sizeBytes = 0;
       let updatedAt = "";
       try {
@@ -10925,7 +11265,7 @@ var CanvasService = class {
         };
       }
       try {
-        const bytes = await readFile14(filePath);
+        const bytes = await readFile15(filePath);
         return { filename: safe, kind, sizeBytes, mimeType, updatedAt, bytes };
       } catch {
         continue;
@@ -11075,14 +11415,14 @@ async function reconcileCanvasItems(filenames) {
 // src/services/upload-chat-transcripts.ts
 import { createReadStream } from "fs";
 import { createHash as createHash2 } from "crypto";
-import { readFile as readFile15, readdir as readdir8, stat as stat4 } from "fs/promises";
-import { basename as basename2, join as join28 } from "path";
+import { readFile as readFile16, readdir as readdir8, stat as stat4 } from "fs/promises";
+import { basename as basename2, join as join27 } from "path";
 
 // src/services/chat/chat-senders.ts
-import { join as join27 } from "path";
-var CHAT_SENDERS_DIR = join27(ENGINE_DIR2, "chat-senders");
+import { join as join26 } from "path";
+var CHAT_SENDERS_DIR = join26(ENGINE_DIR2, "chat-senders");
 function chatMessageSendersFilePath(chatId) {
-  return join27(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
+  return join26(CHAT_SENDERS_DIR, `${chatId}.jsonl`);
 }
 function parseChatMessageSendersJsonl(content) {
   return content.split("\n").flatMap((line) => {
@@ -11098,9 +11438,9 @@ function parseChatMessageSendersJsonl(content) {
 
 // src/services/upload-chat-transcripts.ts
 var HISTORY_DIRS = [
-  join28(ENGINE_DIR2, "claude-histories"),
-  join28(ENGINE_DIR2, "relay-histories"),
-  join28(ENGINE_DIR2, "codex-histories")
+  join27(ENGINE_DIR2, "claude-histories"),
+  join27(ENGINE_DIR2, "relay-histories"),
+  join27(ENGINE_DIR2, "codex-histories")
 ];
 async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), capture) {
   let flushed = 0;
@@ -11118,7 +11458,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
       if (!entry.endsWith(".jsonl")) continue;
       const chatId = basename2(entry, ".jsonl");
       tasks.push(
-        uploadChatTranscript(chatId, join28(dir, entry), chatsById.get(chatId), capture).then((artifact) => {
+        uploadChatTranscript(chatId, join27(dir, entry), chatsById.get(chatId), capture).then((artifact) => {
           flushed++;
           if (artifact && capture) revisions.push(artifact);
         }).catch((err) => {
@@ -11134,7 +11474,7 @@ async function flushAllChatTranscripts(chatsById = /* @__PURE__ */ new Map(), ca
 async function uploadChatTranscript(chatId, filePath, chat, capture) {
   const { size } = await stat4(filePath);
   if (size === 0) return null;
-  const historyPages = createChatTranscriptPages(await readFile15(filePath));
+  const historyPages = createChatTranscriptPages(await readFile16(filePath));
   const metadata = chat ? {
     provider: chat.provider,
     credential: ENGINE_ENV.REPLICAS_AGENT_CREDENTIALS[chat.provider],
@@ -11153,7 +11493,7 @@ async function uploadChatTranscript(chatId, filePath, chat, capture) {
   }
   try {
     metadata.senders = parseChatMessageSendersJsonl(
-      await readFile15(chatMessageSendersFilePath(chatId), "utf-8")
+      await readFile16(chatMessageSendersFilePath(chatId), "utf-8")
     );
   } catch (error) {
     if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) throw error;
@@ -11236,7 +11576,7 @@ async function flushRepoState() {
 // src/services/upload-engine-logs.ts
 import { createReadStream as createReadStream2 } from "fs";
 import { readdir as readdir9, stat as stat5 } from "fs/promises";
-import { join as join29 } from "path";
+import { join as join28 } from "path";
 var MAX_ENGINE_LOG_FLUSH_SESSIONS = 10;
 var MAX_ENGINE_LOG_FLUSH_BYTES = 5 * 1024 * 1024;
 var ENGINE_LOG_FLUSH_TIMEOUT_MS = 2e4;
@@ -11265,7 +11605,7 @@ async function flushAllEngineLogs() {
   const candidates = (await Promise.all(filenames.slice(0, MAX_ENGINE_LOG_FLUSH_SESSIONS).map(async (filename) => {
     try {
       const sessionId = filename.slice(0, -".log".length);
-      const filePath = join29(LOG_DIR, filename);
+      const filePath = join28(LOG_DIR, filename);
       const fileStat = await runBeforeDeadline(() => stat5(filePath), deadline);
       if (!fileStat.isFile()) {
         skipped++;
@@ -11361,7 +11701,7 @@ async function uploadEngineLog(input, timeoutMs) {
 }
 
 // src/services/chat/chat-service.ts
-var CODEX_AUTH_PATH2 = join30(homedir15(), ".codex", "auth.json");
+var CODEX_AUTH_PATH2 = join29(homedir15(), ".codex", "auth.json");
 var CHATS_BACKUP_FILE = `${CHATS_FILE}.bak`;
 function isCodexAvailable() {
   return existsSync8(CODEX_AUTH_PATH2) || Boolean(ENGINE_ENV.OPENAI_API_KEY);
@@ -11375,6 +11715,9 @@ function isDeepseekAvailable() {
 function isFxAvailable() {
   return Boolean(ENGINE_ENV.AI_GATEWAY_API_KEY);
 }
+function isKimiAvailable() {
+  return Boolean(ENGINE_ENV.AI_GATEWAY_API_KEY);
+}
 function isPiAvailable() {
   return existsSync8(PI_AUTH_PATH);
 }
@@ -11567,7 +11910,7 @@ var ChatService = class {
       throw new ChatNotFoundError(parentChatId);
     }
     const persisted = {
-      id: request.id ?? randomUUID7(),
+      id: request.id ?? randomUUID8(),
       provider: request.provider,
       title,
       createdAt: now,
@@ -11658,7 +12001,7 @@ var ChatService = class {
     }
   }
   async readSenders(chatId) {
-    return readFile16(chatMessageSendersFilePath(chatId), "utf-8").then(parseChatMessageSendersJsonl).catch((error) => {
+    return readFile17(chatMessageSendersFilePath(chatId), "utf-8").then(parseChatMessageSendersJsonl).catch((error) => {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") return [];
       console.error("[ChatService] Failed to read sender records:", error);
       return [];
@@ -11884,7 +12227,7 @@ var ChatService = class {
     return descendants;
   }
   async deleteHistoryFile(persisted) {
-    const historyPath = join30(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
+    const historyPath = join29(HISTORY_DIR_BY_PROVIDER[persisted.provider], `${persisted.id}.jsonl`);
     await Promise.all([
       historyPath,
       `${historyPath}.pages.jsonl`,
@@ -12007,7 +12350,7 @@ var ChatService = class {
     if (persisted.provider === "claude") {
       provider = new ClaudeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(CLAUDE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12021,11 +12364,12 @@ var ChatService = class {
         piAvailable: isPiAvailable(),
         cursorAvailable: isCursorAvailable(),
         deepseekAvailable: isDeepseekAvailable(),
-        fxAvailable: isFxAvailable()
+        fxAvailable: isFxAvailable(),
+        kimiAvailable: isKimiAvailable()
       });
       provider = new RelayManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(RELAY_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12038,7 +12382,7 @@ var ChatService = class {
     } else if (persisted.provider === "cursor") {
       provider = new CursorManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(CURSOR_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(CURSOR_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12048,7 +12392,7 @@ var ChatService = class {
     } else if (persisted.provider === "deepseek") {
       provider = new DeepseekManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(DEEPSEEK_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(DEEPSEEK_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12058,7 +12402,17 @@ var ChatService = class {
     } else if (persisted.provider === "fx") {
       provider = new FxManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(FX_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(FX_HISTORY_DIR, `${persisted.id}.jsonl`),
+        initialSessionId: persisted.providerSessionId,
+        onSaveSessionId: saveSession,
+        onTurnComplete: onProviderTurnComplete,
+        onEvent: onProviderEvent,
+        onProcessingChanged
+      });
+    } else if (persisted.provider === "kimi") {
+      provider = new KimiManager({
+        workingDirectory: this.workingDirectory,
+        historyFilePath: join29(KIMI_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12068,7 +12422,7 @@ var ChatService = class {
     } else if (persisted.provider === "opencode") {
       provider = new OpencodeManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(OPENCODE_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(OPENCODE_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12078,7 +12432,7 @@ var ChatService = class {
     } else if (persisted.provider === "pi") {
       provider = new PiManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(PI_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(PI_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12088,7 +12442,7 @@ var ChatService = class {
     } else {
       provider = new CodexAspManager({
         workingDirectory: this.workingDirectory,
-        historyFilePath: join30(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
+        historyFilePath: join29(CODEX_HISTORY_DIR, `${persisted.id}.jsonl`),
         initialSessionId: persisted.providerSessionId,
         onSaveSessionId: saveSession,
         onTurnComplete: onProviderTurnComplete,
@@ -12253,7 +12607,7 @@ var ChatService = class {
     });
     uploadChatTranscript(
       chatId,
-      join30(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
+      join29(HISTORY_DIR_BY_PROVIDER[chat.persisted.provider], `${chatId}.jsonl`),
       this.toSummary(chat)
     ).catch((err) => {
       console.error("[ChatService] Failed to upload chat transcript:", { chatId, err });
@@ -12269,7 +12623,7 @@ var ChatService = class {
   }
   async loadChats() {
     try {
-      const content = await readFile16(CHATS_FILE, "utf-8");
+      const content = await readFile17(CHATS_FILE, "utf-8");
       return parsePersistedChatsContent(content);
     } catch (error) {
       if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
@@ -12284,7 +12638,7 @@ var ChatService = class {
         console.error("[ChatService] Failed to quarantine corrupt chats file:", renameError);
       }
       try {
-        const backupContent = await readFile16(CHATS_BACKUP_FILE, "utf-8");
+        const backupContent = await readFile17(CHATS_BACKUP_FILE, "utf-8");
         return parsePersistedChatsContent(backupContent);
       } catch (backupError) {
         if (backupError && typeof backupError === "object" && "code" in backupError && backupError.code === "ENOENT") {
@@ -12323,7 +12677,7 @@ var ChatService = class {
   }
   async publish(input) {
     const event = {
-      id: randomUUID7(),
+      id: randomUUID8(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       ...input
     };
@@ -12390,8 +12744,8 @@ var ChatService = class {
 
 // src/services/repo-file-service.ts
 import { execFile } from "child_process";
-import { readFile as readFile17, realpath, stat as stat6 } from "fs/promises";
-import { join as join31, resolve as resolve2, extname as extname2 } from "path";
+import { readFile as readFile18, realpath, stat as stat6 } from "fs/promises";
+import { join as join30, resolve as resolve2, extname as extname2 } from "path";
 var CACHE_TTL_MS = 3e4;
 var SEARCH_TIMEOUT_MS = 15e3;
 var MAX_CONTENT_BYTES = 256 * 1024;
@@ -12543,7 +12897,7 @@ var RepoFileService = class {
     const repo = repos.find((r) => r.name === repoName);
     if (!repo) return null;
     try {
-      const fullPath = await realpath(resolve2(join31(repo.path, filePath)));
+      const fullPath = await realpath(resolve2(join30(repo.path, filePath)));
       const repoRoot = await realpath(repo.path);
       const repoPrefix = repoRoot.endsWith("/") ? repoRoot : repoRoot + "/";
       if (!fullPath.startsWith(repoPrefix) && fullPath !== repoRoot) return null;
@@ -12574,7 +12928,7 @@ var RepoFileService = class {
             sizeBytes,
             binary: true,
             tooLarge: false,
-            base64: (await readFile17(fullPath)).toString("base64"),
+            base64: (await readFile18(fullPath)).toString("base64"),
             mimeType
           };
         }
@@ -12599,7 +12953,7 @@ var RepoFileService = class {
           tooLarge: true
         };
       }
-      const content = await readFile17(fullPath, "utf-8");
+      const content = await readFile18(fullPath, "utf-8");
       return {
         repoName,
         path: filePath,
@@ -12677,21 +13031,21 @@ var RepoFileService = class {
 // src/v1-routes.ts
 import { Hono } from "hono";
 import { z as z6 } from "zod";
-import { readdir as readdir11, stat as stat7, readFile as readFile20 } from "fs/promises";
-import { join as join34, resolve as resolve3 } from "path";
+import { readdir as readdir11, stat as stat7, readFile as readFile21 } from "fs/promises";
+import { join as join33, resolve as resolve3 } from "path";
 
 // src/services/warm-hooks-service.ts
-import { spawn as spawn5 } from "child_process";
-import { readFile as readFile19 } from "fs/promises";
+import { spawn as spawn6 } from "child_process";
+import { readFile as readFile20 } from "fs/promises";
 import { existsSync as existsSync9 } from "fs";
-import { join as join33 } from "path";
+import { join as join32 } from "path";
 
 // src/services/warm-hook-logs-service.ts
-import { mkdir as mkdir18, readFile as readFile18, writeFile as writeFile6, readdir as readdir10, appendFile as appendFile5, unlink as unlink4 } from "fs/promises";
+import { mkdir as mkdir18, readFile as readFile19, writeFile as writeFile7, readdir as readdir10, appendFile as appendFile5, unlink as unlink4 } from "fs/promises";
 import { homedir as homedir16 } from "os";
-import { join as join32 } from "path";
-var LOGS_DIR2 = join32(homedir16(), ".replicas", "warm-hook-logs");
-var CURRENT_RUN_LOG = join32(LOGS_DIR2, "current-run.log");
+import { join as join31 } from "path";
+var LOGS_DIR2 = join31(homedir16(), ".replicas", "warm-hook-logs");
+var CURRENT_RUN_LOG = join31(LOGS_DIR2, "current-run.log");
 var GLOBAL_FILENAME = "global.json";
 function withPreview2(stored) {
   const preview = buildHookOutputPreview(stored.output);
@@ -12708,7 +13062,7 @@ var WarmHookLogsService = class {
       hookName: "organization",
       ...entry
     };
-    await writeFile6(join32(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join31(LOGS_DIR2, GLOBAL_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveEnvironmentHookLog(entry) {
@@ -12718,7 +13072,7 @@ var WarmHookLogsService = class {
       hookName: "environment",
       ...entry
     };
-    await writeFile6(join32(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join31(LOGS_DIR2, ENVIRONMENT_HOOK_LOG_FILENAME), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async saveRepoHookLog(repoName, entry) {
@@ -12728,7 +13082,7 @@ var WarmHookLogsService = class {
       hookName: repoName,
       ...entry
     };
-    await writeFile6(join32(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
+    await writeFile7(join31(LOGS_DIR2, repoHookLogFilename(repoName)), `${JSON.stringify(log, null, 2)}
 `, "utf-8");
   }
   async getAllLogs() {
@@ -12747,7 +13101,7 @@ var WarmHookLogsService = class {
         continue;
       }
       try {
-        const raw = await readFile18(join32(LOGS_DIR2, file), "utf-8");
+        const raw = await readFile19(join31(LOGS_DIR2, file), "utf-8");
         const stored = JSON.parse(raw);
         logs.push(withPreview2(stored));
       } catch {
@@ -12776,7 +13130,7 @@ var WarmHookLogsService = class {
   }
   async getCurrentRunLog() {
     try {
-      return await readFile18(CURRENT_RUN_LOG, "utf-8");
+      return await readFile19(CURRENT_RUN_LOG, "utf-8");
     } catch (err) {
       if (err.code === "ENOENT") return null;
       throw err;
@@ -12785,7 +13139,7 @@ var WarmHookLogsService = class {
   async getFullOutput(hookType, hookName) {
     const filename = hookType === "global" ? GLOBAL_FILENAME : hookType === "environment" ? ENVIRONMENT_HOOK_LOG_FILENAME : repoHookLogFilename(hookName);
     try {
-      const raw = await readFile18(join32(LOGS_DIR2, filename), "utf-8");
+      const raw = await readFile19(join31(LOGS_DIR2, filename), "utf-8");
       const stored = JSON.parse(raw);
       if (stored.hookType !== hookType || stored.hookName !== hookName) {
         return null;
@@ -12804,12 +13158,12 @@ var warmHookLogsService = new WarmHookLogsService();
 // src/services/warm-hooks-service.ts
 async function readRepoWarmHook(repoPath) {
   for (const filename of REPLICAS_CONFIG_FILENAMES) {
-    const configPath = join33(repoPath, filename);
+    const configPath = join32(repoPath, filename);
     if (!existsSync9(configPath)) {
       continue;
     }
     try {
-      const raw = await readFile19(configPath, "utf-8");
+      const raw = await readFile20(configPath, "utf-8");
       const config = parseReplicasConfigString(raw, filename);
       if (!config.warmHook) {
         return null;
@@ -12856,7 +13210,7 @@ async function executeHookScriptStreaming(params) {
   params.onChunk(`$ ${params.label}
 `);
   return new Promise((resolve5) => {
-    const proc = spawn5("bash", ["-lc", params.content], {
+    const proc = spawn6("bash", ["-lc", params.content], {
       cwd: params.cwd,
       env: process.env,
       stdio: ["pipe", "pipe", "pipe"]
@@ -13065,9 +13419,9 @@ ${combinedScript}` : combinedScript;
 }
 
 // src/services/terminal-service.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 import { existsSync as existsSync10 } from "fs";
-import { spawn as spawn6 } from "node-pty";
+import { spawn as spawn7 } from "node-pty";
 var MAX_REPLAY_CHARS = 1024 * 1024;
 var MAX_TERMINAL_SESSIONS = 8;
 var MAX_PENDING_INPUT = 64;
@@ -13084,9 +13438,9 @@ var TerminalService = class {
         code: "limit"
       });
     }
-    const id = randomUUID8();
+    const id = randomUUID9();
     const shell = process.env.SHELL && existsSync10(process.env.SHELL) ? process.env.SHELL : "/bin/bash";
-    const pty = spawn6(shell, ["-l"], {
+    const pty = spawn7(shell, ["-l"], {
       name: "xterm-256color",
       cols,
       rows,
@@ -14088,7 +14442,7 @@ data: ${JSON.stringify("Terminal session not found")}
       const logFiles = files.filter((f) => f.endsWith(".log"));
       const sessions = await Promise.all(
         logFiles.map(async (filename) => {
-          const filePath = join34(LOG_DIR, filename);
+          const filePath = join33(LOG_DIR, filename);
           const fileStat = await stat7(filePath);
           const sessionId = filename.replace(/\.log$/, "");
           return {
@@ -14123,7 +14477,7 @@ data: ${JSON.stringify("Terminal session not found")}
       }
       let content;
       try {
-        content = await readFile20(filePath, "utf-8");
+        content = await readFile21(filePath, "utf-8");
       } catch {
         return c.json(jsonError("Log session not found"), 404);
       }
@@ -14399,7 +14753,7 @@ function startStatusBroadcaster() {
       if (serialized !== previousRepoStatus) {
         previousRepoStatus = serialized;
         eventService.publish({
-          id: randomUUID9(),
+          id: randomUUID10(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "repo.status.changed",
           payload: { repos }
@@ -14420,7 +14774,7 @@ function startStatusBroadcaster() {
       if (engineStatusJson !== previousEngineStatus) {
         previousEngineStatus = engineStatusJson;
         eventService.publish({
-          id: randomUUID9(),
+          id: randomUUID10(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "engine.status.changed",
           payload: { status: engineStatus }
@@ -14439,7 +14793,7 @@ function startStatusBroadcaster() {
         previousHookStatus = hookSnapshot;
         if (!lastHooksRunning && hooksRunning) {
           eventService.publish({
-            id: randomUUID9(),
+            id: randomUUID10(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.started",
             payload: { running: true, completed: false }
@@ -14448,7 +14802,7 @@ function startStatusBroadcaster() {
         }
         if (hooksRunning) {
           eventService.publish({
-            id: randomUUID9(),
+            id: randomUUID10(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.progress",
             payload: { running: true, completed: false }
@@ -14457,7 +14811,7 @@ function startStatusBroadcaster() {
         }
         if (lastHooksRunning && !hooksRunning && hooksCompleted && !hooksFailed) {
           eventService.publish({
-            id: randomUUID9(),
+            id: randomUUID10(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.completed",
             payload: { running: false, completed: true }
@@ -14466,7 +14820,7 @@ function startStatusBroadcaster() {
         }
         if (lastHooksRunning && !hooksRunning && hooksFailed) {
           eventService.publish({
-            id: randomUUID9(),
+            id: randomUUID10(),
             ts: (/* @__PURE__ */ new Date()).toISOString(),
             type: "hooks.failed",
             payload: { running: false, completed: hooksCompleted }
@@ -14474,7 +14828,7 @@ function startStatusBroadcaster() {
           });
         }
         eventService.publish({
-          id: randomUUID9(),
+          id: randomUUID10(),
           ts: (/* @__PURE__ */ new Date()).toISOString(),
           type: "hooks.status",
           payload: {
@@ -14529,20 +14883,20 @@ serve(
     }
     const repos = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID9(),
+      id: randomUUID10(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.discovered",
       payload: { repos }
     });
     const repoStatuses = await gitService.listRepos();
     await eventService.publish({
-      id: randomUUID9(),
+      id: randomUUID10(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "repo.status.changed",
       payload: { repos: repoStatuses }
     });
     await eventService.publish({
-      id: randomUUID9(),
+      id: randomUUID10(),
       ts: (/* @__PURE__ */ new Date()).toISOString(),
       type: "engine.ready",
       payload: { version: "v1" }