@love-moon/conductor-cli 0.2.25 → 0.2.26

package/bin/conductor-config.js

@@ -5,7 +5,7 @@ import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
-import { execSync } from "node:child_process";
+import { execFileSync, execSync } from "node:child_process";
 import yargs from "yargs/yargs";
 import { hideBin } from "yargs/helpers";
 import { RUNTIME_SUPPORTED_BACKENDS } from "../src/runtime-backends.js";
@@ -27,6 +27,11 @@ const DEFAULT_CLIs = {
     execArgs: "--dangerously-bypass-approvals-and-sandbox --ask-for-approval never",
     description: "OpenAI Codex CLI"
   },
+  kimi: {
+    command: "kimi",
+    execArgs: "",
+    description: "Moonshot Kimi CLI"
+  },
   opencode: {
     command: "opencode",
     execArgs: "",
@@ -40,6 +45,8 @@ const backendUrl =
   "https://conductor-ai.top";
 const defaultDaemonName = os.hostname() || "my-daemon";
 const cliVersion = packageJson.version || "unknown";
+const OPENCODE_INSTALL_URL = "https://opencode.ai/install";
+const OPENCODE_NPM_PACKAGE = "opencode-ai";
 
 const COLORS = {
   yellow: "\x1b[33m",
@@ -50,6 +57,7 @@ const COLORS = {
 };
 
 let lastDeviceAuthConfig = null;
+let promptInterface = null;
 
 function colorize(text, color) {
   return `${COLORS[color] || ""}${text}${COLORS.reset}`;
@@ -71,6 +79,29 @@ function buildConfigEntryLines(cli, info, { commented = false } = {}) {
   return lines;
 }
 
+function getPromptInterface() {
+  if (!promptInterface) {
+    promptInterface = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+    });
+  }
+  return promptInterface;
+}
+
+function closePromptInterface() {
+  if (!promptInterface) {
+    return;
+  }
+  promptInterface.close();
+  promptInterface = null;
+}
+
+function exitWithCode(code) {
+  closePromptInterface();
+  process.exit(code);
+}
+
 async function main() {
   const argv = yargs(hideBin(process.argv))
     .option("token", {
@@ -104,12 +135,12 @@ async function main() {
     process.stderr.write(
       colorize(`Config already exists at ${CONFIG_FILE}. Use --force to overwrite.\n`, "yellow")
     );
-    process.exit(1);
+    exitWithCode(1);
   }
 
   let resolvedBackendUrl = backendUrl;
   let resolvedWebsocketUrl = null;
-  const detectedCLIs = detectInstalledCLIs();
+  let detectedCLIs = detectInstalledCLIs();
 
   if (detectedCLIs.length === 0) {
     console.log("");
@@ -127,16 +158,43 @@ async function main() {
     });
 
     console.log("");
-    console.log(colorize("After installing a CLI, run 'conductor config' again.", "yellow"));
-    console.log(colorize("=".repeat(70), "yellow"));
-    console.log("");
-
-    const shouldContinue = await promptYesNo(
-      "Do you want to continue creating the config anyway? (y/N): "
+    const shouldInstallOpencode = await promptYesNo(
+      "Do you want to install opencode now? (Y/n): ",
+      { defaultValue: true }
     );
 
-    if (!shouldContinue) {
-      process.exit(1);
+    if (shouldInstallOpencode) {
+      const installResult = installOpencode();
+      if (installResult.installed) {
+        detectedCLIs = detectInstalledCLIs();
+        if (!detectedCLIs.includes("opencode")) {
+          detectedCLIs = ["opencode", ...detectedCLIs];
+        }
+        console.log("");
+        if (installResult.message) {
+          console.log(colorize(installResult.message, "green"));
+        }
+        console.log(colorize("✓ OpenCode installed. Continuing with conductor config.", "green"));
+        console.log("");
+      } else {
+        console.log("");
+        console.log(colorize(installResult.message, "yellow"));
+        console.log("");
+      }
+    }
+
+    if (detectedCLIs.length === 0) {
+      console.log(colorize("After installing a CLI, run 'conductor config' again.", "yellow"));
+      console.log(colorize("=".repeat(70), "yellow"));
+      console.log("");
+
+      const shouldContinue = await promptYesNo(
+        "Do you want to continue creating the config anyway? (y/N): "
+      );
+
+      if (!shouldContinue) {
+        exitWithCode(1);
+      }
     }
   } else {
     console.log("");
@@ -154,7 +212,7 @@ async function main() {
       token = await promptForToken();
       if (!token) {
         process.stderr.write(colorize("No token provided. Aborting.\n", "yellow"));
-        process.exit(1);
+        exitWithCode(1);
       }
     } else {
       const authResult = await authorizeDeviceAndGetToken();
@@ -227,6 +285,22 @@ function detectInstalledCLIs() {
   return detected;
 }
 
+function resolveBundledCommandPath(command) {
+  const binDir = path.dirname(process.execPath);
+  const candidates = os.platform() === "win32"
+    ? [`${command}.cmd`, `${command}.exe`, command]
+    : [command];
+
+  for (const candidate of candidates) {
+    const fullPath = path.join(binDir, candidate);
+    if (fs.existsSync(fullPath)) {
+      return fullPath;
+    }
+  }
+
+  return null;
+}
+
 function isCommandAvailable(command) {
   try {
     const platform = os.platform();
@@ -268,6 +342,108 @@ function checkAlternativeInstallations(command) {
   return commonPaths.some((checkPath) => fs.existsSync(checkPath));
 }
 
+function resolveInstallCommand(command) {
+  const bundledPath = resolveBundledCommandPath(command);
+  if (bundledPath) {
+    return bundledPath;
+  }
+  return isCommandAvailable(command) ? command : null;
+}
+
+function resolveOpencodeInstaller() {
+  const overrideCommand = process.env.CONDUCTOR_OPENCODE_INSTALL_COMMAND?.trim();
+  if (overrideCommand) {
+    return {
+      command: overrideCommand,
+      args: [],
+      display: overrideCommand,
+    };
+  }
+
+  const npmCommand = resolveInstallCommand("npm");
+  if (npmCommand) {
+    return {
+      command: npmCommand,
+      args: ["install", "-g", OPENCODE_NPM_PACKAGE],
+      display: `${path.basename(npmCommand)} install -g ${OPENCODE_NPM_PACKAGE}`,
+    };
+  }
+
+  const pnpmCommand = resolveInstallCommand("pnpm");
+  if (pnpmCommand) {
+    return {
+      command: pnpmCommand,
+      args: ["install", "-g", OPENCODE_NPM_PACKAGE],
+      display: `${path.basename(pnpmCommand)} install -g ${OPENCODE_NPM_PACKAGE}`,
+    };
+  }
+
+  const bunCommand = resolveInstallCommand("bun");
+  if (bunCommand) {
+    return {
+      command: bunCommand,
+      args: ["install", "-g", OPENCODE_NPM_PACKAGE],
+      display: `${path.basename(bunCommand)} install -g ${OPENCODE_NPM_PACKAGE}`,
+    };
+  }
+
+  if (os.platform() !== "win32" && isCommandAvailable("bash") && isCommandAvailable("curl")) {
+    return {
+      command: "bash",
+      args: ["-lc", `curl -fsSL ${OPENCODE_INSTALL_URL} | bash`],
+      display: `curl -fsSL ${OPENCODE_INSTALL_URL} | bash`,
+    };
+  }
+
+  return null;
+}
+
+function printOpencodeInstallInstructions() {
+  console.log(colorize("You can install OpenCode manually with one of these commands:", "yellow"));
+  console.log(`  curl -fsSL ${OPENCODE_INSTALL_URL} | bash`);
+  console.log(`  npm install -g ${OPENCODE_NPM_PACKAGE}`);
+}
+
+function installOpencode() {
+  const installer = resolveOpencodeInstaller();
+  if (!installer) {
+    printOpencodeInstallInstructions();
+    return {
+      installed: false,
+      message: "Could not find an automatic installer for opencode in the current environment.",
+    };
+  }
+
+  console.log("");
+  console.log(colorize(`Installing opencode with: ${installer.display}`, "cyan"));
+  console.log("");
+
+  try {
+    execFileSync(installer.command, installer.args, {
+      stdio: "inherit",
+      env: process.env,
+    });
+  } catch (error) {
+    printOpencodeInstallInstructions();
+    return {
+      installed: false,
+      message: `opencode installation failed: ${error?.message || error}`,
+    };
+  }
+
+  if (isCommandAvailable("opencode")) {
+    return {
+      installed: true,
+      message: "OpenCode installed successfully.",
+    };
+  }
+
+  return {
+    installed: true,
+    message: "OpenCode installed, but the current shell may need a refreshed PATH before detection works.",
+  };
+}
+
 async function authorizeDeviceAndGetToken() {
   const startResponse = await fetch(new URL("/api/auth/device/start", backendUrl), {
     method: "POST",
@@ -350,32 +526,21 @@ async function parseJsonResponse(response) {
 }
 
 async function promptForToken() {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  try {
-    let token = "";
-    while (!token) {
-      token = (await rl.question("Enter Conductor token: ")).trim();
-    }
-    return token;
-  } finally {
-    rl.close();
+  const rl = getPromptInterface();
+  let token = "";
+  while (!token) {
+    token = (await rl.question("Enter Conductor token: ")).trim();
   }
+  return token;
 }
 
-async function promptYesNo(question) {
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  });
-  try {
-    const answer = (await rl.question(question)).trim().toLowerCase();
-    return answer === "y" || answer === "yes";
-  } finally {
-    rl.close();
+async function promptYesNo(question, { defaultValue = false } = {}) {
+  const rl = getPromptInterface();
+  const answer = (await rl.question(question)).trim().toLowerCase();
+  if (!answer) {
+    return defaultValue;
   }
+  return answer === "y" || answer === "yes";
 }
 
 function sleep(ms) {
@@ -388,7 +553,11 @@ function yamlQuote(value) {
   return JSON.stringify(value);
 }
 
-main().catch((error) => {
-  process.stderr.write(`Failed to write config: ${error?.message || error}\n`);
-  process.exit(1);
-});
+main()
+  .catch((error) => {
+    process.stderr.write(`Failed to write config: ${error?.message || error}\n`);
+    exitWithCode(1);
+  })
+  .finally(() => {
+    closePromptInterface();
+  });

package/bin/conductor-fire.js

@@ -68,19 +68,23 @@ function loadAllowCliList(configFilePath) {
 
 export function resolveAiSessionCommandLine(backend, allowCliList, env = process.env) {
   const normalizedBackend = normalizeRuntimeBackendName(backend);
-  if (normalizedBackend !== "opencode") {
+  const envKeyByBackend = {
+    opencode: "CONDUCTOR_OPENCODE_COMMAND",
+    kimi: "CONDUCTOR_KIMI_COMMAND",
+  };
+  const envKey = envKeyByBackend[normalizedBackend];
+  if (!envKey) {
     return "";
   }
 
-  const opencodeEnvCommand =
-    typeof env?.CONDUCTOR_OPENCODE_COMMAND === "string" ? env.CONDUCTOR_OPENCODE_COMMAND.trim() : "";
-  if (opencodeEnvCommand) {
-    return opencodeEnvCommand;
+  const preferredEnvCommand = typeof env?.[envKey] === "string" ? env[envKey].trim() : "";
+  if (preferredEnvCommand) {
+    return preferredEnvCommand;
   }
 
   const configuredCommand =
-    allowCliList && typeof allowCliList === "object" && typeof allowCliList.opencode === "string"
-      ? allowCliList.opencode.trim()
+    allowCliList && typeof allowCliList === "object" && typeof allowCliList[normalizedBackend] === "string"
+      ? allowCliList[normalizedBackend].trim()
       : "";
   if (configuredCommand) {
     return configuredCommand;
@@ -410,7 +414,7 @@ async function main() {
 
   if (cliArgs.listBackends) {
     if (supportedBackends.length === 0) {
-      process.stdout.write(`No supported backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    opencode: opencode\n`);
+      process.stdout.write(`No supported backends configured.\n\nAdd allow_cli_list to your config file (~/.conductor/config.yaml):\n  allow_cli_list:\n    codex: codex --dangerously-bypass-approvals-and-sandbox\n    claude: claude --dangerously-skip-permissions\n    kimi: kimi\n    opencode: opencode\n`);
     } else {
       process.stdout.write(`Supported backends (from config):\n`);
       for (const [name, command] of Object.entries(allowCliList)) {
@@ -902,13 +906,16 @@ Config file format (~/.conductor/config.yaml):
   allow_cli_list:
     codex: codex --dangerously-bypass-approvals-and-sandbox
     claude: claude --dangerously-skip-permissions
+    kimi: kimi
     opencode: opencode
 
 Examples:
   ${CLI_NAME} -- "fix the bug"                    # Use default backend
   ${CLI_NAME} --backend claude -- "fix the bug"   # Use Claude CLI backend
+  ${CLI_NAME} --backend kimi -- "fix the bug"     # Use Kimi CLI backend
   ${CLI_NAME} --backend opencode -- "fix the bug" # Use OpenCode backend
   ${CLI_NAME} --backend codex --resume <id>       # Resume Codex session
+  ${CLI_NAME} --backend kimi --resume <id>        # Resume Kimi session
   ${CLI_NAME} --list-backends                     # Show configured backends
   ${CLI_NAME} --config-file ~/.conductor/config.yaml -- "fix the bug"
 
@@ -944,7 +951,7 @@ Environment:
     );
   }
   if (!backend && shouldRequireBackend) {
-    throw new Error("No supported backends configured. Add codex, claude, or opencode to allow_cli_list.");
+    throw new Error("No supported backends configured. Add codex, claude, kimi, or opencode to allow_cli_list.");
   }
 
   const prompt = (backendArgs._ || []).map((part) => String(part)).join(" ").trim();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@love-moon/conductor-cli",
-  "version": "0.2.25",
-  "gitCommitId": "6d7b348",
+  "version": "0.2.26",
+  "gitCommitId": "fc0cb59",
   "type": "module",
   "bin": {
     "conductor": "bin/conductor.js"
@@ -17,8 +17,8 @@
     "test": "node --test test/*.test.js"
   },
   "dependencies": {
-    "@love-moon/ai-sdk": "0.2.25",
-    "@love-moon/conductor-sdk": "0.2.25",
+    "@love-moon/ai-sdk": "0.2.26",
+    "@love-moon/conductor-sdk": "0.2.26",
     "dotenv": "^16.4.5",
     "enquirer": "^2.4.1",
     "js-yaml": "^4.1.1",

package/src/daemon.js

@@ -49,6 +49,7 @@ const PLAN_LIMIT_MESSAGES = {
 const DEFAULT_TERMINAL_COLS = 120;
 const DEFAULT_TERMINAL_ROWS = 40;
 const DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES = 2 * 1024 * 1024;
+const DEFAULT_TERMINAL_RESUME_SNAPSHOT_MAX_BYTES = 128 * 1024;
 const DEFAULT_RTC_MODULE_CANDIDATES = ["@roamhq/wrtc", "wrtc"];
 let nodePtySpawnPromise = null;
 
@@ -282,6 +283,14 @@ function normalizeOptionalString(value) {
   return normalized || null;
 }
 
+function normalizeTerminalResumeStrategy(value) {
+  const normalized = normalizeOptionalString(value);
+  if (!normalized) {
+    return null;
+  }
+  return normalized.toLowerCase() === "snapshot" ? "snapshot" : null;
+}
+
 function normalizeStringArray(value) {
   if (!Array.isArray(value)) {
     return [];
@@ -529,6 +538,10 @@ export function startDaemon(config = {}, deps = {}) {
     config.TERMINAL_RING_BUFFER_MAX_BYTES || process.env.CONDUCTOR_TERMINAL_RING_BUFFER_MAX_BYTES,
     DEFAULT_TERMINAL_RING_BUFFER_MAX_BYTES,
   );
+  const TERMINAL_RESUME_SNAPSHOT_MAX_BYTES = parsePositiveInt(
+    config.TERMINAL_RESUME_SNAPSHOT_MAX_BYTES || process.env.CONDUCTOR_TERMINAL_RESUME_SNAPSHOT_MAX_BYTES,
+    DEFAULT_TERMINAL_RESUME_SNAPSHOT_MAX_BYTES,
+  );
 
   const readLockState = () => {
     const raw = String(readFileSyncFn(LOCK_FILE, "utf-8") || "").trim();
@@ -814,7 +827,7 @@ export function startDaemon(config = {}, deps = {}) {
     "x-conductor-version": cliVersion,
   };
   if (ptyTaskCapabilityEnabled) {
-    extraHeaders["x-conductor-capabilities"] = "pty_task";
+    extraHeaders["x-conductor-capabilities"] = "pty_task,terminal_snapshot";
   }
   const client = createWebSocketClient(sdkConfig, {
     extraHeaders,
@@ -1914,6 +1927,23 @@ export function startDaemon(config = {}, deps = {}) {
     return record.outputSeq;
   }
 
+  function buildTerminalResumeSnapshot(record) {
+    if (!record || !Array.isArray(record.ringBuffer) || record.ringBuffer.length === 0) {
+      return {
+        lastSeq: normalizeNonNegativeInt(record?.outputSeq, 0),
+        data: "",
+        truncated: false,
+      };
+    }
+    const joinedData = record.ringBuffer.map((chunk) => chunk?.data || "").join("");
+    const trimmedData = trimTerminalChunkToTailBytes(joinedData, TERMINAL_RESUME_SNAPSHOT_MAX_BYTES);
+    return {
+      lastSeq: normalizeNonNegativeInt(record.outputSeq, 0),
+      data: trimmedData,
+      truncated: getTerminalChunkByteLength(trimmedData) < getTerminalChunkByteLength(joinedData),
+    };
+  }
+
   function sendDirectPtyPayload(taskId, payload) {
     const transport = activePtyRtcTransports.get(taskId);
     const channel = transport?.channel;
@@ -2284,6 +2314,23 @@ export function startDaemon(config = {}, deps = {}) {
     });
 
     const lastSeq = normalizePositiveInt(payload?.last_seq ?? payload?.lastSeq, 0);
+    const connectionId = normalizeOptionalString(payload?.connection_id ?? payload?.connectionId);
+    const resumeStrategy = normalizeTerminalResumeStrategy(payload?.resume_strategy ?? payload?.resumeStrategy);
+    if (lastSeq === 0 && resumeStrategy === "snapshot" && connectionId) {
+      const snapshot = buildTerminalResumeSnapshot(record);
+      await sendTerminalEvent("terminal_snapshot", {
+        task_id: taskId,
+        project_id: record.projectId,
+        pty_session_id: record.ptySessionId,
+        connection_id: connectionId,
+        last_seq: snapshot.lastSeq,
+        data: snapshot.data,
+        truncated: snapshot.truncated,
+      }).catch((err) => {
+        logError(`Failed to report terminal_snapshot for ${taskId}: ${err?.message || err}`);
+      });
+      return;
+    }
     for (const chunk of record.ringBuffer) {
       if (chunk.seq <= lastSeq) continue;
       await sendTerminalEvent("terminal_output", {

package/src/fire/resume.js

@@ -3,6 +3,7 @@ import { promises as fsp } from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import readline from "node:readline";
+import crypto from "node:crypto";
 
 import yaml from "js-yaml";
 
@@ -36,6 +37,9 @@ export function buildResumeArgsForBackend(backend, sessionId) {
   if (normalizedBackend === "copilot") {
     return [`--resume=${resumeSessionId}`];
   }
+  if (normalizedBackend === "kimi" || normalizedBackend === "kimi-cli" || normalizedBackend === "kimi-code") {
+    return ["--session", resumeSessionId];
+  }
   throw new Error(`--resume is not supported for backend "${backend}"`);
 }
 
@@ -50,6 +54,9 @@ export function resumeProviderForBackend(backend) {
   if (normalizedBackend === "copilot") {
     return "copilot";
   }
+  if (normalizedBackend === "kimi" || normalizedBackend === "kimi-cli" || normalizedBackend === "kimi-code") {
+    return "kimi";
+  }
   return null;
 }
 
@@ -64,6 +71,9 @@ export async function findSessionPath(provider, sessionId, options = {}) {
   if (normalizedProvider === "copilot") {
     return findCopilotSessionPath(sessionId, options);
   }
+  if (normalizedProvider === "kimi") {
+    return findKimiSessionPath(sessionId, options);
+  }
   throw new Error(`Unsupported provider: ${provider}`);
 }
 
@@ -120,6 +130,17 @@ export async function findCopilotSessionPath(sessionId, options = {}) {
   return findPathByName(sessionStateDir, normalizedSessionId);
 }
 
+export async function findKimiSessionPath(sessionId, options = {}) {
+  const normalizedSessionId = normalizeSessionId(sessionId);
+  if (!normalizedSessionId) {
+    return null;
+  }
+
+  const homeDir = resolveHomeDir(options);
+  const sessionsDir = options.kimiSessionsDir || path.join(homeDir, ".kimi", "sessions");
+  return findKimiSessionDirectory(sessionsDir, normalizedSessionId);
+}
+
 export async function resolveSessionRunDirectory(sessionPath) {
   const normalizedPath = typeof sessionPath === "string" ? sessionPath.trim() : "";
   if (!normalizedPath) {
@@ -153,9 +174,23 @@ export async function resolveResumeContext(backend, sessionId, options = {}) {
     throw new Error(`Invalid --resume session id for ${provider}: ${normalizedSessionId}`);
   }
 
-  const cwdFromSession = await extractResumeCwdFromSession(provider, sessionPath, normalizedSessionId);
-  const fallbackCwd = await resolveSessionRunDirectory(sessionPath);
+  const cwdFromSession = await extractResumeCwdFromSession(
+    provider,
+    sessionPath,
+    normalizedSessionId,
+    options,
+  );
+  const fallbackCwd =
+    provider === "kimi" ? null : await resolveSessionRunDirectory(sessionPath);
   const cwd = cwdFromSession || fallbackCwd;
+  if (!cwd) {
+    if (provider === "kimi") {
+      throw new Error(
+        `Could not resolve workspace for Kimi session ${normalizedSessionId}. Re-run from the original workspace or resume a session previously started by conductor fire.`,
+      );
+    }
+    throw new Error(`Could not resolve workspace for ${provider} session ${normalizedSessionId}`);
+  }
   if (!(await isExistingDirectory(cwd))) {
     throw new Error(`Resume workspace path does not exist: ${cwd}`);
   }
@@ -290,7 +325,167 @@ async function extractCopilotResumeCwd(sessionPath) {
   return null;
 }
 
-async function extractResumeCwdFromSession(provider, sessionPath, sessionId) {
+function md5Hex(value) {
+  return crypto.createHash("md5").update(String(value ?? "")).digest("hex");
+}
+
+function listCandidateWorkingDirectories(options = {}) {
+  const candidates = [];
+  const push = (value) => {
+    const normalized = typeof value === "string" ? value.trim() : "";
+    if (!normalized) {
+      return;
+    }
+    if (!candidates.includes(normalized)) {
+      candidates.push(normalized);
+    }
+  };
+
+  push(options.cwd);
+  push(options.currentWorkingDirectory);
+  push(process.env.PWD);
+  push(process.cwd());
+
+  return candidates;
+}
+
+async function loadConductorSessionRecords(options = {}) {
+  const homeDir = resolveHomeDir(options);
+  const defaultPaths = [
+    path.join(homeDir, ".conductor", "session.yaml"),
+    path.join(homeDir, ".conductor", "sessions"),
+  ];
+  const recordFiles = [];
+  const pushFile = (filePath) => {
+    const normalized = typeof filePath === "string" ? filePath.trim() : "";
+    if (!normalized || recordFiles.includes(normalized)) {
+      return;
+    }
+    recordFiles.push(normalized);
+  };
+
+  if (Array.isArray(options.conductorSessionFiles)) {
+    for (const entry of options.conductorSessionFiles) {
+      pushFile(entry);
+    }
+  }
+
+  if (Array.isArray(options.conductorSessionDirs)) {
+    for (const entry of options.conductorSessionDirs) {
+      const normalizedDir = typeof entry === "string" ? entry.trim() : "";
+      if (!normalizedDir) {
+        continue;
+      }
+      let files = [];
+      try {
+        files = await fsp.readdir(normalizedDir, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const file of files) {
+        if (!file.isFile() || !file.name.endsWith(".yaml")) {
+          continue;
+        }
+        pushFile(path.join(normalizedDir, file.name));
+      }
+    }
+  } else {
+    pushFile(defaultPaths[0]);
+    let files = [];
+    try {
+      files = await fsp.readdir(defaultPaths[1], { withFileTypes: true });
+    } catch {
+      files = [];
+    }
+    for (const file of files) {
+      if (!file.isFile() || !file.name.endsWith(".yaml")) {
+        continue;
+      }
+      pushFile(path.join(defaultPaths[1], file.name));
+    }
+  }
+
+  const records = [];
+  for (const filePath of recordFiles) {
+    let content = "";
+    try {
+      content = await fsp.readFile(filePath, "utf8");
+    } catch {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = yaml.load(content);
+    } catch {
+      continue;
+    }
+    const entries = Array.isArray(parsed?.sessions) ? parsed.sessions : Array.isArray(parsed) ? parsed : [];
+    for (const entry of entries) {
+      if (!entry || typeof entry !== "object") {
+        continue;
+      }
+      records.push(entry);
+    }
+  }
+  return records;
+}
+
+function normalizeProjectPathCandidate(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : "";
+}
+
+async function resolveKimiResumeCwd(sessionPath, sessionId, options = {}) {
+  const sessionDirectory = typeof sessionPath === "string" ? sessionPath.trim() : "";
+  if (!sessionDirectory) {
+    return null;
+  }
+
+  const worktreeHash = path.basename(path.dirname(sessionDirectory));
+  if (!worktreeHash) {
+    return null;
+  }
+
+  for (const candidate of listCandidateWorkingDirectories(options)) {
+    if (md5Hex(candidate) === worktreeHash) {
+      return candidate;
+    }
+  }
+
+  const records = await loadConductorSessionRecords(options);
+  const bySessionId = [];
+  const byHash = [];
+
+  for (const record of records) {
+    const projectPath = normalizeProjectPathCandidate(record?.project_path);
+    if (!projectPath) {
+      continue;
+    }
+    const backendType = normalizeBackend(record?.backend_type);
+    const recordSessionId = normalizeSessionId(record?.session_id);
+    const projectHash = md5Hex(projectPath);
+    if (
+      recordSessionId === sessionId &&
+      (backendType === "kimi" || !backendType) &&
+      projectHash === worktreeHash &&
+      !bySessionId.includes(projectPath)
+    ) {
+      bySessionId.push(projectPath);
+    }
+    if (projectHash === worktreeHash && !byHash.includes(projectPath)) {
+      byHash.push(projectPath);
+    }
+  }
+
+  if (bySessionId.length > 0) {
+    return bySessionId[0];
+  }
+  if (byHash.length === 1) {
+    return byHash[0];
+  }
+  return null;
+}
+
+async function extractResumeCwdFromSession(provider, sessionPath, sessionId, options = {}) {
   if (provider === "codex") {
     return extractCodexResumeCwd(sessionPath);
   }
@@ -300,6 +495,9 @@ async function extractResumeCwdFromSession(provider, sessionPath, sessionId) {
   if (provider === "copilot") {
     return extractCopilotResumeCwd(sessionPath);
   }
+  if (provider === "kimi") {
+    return resolveKimiResumeCwd(sessionPath, sessionId, options);
+  }
   return null;
 }
 
@@ -404,6 +602,26 @@ async function findPathByName(rootDir, sessionId) {
   return null;
 }
 
+async function findKimiSessionDirectory(rootDir, sessionId) {
+  let hashDirs = [];
+  try {
+    hashDirs = await fsp.readdir(rootDir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  for (const hashDir of hashDirs) {
+    if (!hashDir.isDirectory()) {
+      continue;
+    }
+    const candidateDir = path.join(rootDir, hashDir.name, sessionId);
+    if (await pathExists(candidateDir, "directory")) {
+      return candidateDir;
+    }
+  }
+  return null;
+}
+
 async function pathExists(targetPath, expectedType) {
   try {
     const stats = await fsp.stat(targetPath);

package/src/runtime-backends.js

@@ -1,4 +1,4 @@
-export const RUNTIME_SUPPORTED_BACKENDS = ["codex", "claude", "opencode"];
+export const RUNTIME_SUPPORTED_BACKENDS = ["codex", "claude", "kimi", "opencode"];
 
 export function normalizeRuntimeBackendName(backend) {
   return String(backend || "").trim().toLowerCase();