@arcships/morula-runtime 0.1.0-alpha.19 → 0.1.0-alpha.20

package/dist/index.js

@@ -747,7 +747,7 @@ var BUILD_ID, BUILD_CONTEXTS, BUILD_DEFAULT_CONTEXT;
 var init_build_env = __esm({
   "../morula-cli-core/dist/build-env.js"() {
     "use strict";
-    BUILD_ID = "20261010070134.5226cb13";
+    BUILD_ID = "20261010111428.e5cce225";
     BUILD_CONTEXTS = {
       "local": "http://localhost:8080/api",
       "test": "https://morula.basecastle.com/api",
@@ -4380,7 +4380,7 @@ __export(dim_model_exports, {
   listDimModels: () => listDimModels
 });
 import { createRequire } from "node:module";
-import { spawnSync } from "node:child_process";
+import { spawnSync as spawnSync3 } from "node:child_process";
 import { closeSync as closeSync4, existsSync as existsSync15, openSync as openSync4, readFileSync as readFileSync11, unlinkSync } from "node:fs";
 import { homedir as homedir14, tmpdir } from "node:os";
 import { join as join20 } from "node:path";
@@ -4430,7 +4430,7 @@ function listDimModelsFromCli(dimPath, env) {
   const fd = openSync4(tmpFile, "w");
   let collected = "";
   try {
-    const result = spawnSync(dimPath, ["model", "list", "--json"], {
+    const result = spawnSync3(dimPath, ["model", "list", "--json"], {
       stdio: ["ignore", fd, "ignore"],
       // 与 execFileSync 相同的 env 语义：显式 env 时合并 process.env
       ...env ? { env: { ...process.env, ...env } } : {},
@@ -4609,13 +4609,13 @@ init_dist2();
 init_dist2();
 
 // src/build-env.ts
-var BUILD_VERSION2 = "0.1.0-alpha.19";
+var BUILD_VERSION2 = "0.1.0-alpha.20";
 
 // src/commands/daemon.ts
 init_dist();
 init_dist2();
-import { existsSync as existsSync23, mkdirSync as mkdirSync18, readFileSync as readFileSync15, rmSync as rmSync11, writeFileSync as writeFileSync16 } from "node:fs";
-import { dirname as dirname15, join as join30 } from "node:path";
+import { existsSync as existsSync24, mkdirSync as mkdirSync19, readFileSync as readFileSync16, rmSync as rmSync11, writeFileSync as writeFileSync17 } from "node:fs";
+import { dirname as dirname16, join as join30 } from "node:path";
 
 // src/daemon/daemon-autostart.ts
 init_portal_autostart();
@@ -4684,9 +4684,9 @@ init_portal_server();
 // src/daemon/runner.ts
 init_dist2();
 import { execFileSync as execFileSync11 } from "node:child_process";
-import { existsSync as existsSync21, mkdirSync as mkdirSync17, statSync as statSync5, writeFileSync as writeFileSync15 } from "node:fs";
+import { existsSync as existsSync22, mkdirSync as mkdirSync18, statSync as statSync5, writeFileSync as writeFileSync16 } from "node:fs";
 import { arch, hostname } from "node:os";
-import { dirname as dirname13, join as join28 } from "node:path";
+import { dirname as dirname14, join as join28 } from "node:path";
 
 // src/daemon/acp/acp-connection-pool.ts
 var DEFAULT_IDLE_MS = 30 * 60 * 1e3;
@@ -7051,7 +7051,7 @@ function registerPlugin(opts) {
 import { join as join21 } from "node:path";
 
 // src/daemon/providers/claude/claude-preset.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
+import { copyFileSync as copyFileSync2, existsSync as existsSync13, readFileSync as readFileSync9 } from "node:fs";
 import { homedir as homedir11 } from "node:os";
 import { join as join17 } from "node:path";
 
@@ -7096,6 +7096,94 @@ function resolveCommandOnPath(name) {
   return null;
 }
 
+// src/daemon/providers/claude/claude-models.ts
+import { spawnSync } from "node:child_process";
+var LIST_MODELS_REQUEST_ID = "morula-list-models";
+var LIST_MODELS_TIMEOUT_MS = 3e4;
+var LIST_MODELS_REQUEST = `${JSON.stringify({
+  type: "control_request",
+  request_id: LIST_MODELS_REQUEST_ID,
+  request: { subtype: "list_models" }
+})}
+`;
+var LIST_MODELS_ARGS = [
+  "--print",
+  "--verbose",
+  "--input-format",
+  "stream-json",
+  "--output-format",
+  "stream-json",
+  "--strict-mcp-config"
+];
+function listClaudeModels() {
+  const claude = resolveCommandOnPath("claude");
+  if (!claude)
+    return [];
+  try {
+    const result = spawnSync(claude, LIST_MODELS_ARGS, {
+      input: LIST_MODELS_REQUEST,
+      encoding: "utf8",
+      timeout: LIST_MODELS_TIMEOUT_MS
+    });
+    if (result.error || result.status !== 0 || !result.stdout)
+      return [];
+    return parseClaudeModelCatalog(result.stdout);
+  } catch {
+    return [];
+  }
+}
+function parseClaudeModelCatalog(stdout) {
+  for (const line of stdout.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (parsed.type !== "control_response" || parsed.response?.request_id !== LIST_MODELS_REQUEST_ID)
+      continue;
+    if (parsed.response.subtype !== "success" || !Array.isArray(parsed.response.response?.models))
+      return [];
+    return dedupeByResolvedModel(parsed.response.response.models);
+  }
+  return [];
+}
+function dedupeByResolvedModel(infos) {
+  const seen = /* @__PURE__ */ new Set();
+  const models2 = [];
+  for (const raw of infos) {
+    const info = raw;
+    const resolved = typeof info.resolvedModel === "string" && info.resolvedModel.trim() ? info.resolvedModel.trim() : typeof info.value === "string" ? info.value.trim() : "";
+    if (!resolved)
+      continue;
+    const key = resolved.toLowerCase();
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    models2.push({
+      id: resolved,
+      name: typeof info.displayName === "string" && info.displayName ? info.displayName : resolved
+    });
+  }
+  return models2;
+}
+function claudeCliVersion() {
+  const claude = resolveCommandOnPath("claude");
+  if (!claude)
+    return void 0;
+  try {
+    const result = spawnSync(claude, ["--version"], { encoding: "utf8", timeout: 15e3 });
+    if (result.error || result.status !== 0 || !result.stdout)
+      return void 0;
+    return result.stdout.trim().match(/\d+\.\d+[\w.-]*/)?.[0];
+  } catch {
+    return void 0;
+  }
+}
+
 // src/daemon/providers/claude/claude-preset.ts
 var CLAUDE_PROVIDER_KEY = "claude";
 var CLAUDE_DISPLAY_NAME = "Claude Code";
@@ -7130,6 +7218,25 @@ function readHostClaudeOauthToken() {
     return null;
   }
 }
+function readHostClaudeSettingsEnv() {
+  const file = join17(homedir11(), ".claude", "settings.json");
+  try {
+    if (!existsSync13(file))
+      return {};
+    const parsed = JSON.parse(readFileSync9(file, "utf8"));
+    const env = {};
+    for (const [key, value] of Object.entries(parsed.env ?? {})) {
+      if (typeof value === "string" && value.length > 0)
+        env[key] = value;
+    }
+    return env;
+  } catch {
+    return {};
+  }
+}
+function hostClaudeSettingsFile() {
+  return join17(homedir11(), ".claude", "settings.json");
+}
 function resolveClaudeCredentialEnv(configuredEnv) {
   if (configuredEnv.CLAUDE_CODE_OAUTH_TOKEN) {
     return { env: {}, authStatus: "unknown", authMode: "oauth" };
@@ -7137,6 +7244,13 @@ function resolveClaudeCredentialEnv(configuredEnv) {
   if (configuredEnv.ANTHROPIC_API_KEY) {
     return { env: {}, authStatus: "unknown", authMode: "api-key" };
   }
+  if (configuredEnv.ANTHROPIC_AUTH_TOKEN) {
+    return { env: {}, authStatus: "unknown", authMode: "api-key" };
+  }
+  const hostSettingsEnv = readHostClaudeSettingsEnv();
+  if (hostSettingsEnv.CLAUDE_CODE_OAUTH_TOKEN || hostSettingsEnv.ANTHROPIC_API_KEY || hostSettingsEnv.ANTHROPIC_AUTH_TOKEN) {
+    return { env: {}, authStatus: "unknown", authMode: "api-key" };
+  }
   const hostToken = readHostClaudeOauthToken();
   if (hostToken) {
     return { env: { CLAUDE_CODE_OAUTH_TOKEN: hostToken }, authStatus: "unknown", authMode: "oauth" };
@@ -7146,7 +7260,7 @@ function resolveClaudeCredentialEnv(configuredEnv) {
     authStatus: "unauthenticated",
     authMode: "none",
     lastProbeErrorCode: "CLAUDE_NO_CREDENTIAL",
-    lastProbeError: "\u672A\u68C0\u6D4B\u5230 Claude \u767B\u5F55\u6001\uFF08\u5BBF\u4E3B ~/.claude/.credentials.json \u65E0 OAuth token\uFF0C\u4E14\u672A\u914D\u7F6E CLAUDE_CODE_OAUTH_TOKEN / ANTHROPIC_API_KEY\uFF09\uFF1B\u5728\u5BBF\u4E3B\u6267\u884C `claude login` \u540E\u91CD\u65B0\u63A2\u6D4B\uFF0C\u6216\u5728 daemon \u914D\u7F6E\u91CC\u4E3A claude \u914D\u7F6E CLAUDE_CODE_OAUTH_TOKEN"
+    lastProbeError: "\u672A\u68C0\u6D4B\u5230 Claude \u767B\u5F55\u6001\uFF08\u5BBF\u4E3B ~/.claude/settings.json \u65E0\u63A5\u5165 env\u3001.credentials.json \u65E0 OAuth token\uFF0C\u4E14\u672A\u914D\u7F6E CLAUDE_CODE_OAUTH_TOKEN / ANTHROPIC_API_KEY / ANTHROPIC_AUTH_TOKEN\uFF09\uFF1B\u5728\u5BBF\u4E3B\u5B8C\u6210 `claude login` \u6216\u914D\u7F6E\u7B2C\u4E09\u65B9\u63A5\u5165\uFF08ANTHROPIC_BASE_URL + ANTHROPIC_AUTH_TOKEN / ANTHROPIC_API_KEY\uFF09\u540E\u91CD\u65B0\u63A2\u6D4B"
   };
 }
 var CLAUDE_PROVIDER_SPEC = {
@@ -7182,13 +7296,26 @@ var CLAUDE_PROVIDER_SPEC = {
   prepareTaskDataDir: async (home, configuredEnv) => {
     ensureAgentHome(home);
     const cred = resolveClaudeCredentialEnv(configuredEnv);
+    const hostSettings = hostClaudeSettingsFile();
+    try {
+      if (existsSync13(hostSettings))
+        copyFileSync2(hostSettings, join17(home, "settings.json"));
+    } catch {
+    }
     return { CLAUDE_CODE_DISABLE_AUTO_MEMORY: "1", ...cred.env };
   },
   probeExtras: async ({ configuredEnv }) => {
     const cred = resolveClaudeCredentialEnv(configuredEnv);
+    const cliVersion = claudeCliVersion();
     return {
       authStatus: cred.authStatus,
       authMode: cred.authMode,
+      // CLI 本体版本（claude --version；握手 agentInfo.version 是 ACP 桥版本，不是 CLI 本体）。
+      // undefined 时不覆盖握手版本（spread 显式 undefined 会把 adapter 层的值抹掉）
+      ...cliVersion ? { cliVersion } : {},
+      // 模型目录（live：claude 控制协议 list_models；第三方网关下 resolvedModel 即实际生效模型；
+      // 拉不到 = 空列表，会话级 configOptions 仍是权威值域）
+      models: listClaudeModels(),
       ...cred.lastProbeErrorCode ? { lastProbeErrorCode: cred.lastProbeErrorCode } : {},
       ...cred.lastProbeError ? { lastProbeError: cred.lastProbeError } : {}
     };
@@ -7204,31 +7331,142 @@ var CLAUDE_PROVIDER_SPEC = {
 };
 
 // src/daemon/providers/codex/codex-preset.ts
-import { existsSync as existsSync14, readFileSync as readFileSync10, symlinkSync, writeFileSync as writeFileSync10 } from "node:fs";
+import { copyFileSync as copyFileSync3, existsSync as existsSync14, readFileSync as readFileSync10, symlinkSync, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir12 } from "node:os";
 import { join as join18 } from "node:path";
+
+// src/daemon/providers/codex/codex-models.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+var DEBUG_MODELS_TIMEOUT_MS = 3e4;
+function listCodexModels() {
+  const codex = resolveCommandOnPath("codex");
+  if (!codex)
+    return [];
+  const live = runCodexDebugModels(codex, ["debug", "models"]);
+  if (live.length > 0)
+    return live;
+  return runCodexDebugModels(codex, ["debug", "models", "--bundled"]);
+}
+function runCodexDebugModels(codex, args) {
+  try {
+    const result = spawnSync2(codex, args, {
+      encoding: "utf8",
+      timeout: DEBUG_MODELS_TIMEOUT_MS
+    });
+    if (result.error || result.status !== 0 || !result.stdout)
+      return [];
+    return parseCodexModelCatalog(result.stdout);
+  } catch {
+    return [];
+  }
+}
+function parseCodexModelCatalog(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (!Array.isArray(parsed.models))
+      return [];
+    const models2 = [];
+    for (const raw of parsed.models) {
+      const info = raw;
+      const slug = typeof info.slug === "string" && info.slug.trim() ? info.slug.trim() : "";
+      if (!slug)
+        continue;
+      models2.push({
+        id: slug,
+        name: typeof info.display_name === "string" && info.display_name ? info.display_name : slug
+      });
+    }
+    return models2;
+  } catch {
+    return [];
+  }
+}
+function codexCliVersion() {
+  const codex = resolveCommandOnPath("codex");
+  if (!codex)
+    return void 0;
+  try {
+    const result = spawnSync2(codex, ["--version"], { encoding: "utf8", timeout: 15e3 });
+    if (result.error || result.status !== 0 || !result.stdout)
+      return void 0;
+    return result.stdout.trim().match(/\d+\.\d+[\w.-]*/)?.[0];
+  } catch {
+    return void 0;
+  }
+}
+
+// src/daemon/providers/codex/codex-preset.ts
 var CODEX_PROVIDER_KEY = "codex";
 var CODEX_DISPLAY_NAME = "Codex";
 var CODEX_ACP_MATCH_ARGS = "codex-acp";
 var CODEX_ACP_PACKAGE = "@agentclientprotocol/codex-acp";
 var CODEX_INIT_TIMEOUT_MS = 12e4;
 var CODEX_SUBSCRIPTION_MAX_CONCURRENT = 1;
+var CODEX_CUSTOM_PROVIDER_ID = "morula_custom";
 function hostCodexAuthFile() {
   return join18(homedir12(), ".codex", "auth.json");
 }
+function resolveCodexCustomEndpoint(configuredEnv) {
+  const baseUrl = configuredEnv.CODEX_BASE_URL?.trim();
+  if (!baseUrl)
+    return null;
+  return {
+    baseUrl,
+    apiKey: configuredEnv.CODEX_API_KEY?.trim() || void 0,
+    model: configuredEnv.CODEX_MODEL?.trim() || void 0
+  };
+}
+function readHostCodexAuthShape() {
+  const file = hostCodexAuthFile();
+  if (!existsSync14(file))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync10(file, "utf8"));
+    const tokens = parsed.tokens;
+    const hasToken = !!tokens && (typeof tokens.access_token === "string" && tokens.access_token.length > 0 || typeof tokens.refresh_token === "string" && tokens.refresh_token.length > 0 || typeof tokens.id_token === "string" && tokens.id_token.length > 0);
+    if (hasToken)
+      return "subscription";
+    if (typeof parsed.OPENAI_API_KEY === "string" && parsed.OPENAI_API_KEY.length > 0)
+      return "api-key-file";
+    return null;
+  } catch {
+    return null;
+  }
+}
+function hostCodexHasCustomProvider() {
+  const base = readHostCodexConfigToml();
+  if (base === null)
+    return false;
+  return /^[ \t]*model_provider[ \t]*=/m.test(base) && /^\[model_providers\./m.test(base);
+}
 function resolveCodexAuthMode(configuredEnv) {
+  const custom = resolveCodexCustomEndpoint(configuredEnv);
+  const hostAuth = readHostCodexAuthShape();
+  if (custom) {
+    if (hostAuth) {
+      return {
+        mode: "none",
+        custom,
+        conflictError: "CODEX_AUTH_CONFLICT: \u540C\u65F6\u68C0\u6D4B\u5230\u7B2C\u4E09\u65B9\u7AEF\u70B9\u914D\u7F6E\uFF08CODEX_BASE_URL\uFF09\u4E0E\u5BBF\u4E3B\u767B\u5F55\u6001\uFF08~/.codex/auth.json\uFF09\uFF1B\u4E24\u79CD\u8BA4\u8BC1\u5F62\u6001\u4E92\u65A5\uFF0C\u8BF7\u53EA\u4FDD\u7559\u5176\u4E00\uFF08\u5220\u9664 env \u914D\u7F6E\u6216\u5BBF\u4E3B `codex logout`\uFF09"
+      };
+    }
+    return { mode: "custom-endpoint", custom };
+  }
   const apiKey = configuredEnv.CODEX_API_KEY || configuredEnv.OPENAI_API_KEY || void 0;
-  const hasHostAuth = existsSync14(hostCodexAuthFile());
-  if (apiKey && hasHostAuth) {
+  if (apiKey && hostAuth) {
     return {
       mode: "none",
-      conflictError: "CODEX_AUTH_CONFLICT: \u540C\u65F6\u68C0\u6D4B\u5230 API key \u914D\u7F6E\uFF08CODEX_API_KEY / OPENAI_API_KEY\uFF09\u4E0E\u5BBF\u4E3B\u8BA2\u9605\u767B\u5F55\u6001\uFF08~/.codex/auth.json\uFF09\uFF1B\u4E24\u79CD\u8BA4\u8BC1\u5F62\u6001\u4E92\u65A5\uFF0C\u8BF7\u53EA\u4FDD\u7559\u5176\u4E00\uFF08\u5220\u9664 env \u914D\u7F6E\u6216\u5BBF\u4E3B `codex logout`\uFF09"
+      conflictError: "CODEX_AUTH_CONFLICT: \u540C\u65F6\u68C0\u6D4B\u5230 API key \u914D\u7F6E\uFF08CODEX_API_KEY / OPENAI_API_KEY\uFF09\u4E0E\u5BBF\u4E3B\u767B\u5F55\u6001\uFF08~/.codex/auth.json\uFF09\uFF1B\u4E24\u79CD\u8BA4\u8BC1\u5F62\u6001\u4E92\u65A5\uFF0C\u8BF7\u53EA\u4FDD\u7559\u5176\u4E00\uFF08\u5220\u9664 env \u914D\u7F6E\u6216\u5BBF\u4E3B `codex logout`\uFF09"
     };
   }
   if (apiKey)
     return { mode: "api-key", apiKey };
-  if (hasHostAuth)
+  if (hostAuth === "subscription")
     return { mode: "subscription" };
+  if (hostAuth === "api-key-file")
+    return { mode: "host-api-key" };
+  if (hostCodexHasCustomProvider())
+    return { mode: "host-config" };
   return { mode: "none" };
 }
 function resolveCodexAcpLaunch() {
@@ -7253,9 +7491,10 @@ async function prepareCodexTaskHome(home, configuredEnv) {
   if (auth.conflictError)
     throw new Error(auth.conflictError);
   const authFile = join18(home, "auth.json");
-  if (auth.mode === "api-key") {
+  if (auth.mode === "custom-endpoint") {
+  } else if (auth.mode === "api-key") {
     writeFileSync10(authFile, JSON.stringify({ OPENAI_API_KEY: auth.apiKey }, null, 2), { mode: 384 });
-  } else if (auth.mode === "subscription") {
+  } else if (auth.mode === "subscription" || auth.mode === "host-api-key") {
     const target = hostCodexAuthFile();
     if (!existsSync14(authFile)) {
       symlinkSync(target, authFile);
@@ -7263,10 +7502,71 @@ async function prepareCodexTaskHome(home, configuredEnv) {
   }
   const configToml = join18(home, "config.toml");
   if (!existsSync14(configToml)) {
-    writeFileSync10(configToml, '# managed by morula daemoncli_auth_credentials_store = "file"\n', { mode: 384 });
+    writeFileSync10(configToml, buildCodexConfigToml(auth), { mode: 384 });
   }
+  if (auth.mode !== "custom-endpoint" && auth.mode !== "api-key")
+    copyHostCodexReferencedFiles(home);
   return {};
 }
+function copyHostCodexReferencedFiles(home) {
+  const base = readHostCodexConfigToml();
+  if (base === null)
+    return;
+  const match = base.match(/^[ \t]*model_catalog_json[ \t]*=[ \t]*"([^"]+)"/m);
+  if (!match)
+    return;
+  const fileName = match[1];
+  if (!fileName || fileName.startsWith("/"))
+    return;
+  try {
+    const src = join18(homedir12(), ".codex", fileName);
+    if (existsSync14(src) && !existsSync14(join18(home, fileName)))
+      copyFileSync3(src, join18(home, fileName));
+  } catch {
+  }
+}
+function buildCodexConfigToml(auth) {
+  if (auth.mode === "custom-endpoint" && auth.custom) {
+    const custom = auth.custom;
+    const lines = [
+      "# managed by morula daemon",
+      'cli_auth_credentials_store = "file"'
+    ];
+    if (custom.model)
+      lines.push(`model = ${JSON.stringify(custom.model)}`);
+    lines.push(`model_provider = ${JSON.stringify(CODEX_CUSTOM_PROVIDER_ID)}`, "");
+    lines.push(`[model_providers.${CODEX_CUSTOM_PROVIDER_ID}]`);
+    lines.push(`name = ${JSON.stringify("Custom endpoint (morula)")}`);
+    lines.push(`base_url = ${JSON.stringify(custom.baseUrl)}`);
+    if (custom.apiKey)
+      lines.push('env_key = "CODEX_API_KEY"');
+    return `${lines.join("\n")}
+`;
+  }
+  const forcedLine = 'cli_auth_credentials_store = "file"';
+  if (auth.mode === "api-key")
+    return `# managed by morula daemon
+${forcedLine}
+`;
+  const base = readHostCodexConfigToml();
+  if (base === null)
+    return `# managed by morula daemon
+${forcedLine}
+`;
+  if (/^[ \t]*cli_auth_credentials_store[ \t]*=/m.test(base))
+    return base.replace(/^[ \t]*cli_auth_credentials_store[ \t]*=.*$/m, forcedLine);
+  return `${base}
+${forcedLine}
+`;
+}
+function readHostCodexConfigToml() {
+  try {
+    const file = join18(homedir12(), ".codex", "config.toml");
+    return existsSync14(file) ? readFileSync10(file, "utf8") : null;
+  } catch {
+    return null;
+  }
+}
 var CODEX_PROVIDER_SPEC = {
   key: CODEX_PROVIDER_KEY,
   displayName: CODEX_DISPLAY_NAME,
@@ -7298,20 +7598,33 @@ var CODEX_PROVIDER_SPEC = {
   prepareTaskDataDir: prepareCodexTaskHome,
   probeExtras: async ({ configuredEnv }) => {
     const auth = resolveCodexAuthMode(configuredEnv);
+    const cliVersion = codexCliVersion();
+    const models2 = listCodexModels();
     if (auth.conflictError) {
-      return { authStatus: "error", authMode: "none", lastProbeErrorCode: "CODEX_AUTH_CONFLICT", lastProbeError: auth.conflictError };
+      return { authStatus: "error", authMode: "none", ...cliVersion ? { cliVersion } : {}, models: models2, lastProbeErrorCode: "CODEX_AUTH_CONFLICT", lastProbeError: auth.conflictError };
+    }
+    if (auth.mode === "custom-endpoint") {
+      return { authStatus: "unknown", authMode: auth.custom?.apiKey ? "api-key" : "none", ...cliVersion ? { cliVersion } : {}, models: models2 };
     }
     if (auth.mode === "api-key") {
-      return { authStatus: "unknown", authMode: "api-key" };
+      return { authStatus: "unknown", authMode: "api-key", ...cliVersion ? { cliVersion } : {}, models: models2 };
+    }
+    if (auth.mode === "host-api-key") {
+      return { authStatus: "unknown", authMode: "api-key", ...cliVersion ? { cliVersion } : {}, models: models2 };
+    }
+    if (auth.mode === "host-config") {
+      return { authStatus: "unknown", authMode: "api-key", ...cliVersion ? { cliVersion } : {}, models: models2 };
     }
     if (auth.mode === "subscription") {
-      return { authStatus: "unknown", authMode: "subscription", maxConcurrentTasks: CODEX_SUBSCRIPTION_MAX_CONCURRENT };
+      return { authStatus: "unknown", authMode: "subscription", ...cliVersion ? { cliVersion } : {}, models: models2, maxConcurrentTasks: CODEX_SUBSCRIPTION_MAX_CONCURRENT };
     }
     return {
       authStatus: "unauthenticated",
       authMode: "none",
+      ...cliVersion ? { cliVersion } : {},
+      models: models2,
       lastProbeErrorCode: "CODEX_NO_CREDENTIAL",
-      lastProbeError: "\u672A\u68C0\u6D4B\u5230 Codex \u767B\u5F55\u6001\uFF08\u5BBF\u4E3B ~/.codex/auth.json \u4E0D\u5B58\u5728\uFF0C\u4E14\u672A\u914D\u7F6E CODEX_API_KEY / OPENAI_API_KEY\uFF09\uFF1B\u5728\u5BBF\u4E3B\u6267\u884C `codex login` \u540E\u91CD\u65B0\u63A2\u6D4B\uFF0C\u6216\u5728 daemon \u914D\u7F6E\u91CC\u4E3A codex \u914D\u7F6E API key"
+      lastProbeError: "\u672A\u68C0\u6D4B\u5230 Codex \u767B\u5F55\u6001\uFF08\u5BBF\u4E3B ~/.codex/auth.json \u65E0\u6709\u6548\u51ED\u8BC1\uFF0C\u4E14\u672A\u914D\u7F6E CODEX_API_KEY / OPENAI_API_KEY\uFF09\uFF1B\u5728\u5BBF\u4E3B\u6267\u884C `codex login` \u540E\u91CD\u65B0\u63A2\u6D4B\uFF0C\u6216\u5728 daemon \u914D\u7F6E\u91CC\u4E3A codex \u914D\u7F6E API key\uFF08\u5B98\u65B9\u7AEF\u70B9 CODEX_API_KEY\uFF0C\u7B2C\u4E09\u65B9\u7AEF\u70B9 CODEX_BASE_URL + CODEX_API_KEY\uFF09"
     };
   },
   permissionPreset: null,
@@ -8426,13 +8739,24 @@ var DimAgentAdapter = class {
         lastProbeError = `dim model list \u5931\u8D25\uFF1A${msg}`;
       }
     }
+    let cliVersion;
+    if (installed) {
+      try {
+        const { spawnSync: spawnSync4 } = await import("node:child_process");
+        const result = spawnSync4(this.dimPath, ["--version"], { encoding: "utf8", timeout: 15e3, env: this.probeEnv() });
+        if (!result.error && result.status === 0 && result.stdout)
+          cliVersion = result.stdout.trim().match(/\d+\.\d+[\w.-]*/)?.[0];
+      } catch {
+      }
+    }
     return {
       key: "dim",
-      displayName: "Dim Agent CLI",
+      displayName: "DimAgent",
       adapterVersion: DIM_ADAPTER_VERSION,
       protocolVersion: DIM_PROTOCOL_VERSION,
       status: installed ? "available" : "unavailable",
       authStatus,
+      cliVersion,
       capabilities: installed ? await this.probeHandshakeCapabilities() : DIM_CAPABILITIES,
       lastProbeErrorCode,
       lastProbeError
@@ -8560,7 +8884,7 @@ var DIM_PROJECTION = {
 };
 var DIM_PROVIDER_SPEC = {
   key: "dim",
-  displayName: "Dim Agent CLI",
+  displayName: "DimAgent",
   launch: resolveDimAcpLaunch(),
   capabilities: DIM_CAPABILITIES,
   // dim 的权限引擎按 preset 生效：对齐 `dim exec --policy workspace-write`（§4.4 私有值）
@@ -9197,6 +9521,135 @@ function sanitizeProviderConfigPatch(raw) {
   return patch;
 }
 
+// src/daemon/providers/catalog/acp-registry.ts
+init_daemon_config();
+import { existsSync as existsSync17, mkdirSync as mkdirSync13, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname11 } from "node:path";
+var DEFAULT_ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
+var CATALOG_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
+var CATALOG_FETCH_TIMEOUT_MS = 15e3;
+function resolveRegistryUrl(env = process.env) {
+  const fromEnv = env.MORULA_ACP_REGISTRY_URL?.trim();
+  return (fromEnv || DEFAULT_ACP_REGISTRY_URL).replace(/\/+$/, "");
+}
+function catalogCachePath(env = process.env) {
+  return `${daemonDirForEnv(env)}/acp-registry.json`;
+}
+function parseRegistryDocument(raw, url, fetchedAt) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw))
+    throw new Error("ACP Registry \u54CD\u5E94\u4E0D\u662F\u5BF9\u8C61");
+  const doc = raw;
+  const agents = Array.isArray(doc.agents) ? doc.agents : [];
+  const entries = [];
+  for (const item of agents) {
+    if (!item || typeof item !== "object" || Array.isArray(item))
+      continue;
+    const a = item;
+    const id = typeof a.id === "string" ? a.id.trim() : "";
+    const name = typeof a.name === "string" ? a.name.trim() : "";
+    if (!id || !name)
+      continue;
+    entries.push({
+      id,
+      name,
+      ...typeof a.version === "string" ? { version: a.version } : {},
+      ...typeof a.description === "string" ? { description: a.description } : {},
+      ...typeof a.repository === "string" ? { repository: a.repository } : {},
+      ...typeof a.website === "string" ? { website: a.website } : {},
+      ...typeof a.license === "string" ? { license: a.license } : {},
+      ...typeof a.icon === "string" ? { icon: a.icon } : {},
+      ...a.distribution && typeof a.distribution === "object" && !Array.isArray(a.distribution) ? { distribution: a.distribution } : {}
+    });
+  }
+  entries.sort((x, y) => x.id.localeCompare(y.id));
+  return {
+    url,
+    fetchedAt,
+    ...typeof doc.version === "string" ? { registryVersion: doc.version } : {},
+    entries
+  };
+}
+function readCatalogCache(env = process.env) {
+  const path = catalogCachePath(env);
+  if (!existsSync17(path))
+    return null;
+  try {
+    const parsed = JSON.parse(readFileSync12(path, "utf8"));
+    if (!Array.isArray(parsed?.entries) || typeof parsed?.fetchedAt !== "string")
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function listCatalog(env = process.env, now = Date.now()) {
+  const cached = readCatalogCache(env);
+  if (!cached) {
+    return { url: resolveRegistryUrl(env), fetchedAt: "", entries: [], stale: true, source: "empty" };
+  }
+  const age = now - Date.parse(cached.fetchedAt);
+  return { ...cached, stale: !Number.isFinite(age) || age > CATALOG_CACHE_TTL_MS, source: "cache" };
+}
+async function refreshCatalog(options = {}) {
+  const env = options.env ?? process.env;
+  const url = options.url?.trim() || resolveRegistryUrl(env);
+  const doFetch = options.fetchImpl ?? fetch;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), CATALOG_FETCH_TIMEOUT_MS);
+  try {
+    const res = await doFetch(url, { signal: controller.signal, headers: { accept: "application/json" } });
+    if (!res.ok)
+      throw new Error(`ACP Registry \u8FD4\u56DE ${res.status}`);
+    const snapshot = parseRegistryDocument(await res.json(), url, new Date(options.now ?? Date.now()).toISOString());
+    const path = catalogCachePath(env);
+    mkdirSync13(dirname11(path), { recursive: true });
+    writeFileSync11(path, `${JSON.stringify(snapshot, null, 2)}
+`);
+    return snapshot;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+function catalogEntryLaunch(entry) {
+  const dist = entry.distribution;
+  if (!dist)
+    return null;
+  const npx = dist.npx;
+  if (npx && typeof npx.package === "string" && npx.package.trim()) {
+    const extra = Array.isArray(npx.args) ? npx.args.filter((a) => typeof a === "string") : [];
+    return { command: "npx", args: ["-y", npx.package.trim(), ...extra] };
+  }
+  const uvx = dist.uvx;
+  if (uvx && typeof uvx.package === "string" && uvx.package.trim()) {
+    const extra = Array.isArray(uvx.args) ? uvx.args.filter((a) => typeof a === "string") : [];
+    return { command: "uvx", args: [uvx.package.trim(), ...extra] };
+  }
+  return null;
+}
+function catalogEntryView(entry) {
+  return { ...entry, launch: catalogEntryLaunch(entry) };
+}
+
+// src/daemon/providers/installed-clis.ts
+function isNpxCommand(command) {
+  return command === "npx" || command === "npx.cmd" || command.endsWith("/npx") || command.endsWith("\\npx.cmd");
+}
+function probeInstalledClis() {
+  const installed = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of listCatalog().entries ?? []) {
+    if (seen.has(entry.id))
+      continue;
+    seen.add(entry.id);
+    const command = catalogEntryLaunch(entry)?.command?.trim();
+    if (!command || isNpxCommand(command))
+      continue;
+    if (resolveCommandOnPath(command))
+      installed.push({ key: entry.id, command });
+  }
+  return installed;
+}
+
 // src/daemon/providers/inventory.ts
 init_daemon_config();
 var INVENTORY_EXCLUDED = /* @__PURE__ */ new Set(["fake"]);
@@ -9309,8 +9762,8 @@ function pickLegacyDimModels(inventory) {
 
 // src/daemon/repo-cache.ts
 import { execFileSync as execFileSync8 } from "node:child_process";
-import { existsSync as existsSync17, mkdirSync as mkdirSync13 } from "node:fs";
-import { dirname as dirname11, join as join22 } from "node:path";
+import { existsSync as existsSync18, mkdirSync as mkdirSync14 } from "node:fs";
+import { dirname as dirname12, join as join22 } from "node:path";
 function ownerOf(repoFullName) {
   const idx = repoFullName.indexOf("/");
   return idx > 0 ? repoFullName.slice(0, idx) : "_default";
@@ -9328,7 +9781,7 @@ function buildRepoCachePath(workdir, tenantId, runtimeId, repoFullName) {
 function openRepoCache(workdir, tenantId, runtimeId, repoFullName, env, agentRemoteUrl, daemonRemoteUrl) {
   const repoCachePath = buildRepoCachePath(workdir, tenantId, runtimeId, repoFullName);
   const currentOrigin = () => {
-    if (!existsSync17(join22(repoCachePath, ".git")))
+    if (!existsSync18(join22(repoCachePath, ".git")))
       return null;
     try {
       return execFileSync8("git", ["-C", repoCachePath, "remote", "get-url", "origin"], { encoding: "utf8", env, stdio: "pipe" }).trim() || null;
@@ -9341,11 +9794,11 @@ function openRepoCache(workdir, tenantId, runtimeId, repoFullName, env, agentRem
   return {
     repoCachePath,
     ensure() {
-      if (existsSync17(join22(repoCachePath, ".git"))) {
+      if (existsSync18(join22(repoCachePath, ".git"))) {
         syncRemoteUrl(repoCachePath, originUrl(), env);
         return;
       }
-      mkdirSync13(dirname11(repoCachePath), { recursive: true });
+      mkdirSync14(dirname12(repoCachePath), { recursive: true });
       const cloneUrl = fetchUrl();
       try {
         execFileSync8("git", ["clone", "--filter=blob:none", cloneUrl, repoCachePath], { env, stdio: "pipe" });
@@ -9380,17 +9833,17 @@ function gitErrorText2(err) {
 
 // src/daemon/repo-checkout-service.ts
 import { execFileSync as execFileSync10 } from "node:child_process";
-import { existsSync as existsSync20, mkdirSync as mkdirSync15, readdirSync as readdirSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { existsSync as existsSync21, mkdirSync as mkdirSync16, readdirSync as readdirSync5, writeFileSync as writeFileSync14 } from "node:fs";
 import { createServer as createServer3 } from "node:http";
 import { basename as basename3, join as join25 } from "node:path";
 
 // src/daemon/worktree-manager.ts
 import { execFileSync as execFileSync9 } from "node:child_process";
-import { existsSync as existsSync19, mkdirSync as mkdirSync14, readdirSync as readdirSync4, readFileSync as readFileSync13, renameSync as renameSync3, rmSync as rmSync10, statSync as statSync4, writeFileSync as writeFileSync12 } from "node:fs";
-import { basename as basename2, dirname as dirname12, join as join24, sep as sep2 } from "node:path";
+import { existsSync as existsSync20, mkdirSync as mkdirSync15, readdirSync as readdirSync4, readFileSync as readFileSync14, renameSync as renameSync3, rmSync as rmSync10, statSync as statSync4, writeFileSync as writeFileSync13 } from "node:fs";
+import { basename as basename2, dirname as dirname13, join as join24, sep as sep2 } from "node:path";
 
 // src/daemon/workspace-marker.ts
-import { existsSync as existsSync18, readFileSync as readFileSync12, writeFileSync as writeFileSync11 } from "node:fs";
+import { existsSync as existsSync19, readFileSync as readFileSync13, writeFileSync as writeFileSync12 } from "node:fs";
 import { join as join23 } from "node:path";
 var WORKTREE_MARKER_FILE = ".morula-worktree.json";
 var WORKTREE_MARKER_SCHEMA = 1;
@@ -9398,15 +9851,15 @@ function markerPath(worktreePath) {
   return join23(worktreePath, WORKTREE_MARKER_FILE);
 }
 function writeWorktreeMarker(worktreePath, marker) {
-  writeFileSync11(markerPath(worktreePath), `${JSON.stringify(marker, null, 2)}
+  writeFileSync12(markerPath(worktreePath), `${JSON.stringify(marker, null, 2)}
 `, "utf8");
 }
 function readWorktreeMarker(worktreePath) {
   const p = markerPath(worktreePath);
-  if (!existsSync18(p))
+  if (!existsSync19(p))
     return null;
   try {
-    const raw = JSON.parse(readFileSync12(p, "utf8"));
+    const raw = JSON.parse(readFileSync13(p, "utf8"));
     return raw && raw.schemaVersion === WORKTREE_MARKER_SCHEMA ? raw : null;
   } catch {
     return null;
@@ -9441,28 +9894,28 @@ function buildLegacyWorktreePath(workdir, tenantId, workContextId, code) {
 }
 var legacyPathWarned = /* @__PURE__ */ new Set();
 function warnLegacyWorktreeResidue(legacyPath) {
-  if (legacyPathWarned.has(legacyPath) || !existsSync19(legacyPath))
+  if (legacyPathWarned.has(legacyPath) || !existsSync20(legacyPath))
     return;
   legacyPathWarned.add(legacyPath);
   console.warn(`[daemon] \u68C0\u6D4B\u5230\u65E7\u5F62\u6001 worktree \u6B8B\u7559\uFF08\u4E0D\u542B runtimeId \u6BB5\uFF09: ${legacyPath} \u2014\u2014 \u8BE5\u8DEF\u5F84\u5DF2\u5F03\u7528\uFF0C\u65B0\u4EFB\u52A1\u4F7F\u7528 <worktree>/<tenant>/<runtimeId8>/<task>\uFF1B\u786E\u8BA4\u65E0\u9700\u4FDD\u7559\u540E\u53EF\u624B\u52A8\u5220\u9664\uFF08\u4E0D\u81EA\u52A8\u8FC1\u79FB/\u6E05\u7406\uFF09`);
 }
 var legacyLayoutWarned = /* @__PURE__ */ new Set();
 function warnLegacyLayoutWorktreeResidue(taskRoot, worktreePath) {
-  if (legacyLayoutWarned.has(taskRoot) || existsSync19(worktreePath) || !existsSync19(join24(taskRoot, WORKTREE_MARKER_FILE)))
+  if (legacyLayoutWarned.has(taskRoot) || existsSync20(worktreePath) || !existsSync20(join24(taskRoot, WORKTREE_MARKER_FILE)))
     return;
   legacyLayoutWarned.add(taskRoot);
   console.warn(`[daemon] \u68C0\u6D4B\u5230\u65E7\u5E03\u5C40\u4EFB\u52A1\u5DE5\u4F5C\u533A\uFF08\u4ED3\u5E93\u76F4\u63A5\u4F4D\u4E8E\u5DE5\u4F5C\u533A\u6839\uFF09: ${taskRoot} \u2014\u2014 \u65B0\u5E03\u5C40\u4F1A\u5728\u5176\u4E0B\u521B\u5EFA\u4ED3\u5E93\u5B50\u76EE\u5F55\uFF0C\u65E7\u76EE\u5F55\u5185\u5BB9\u4E0D\u518D\u88AB\u4F7F\u7528\uFF1B\u5176\u4E2D\u53EF\u80FD\u6709\u672A\u63A8\u9001\u6539\u52A8\uFF0C\u786E\u8BA4\u65E0\u9700\u4FDD\u7559\u540E\u53EF\u624B\u52A8\u5220\u9664\uFF08\u4E0D\u81EA\u52A8\u8FC1\u79FB/\u6E05\u7406\uFF09`);
 }
 function ensureMarkerIgnoredAndCommitted(worktreePath, env) {
   const gitignorePath = join24(worktreePath, ".gitignore");
-  const existing = existsSync19(gitignorePath) ? readFileSync13(gitignorePath, "utf8") : "";
+  const existing = existsSync20(gitignorePath) ? readFileSync14(gitignorePath, "utf8") : "";
   const requiredLines = [WORKTREE_MARKER_FILE];
   const missing = requiredLines.filter((l) => !existing.split("\n").some((line) => line.trim() === l));
   if (missing.length > 0) {
     const next = `${existing.trimEnd() ? `${existing.trimEnd()}
 ` : ""}${missing.join("\n")}
 `;
-    writeFileSync12(gitignorePath, next, "utf8");
+    writeFileSync13(gitignorePath, next, "utf8");
     try {
       execFileSync9("git", ["-C", worktreePath, "add", ".gitignore"], { env, stdio: "pipe" });
       execFileSync9(
@@ -9559,10 +10012,10 @@ function indexLockPathFromError(text) {
   return m && m[0].length > "index.lock".length ? m[0] : null;
 }
 function waitForIndexLockRelease(lockPath, timeoutMs = INDEX_LOCK_WAIT_MAX_MS, pollMs = INDEX_LOCK_POLL_MS) {
-  if (!existsSync19(lockPath))
+  if (!existsSync20(lockPath))
     return true;
   const deadline = Date.now() + timeoutMs;
-  while (existsSync19(lockPath)) {
+  while (existsSync20(lockPath)) {
     const remain = deadline - Date.now();
     if (remain <= 0)
       return false;
@@ -9704,7 +10157,7 @@ function prepareWorktree(input) {
   const worktreePath = buildWorktreePath(input.workdir, input.tenantId, input.runtimeId, input.workContextId, input.code, input.repoFullName);
   warnLegacyWorktreeResidue(buildLegacyWorktreePath(input.workdir, input.tenantId, input.workContextId, input.code));
   warnLegacyLayoutWorktreeResidue(taskRoot, worktreePath);
-  if (existsSync19(worktreePath)) {
+  if (existsSync20(worktreePath)) {
     const isGitRepo = (() => {
       try {
         execFileSync9("git", ["-C", worktreePath, "rev-parse", "--git-dir"], { stdio: "pipe" });
@@ -9771,8 +10224,8 @@ function prepareWorktree(input) {
       }
     }
   }
-  if (!existsSync19(worktreePath)) {
-    mkdirSync14(join24(worktreePath, ".."), { recursive: true });
+  if (!existsSync20(worktreePath)) {
+    mkdirSync15(join24(worktreePath, ".."), { recursive: true });
     addWorktreeWithRetry(cache.repoCachePath, worktreePath, `origin/${input.baseBranch}`);
     writeWorktreeMarker(worktreePath, {
       schemaVersion: 1,
@@ -9788,9 +10241,9 @@ function prepareWorktree(input) {
   }
   {
     const dotMorulaRescue = `${worktreePath}.morula-rescue`;
-    if (existsSync19(dotMorulaRescue)) {
+    if (existsSync20(dotMorulaRescue)) {
       const dotMorulaDir = join24(worktreePath, ".morula");
-      if (!existsSync19(dotMorulaDir)) {
+      if (!existsSync20(dotMorulaDir)) {
         try {
           renameSync3(dotMorulaRescue, dotMorulaDir);
           console.warn(`[daemon] worktree \u6F02\u79FB\u81EA\u52A8\u6062\u590D: \u65E7\u7248 .morula/ \u5907\u4EFD\u5DF2\u5F52\u8FD8\uFF08checkout \u51ED\u636E\u4E0E\u6B21\u4ED3\u5E93\u4FDD\u7559\uFF09`);
@@ -9819,9 +10272,9 @@ function prepareWorktree(input) {
 }
 function resolveWorkspaceLayout(root, expected) {
   const primaryDir = join24(root, safeDirName(expected.repoFullName));
-  if (existsSync19(join24(primaryDir, WORKTREE_MARKER_FILE)))
+  if (existsSync20(join24(primaryDir, WORKTREE_MARKER_FILE)))
     return { primaryDir, legacy: false };
-  if (existsSync19(join24(root, WORKTREE_MARKER_FILE)))
+  if (existsSync20(join24(root, WORKTREE_MARKER_FILE)))
     return { primaryDir: root, legacy: true };
   return null;
 }
@@ -9885,7 +10338,7 @@ function repoHasActivity(repoPath) {
   return false;
 }
 function findActivityInReposDir(reposDir) {
-  if (!existsSync19(reposDir))
+  if (!existsSync20(reposDir))
     return null;
   let names = [];
   try {
@@ -9895,7 +10348,7 @@ function findActivityInReposDir(reposDir) {
   }
   for (const name of names) {
     const repoPath = join24(reposDir, name);
-    if (!existsSync19(join24(repoPath, ".git")))
+    if (!existsSync20(join24(repoPath, ".git")))
       continue;
     if (repoHasActivity(repoPath))
       return repoPath;
@@ -9912,14 +10365,14 @@ function findAdditionalRepoActivity(taskRoot, options = {}) {
   }
   const candidates = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join24(taskRoot, e.name)).filter((dir) => !excluded.has(dir));
   const legacyReposDir = join24(taskRoot, ".morula", "repos");
-  if (existsSync19(legacyReposDir)) {
+  if (existsSync20(legacyReposDir)) {
     try {
       candidates.push(...readdirSync4(legacyReposDir).map((n) => join24(legacyReposDir, n)));
     } catch {
     }
   }
   for (const repoPath of candidates) {
-    if (!existsSync19(join24(repoPath, ".git")))
+    if (!existsSync20(join24(repoPath, ".git")))
       continue;
     if (repoHasActivity(repoPath))
       return repoPath;
@@ -9929,7 +10382,7 @@ function findAdditionalRepoActivity(taskRoot, options = {}) {
 function cleanupInjectedSkills(dir) {
   const injectedSkillsRoots = [join24(dir, ".agents", "skills"), join24(dir, ".claude", "skills")];
   for (const injectedSkillsRoot of injectedSkillsRoots) {
-    if (!existsSync19(injectedSkillsRoot))
+    if (!existsSync20(injectedSkillsRoot))
       continue;
     try {
       for (const name of readdirSync4(injectedSkillsRoot)) {
@@ -9939,7 +10392,7 @@ function cleanupInjectedSkills(dir) {
       }
       if (readdirSync4(injectedSkillsRoot).length === 0) {
         rmSync10(injectedSkillsRoot, { recursive: true, force: true });
-        const shell = dirname12(injectedSkillsRoot);
+        const shell = dirname13(injectedSkillsRoot);
         if (readdirSync4(shell).length === 0)
           rmSync10(shell, { recursive: true, force: true });
       }
@@ -9967,7 +10420,7 @@ function collectSiblingGitCommonDirs(taskRoot, excludeDir) {
     if (!e.isDirectory() || e.name.startsWith("."))
       continue;
     const repoPath = join24(taskRoot, e.name);
-    if (repoPath === excludeDir || !existsSync19(join24(repoPath, ".git")))
+    if (repoPath === excludeDir || !existsSync20(join24(repoPath, ".git")))
       continue;
     try {
       const commonDir = execFileSync9("git", ["-C", repoPath, "rev-parse", "--path-format=absolute", "--git-common-dir"], { encoding: "utf8", stdio: "pipe" }).trim();
@@ -10002,7 +10455,7 @@ function removeTaskWorkspace(repoCachePath, taskRoot, expected) {
   }
 }
 function removeWorktree(repoCachePath, worktreePath) {
-  if (!existsSync19(worktreePath))
+  if (!existsSync20(worktreePath))
     return;
   try {
     cleanupInjectedSkills(worktreePath);
@@ -10103,8 +10556,8 @@ var LocalRepoCheckoutService = class {
     this.tasks.set(taskId, { workdir, checkToken, primaryRepoDir });
     try {
       const dir = join25(workdir, ".morula");
-      mkdirSync15(dir, { recursive: true, mode: 448 });
-      writeFileSync13(join25(dir, "checkout.json"), JSON.stringify({
+      mkdirSync16(dir, { recursive: true, mode: 448 });
+      writeFileSync14(join25(dir, "checkout.json"), JSON.stringify({
         taskId,
         port: this.boundPort,
         checkToken
@@ -10271,11 +10724,11 @@ function isReadOnlyRepoDir(dirName) {
 }
 function resolveRepoTargetDir(taskRoot, base) {
   const direct = join25(taskRoot, base);
-  if (!existsSync20(direct) || existsSync20(join25(direct, ".git")))
+  if (!existsSync21(direct) || existsSync21(join25(direct, ".git")))
     return direct;
   for (let i = 2; i < 100; i++) {
     const candidate = join25(taskRoot, `${base}-${i}`);
-    if (!existsSync20(candidate))
+    if (!existsSync21(candidate))
       return candidate;
   }
   throw new Error(`REPO_DIR_CONFLICT: ${taskRoot} \u4E0B\u65E0\u6CD5\u4E3A ${base} \u5206\u914D\u4ED3\u5E93\u76EE\u5F55`);
@@ -10283,7 +10736,7 @@ function resolveRepoTargetDir(taskRoot, base) {
 function materializeReadWorktree(input) {
   const worktreePath = resolveRepoTargetDir(input.taskRoot, `${safeRepoDirName(input.repoFullName)}${READ_ONLY_REPO_DIR_SUFFIX}`);
   const targetRef = resolveReadRef(input.repoCachePath, input.env, input.ref, input.baseBranch);
-  if (existsSync20(join25(worktreePath, ".git"))) {
+  if (existsSync21(join25(worktreePath, ".git"))) {
     const current = currentBranchName(worktreePath);
     if (current)
       throw new Error(`READ_WORKTREE_DIRTY: \u53EA\u8BFB\u68C0\u51FA\u5DF2\u5207\u5230\u5206\u652F ${current}\uFF0C\u62D2\u7EDD\u81EA\u52A8\u66F4\u65B0\uFF08\u8BF7\u6E05\u7406\u8BE5\u76EE\u5F55\u540E\u91CD\u8BD5\uFF09`);
@@ -10291,7 +10744,7 @@ function materializeReadWorktree(input) {
       throw new Error("READ_WORKTREE_DIRTY: \u53EA\u8BFB\u68C0\u51FA\u5B58\u5728\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u62D2\u7EDD\u81EA\u52A8\u66F4\u65B0\uFF08\u8BF7\u6E05\u7406\u8BE5\u76EE\u5F55\u540E\u91CD\u8BD5\uFF09");
     execFileSync10("git", ["-C", worktreePath, "checkout", "--detach", targetRef], { env: input.env, stdio: "pipe" });
   } else {
-    mkdirSync15(join25(worktreePath, ".."), { recursive: true });
+    mkdirSync16(join25(worktreePath, ".."), { recursive: true });
     execFileSync10("git", ["-C", input.repoCachePath, "worktree", "add", "--detach", worktreePath, targetRef], {
       env: input.env,
       stdio: "pipe"
@@ -10363,7 +10816,7 @@ function listMaterializedRepoDirs(taskRoot, options = {}) {
   } catch {
     return [];
   }
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join25(taskRoot, e.name)).filter((dir) => !excluded.has(dir) && !isReadOnlyRepoDir(basename3(dir))).filter((dir) => existsSync20(join25(dir, ".git"))).sort();
+  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => join25(taskRoot, e.name)).filter((dir) => !excluded.has(dir) && !isReadOnlyRepoDir(basename3(dir))).filter((dir) => existsSync21(join25(dir, ".git"))).sort();
 }
 function parseRepoFullNameFromRemoteUrl(url) {
   const raw = url?.trim();
@@ -10448,7 +10901,7 @@ function syncGitIdentity(primaryDir, targetDir, env) {
   }
 }
 function materializeAdditionalRepo(input) {
-  if (existsSync20(join25(input.targetPath, ".git"))) {
+  if (existsSync21(join25(input.targetPath, ".git"))) {
     const current = currentBranchName(input.targetPath);
     if (!current && !hasLocalChanges2(input.targetPath, input.env)) {
       const targetRef = resolveReadRef(input.repoCachePath, input.env, void 0, input.baseBranch);
@@ -10468,7 +10921,7 @@ function materializeAdditionalRepo(input) {
   }
   if (!baseRef)
     throw new Error("BASE_REF_NOT_FOUND: repo cache \u65E0\u53EF\u7528\u8FDC\u7AEF\u5F15\u7528\uFF08origin/<base> / origin/main / origin/master\uFF09");
-  mkdirSync15(join25(input.targetPath, ".."), { recursive: true });
+  mkdirSync16(join25(input.targetPath, ".."), { recursive: true });
   execFileSync10("git", ["-C", input.repoCachePath, "worktree", "add", "--detach", input.targetPath, baseRef], {
     env: input.env,
     stdio: "pipe"
@@ -10479,7 +10932,7 @@ function materializeAdditionalRepo(input) {
 // src/daemon/session-host.ts
 init_dist2();
 init_acp_connection();
-import { mkdirSync as mkdirSync16, writeFileSync as writeFileSync14 } from "node:fs";
+import { mkdirSync as mkdirSync17, writeFileSync as writeFileSync15 } from "node:fs";
 import { join as join27 } from "node:path";
 init_daemon_config();
 
@@ -10755,7 +11208,7 @@ var SessionHost = class {
     if (!cmd?.sessionId || !cmd?.tenantId || !cmd?.projectId)
       return { ok: false, error: "SESSION_OPEN_INVALID_ARGS" };
     const workspaceDir = join27(this.options.workdir, "steward", cmd.tenantId, cmd.projectId);
-    mkdirSync16(workspaceDir, { recursive: true });
+    mkdirSync17(workspaceDir, { recursive: true });
     const providerKey = cmd.providerKey?.trim() || "dim";
     if (isProviderDisabled(this.options.configStore ?? null, providerKey))
       return { ok: false, error: `PROVIDER_DISABLED: ${providerKey} \u5DF2\u5728\u8BBE\u5907\u672C\u5730\u505C\u7528` };
@@ -11144,9 +11597,9 @@ ${fileRefs.join("\n")}` : text }];
         if (attachment.isImage) {
           blocks.push({ type: "image", data: bytes.toString("base64"), mimeType: attachment.fileType || "image/png" });
         } else {
-          mkdirSync16(dir, { recursive: true });
+          mkdirSync17(dir, { recursive: true });
           const target = join27(dir, safeAttachmentName(attachment.fileName));
-          writeFileSync14(target, bytes);
+          writeFileSync15(target, bytes);
           fileRefs.push(`- ${attachment.fileName} \u2192 ${target}`);
         }
       } catch (err) {
@@ -11255,17 +11708,17 @@ ${fileRefs.join("\n")}` : text }];
     const skillContent = buildStewardSkillFile();
     if (projection.skillsDir) {
       const skillDir = join27(workspaceDir, projection.skillsDir, STEWARD_SKILL_NAME);
-      mkdirSync16(skillDir, { recursive: true });
-      writeFileSync14(join27(skillDir, "SKILL.md"), skillContent, "utf8");
+      mkdirSync17(skillDir, { recursive: true });
+      writeFileSync15(join27(skillDir, "SKILL.md"), skillContent, "utf8");
     }
     if (projection.promptsDir) {
       const promptsDir = join27(workspaceDir, projection.promptsDir);
-      mkdirSync16(promptsDir, { recursive: true });
-      writeFileSync14(join27(promptsDir, `${STEWARD_SKILL_NAME}.md`), skillContent, "utf8");
+      mkdirSync17(promptsDir, { recursive: true });
+      writeFileSync15(join27(promptsDir, `${STEWARD_SKILL_NAME}.md`), skillContent, "utf8");
     }
     const contextDir = join27(workspaceDir, projection.contextDir);
-    mkdirSync16(contextDir, { recursive: true });
-    writeFileSync14(
+    mkdirSync17(contextDir, { recursive: true });
+    writeFileSync15(
       join27(contextDir, "steward-context.md"),
       buildStewardContextMd(cmd.facts ?? { projectId: cmd.projectId, tenantId: cmd.tenantId }, paths),
       "utf8"
@@ -12491,6 +12944,7 @@ var DaemonRunner = class {
       // 对它显示按钮只会误导用户（能力自报比服务端维护最低版本号更准确，register 即刷新）
       hostCapabilities: { worktreeV2: true, workspaceCleanupV1: false, selfUpgrade: true },
       inventoryRevision: `daemon-v${BUILD_VERSION2}`,
+      installedClis: probeInstalledClis(),
       providers: inventory
     });
     this.runtimeId = registered.id;
@@ -13002,10 +13456,10 @@ var DaemonRunner = class {
         env = { ...env, ...buildRepoEnv(spaceToken.token, spaceToken.baseUrl) };
       repoDir = join28(cfg.workdir, "scratch", taskId);
       taskRoot = repoDir;
-      mkdirSync17(repoDir, { recursive: true });
+      mkdirSync18(repoDir, { recursive: true });
       const readme = join28(repoDir, "README.md");
-      if (!existsSync21(readme)) {
-        writeFileSync15(
+      if (!existsSync22(readme)) {
+        writeFileSync16(
           readme,
           `# \u9694\u79BB\u5DE5\u4F5C\u533A\uFF08\u4EFB\u52A1 ${taskId}\uFF09
 
@@ -13061,9 +13515,9 @@ var DaemonRunner = class {
     env.GCX_AGENT_MODE = "1";
     try {
       const configPath = gcxConfigPathForTaskRoot(taskRoot);
-      mkdirSync17(dirname13(configPath), { recursive: true });
-      if (!existsSync21(configPath))
-        writeFileSync15(configPath, GCX_CONFIG_SKELETON, "utf8");
+      mkdirSync18(dirname14(configPath), { recursive: true });
+      if (!existsSync22(configPath))
+        writeFileSync16(configPath, GCX_CONFIG_SKELETON, "utf8");
       env.GCX_CONFIG = configPath;
     } catch (error) {
       this.log(`[daemon] \u4EFB\u52A1 ${taskId} GCX_CONFIG \u6CE8\u5165\u5931\u8D25\uFF08\u4E0D\u5F71\u54CD\u4EFB\u52A1\u6267\u884C\uFF09: ${error instanceof Error ? error.message : String(error)}`);
@@ -13361,7 +13815,7 @@ var DaemonRunner = class {
     const supportsResume = this.providerCapabilities.get(providerKey)?.sessionResume === true;
     const resumeSessionId = supportsResume ? detail.acpSessionId ?? detail.lastRun?.acpSessionId ?? null : null;
     const resumeWorkDir = detail.acpWorkDir ?? detail.lastRun?.acpWorkDir ?? null;
-    const canResume = !!resumeSessionId && !!resumeWorkDir && existsSync21(resumeWorkDir);
+    const canResume = !!resumeSessionId && !!resumeWorkDir && existsSync22(resumeWorkDir);
     const input = {
       executionId: `${taskId}:1`,
       // task-workspace-layout：新会话 cwd = 任务工作区根（AGENTS.md/.agents 在根下，仓库在子目录）
@@ -13688,16 +14142,16 @@ function writeCustomSkills(targetDir, skills, log, projection = resolveInstructi
 ${skill.content ?? ""}`;
     if (skillsBase) {
       const dir = join28(skillsBase, name);
-      if (dirname13(dir) !== skillsBase) {
+      if (dirname14(dir) !== skillsBase) {
         log?.(`[daemon] \u8DF3\u8FC7\u8D8A\u754C skill \u8DEF\u5F84: ${JSON.stringify(name)}`);
         continue;
       }
-      mkdirSync17(dir, { recursive: true });
-      writeFileSync15(join28(dir, "SKILL.md"), content, "utf8");
+      mkdirSync18(dir, { recursive: true });
+      writeFileSync16(join28(dir, "SKILL.md"), content, "utf8");
     }
     if (promptsBase) {
-      mkdirSync17(promptsBase, { recursive: true });
-      writeFileSync15(join28(promptsBase, `${name}.md`), content, "utf8");
+      mkdirSync18(promptsBase, { recursive: true });
+      writeFileSync16(join28(promptsBase, `${name}.md`), content, "utf8");
     }
   }
 }
@@ -13720,22 +14174,22 @@ ${buildPlatformSkillBody(paths)}`;
   if (projection.skillsDir) {
     const dir = join28(targetDir, projection.skillsDir, COLLABORATION_SKILL_NAME);
     const refsDir = join28(dir, "references");
-    mkdirSync17(refsDir, { recursive: true });
-    writeFileSync15(join28(dir, "SKILL.md"), entry, "utf8");
+    mkdirSync18(refsDir, { recursive: true });
+    writeFileSync16(join28(dir, "SKILL.md"), entry, "utf8");
     for (const r of refs)
-      writeFileSync15(join28(refsDir, `${r.name}.md`), r.content, "utf8");
+      writeFileSync16(join28(refsDir, `${r.name}.md`), r.content, "utf8");
     const legacyDir = join28(targetDir, projection.skillsDir, LEGACY_COLLABORATION_SKILL_NAME);
-    mkdirSync17(legacyDir, { recursive: true });
-    writeFileSync15(join28(legacyDir, "SKILL.md"), LEGACY_REDIRECT_STUB, "utf8");
+    mkdirSync18(legacyDir, { recursive: true });
+    writeFileSync16(join28(legacyDir, "SKILL.md"), LEGACY_REDIRECT_STUB, "utf8");
     wroteTo.push(projection.skillsDir);
   }
   if (projection.promptsDir) {
     const promptsDir = join28(targetDir, projection.promptsDir);
-    mkdirSync17(promptsDir, { recursive: true });
-    writeFileSync15(join28(promptsDir, `${COLLABORATION_SKILL_NAME}.md`), entry, "utf8");
+    mkdirSync18(promptsDir, { recursive: true });
+    writeFileSync16(join28(promptsDir, `${COLLABORATION_SKILL_NAME}.md`), entry, "utf8");
     for (const r of refs)
-      writeFileSync15(join28(promptsDir, `${COLLABORATION_SKILL_NAME}-${r.name}.md`), r.content, "utf8");
-    writeFileSync15(join28(promptsDir, `${LEGACY_COLLABORATION_SKILL_NAME}.md`), LEGACY_REDIRECT_STUB, "utf8");
+      writeFileSync16(join28(promptsDir, `${COLLABORATION_SKILL_NAME}-${r.name}.md`), r.content, "utf8");
+    writeFileSync16(join28(promptsDir, `${LEGACY_COLLABORATION_SKILL_NAME}.md`), LEGACY_REDIRECT_STUB, "utf8");
     wroteTo.push(projection.promptsDir);
   }
   if (wroteTo.length === 0) {
@@ -13774,7 +14228,7 @@ function resolveContractPlatform(availableRepos, boundRepo, boundBaseUrl, boundB
 }
 function writeTaskContextBrief(targetDir, taskId, detail, repo, log, projection = resolveInstructionProjection("dim")) {
   const briefDir = join28(targetDir, projection.contextDir);
-  mkdirSync17(briefDir, { recursive: true });
+  mkdirSync18(briefDir, { recursive: true });
   const contractPath = projection.contractPath ?? contractPathsFor(projection).contractPath;
   const brief = `# \u4EFB\u52A1\u4E0A\u4E0B\u6587\uFF08Task Context\uFF09
 
@@ -13785,7 +14239,7 @@ function writeTaskContextBrief(targetDir, taskId, detail, repo, log, projection
 ---
 
 ${buildTaskPromptWithContract(detail, void 0, projection)}`;
-  writeFileSync15(join28(briefDir, "task-context.md"), brief, "utf8");
+  writeFileSync16(join28(briefDir, "task-context.md"), brief, "utf8");
   log?.(`[daemon] \u5DF2\u6CE8\u5165\u4EFB\u52A1\u4E0A\u4E0B\u6587 brief \u5230 ${join28(projection.contextDir, "task-context.md")}`);
 }
 var PROJECT_AGENTS_MD_MAX_CHARS = 1e5;
@@ -13799,9 +14253,9 @@ function writeProjectAgentsMd(targetDir, agentsMd, log, projection = resolveInst
     log?.(`[daemon] \u7A7A\u95F4 AGENTS.md \u5185\u5BB9\u8D85\u957F\uFF08${content.length} \u5B57\u7B26 > ${PROJECT_AGENTS_MD_MAX_CHARS}\uFF09\uFF0C\u5DF2\u622A\u65AD\u5199\u5165`);
     content = content.slice(0, PROJECT_AGENTS_MD_MAX_CHARS);
   }
-  mkdirSync17(targetDir, { recursive: true });
+  mkdirSync18(targetDir, { recursive: true });
   for (const file of projection.memoryFiles) {
-    writeFileSync15(join28(targetDir, file), `${content}
+    writeFileSync16(join28(targetDir, file), `${content}
 `, "utf8");
   }
   log?.(`[daemon] \u5DF2\u6CE8\u5165\u7A7A\u95F4\u9879\u76EE\u8BF4\u660E\u5230 ${projection.memoryFiles.join(" + ")}\uFF08${content.length} \u5B57\u7B26\uFF0C\u4F5C\u4E3A\u9879\u76EE\u8BF4\u660E\u81EA\u52A8\u52A0\u8F7D\uFF09`);
@@ -13826,9 +14280,9 @@ ${core}` : core;
 
 ${core}` : core;
   }
-  mkdirSync17(targetDir, { recursive: true });
+  mkdirSync18(targetDir, { recursive: true });
   for (const file of projection.memoryFiles) {
-    writeFileSync15(join28(targetDir, file), `${combined}
+    writeFileSync16(join28(targetDir, file), `${combined}
 `, "utf8");
   }
   log?.(`[daemon] \u5DF2\u6CE8\u5165 ${projection.memoryFiles.join(" + ")}\uFF08\u7A7A\u95F4\u8BF4\u660E ${userContent.length} \u5B57\u7B26 + \u5951\u7EA6\u6838\u5FC3\u6BB5\uFF0C\u6052\u5B9A\u52A0\u8F7D\uFF09`);
@@ -13889,7 +14343,7 @@ async function reportRepoTargets(taskId, targets, env, ops) {
 }
 async function reportOneRepoTarget(taskId, target, env, ops) {
   const execEnv = mergeExecEnv(env);
-  if (!existsSync21(target.dir) || !existsSync21(join28(target.dir, ".git"))) {
+  if (!existsSync22(target.dir) || !existsSync22(join28(target.dir, ".git"))) {
     ops.log(`[daemon] \u4EFB\u52A1 ${taskId} \u4ED3\u5E93 ${target.repoFullName} \u4EA4\u4ED8\u8DF3\u8FC7\uFF1A\u5DE5\u4F5C\u76EE\u5F55\u5DF2\u4E0D\u5B58\u5728\uFF08cleanup/\u5206\u652F\u6539\u540D\u65F6\u5E8F\uFF09`);
     return;
   }
@@ -14057,9 +14511,9 @@ Task ref: ${taskCode}\uFF08\u7531 morula \u81EA\u52A8\u8865\u5145\uFF0C\u7528\u4
 
 // src/commands/doctor.ts
 init_dist2();
-import { existsSync as existsSync22, readFileSync as readFileSync14, realpathSync } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync15, realpathSync } from "node:fs";
 import { homedir as homedir15 } from "node:os";
-import { dirname as dirname14, join as join29 } from "node:path";
+import { dirname as dirname15, join as join29 } from "node:path";
 init_daemon_config();
 init_daemon_lock();
 var BUILTIN_PROVIDER_KEYS2 = ["dim", "claude", "codex"];
@@ -14082,16 +14536,16 @@ async function collectDoctor(context, probe) {
   const env = context.env;
   const configDir = env.MORULA_CONFIG_DIR ?? join29(homedir15(), ".morula-cli");
   const configPath = env.MORULA_CONFIG ?? join29(configDir, "config.yaml");
-  const daemonPath = join29(dirname14(configPath), "daemon");
+  const daemonPath = join29(dirname15(configPath), "daemon");
   const logFile = join29(daemonPath, "daemon.log");
   const contextName = context.runtime.context ?? null;
   const baseUrl = context.runtime.baseUrl ?? null;
   const tokenPresent = Boolean(context.runtime.token);
   const tokenSource = context.runtime.tokenSource ?? null;
   let configReadable = false;
-  if (existsSync22(configPath)) {
+  if (existsSync23(configPath)) {
     try {
-      readFileSync14(configPath, "utf8");
+      readFileSync15(configPath, "utf8");
       configReadable = true;
     } catch {
       configReadable = false;
@@ -14166,7 +14620,7 @@ async function collectDoctor(context, probe) {
       hint: "morula-runtime daemon doctor --probe\uFF08\u8054\u7F51\u786E\u8BA4\u767B\u5F55\u6001\uFF09"
     });
   }
-  checks.push(configReadable ? { id: "config.readable", status: "ok", message: `\u914D\u7F6E\u53EF\u8BFB\uFF1A${configPath}` } : existsSync22(configPath) ? { id: "config.readable", status: "fail", message: `\u914D\u7F6E\u5B58\u5728\u4F46\u4E0D\u53EF\u8BFB\uFF08\u6743\u9650\uFF1F\uFF09\uFF1A${configPath}`, hint: `ls -l ${configPath}` } : { id: "config.readable", status: "warn", message: `\u914D\u7F6E\u6587\u4EF6\u5C1A\u4E0D\u5B58\u5728\uFF1A${configPath}`, hint: "morula-runtime auth login\uFF08\u767B\u5F55\u540E\u751F\u6210\uFF09" });
+  checks.push(configReadable ? { id: "config.readable", status: "ok", message: `\u914D\u7F6E\u53EF\u8BFB\uFF1A${configPath}` } : existsSync23(configPath) ? { id: "config.readable", status: "fail", message: `\u914D\u7F6E\u5B58\u5728\u4F46\u4E0D\u53EF\u8BFB\uFF08\u6743\u9650\uFF1F\uFF09\uFF1A${configPath}`, hint: `ls -l ${configPath}` } : { id: "config.readable", status: "warn", message: `\u914D\u7F6E\u6587\u4EF6\u5C1A\u4E0D\u5B58\u5728\uFF1A${configPath}`, hint: "morula-runtime auth login\uFF08\u767B\u5F55\u540E\u751F\u6210\uFF09" });
   if (!dimFound) {
     checks.push({
       id: "dim.present",
@@ -14655,7 +15109,7 @@ async function run3(context) {
     saveDaemonConfig(context.store, { name, workdir, maxConcurrent });
   }
   const resolvedWorkdir = workdir ?? loadDaemonConfig(context.store)?.workdir ?? DEFAULT_WORKDIR;
-  mkdirSync18(resolvedWorkdir, { recursive: true });
+  mkdirSync19(resolvedWorkdir, { recursive: true });
   const lockPath = join30(daemonDirForEnv(context.env), DAEMON_LOCK_FILE);
   let acquired = acquireDaemonLock(lockPath, { workdir: resolvedWorkdir });
   const restartWaitMs = Number(context.env.MORULA_DAEMON_RESTART_WAIT_MS ?? 0) || 0;
@@ -14745,7 +15199,7 @@ async function start(context) {
   }
   const dir = daemonDirForEnv(context.env);
   if (!dryRun)
-    mkdirSync18(dir, { recursive: true, mode: 448 });
+    mkdirSync19(dir, { recursive: true, mode: 448 });
   const pidFile = join30(dir, PID_FILE);
   const logFile = join30(dir, LOG_FILE);
   const lockPath = join30(dir, DAEMON_LOCK_FILE);
@@ -14759,8 +15213,8 @@ async function start(context) {
       { hint: "morula-runtime daemon status" }
     );
   }
-  if (existsSync23(pidFile)) {
-    const pid = Number(readFileSync15(pidFile, "utf8").trim());
+  if (existsSync24(pidFile)) {
+    const pid = Number(readFileSync16(pidFile, "utf8").trim());
     if (isProcessAlive(pid)) {
       throw new CliError("ALREADY_RUNNING", EXIT.CONFLICT, `daemon \u5DF2\u5728\u8FD0\u884C\uFF08pid=${pid}\uFF09\uFF1B\u5982\u9700\u5F3A\u5236\u91CD\u542F\u8BF7\u5148\u6267\u884C kill -9 ${pid}`, false, {
         hint: "morula-runtime daemon status"
@@ -14810,7 +15264,7 @@ async function start(context) {
       hint: `tail -n 50 ${logFile}`
     });
   }
-  writeFileSync16(pidFile, String(result.pid), { mode: 384 });
+  writeFileSync17(pidFile, String(result.pid), { mode: 384 });
   context.err(`[daemon] \u5DF2\u540E\u53F0\u542F\u52A8\uFF08pid=${result.pid}\uFF09\uFF0C\u65E5\u5FD7: ${logFile}`);
   return { running: true, pid: result.pid, logFile, lockFile: lockPath };
 }
@@ -14822,7 +15276,7 @@ async function stop(context) {
   const lockPath = join30(dir, DAEMON_LOCK_FILE);
   const lock = probeDaemonLock(lockPath);
   const lockPid = lock.state === "absent" ? null : lock.record?.pid ?? null;
-  const filePid = existsSync23(pidFile) ? Number(readFileSync15(pidFile, "utf8").trim()) : null;
+  const filePid = existsSync24(pidFile) ? Number(readFileSync16(pidFile, "utf8").trim()) : null;
   const pid = [lockPid, filePid].find((p) => p !== null && isProcessAlive(p)) ?? null;
   if (dryRun) {
     return {
@@ -14851,7 +15305,7 @@ async function status2(context) {
   const cfg = loadDaemonConfig(context.store);
   const dir = daemonDirForEnv(context.env);
   const lockPath = join30(dir, DAEMON_LOCK_FILE);
-  const probe = probeDaemonInstance(dirname15(configFilePathForEnv(context.env)));
+  const probe = probeDaemonInstance(dirname16(configFilePathForEnv(context.env)));
   return {
     running: probe.running,
     pid: probe.pid,
@@ -14889,117 +15343,6 @@ function parseMaxConcurrent(context) {
 // src/commands/provider.ts
 init_dist2();
 init_daemon_config();
-
-// src/daemon/providers/catalog/acp-registry.ts
-init_daemon_config();
-import { existsSync as existsSync24, mkdirSync as mkdirSync19, readFileSync as readFileSync16, writeFileSync as writeFileSync17 } from "node:fs";
-import { dirname as dirname16 } from "node:path";
-var DEFAULT_ACP_REGISTRY_URL = "https://cdn.agentclientprotocol.com/registry/v1/latest/registry.json";
-var CATALOG_CACHE_TTL_MS = 24 * 60 * 60 * 1e3;
-var CATALOG_FETCH_TIMEOUT_MS = 15e3;
-function resolveRegistryUrl(env = process.env) {
-  const fromEnv = env.MORULA_ACP_REGISTRY_URL?.trim();
-  return (fromEnv || DEFAULT_ACP_REGISTRY_URL).replace(/\/+$/, "");
-}
-function catalogCachePath(env = process.env) {
-  return `${daemonDirForEnv(env)}/acp-registry.json`;
-}
-function parseRegistryDocument(raw, url, fetchedAt) {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw))
-    throw new Error("ACP Registry \u54CD\u5E94\u4E0D\u662F\u5BF9\u8C61");
-  const doc = raw;
-  const agents = Array.isArray(doc.agents) ? doc.agents : [];
-  const entries = [];
-  for (const item of agents) {
-    if (!item || typeof item !== "object" || Array.isArray(item))
-      continue;
-    const a = item;
-    const id = typeof a.id === "string" ? a.id.trim() : "";
-    const name = typeof a.name === "string" ? a.name.trim() : "";
-    if (!id || !name)
-      continue;
-    entries.push({
-      id,
-      name,
-      ...typeof a.version === "string" ? { version: a.version } : {},
-      ...typeof a.description === "string" ? { description: a.description } : {},
-      ...typeof a.repository === "string" ? { repository: a.repository } : {},
-      ...typeof a.website === "string" ? { website: a.website } : {},
-      ...typeof a.license === "string" ? { license: a.license } : {},
-      ...typeof a.icon === "string" ? { icon: a.icon } : {},
-      ...a.distribution && typeof a.distribution === "object" && !Array.isArray(a.distribution) ? { distribution: a.distribution } : {}
-    });
-  }
-  entries.sort((x, y) => x.id.localeCompare(y.id));
-  return {
-    url,
-    fetchedAt,
-    ...typeof doc.version === "string" ? { registryVersion: doc.version } : {},
-    entries
-  };
-}
-function readCatalogCache(env = process.env) {
-  const path = catalogCachePath(env);
-  if (!existsSync24(path))
-    return null;
-  try {
-    const parsed = JSON.parse(readFileSync16(path, "utf8"));
-    if (!Array.isArray(parsed?.entries) || typeof parsed?.fetchedAt !== "string")
-      return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function listCatalog(env = process.env, now = Date.now()) {
-  const cached = readCatalogCache(env);
-  if (!cached) {
-    return { url: resolveRegistryUrl(env), fetchedAt: "", entries: [], stale: true, source: "empty" };
-  }
-  const age = now - Date.parse(cached.fetchedAt);
-  return { ...cached, stale: !Number.isFinite(age) || age > CATALOG_CACHE_TTL_MS, source: "cache" };
-}
-async function refreshCatalog(options = {}) {
-  const env = options.env ?? process.env;
-  const url = options.url?.trim() || resolveRegistryUrl(env);
-  const doFetch = options.fetchImpl ?? fetch;
-  const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), CATALOG_FETCH_TIMEOUT_MS);
-  try {
-    const res = await doFetch(url, { signal: controller.signal, headers: { accept: "application/json" } });
-    if (!res.ok)
-      throw new Error(`ACP Registry \u8FD4\u56DE ${res.status}`);
-    const snapshot = parseRegistryDocument(await res.json(), url, new Date(options.now ?? Date.now()).toISOString());
-    const path = catalogCachePath(env);
-    mkdirSync19(dirname16(path), { recursive: true });
-    writeFileSync17(path, `${JSON.stringify(snapshot, null, 2)}
-`);
-    return snapshot;
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function catalogEntryLaunch(entry) {
-  const dist = entry.distribution;
-  if (!dist)
-    return null;
-  const npx = dist.npx;
-  if (npx && typeof npx.package === "string" && npx.package.trim()) {
-    const extra = Array.isArray(npx.args) ? npx.args.filter((a) => typeof a === "string") : [];
-    return { command: "npx", args: ["-y", npx.package.trim(), ...extra] };
-  }
-  const uvx = dist.uvx;
-  if (uvx && typeof uvx.package === "string" && uvx.package.trim()) {
-    const extra = Array.isArray(uvx.args) ? uvx.args.filter((a) => typeof a === "string") : [];
-    return { command: "uvx", args: [uvx.package.trim(), ...extra] };
-  }
-  return null;
-}
-function catalogEntryView(entry) {
-  return { ...entry, launch: catalogEntryLaunch(entry) };
-}
-
-// src/commands/provider.ts
 var KNOWN_ACTIONS = ["list", "add", "set", "remove", "test", "catalog"];
 async function providerCommand(context) {
   const { action } = context.parsed;