ccem 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/index.js

@@ -7,31 +7,127 @@ import inquirer from "inquirer";
 import chalk7 from "chalk";
 import Table3 from "cli-table3";
 import { spawn as spawn3 } from "child_process";
-import * as fs8 from "fs";
-import * as path6 from "path";
-import { fileURLToPath } from "url";
+import * as fs9 from "fs";
+import * as path7 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 
-// ../../packages/core/dist/chunk-YO7HO5AS.js
+// ../../packages/core/dist/chunk-KHQOO3XJ.js
+var TIER_MODEL_ALIASES = /* @__PURE__ */ new Set(["opus", "sonnet", "haiku"]);
+function normalizeEnvConfig(envConfig, defaultRuntimeModel = "opus") {
+  const hasTierDefaults = Boolean(envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL) || Boolean(envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL) || Boolean(envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL);
+  const defaultOpusModel = envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL ?? (hasTierDefaults ? void 0 : envConfig.ANTHROPIC_MODEL);
+  const defaultSonnetModel = envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL ?? defaultOpusModel ?? (hasTierDefaults ? void 0 : envConfig.ANTHROPIC_MODEL);
+  const defaultHaikuModel = envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL ?? envConfig.ANTHROPIC_SMALL_FAST_MODEL;
+  return {
+    ...envConfig.ANTHROPIC_BASE_URL && {
+      ANTHROPIC_BASE_URL: envConfig.ANTHROPIC_BASE_URL
+    },
+    ...(envConfig.ANTHROPIC_AUTH_TOKEN ?? envConfig.ANTHROPIC_API_KEY) && {
+      ANTHROPIC_AUTH_TOKEN: envConfig.ANTHROPIC_AUTH_TOKEN ?? envConfig.ANTHROPIC_API_KEY
+    },
+    ...defaultOpusModel && {
+      ANTHROPIC_DEFAULT_OPUS_MODEL: defaultOpusModel
+    },
+    ...defaultSonnetModel && {
+      ANTHROPIC_DEFAULT_SONNET_MODEL: defaultSonnetModel
+    },
+    ...defaultHaikuModel && {
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: defaultHaikuModel
+    },
+    ANTHROPIC_MODEL: hasTierDefaults ? envConfig.ANTHROPIC_MODEL ?? defaultRuntimeModel : defaultRuntimeModel,
+    ...envConfig.CLAUDE_CODE_SUBAGENT_MODEL && {
+      CLAUDE_CODE_SUBAGENT_MODEL: envConfig.CLAUDE_CODE_SUBAGENT_MODEL
+    }
+  };
+}
+function shouldRecoverTierModel(model) {
+  return !model || TIER_MODEL_ALIASES.has(model);
+}
+function recoverEnvConfigFromLegacy(currentEnvConfig, legacyEnvConfig) {
+  const current = normalizeEnvConfig(currentEnvConfig);
+  const legacy = normalizeEnvConfig(legacyEnvConfig);
+  return {
+    ...current,
+    ...!current.ANTHROPIC_AUTH_TOKEN && legacy.ANTHROPIC_AUTH_TOKEN && {
+      ANTHROPIC_AUTH_TOKEN: legacy.ANTHROPIC_AUTH_TOKEN
+    },
+    ...shouldRecoverTierModel(current.ANTHROPIC_DEFAULT_OPUS_MODEL) && legacy.ANTHROPIC_DEFAULT_OPUS_MODEL && {
+      ANTHROPIC_DEFAULT_OPUS_MODEL: legacy.ANTHROPIC_DEFAULT_OPUS_MODEL
+    },
+    ...shouldRecoverTierModel(current.ANTHROPIC_DEFAULT_SONNET_MODEL) && legacy.ANTHROPIC_DEFAULT_SONNET_MODEL && {
+      ANTHROPIC_DEFAULT_SONNET_MODEL: legacy.ANTHROPIC_DEFAULT_SONNET_MODEL
+    },
+    ...shouldRecoverTierModel(current.ANTHROPIC_DEFAULT_HAIKU_MODEL) && legacy.ANTHROPIC_DEFAULT_HAIKU_MODEL && {
+      ANTHROPIC_DEFAULT_HAIKU_MODEL: legacy.ANTHROPIC_DEFAULT_HAIKU_MODEL
+    },
+    ...!current.CLAUDE_CODE_SUBAGENT_MODEL && legacy.CLAUDE_CODE_SUBAGENT_MODEL && {
+      CLAUDE_CODE_SUBAGENT_MODEL: legacy.CLAUDE_CODE_SUBAGENT_MODEL
+    }
+  };
+}
 var ENV_PRESETS = {
   "GLM": {
     ANTHROPIC_BASE_URL: "https://open.bigmodel.cn/api/anthropic",
-    ANTHROPIC_MODEL: "glm-4.6",
-    ANTHROPIC_SMALL_FAST_MODEL: "glm-4.5-air"
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "glm-5.1",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "glm-5.1",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "glm-4.5-air",
+    ANTHROPIC_MODEL: "opus"
   },
   "KIMI": {
     ANTHROPIC_BASE_URL: "https://api.moonshot.cn/anthropic",
-    ANTHROPIC_MODEL: "kimi-k2-thinking-turbo",
-    ANTHROPIC_SMALL_FAST_MODEL: "kimi-k2-turbo-preview"
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "kimi-k2.5",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "kimi-k2.5",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "kimi-k2.5",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "KimiCodePlan": {
+    ANTHROPIC_BASE_URL: "https://api.kimi.com/coding/",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "kimi-for-coding",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "kimi-for-coding",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "kimi-for-coding",
+    ANTHROPIC_MODEL: "opus"
   },
   "MiniMax": {
     ANTHROPIC_BASE_URL: "https://api.minimaxi.com/anthropic",
-    ANTHROPIC_MODEL: "MiniMax-M2",
-    ANTHROPIC_SMALL_FAST_MODEL: "MiniMax-M2"
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "MiniMax-M2.7",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "MiniMax-M2.7",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "MiniMax-M2.7-highspeed",
+    ANTHROPIC_MODEL: "opus"
   },
   "DeepSeek": {
     ANTHROPIC_BASE_URL: "https://api.deepseek.com/anthropic",
-    ANTHROPIC_MODEL: "deepseek-chat",
-    ANTHROPIC_SMALL_FAST_MODEL: "deepseek-chat"
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "deepseek-v4-pro",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "deepseek-v4-pro",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "deepseek-v4-flash",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "Bailian": {
+    ANTHROPIC_BASE_URL: "https://dashscope.aliyuncs.com/api/v2/apps/claude-code-proxy",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "qwen3-coder-next",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3-coder-flash",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "BailianCodePlan": {
+    ANTHROPIC_BASE_URL: "https://coding.dashscope.aliyuncs.com/api/v2/apps/claude-code-proxy",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "qwen3-coder-next",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "qwen3-coder-plus",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "qwen3-coder-flash",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "OpenRouter": {
+    ANTHROPIC_BASE_URL: "https://openrouter.ai/api/v1",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "anthropic/claude-opus-4.6",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "anthropic/claude-sonnet-4.6",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "anthropic/claude-haiku-4.5",
+    ANTHROPIC_MODEL: "opus"
+  },
+  "Ollama": {
+    ANTHROPIC_BASE_URL: "http://localhost:11434",
+    ANTHROPIC_DEFAULT_OPUS_MODEL: "gemma4:31b",
+    ANTHROPIC_DEFAULT_SONNET_MODEL: "gemma4:26b",
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: "gemma4:e4b",
+    ANTHROPIC_MODEL: "opus"
   }
 };
 var PERMISSION_PRESETS = {
@@ -338,6 +434,9 @@ import * as fsPromises from "fs/promises";
 import * as path2 from "path";
 import * as os from "os";
 import * as readline from "readline";
+import { fileURLToPath } from "url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path2.dirname(__filename);
 var CLAUDE_PROJECTS_DIR = path2.join(os.homedir(), ".claude", "projects");
 var CCEM_DIR = path2.join(os.homedir(), ".ccem");
 var CACHE_VERSION = 1;
@@ -811,9 +910,10 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
   const titleShort = theme.primary("CCEM");
   const envLabel = theme.muted("Env:   ") + theme.primary(envName);
   const baseUrl = env.ANTHROPIC_BASE_URL || "-";
-  const model = env.ANTHROPIC_MODEL || "-";
-  const fastModel = env.ANTHROPIC_SMALL_FAST_MODEL || "-";
-  const apiKey = env.ANTHROPIC_API_KEY ? env.ANTHROPIC_API_KEY.slice(0, 2) + "\u2022\u2022\u2022\u2022" + env.ANTHROPIC_API_KEY.slice(-4) : "-";
+  const runtimeModel = env.ANTHROPIC_MODEL || "-";
+  const opusModel = env.ANTHROPIC_DEFAULT_OPUS_MODEL || "-";
+  const haikuModel = env.ANTHROPIC_DEFAULT_HAIKU_MODEL || "-";
+  const authToken = env.ANTHROPIC_AUTH_TOKEN ? env.ANTHROPIC_AUTH_TOKEN.slice(0, 2) + "\u2022\u2022\u2022\u2022" + env.ANTHROPIC_AUTH_TOKEN.slice(-4) : "-";
   const truncate = (s, max) => s.length > max ? s.slice(0, max - 3) + "..." : s;
   const maskUrl = (url, max) => {
     if (url.length <= max) return url;
@@ -821,10 +921,10 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
       const parsed = new URL(url);
       const protocol = parsed.protocol + "//";
       const host = parsed.host;
-      const path7 = parsed.pathname + parsed.search;
+      const path8 = parsed.pathname + parsed.search;
       const hostStart = host.slice(0, 8);
       const hostEnd = host.slice(-4);
-      const pathPart = path7.length > 10 ? path7.slice(0, 7) + "..." : path7;
+      const pathPart = path8.length > 10 ? path8.slice(0, 7) + "..." : path8;
       return `${protocol}${hostStart}...${hostEnd}${pathPart}`;
     } catch {
       return truncate(url, max);
@@ -835,15 +935,15 @@ var renderLogoWithEnvPanel = (envName, env, defaultMode) => {
   if (isNarrow) {
     envLines = [
       envLabel,
-      theme.muted("Model:".padEnd(labelWidth)) + theme.dim(truncate(model, 25)),
-      theme.muted("Key:".padEnd(labelWidth)) + theme.dim(apiKey)
+      theme.muted("Opus:".padEnd(labelWidth)) + theme.dim(truncate(opusModel, 25)),
+      theme.muted("Token:".padEnd(labelWidth)) + theme.dim(authToken)
     ];
   } else {
     envLines = [
       envLabel + (defaultMode && PERMISSION_PRESETS[defaultMode] ? "  " + theme.accent(`[${PERMISSION_PRESETS[defaultMode].name}]`) : ""),
       theme.muted("URL:".padEnd(labelWidth)) + theme.dim(maskUrl(baseUrl, 40)),
-      theme.muted("Model:".padEnd(labelWidth)) + theme.dim(truncate(model, 15)) + "  " + theme.muted("Fast:".padEnd(labelWidth)) + theme.dim(truncate(fastModel, 15)),
-      theme.muted("Key:".padEnd(labelWidth)) + theme.dim(apiKey)
+      theme.muted("Run:".padEnd(labelWidth)) + theme.dim(truncate(runtimeModel, 12)) + "  " + theme.muted("Opus:".padEnd(labelWidth)) + theme.dim(truncate(opusModel, 15)),
+      theme.muted("Haiku:".padEnd(labelWidth)) + theme.dim(truncate(haikuModel, 15)) + "  " + theme.muted("Token:".padEnd(labelWidth)) + theme.dim(authToken)
     ];
   }
   const lines = [];
@@ -1262,7 +1362,7 @@ var selectEnvWithKeys = (registries, current) => {
 };
 
 // src/permissions.ts
-import fs5 from "fs";
+import fs6 from "fs";
 import chalk3 from "chalk";
 import Table2 from "cli-table3";
 
@@ -1315,15 +1415,367 @@ var ensureGlobalClaudeDir = () => {
 
 // src/launcher.ts
 import { spawn } from "child_process";
-import * as fs4 from "fs";
-import * as path4 from "path";
+import * as fs5 from "fs";
+import * as path5 from "path";
 import chalk2 from "chalk";
+
+// src/sessionProvenance.ts
+import { execFileSync } from "child_process";
+import fs4 from "fs";
+import { createRequire } from "module";
+import os2 from "os";
+import path4 from "path";
+var DEFAULT_CONFIG_SOURCE = "ccem";
+var STATE_DB_FILE_NAME = "state.sqlite";
+var BIND_POLL_INTERVAL_MS = 500;
+var BIND_POLL_TIMEOUT_MS = 2e4;
+var SQLITE_EXPERIMENTAL_WARNING = "SQLite is an experimental feature";
+var require2 = createRequire(import.meta.url);
+var databaseSyncCtor = null;
+var databaseSyncResolved = false;
+var sqlite3CliAvailable = null;
+function startCliClaudeProvenanceTracking(options) {
+  const envName = normalizeText(options.envName) ?? "unknown";
+  const workingDir = normalizeText(options.workingDir);
+  if (!workingDir) {
+    return null;
+  }
+  const ccemSessionId = `cli-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+  try {
+    registerLaunch({
+      ccemSessionId,
+      client: "claude",
+      envName,
+      configSource: DEFAULT_CONFIG_SOURCE,
+      workingDir,
+      permMode: normalizeText(options.permMode),
+      launchMode: "cli_external",
+      startedVia: "cli",
+      sourceSessionId: normalizeText(options.resumeSessionId)
+    });
+  } catch (error) {
+    reportTrackingError("register launch", error);
+    return null;
+  }
+  let timer = null;
+  const stop = () => {
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+  };
+  const resumeSessionId = normalizeText(options.resumeSessionId);
+  if (resumeSessionId) {
+    return { ccemSessionId, stop };
+  }
+  const startedAtMs = Date.now();
+  timer = setInterval(() => {
+    if (Date.now() - startedAtMs > BIND_POLL_TIMEOUT_MS) {
+      stop();
+      return;
+    }
+    try {
+      const jsonlPath = discoverClaudeJsonlPath(workingDir, startedAtMs);
+      if (!jsonlPath) {
+        return;
+      }
+      const sourceSessionId = readClaudeSessionId(jsonlPath) ?? normalizeText(path4.parse(jsonlPath).name);
+      if (!sourceSessionId) {
+        return;
+      }
+      bindSourceSessionId("claude", ccemSessionId, sourceSessionId);
+      stop();
+    } catch (error) {
+      reportTrackingError("bind source session id", error);
+      stop();
+    }
+  }, BIND_POLL_INTERVAL_MS);
+  return { ccemSessionId, stop };
+}
+function registerLaunch(options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const DatabaseSync = getDatabaseSyncCtor();
+  if (DatabaseSync) {
+    const db = openNodeSqliteDb(DatabaseSync);
+    try {
+      const statement = db.prepare(`
+        INSERT INTO session_provenance (
+          ccem_session_id,
+          client,
+          env_name,
+          config_source,
+          working_dir,
+          perm_mode,
+          launch_mode,
+          started_via,
+          source_session_id,
+          created_at,
+          updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ON CONFLICT(ccem_session_id) DO UPDATE SET
+          client = excluded.client,
+          env_name = excluded.env_name,
+          config_source = COALESCE(excluded.config_source, session_provenance.config_source),
+          working_dir = excluded.working_dir,
+          perm_mode = COALESCE(excluded.perm_mode, session_provenance.perm_mode),
+          launch_mode = excluded.launch_mode,
+          started_via = excluded.started_via,
+          source_session_id = COALESCE(excluded.source_session_id, session_provenance.source_session_id),
+          updated_at = excluded.updated_at
+      `);
+      statement.run(
+        options.ccemSessionId,
+        options.client,
+        options.envName,
+        normalizeText(options.configSource),
+        options.workingDir,
+        normalizeText(options.permMode),
+        options.launchMode,
+        options.startedVia,
+        normalizeText(options.sourceSessionId),
+        now,
+        now
+      );
+      return;
+    } finally {
+      db.close();
+    }
+  }
+  execSqlite3Cli(`
+    INSERT INTO session_provenance (
+      ccem_session_id,
+      client,
+      env_name,
+      config_source,
+      working_dir,
+      perm_mode,
+      launch_mode,
+      started_via,
+      source_session_id,
+      created_at,
+      updated_at
+    ) VALUES (
+      ${sqliteLiteral(options.ccemSessionId)},
+      ${sqliteLiteral(options.client)},
+      ${sqliteLiteral(options.envName)},
+      ${sqliteLiteral(normalizeText(options.configSource))},
+      ${sqliteLiteral(options.workingDir)},
+      ${sqliteLiteral(normalizeText(options.permMode))},
+      ${sqliteLiteral(options.launchMode)},
+      ${sqliteLiteral(options.startedVia)},
+      ${sqliteLiteral(normalizeText(options.sourceSessionId))},
+      ${sqliteLiteral(now)},
+      ${sqliteLiteral(now)}
+    )
+    ON CONFLICT(ccem_session_id) DO UPDATE SET
+      client = excluded.client,
+      env_name = excluded.env_name,
+      config_source = COALESCE(excluded.config_source, session_provenance.config_source),
+      working_dir = excluded.working_dir,
+      perm_mode = COALESCE(excluded.perm_mode, session_provenance.perm_mode),
+      launch_mode = excluded.launch_mode,
+      started_via = excluded.started_via,
+      source_session_id = COALESCE(excluded.source_session_id, session_provenance.source_session_id),
+      updated_at = excluded.updated_at;
+  `);
+}
+function bindSourceSessionId(client, ccemSessionId, sourceSessionId) {
+  const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const DatabaseSync = getDatabaseSyncCtor();
+  if (DatabaseSync) {
+    const db = openNodeSqliteDb(DatabaseSync);
+    try {
+      const statement = db.prepare(`
+        UPDATE session_provenance
+        SET source_session_id = ?, updated_at = ?
+        WHERE ccem_session_id = ? AND client = ?
+      `);
+      statement.run(sourceSessionId, updatedAt, ccemSessionId, client);
+      return;
+    } finally {
+      db.close();
+    }
+  }
+  execSqlite3Cli(`
+    UPDATE session_provenance
+    SET source_session_id = ${sqliteLiteral(sourceSessionId)},
+        updated_at = ${sqliteLiteral(updatedAt)}
+    WHERE ccem_session_id = ${sqliteLiteral(ccemSessionId)}
+      AND client = ${sqliteLiteral(client)};
+  `);
+}
+function openNodeSqliteDb(DatabaseSync) {
+  const dbPath = getStateDbPath();
+  fs4.mkdirSync(path4.dirname(dbPath), { recursive: true });
+  const db = new DatabaseSync(dbPath);
+  db.exec(schemaSql());
+  return db;
+}
+function getDatabaseSyncCtor() {
+  if (databaseSyncResolved) {
+    return databaseSyncCtor;
+  }
+  const originalEmitWarning = process.emitWarning;
+  process.emitWarning = ((warning, ...args) => {
+    const message = typeof warning === "string" ? warning : warning instanceof Error ? warning.message : String(warning);
+    if (message.includes(SQLITE_EXPERIMENTAL_WARNING)) {
+      return;
+    }
+    return originalEmitWarning(warning, ...args);
+  });
+  try {
+    const loaded = require2("node:sqlite");
+    databaseSyncCtor = loaded.DatabaseSync;
+  } catch {
+    databaseSyncCtor = null;
+  } finally {
+    process.emitWarning = originalEmitWarning;
+    databaseSyncResolved = true;
+  }
+  return databaseSyncCtor;
+}
+function execSqlite3Cli(statementSql) {
+  if (sqlite3CliAvailable == null) {
+    try {
+      execFileSync("sqlite3", ["-version"], { stdio: "ignore" });
+      sqlite3CliAvailable = true;
+    } catch {
+      sqlite3CliAvailable = false;
+    }
+  }
+  if (!sqlite3CliAvailable) {
+    throw new Error("sqlite3 CLI is unavailable and node:sqlite is not supported by this Node runtime");
+  }
+  const dbPath = getStateDbPath();
+  fs4.mkdirSync(path4.dirname(dbPath), { recursive: true });
+  execFileSync("sqlite3", [dbPath], {
+    input: `${schemaSql()}
+${statementSql}
+`,
+    stdio: ["pipe", "ignore", "pipe"]
+  });
+}
+function getStateDbPath() {
+  const override = normalizeText(process.env.CCEM_STATE_DB_PATH);
+  if (override) {
+    return override;
+  }
+  return path4.join(os2.homedir(), ".ccem", STATE_DB_FILE_NAME);
+}
+function schemaSql() {
+  return `
+    PRAGMA journal_mode = WAL;
+    PRAGMA synchronous = NORMAL;
+    CREATE TABLE IF NOT EXISTS session_provenance (
+      ccem_session_id TEXT PRIMARY KEY,
+      client TEXT NOT NULL,
+      env_name TEXT NOT NULL,
+      config_source TEXT,
+      working_dir TEXT NOT NULL,
+      perm_mode TEXT,
+      launch_mode TEXT NOT NULL,
+      started_via TEXT NOT NULL,
+      source_session_id TEXT,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_provenance_client_source
+      ON session_provenance (client, source_session_id);
+    CREATE INDEX IF NOT EXISTS idx_session_provenance_client_updated
+      ON session_provenance (client, updated_at DESC);
+  `;
+}
+function discoverClaudeJsonlPath(projectDir, startedAtMs) {
+  const projectsDir = path4.join(os2.homedir(), ".claude", "projects");
+  const earliestModifiedAt = startedAtMs - 15e3;
+  for (const key of projectDirKeys(projectDir)) {
+    const baseDir = path4.join(projectsDir, key);
+    if (!fs4.existsSync(baseDir)) {
+      continue;
+    }
+    const candidates = fs4.readdirSync(baseDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => {
+      const fullPath = path4.join(baseDir, entry.name);
+      return { path: fullPath, modifiedAt: fs4.statSync(fullPath).mtimeMs };
+    }).filter((candidate) => candidate.modifiedAt >= earliestModifiedAt).sort((left, right) => right.modifiedAt - left.modifiedAt);
+    if (candidates.length > 0) {
+      return candidates[0].path;
+    }
+  }
+  return null;
+}
+function projectDirKeys(projectDir) {
+  const candidates = [projectDir];
+  try {
+    candidates.push(fs4.realpathSync(projectDir));
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    if (projectDir.startsWith("/private/")) {
+      candidates.push(projectDir.slice("/private".length));
+    } else if (projectDir.startsWith("/tmp")) {
+      candidates.push(path4.posix.join("/private", projectDir));
+    } else if (projectDir.startsWith("/var/")) {
+      candidates.push(path4.posix.join("/private", projectDir));
+    }
+  }
+  return [...new Set(candidates.map(projectDirKey))];
+}
+function projectDirKey(projectDir) {
+  return projectDir.replace(/[\/\\: ]/g, "-");
+}
+function readClaudeSessionId(jsonlPath) {
+  const lines = fs4.readFileSync(jsonlPath, "utf8").split("\n");
+  for (const line of lines) {
+    if (!line.trim()) {
+      continue;
+    }
+    try {
+      const value = JSON.parse(line);
+      const sessionId = normalizeText(value.sessionId);
+      if (sessionId) {
+        return sessionId;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+function normalizeText(value) {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : void 0;
+}
+function sqliteLiteral(value) {
+  if (!value) {
+    return "NULL";
+  }
+  return `'${value.replace(/'/g, "''")}'`;
+}
+function reportTrackingError(stage, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`[ccem] Failed to ${stage}: ${message}`);
+}
+
+// src/launcher.ts
+var MANAGED_CLAUDE_ENV_KEYS = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_MODEL",
+  "CLAUDE_CODE_SUBAGENT_MODEL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_SMALL_FAST_MODEL"
+];
 function buildEnvVars(envConfig) {
   const vars = {};
   if (envConfig.ANTHROPIC_BASE_URL) vars.ANTHROPIC_BASE_URL = envConfig.ANTHROPIC_BASE_URL;
-  if (envConfig.ANTHROPIC_API_KEY) vars.ANTHROPIC_API_KEY = decrypt(envConfig.ANTHROPIC_API_KEY);
+  if (envConfig.ANTHROPIC_AUTH_TOKEN) vars.ANTHROPIC_AUTH_TOKEN = decrypt(envConfig.ANTHROPIC_AUTH_TOKEN);
+  if (envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL) vars.ANTHROPIC_DEFAULT_OPUS_MODEL = envConfig.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  if (envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL) vars.ANTHROPIC_DEFAULT_SONNET_MODEL = envConfig.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  if (envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL) vars.ANTHROPIC_DEFAULT_HAIKU_MODEL = envConfig.ANTHROPIC_DEFAULT_HAIKU_MODEL;
   if (envConfig.ANTHROPIC_MODEL) vars.ANTHROPIC_MODEL = envConfig.ANTHROPIC_MODEL;
-  if (envConfig.ANTHROPIC_SMALL_FAST_MODEL) vars.ANTHROPIC_SMALL_FAST_MODEL = envConfig.ANTHROPIC_SMALL_FAST_MODEL;
+  if (envConfig.CLAUDE_CODE_SUBAGENT_MODEL) vars.CLAUDE_CODE_SUBAGENT_MODEL = envConfig.CLAUDE_CODE_SUBAGENT_MODEL;
   return vars;
 }
 function buildPermArgs(modeName) {
@@ -1341,15 +1793,18 @@ function buildPermArgs(modeName) {
   return args;
 }
 function ensureSessionsDir() {
-  const dir = path4.join(ensureCcemDir(), "sessions");
-  if (!fs4.existsSync(dir)) {
-    fs4.mkdirSync(dir, { recursive: true });
+  const dir = path5.join(ensureCcemDir(), "sessions");
+  if (!fs5.existsSync(dir)) {
+    fs5.mkdirSync(dir, { recursive: true });
   }
   return dir;
 }
 async function launchClaude(options) {
-  const { envConfig, permMode, workingDir, sessionId, resumeSessionId, silent } = options;
+  const { envName, envConfig, permMode, workingDir, sessionId, resumeSessionId, silent } = options;
   const env = { ...process.env };
+  for (const key of MANAGED_CLAUDE_ENV_KEYS) {
+    delete env[key];
+  }
   if (envConfig) {
     Object.assign(env, buildEnvVars(envConfig));
   }
@@ -1372,21 +1827,36 @@ async function launchClaude(options) {
   if (workingDir) {
     process.chdir(workingDir);
   }
+  const effectiveWorkingDir = process.cwd();
   if (!silent && !permMode) {
     console.log(renderStarting());
   }
   const sessionsDir = ensureSessionsDir();
   return new Promise((resolve2) => {
+    let provenanceTracking = null;
     const child = spawn("claude", args, {
       stdio: "inherit",
-      shell: true,
+      shell: false,
+      // 直接执行二进制，避免 shell 注入风险
       env
     });
+    child.once("spawn", () => {
+      if (sessionId) {
+        return;
+      }
+      provenanceTracking = startCliClaudeProvenanceTracking({
+        envName: envName ?? "unknown",
+        workingDir: effectiveWorkingDir,
+        permMode,
+        resumeSessionId
+      });
+    });
     child.on("exit", (code) => {
+      provenanceTracking?.stop();
       if (sessionId) {
         try {
-          fs4.writeFileSync(
-            path4.join(sessionsDir, `${sessionId}.exit`),
+          fs5.writeFileSync(
+            path5.join(sessionsDir, `${sessionId}.exit`),
             String(code ?? 0)
           );
         } catch {
@@ -1395,7 +1865,24 @@ async function launchClaude(options) {
       process.exit(code ?? 0);
     });
     child.on("error", (err) => {
-      console.error(chalk2.red(`\u542F\u52A8 Claude Code \u5931\u8D25: ${err.message}`));
+      provenanceTracking?.stop();
+      if (err.code === "ENOENT") {
+        console.error("");
+        console.error(chalk2.red.bold("\u2718 \u672A\u627E\u5230 Claude Code"));
+        console.error("");
+        console.error(chalk2.white("  CCEM \u9700\u8981 Claude Code CLI \u624D\u80FD\u542F\u52A8\u4F1A\u8BDD\uFF0C\u4F46\u5728\u7CFB\u7EDF\u4E2D\u672A\u68C0\u6D4B\u5230 ") + chalk2.cyan("claude") + chalk2.white(" \u547D\u4EE4\u3002"));
+        console.error("");
+        console.error(chalk2.white("  \u8BF7\u5148\u5B89\u88C5 Claude Code:"));
+        console.error(chalk2.cyan("    npm install -g @anthropic-ai/claude-code"));
+        console.error("");
+        console.error(chalk2.gray("  \u5982\u679C\u5DF2\u5B89\u88C5\u4F46\u4ECD\u62A5\u9519\uFF0C\u8BF7\u68C0\u67E5:"));
+        console.error(chalk2.gray("    1. \u8FD0\u884C claude --version \u786E\u8BA4\u5B89\u88C5\u6210\u529F"));
+        console.error(chalk2.gray("    2. \u786E\u4FDD npm \u5168\u5C40\u76EE\u5F55\u5728\u7CFB\u7EDF PATH \u4E2D\uFF08npm config get prefix\uFF09"));
+        console.error(chalk2.gray("    3. \u5B89\u88C5\u540E\u8BF7\u91CD\u542F\u7EC8\u7AEF"));
+        console.error("");
+      } else {
+        console.error(chalk2.red(`\u542F\u52A8 Claude Code \u5931\u8D25: ${err.message}`));
+      }
       process.exit(1);
     });
   });
@@ -1403,14 +1890,14 @@ async function launchClaude(options) {
 
 // src/permissions.ts
 var readSettings = (settingsPath) => {
-  if (fs5.existsSync(settingsPath)) {
+  if (fs6.existsSync(settingsPath)) {
     try {
-      const content = fs5.readFileSync(settingsPath, "utf-8");
+      const content = fs6.readFileSync(settingsPath, "utf-8");
       return JSON.parse(content);
     } catch {
       console.warn(chalk3.yellow(`\u8B66\u544A: \u65E0\u6CD5\u89E3\u6790 ${settingsPath}\uFF0C\u5C06\u521B\u5EFA\u5907\u4EFD`));
       const backupPath = settingsPath + ".error." + Date.now();
-      fs5.copyFileSync(settingsPath, backupPath);
+      fs6.copyFileSync(settingsPath, backupPath);
       console.log(chalk3.gray(`\u5907\u4EFD\u5DF2\u4FDD\u5B58\u5230: ${backupPath}`));
       return {};
     }
@@ -1419,7 +1906,7 @@ var readSettings = (settingsPath) => {
 };
 var writeSettings = (settingsPath, config3) => {
   ensureClaudeDir();
-  fs5.writeFileSync(settingsPath, JSON.stringify(config3, null, 2) + "\n");
+  fs6.writeFileSync(settingsPath, JSON.stringify(config3, null, 2) + "\n");
 };
 var mergePermissions = (existing, preset) => {
   const existingAllow = existing.permissions?.allow || [];
@@ -1451,14 +1938,14 @@ var applyPermissionMode = (modeName) => {
 };
 var resetPermissions = () => {
   const settingsPath = getSettingsPath(true);
-  if (!fs5.existsSync(settingsPath)) {
+  if (!fs6.existsSync(settingsPath)) {
     console.log(chalk3.yellow("\u6CA1\u6709\u81EA\u5B9A\u4E49\u6743\u9650\u914D\u7F6E\u9700\u8981\u91CD\u7F6E"));
     return;
   }
   const config3 = readSettings(settingsPath);
   delete config3.permissions;
   if (Object.keys(config3).length === 0) {
-    fs5.unlinkSync(settingsPath);
+    fs6.unlinkSync(settingsPath);
     console.log(chalk3.green("\u5DF2\u5220\u9664\u914D\u7F6E\u6587\u4EF6\uFF08\u6587\u4EF6\u4E3A\u7A7A\uFF09"));
   } else {
     writeSettings(settingsPath, config3);
@@ -1468,7 +1955,7 @@ var resetPermissions = () => {
 };
 var showCurrentMode = () => {
   const settingsPath = getSettingsPath(true);
-  if (!fs5.existsSync(settingsPath)) {
+  if (!fs6.existsSync(settingsPath)) {
     console.log(chalk3.yellow("\u672A\u914D\u7F6E\u81EA\u5B9A\u4E49\u6743\u9650"));
     console.log(chalk3.gray(`\u6587\u4EF6\u4E0D\u5B58\u5728: ${settingsPath}`));
     return;
@@ -1518,24 +2005,24 @@ var listAvailableModes = () => {
   console.log(chalk3.gray("\n\u4E34\u65F6\u6A21\u5F0F: ccem <mode>"));
   console.log(chalk3.gray("\u6C38\u4E45\u6A21\u5F0F: ccem setup perms --<mode>"));
 };
-var runWithTempPermissions = async (modeName, envConfig) => {
+var runWithTempPermissions = async (modeName, envConfig, envName) => {
   const preset = PERMISSION_PRESETS[modeName];
   if (!preset) {
     console.error(chalk3.red(`\u672A\u77E5\u7684\u6743\u9650\u6A21\u5F0F: ${modeName}`));
     console.log(chalk3.yellow("\u53EF\u7528\u6A21\u5F0F: " + getPermissionModeNames().join(", ")));
     process.exit(1);
   }
-  await launchClaude({ envConfig, permMode: modeName });
+  await launchClaude({ envConfig, envName, permMode: modeName });
 };
 
 // src/setup.ts
-import fs6 from "fs";
+import fs7 from "fs";
 import chalk4 from "chalk";
 import { spawn as spawn2 } from "child_process";
 var readJsonFile = (filePath) => {
-  if (fs6.existsSync(filePath)) {
+  if (fs7.existsSync(filePath)) {
     try {
-      const content = fs6.readFileSync(filePath, "utf-8");
+      const content = fs7.readFileSync(filePath, "utf-8");
       return JSON.parse(content);
     } catch {
       console.warn(chalk4.yellow(`\u8B66\u544A: \u65E0\u6CD5\u89E3\u6790 ${filePath}`));
@@ -1545,7 +2032,7 @@ var readJsonFile = (filePath) => {
   return {};
 };
 var writeJsonFile = (filePath, data) => {
-  fs6.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
 };
 var setupOnboarding = () => {
   const configPath = getGlobalClaudeConfigPath();
@@ -1645,14 +2132,19 @@ var setupMcpTool = () => {
     });
   });
 };
-var runSetupInit = async () => {
+var runSetupInit = async (options = {}) => {
   console.log(chalk4.bold("\n\u{1F527} Claude Code \u521D\u59CB\u5316\u8BBE\u7F6E\n"));
   console.log(chalk4.cyan("1. \u8BBE\u7F6E onboarding \u72B6\u6001"));
   const step1 = setupOnboarding();
   console.log(chalk4.cyan("\n2. \u914D\u7F6E\u9690\u79C1\u8BBE\u7F6E"));
   const step2 = setupEnvSettings();
-  console.log(chalk4.cyan("\n3. \u5B89\u88C5 MCP \u5DE5\u5177"));
-  const step3 = await setupMcpTool();
+  let step3 = true;
+  if (options.chrome) {
+    console.log(chalk4.cyan("\n3. \u5B89\u88C5 MCP \u5DE5\u5177"));
+    step3 = await setupMcpTool();
+  } else {
+    console.log(chalk4.gray("\n3. \u5B89\u88C5 MCP \u5DE5\u5177\uFF08\u5DF2\u8DF3\u8FC7\uFF0C\u4F7F\u7528 --chrome \u542F\u7528\uFF09"));
+  }
   console.log("");
   if (step1 && step2 && step3) {
     console.log(chalk4.green.bold("\u2705 \u521D\u59CB\u5316\u5B8C\u6210\uFF01"));
@@ -1667,8 +2159,8 @@ var runSetupInit = async () => {
 
 // src/skills.ts
 import { execSync } from "child_process";
-import * as fs7 from "fs";
-import * as path5 from "path";
+import * as fs8 from "fs";
+import * as path6 from "path";
 import chalk5 from "chalk";
 var SKILL_GROUPS = {
   official: { label: "\u5B98\u65B9", icon: "\u{1F3E2}" },
@@ -1837,12 +2329,12 @@ function parseGitHubUrl(url) {
   };
 }
 function getSkillsDir() {
-  return path5.join(process.cwd(), ".claude", "skills");
+  return path6.join(process.cwd(), ".claude", "skills");
 }
 function ensureSkillsDir() {
   const skillsDir = getSkillsDir();
-  if (!fs7.existsSync(skillsDir)) {
-    fs7.mkdirSync(skillsDir, { recursive: true });
+  if (!fs8.existsSync(skillsDir)) {
+    fs8.mkdirSync(skillsDir, { recursive: true });
   } else {
     cleanupTempDirs(skillsDir);
   }
@@ -1850,11 +2342,11 @@ function ensureSkillsDir() {
 }
 function cleanupTempDirs(skillsDir) {
   try {
-    const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+    const entries = fs8.readdirSync(skillsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.isDirectory() && entry.name.startsWith(".tmp-")) {
-        const tmpPath = path5.join(skillsDir, entry.name);
-        fs7.rmSync(tmpPath, { recursive: true });
+        const tmpPath = path6.join(skillsDir, entry.name);
+        fs8.rmSync(tmpPath, { recursive: true });
       }
     }
   } catch {
@@ -1862,24 +2354,24 @@ function cleanupTempDirs(skillsDir) {
 }
 function downloadSkillWithGit(owner, repo, branch, repoPath, targetName) {
   const skillsDir = ensureSkillsDir();
-  const targetDir = path5.join(skillsDir, targetName);
-  if (fs7.existsSync(targetDir)) {
+  const targetDir = path6.join(skillsDir, targetName);
+  if (fs8.existsSync(targetDir)) {
     console.log(chalk5.yellow(`Skill "${targetName}" already exists. Updating...`));
-    fs7.rmSync(targetDir, { recursive: true });
+    fs8.rmSync(targetDir, { recursive: true });
   }
   const repoUrl = `https://github.com/${owner}/${repo}.git`;
-  const tempDir = path5.join(skillsDir, `.tmp-${Date.now()}`);
+  const tempDir = path6.join(skillsDir, `.tmp-${Date.now()}`);
   try {
-    fs7.mkdirSync(tempDir, { recursive: true });
+    fs8.mkdirSync(tempDir, { recursive: true });
     execSync(`git init`, { cwd: tempDir, stdio: "pipe" });
     execSync(`git remote add origin ${repoUrl}`, { cwd: tempDir, stdio: "pipe" });
     execSync(`git config core.sparseCheckout true`, { cwd: tempDir, stdio: "pipe" });
-    const sparseFile = path5.join(tempDir, ".git", "info", "sparse-checkout");
-    fs7.writeFileSync(sparseFile, repoPath ? `${repoPath}/
+    const sparseFile = path6.join(tempDir, ".git", "info", "sparse-checkout");
+    fs8.writeFileSync(sparseFile, repoPath ? `${repoPath}/
 ` : "*\n");
     execSync(`git pull --depth=1 origin ${branch}`, { cwd: tempDir, stdio: "pipe" });
-    const sourceDir = repoPath ? path5.join(tempDir, repoPath) : tempDir;
-    if (!fs7.existsSync(sourceDir)) {
+    const sourceDir = repoPath ? path6.join(tempDir, repoPath) : tempDir;
+    if (!fs8.existsSync(sourceDir)) {
       throw new Error(`Path "${repoPath}" not found in repository`);
     }
     copyDir(sourceDir, targetDir);
@@ -1890,22 +2382,22 @@ function downloadSkillWithGit(owner, repo, branch, repoPath, targetName) {
     console.error(chalk5.red(`Failed to download skill: ${errMsg}`));
     return false;
   } finally {
-    if (fs7.existsSync(tempDir)) {
-      fs7.rmSync(tempDir, { recursive: true });
+    if (fs8.existsSync(tempDir)) {
+      fs8.rmSync(tempDir, { recursive: true });
     }
   }
 }
 function copyDir(src, dest) {
-  fs7.mkdirSync(dest, { recursive: true });
-  const entries = fs7.readdirSync(src, { withFileTypes: true });
+  fs8.mkdirSync(dest, { recursive: true });
+  const entries = fs8.readdirSync(src, { withFileTypes: true });
   for (const entry of entries) {
     if (entry.name === ".git") continue;
-    const srcPath = path5.join(src, entry.name);
-    const destPath = path5.join(dest, entry.name);
+    const srcPath = path6.join(src, entry.name);
+    const destPath = path6.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs7.copyFileSync(srcPath, destPath);
+      fs8.copyFileSync(srcPath, destPath);
     }
   }
 }
@@ -1951,7 +2443,7 @@ function addSkillFromGitHub(urlOrPreset) {
   }
   let skillName;
   if (parsed.path) {
-    skillName = path5.basename(parsed.path);
+    skillName = path6.basename(parsed.path);
   } else {
     skillName = parsed.repo;
   }
@@ -1965,23 +2457,23 @@ function addSkillFromGitHub(urlOrPreset) {
 }
 function listInstalledSkills() {
   const skillsDir = getSkillsDir();
-  if (!fs7.existsSync(skillsDir)) {
+  if (!fs8.existsSync(skillsDir)) {
     return [];
   }
-  const entries = fs7.readdirSync(skillsDir, { withFileTypes: true });
+  const entries = fs8.readdirSync(skillsDir, { withFileTypes: true });
   return entries.filter((entry) => entry.isDirectory() && !entry.name.startsWith(".")).map((entry) => ({
     name: entry.name,
-    path: path5.join(skillsDir, entry.name)
+    path: path6.join(skillsDir, entry.name)
   }));
 }
 function removeSkill(name) {
   const skillsDir = getSkillsDir();
-  const targetDir = path5.join(skillsDir, name);
-  if (!fs7.existsSync(targetDir)) {
+  const targetDir = path6.join(skillsDir, name);
+  if (!fs8.existsSync(targetDir)) {
     console.error(chalk5.red(`Skill "${name}" not found`));
     return false;
   }
-  fs7.rmSync(targetDir, { recursive: true });
+  fs8.rmSync(targetDir, { recursive: true });
   console.log(chalk5.green(`Removed skill "${name}"`));
   return true;
 }
@@ -2143,7 +2635,9 @@ import crypto3 from "crypto";
 import chalk6 from "chalk";
 import Conf from "conf";
 var config = new Conf({
-  projectName: "claude-code-env-manager"
+  projectName: "claude-code-env-manager",
+  cwd: getCcemConfigDir()
+  // 使用统一的配置目录
 });
 var decryptWithSecret = (encryptedBase64, secret) => {
   const key = crypto3.scryptSync(secret, "ccem-salt", 32);
@@ -2171,7 +2665,11 @@ var loadFromRemote = async (url, secret) => {
   console.log(chalk6.gray("Fetching from remote..."));
   let response;
   try {
-    response = await fetch(url);
+    response = await fetch(url, {
+      headers: {
+        "X-CCEM-Key": secret
+      }
+    });
   } catch (err) {
     console.error(chalk6.red("Error: Failed to connect to server"));
     console.error(chalk6.gray(err.message));
@@ -2218,9 +2716,10 @@ var loadFromRemote = async (url, secret) => {
   for (const [name, envConfig] of Object.entries(decrypted.environments)) {
     const uniqueName = getUniqueName(name, existingNames);
     const renamed = uniqueName !== name;
-    const configToSave = { ...envConfig };
-    if (configToSave.ANTHROPIC_API_KEY) {
-      configToSave.ANTHROPIC_API_KEY = encrypt(configToSave.ANTHROPIC_API_KEY);
+    const normalizedConfig = normalizeEnvConfig(envConfig);
+    const configToSave = { ...normalizedConfig };
+    if (configToSave.ANTHROPIC_AUTH_TOKEN) {
+      configToSave.ANTHROPIC_AUTH_TOKEN = encrypt(configToSave.ANTHROPIC_AUTH_TOKEN);
     }
     registries[uniqueName] = configToSave;
     existingNames.add(uniqueName);
@@ -2241,6 +2740,7 @@ Loaded ${results.length} environment(s) from remote:`));
     }
   }
   console.log(chalk6.gray("\nRun 'ccem ls' to see all environments."));
+  return results;
 };
 
 // src/cron-skill.ts
@@ -2386,11 +2886,52 @@ Replace \\\`TARGET_ID\\\` or \\\`TARGET_NAME\\\` with the user's selection.
 `;
 
 // src/index.ts
-var __filename = fileURLToPath(import.meta.url);
-var __dirname2 = path6.dirname(__filename);
-var pkgPath = path6.resolve(__dirname2, "..", "package.json");
-var pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+var __filename2 = fileURLToPath2(import.meta.url);
+var __dirname2 = path7.dirname(__filename2);
+var pkgPath = path7.resolve(__dirname2, "..", "package.json");
+var pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
 var program = new Command();
+var DEFAULT_OFFICIAL_ENV = {
+  ANTHROPIC_BASE_URL: "https://api.anthropic.com",
+  ANTHROPIC_DEFAULT_OPUS_MODEL: "claude-opus-4-1-20250805",
+  ANTHROPIC_DEFAULT_SONNET_MODEL: "claude-opus-4-1-20250805",
+  ANTHROPIC_DEFAULT_HAIKU_MODEL: "claude-3-5-haiku-20241022",
+  ANTHROPIC_MODEL: "opus"
+};
+var MANAGED_CLAUDE_ENV_KEYS2 = [
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_AUTH_TOKEN",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_MODEL",
+  "CLAUDE_CODE_SUBAGENT_MODEL",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_SMALL_FAST_MODEL"
+];
+var shellQuote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+var clearManagedClaudeEnv = (env) => {
+  for (const key of MANAGED_CLAUDE_ENV_KEYS2) {
+    delete env[key];
+  }
+};
+var buildResolvedEnvVars = (env) => {
+  const resolved = {};
+  if (env.ANTHROPIC_BASE_URL) resolved.ANTHROPIC_BASE_URL = env.ANTHROPIC_BASE_URL;
+  if (env.ANTHROPIC_AUTH_TOKEN) resolved.ANTHROPIC_AUTH_TOKEN = decrypt(env.ANTHROPIC_AUTH_TOKEN);
+  if (env.ANTHROPIC_DEFAULT_OPUS_MODEL) resolved.ANTHROPIC_DEFAULT_OPUS_MODEL = env.ANTHROPIC_DEFAULT_OPUS_MODEL;
+  if (env.ANTHROPIC_DEFAULT_SONNET_MODEL) resolved.ANTHROPIC_DEFAULT_SONNET_MODEL = env.ANTHROPIC_DEFAULT_SONNET_MODEL;
+  if (env.ANTHROPIC_DEFAULT_HAIKU_MODEL) resolved.ANTHROPIC_DEFAULT_HAIKU_MODEL = env.ANTHROPIC_DEFAULT_HAIKU_MODEL;
+  if (env.ANTHROPIC_MODEL) resolved.ANTHROPIC_MODEL = env.ANTHROPIC_MODEL;
+  if (env.CLAUDE_CODE_SUBAGENT_MODEL) resolved.CLAUDE_CODE_SUBAGENT_MODEL = env.CLAUDE_CODE_SUBAGENT_MODEL;
+  return resolved;
+};
+var buildShellEnvCommands = (env) => {
+  const resolved = buildResolvedEnvVars(env);
+  return MANAGED_CLAUDE_ENV_KEYS2.map(
+    (key) => resolved[key] ? `export ${key}=${shellQuote(resolved[key])}` : `unset ${key}`
+  );
+};
 ensureCcemDir();
 var config2 = new Conf2({
   projectName: "claude-code-env-manager",
@@ -2398,16 +2939,129 @@ var config2 = new Conf2({
   // 使用新路径
   defaults: {
     registries: {
-      "official": {
-        ANTHROPIC_BASE_URL: "https://api.anthropic.com",
-        ANTHROPIC_MODEL: "claude-sonnet-4-5-20250929",
-        ANTHROPIC_SMALL_FAST_MODEL: "claude-haiku-4-5-20251001"
-      }
+      official: DEFAULT_OFFICIAL_ENV
     },
     current: "official",
     defaultMode: null
   }
 });
+var recoverRegistriesFromLegacy = (registries) => {
+  const currentAuthCount = Object.values(registries).filter(
+    (env) => Boolean(env.ANTHROPIC_AUTH_TOKEN)
+  ).length;
+  if (currentAuthCount > 0) {
+    return registries;
+  }
+  const legacyConfigPath = getLegacyConfigPath();
+  if (!fs9.existsSync(legacyConfigPath)) {
+    return registries;
+  }
+  try {
+    const legacyRaw = JSON.parse(fs9.readFileSync(legacyConfigPath, "utf-8"));
+    const legacyRegistries = legacyRaw.registries ?? {};
+    let changed = false;
+    const recovered = { ...registries };
+    for (const [name, envConfig] of Object.entries(registries)) {
+      const legacyEnvConfig = legacyRegistries[name];
+      if (!legacyEnvConfig) {
+        continue;
+      }
+      const recoveredEnv = recoverEnvConfigFromLegacy(envConfig, legacyEnvConfig);
+      if (JSON.stringify(recoveredEnv) !== JSON.stringify(envConfig)) {
+        recovered[name] = recoveredEnv;
+        changed = true;
+      }
+    }
+    return changed ? recovered : registries;
+  } catch {
+    return registries;
+  }
+};
+var getRegistries = () => {
+  const rawRegistries = config2.get("registries") ?? {};
+  const normalizedEntries = Object.entries(rawRegistries).map(([name, envConfig]) => [
+    name,
+    normalizeEnvConfig(envConfig ?? {})
+  ]);
+  const normalizedRegistries = Object.fromEntries(normalizedEntries);
+  const repairedRegistries = recoverRegistriesFromLegacy(normalizedRegistries);
+  if (!repairedRegistries.official) {
+    repairedRegistries.official = { ...DEFAULT_OFFICIAL_ENV };
+  }
+  const changed = Object.keys(rawRegistries).length !== Object.keys(repairedRegistries).length || JSON.stringify(rawRegistries) !== JSON.stringify(repairedRegistries);
+  if (changed) {
+    config2.set("registries", repairedRegistries);
+  }
+  return repairedRegistries;
+};
+var setRegistries = (registries) => {
+  config2.set("registries", registries);
+};
+var getDecryptedAuthToken = (envConfig) => {
+  return envConfig.ANTHROPIC_AUTH_TOKEN ? decrypt(envConfig.ANTHROPIC_AUTH_TOKEN) : void 0;
+};
+var applyPromptAnswers = (current, answers, keepCurrentSecret) => {
+  const next = {
+    ...current,
+    ANTHROPIC_BASE_URL: answers.ANTHROPIC_BASE_URL?.trim() || current.ANTHROPIC_BASE_URL,
+    ANTHROPIC_DEFAULT_OPUS_MODEL: answers.ANTHROPIC_DEFAULT_OPUS_MODEL?.trim() || current.ANTHROPIC_DEFAULT_OPUS_MODEL,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: answers.ANTHROPIC_DEFAULT_HAIKU_MODEL?.trim() || current.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: answers.ANTHROPIC_DEFAULT_SONNET_MODEL?.trim() || answers.ANTHROPIC_DEFAULT_OPUS_MODEL?.trim() || current.ANTHROPIC_DEFAULT_SONNET_MODEL || current.ANTHROPIC_DEFAULT_OPUS_MODEL,
+    ANTHROPIC_MODEL: answers.ANTHROPIC_MODEL?.trim() || current.ANTHROPIC_MODEL || "opus",
+    CLAUDE_CODE_SUBAGENT_MODEL: answers.CLAUDE_CODE_SUBAGENT_MODEL?.trim() || current.CLAUDE_CODE_SUBAGENT_MODEL
+  };
+  if (!keepCurrentSecret) {
+    next.ANTHROPIC_AUTH_TOKEN = answers.ANTHROPIC_AUTH_TOKEN ? encrypt(answers.ANTHROPIC_AUTH_TOKEN) : void 0;
+  } else if (answers.ANTHROPIC_AUTH_TOKEN) {
+    next.ANTHROPIC_AUTH_TOKEN = encrypt(answers.ANTHROPIC_AUTH_TOKEN);
+  }
+  return normalizeEnvConfig(next);
+};
+var promptForEnvironmentConfig = async (current = {}, keepCurrentSecret = false) => {
+  return inquirer.prompt([
+    {
+      type: "input",
+      name: "ANTHROPIC_BASE_URL",
+      message: "ANTHROPIC_BASE_URL:",
+      default: current.ANTHROPIC_BASE_URL || DEFAULT_OFFICIAL_ENV.ANTHROPIC_BASE_URL
+    },
+    {
+      type: "password",
+      name: "ANTHROPIC_AUTH_TOKEN",
+      message: keepCurrentSecret ? "ANTHROPIC_AUTH_TOKEN (leave empty to keep current):" : "ANTHROPIC_AUTH_TOKEN:"
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_DEFAULT_OPUS_MODEL",
+      message: "ANTHROPIC_DEFAULT_OPUS_MODEL:",
+      default: current.ANTHROPIC_DEFAULT_OPUS_MODEL || DEFAULT_OFFICIAL_ENV.ANTHROPIC_DEFAULT_OPUS_MODEL
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+      message: "ANTHROPIC_DEFAULT_HAIKU_MODEL:",
+      default: current.ANTHROPIC_DEFAULT_HAIKU_MODEL || DEFAULT_OFFICIAL_ENV.ANTHROPIC_DEFAULT_HAIKU_MODEL
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_DEFAULT_SONNET_MODEL",
+      message: "ANTHROPIC_DEFAULT_SONNET_MODEL (blank = same as opus):",
+      default: current.ANTHROPIC_DEFAULT_SONNET_MODEL || current.ANTHROPIC_DEFAULT_OPUS_MODEL || ""
+    },
+    {
+      type: "input",
+      name: "ANTHROPIC_MODEL",
+      message: "ANTHROPIC_MODEL (e.g. opus, opusplan, sonnet):",
+      default: current.ANTHROPIC_MODEL || "opus"
+    },
+    {
+      type: "input",
+      name: "CLAUDE_CODE_SUBAGENT_MODEL",
+      message: "CLAUDE_CODE_SUBAGENT_MODEL (optional):",
+      default: current.CLAUDE_CODE_SUBAGENT_MODEL || ""
+    }
+  ]);
+};
 var PERMISSION_MODES = ["yolo", "dev", "readonly", "safe", "ci", "audit"];
 var usageStats = null;
 var usageLoading = true;
@@ -2446,24 +3100,27 @@ program.name("ccem").description("Claude Code Environment Manager - \u7BA1\u7406
 PERMISSION_MODES.forEach((mode) => {
   const preset = PERMISSION_PRESETS[mode];
   program.command(mode).description(`\u4E34\u65F6\u5E94\u7528 ${preset.name}\uFF0C\u9000\u51FA\u540E\u8FD8\u539F`).action(async () => {
-    const registries = config2.get("registries");
+    const registries = getRegistries();
     const current = config2.get("current");
     const envConfig = registries[current];
-    await runWithTempPermissions(mode, envConfig);
+    await runWithTempPermissions(mode, envConfig, current);
   });
 });
 var showCurrentEnv = (usageStats2, usageLoading2) => {
   if (!process.stdout.isTTY) return;
   const current = config2.get("current");
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const env = registries[current];
   const defaultMode = config2.get("defaultMode");
   if (!env) return;
   console.log(renderLogoWithEnvPanel(current, {
     ANTHROPIC_BASE_URL: env.ANTHROPIC_BASE_URL,
-    ANTHROPIC_API_KEY: env.ANTHROPIC_API_KEY ? decrypt(env.ANTHROPIC_API_KEY) : void 0,
+    ANTHROPIC_AUTH_TOKEN: getDecryptedAuthToken(env),
+    ANTHROPIC_DEFAULT_OPUS_MODEL: env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+    ANTHROPIC_DEFAULT_SONNET_MODEL: env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+    ANTHROPIC_DEFAULT_HAIKU_MODEL: env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
     ANTHROPIC_MODEL: env.ANTHROPIC_MODEL,
-    ANTHROPIC_SMALL_FAST_MODEL: env.ANTHROPIC_SMALL_FAST_MODEL
+    CLAUDE_CODE_SUBAGENT_MODEL: env.CLAUDE_CODE_SUBAGENT_MODEL
   }, defaultMode));
   console.log("");
   console.log(renderUsageLine(usageStats2, usageLoading2));
@@ -2471,7 +3128,7 @@ var showCurrentEnv = (usageStats2, usageLoading2) => {
   console.log("");
 };
 var switchEnvironment = async (name) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[name]) {
     console.error(chalk7.red(`Environment '${name}' not found.`));
     return;
@@ -2484,11 +3141,7 @@ var switchEnvironment = async (name) => {
   }
   showCurrentEnv(null, false);
   const env = registries[name];
-  const exportCmds = [];
-  if (env.ANTHROPIC_BASE_URL) exportCmds.push(`export ANTHROPIC_BASE_URL="${env.ANTHROPIC_BASE_URL}"`);
-  if (env.ANTHROPIC_API_KEY) exportCmds.push(`export ANTHROPIC_API_KEY="${decrypt(env.ANTHROPIC_API_KEY)}"`);
-  if (env.ANTHROPIC_MODEL) exportCmds.push(`export ANTHROPIC_MODEL="${env.ANTHROPIC_MODEL}"`);
-  if (env.ANTHROPIC_SMALL_FAST_MODEL) exportCmds.push(`export ANTHROPIC_SMALL_FAST_MODEL="${env.ANTHROPIC_SMALL_FAST_MODEL}"`);
+  const exportCmds = buildShellEnvCommands(env);
   if (process.stdout.isTTY) {
     console.log(chalk7.yellow("\nTo apply to current shell immediately, run:"));
     console.log(chalk7.cyan("eval $(ccem env)"));
@@ -2498,11 +3151,92 @@ var switchEnvironment = async (name) => {
     exportCmds.forEach((cmd) => console.log(cmd));
   }
 };
+var getSessionsFilePath = () => path7.join(getCcemConfigDir(), "sessions.json");
+var getRuntimeStateFilePath = () => path7.join(getCcemConfigDir(), "runtime-state.json");
+var parseJsonFile = (filePath) => {
+  if (!fs9.existsSync(filePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs9.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+};
+var readInteractiveAttachSessions = () => {
+  const sessionsById = /* @__PURE__ */ new Map();
+  const runtimeState = parseJsonFile(getRuntimeStateFilePath());
+  const persistedSessions = parseJsonFile(getSessionsFilePath()) ?? [];
+  for (const entry of runtimeState?.sessions ?? []) {
+    if (entry.runtime_kind && entry.runtime_kind !== "interactive") {
+      continue;
+    }
+    const fallback = persistedSessions.find((session) => session.id === entry.runtime_id);
+    const tmuxTarget = entry.tmux_session && entry.tmux_window ? `${entry.tmux_session}:${entry.tmux_window}` : fallback?.window_id ?? null;
+    if (!tmuxTarget) {
+      continue;
+    }
+    sessionsById.set(entry.runtime_id, {
+      id: entry.runtime_id,
+      projectDir: entry.project_dir,
+      envName: entry.env_name,
+      permMode: entry.perm_mode,
+      status: fallback?.status ?? "running",
+      tmuxTarget,
+      sortTime: entry.saved_at
+    });
+  }
+  for (const session of persistedSessions) {
+    if (session.status !== "running" || session.terminal_type !== "embedded" || !session.window_id) {
+      continue;
+    }
+    if (sessionsById.has(session.id)) {
+      continue;
+    }
+    sessionsById.set(session.id, {
+      id: session.id,
+      projectDir: session.working_dir,
+      envName: session.env_name,
+      permMode: session.perm_mode,
+      status: session.status,
+      tmuxTarget: session.window_id,
+      sortTime: session.start_time
+    });
+  }
+  return [...sessionsById.values()].sort(
+    (left, right) => right.sortTime.localeCompare(left.sortTime)
+  );
+};
+var findAttachSession = (id) => {
+  const sessions = readInteractiveAttachSessions();
+  if (!id) {
+    return sessions[0];
+  }
+  const exact = sessions.find((session) => session.id === id);
+  if (exact) {
+    return exact;
+  }
+  return sessions.find((session) => session.id.startsWith(id));
+};
+var attachTmuxTarget = (target) => {
+  const args = process.env.TMUX ? ["switch-client", "-t", target] : ["attach-session", "-t", target];
+  return new Promise((resolve2, reject) => {
+    const child = spawn3("tmux", args, { stdio: "inherit" });
+    child.on("error", reject);
+    child.on("exit", (code) => {
+      if (code === 0 || code === null) {
+        resolve2();
+      } else {
+        reject(new Error(`tmux exited with code ${code}`));
+      }
+    });
+  });
+};
 program.command("ls").description("List all configured environments").action(() => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const current = config2.get("current");
   const table = new Table3({
-    head: ["Name", "Base URL", "Model"],
+    head: ["Name", "Base URL", "Opus"],
     style: { head: ["cyan"] }
   });
   Object.keys(registries).forEach((name) => {
@@ -2511,7 +3245,7 @@ program.command("ls").description("List all configured environments").action(()
     table.push([
       prefix + name,
       reg.ANTHROPIC_BASE_URL || "-",
-      reg.ANTHROPIC_MODEL || "-"
+      reg.ANTHROPIC_DEFAULT_OPUS_MODEL || "-"
     ]);
   });
   console.log(table.toString());
@@ -2519,8 +3253,42 @@ program.command("ls").description("List all configured environments").action(()
 program.command("use <name>").description("Switch to a specific environment").action(async (name) => {
   await switchEnvironment(name);
 });
+program.command("sessions").description("List tmux-backed interactive sessions").action(() => {
+  const sessions = readInteractiveAttachSessions();
+  if (sessions.length === 0) {
+    console.log(chalk7.yellow("No tmux-backed interactive sessions found."));
+    return;
+  }
+  const table = new Table3({
+    head: ["ID", "Project", "Env", "Status", "Tmux"],
+    style: { head: ["cyan"] }
+  });
+  sessions.forEach((session) => {
+    table.push([
+      session.id,
+      session.projectDir,
+      session.envName,
+      session.status,
+      session.tmuxTarget
+    ]);
+  });
+  console.log(table.toString());
+});
+program.command("attach [id]").description("Attach to a tmux-backed interactive session").action(async (id) => {
+  const session = findAttachSession(id);
+  if (!session) {
+    console.error(chalk7.red(id ? `Interactive session '${id}' not found.` : "No interactive session available to attach."));
+    process.exit(1);
+  }
+  try {
+    await attachTmuxTarget(session.tmuxTarget);
+  } catch (error) {
+    console.error(chalk7.red(`Failed to attach ${session.tmuxTarget}: ${String(error)}`));
+    process.exit(1);
+  }
+});
 program.command("add <name>").description("Add a new environment configuration").action(async (name) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (registries[name]) {
     console.log(chalk7.red(`Environment '${name}' already exists.`));
     return;
@@ -2545,40 +3313,13 @@ program.command("add <name>").description("Add a new environment configuration")
     ]);
     presetConfig = ENV_PRESETS[presetName];
   }
-  const answers = await inquirer.prompt([
-    {
-      type: "input",
-      name: "ANTHROPIC_BASE_URL",
-      message: "Enter ANTHROPIC_BASE_URL:",
-      default: presetConfig.ANTHROPIC_BASE_URL || "https://api.anthropic.com"
-    },
-    {
-      type: "password",
-      name: "ANTHROPIC_API_KEY",
-      message: "Enter ANTHROPIC_API_KEY:"
-    },
-    {
-      type: "input",
-      name: "ANTHROPIC_MODEL",
-      message: "Enter ANTHROPIC_MODEL:",
-      default: presetConfig.ANTHROPIC_MODEL || "claude-sonnet-4-5-20250929"
-    },
-    {
-      type: "input",
-      name: "ANTHROPIC_SMALL_FAST_MODEL",
-      message: "Enter ANTHROPIC_SMALL_FAST_MODEL:",
-      default: presetConfig.ANTHROPIC_SMALL_FAST_MODEL || "claude-haiku-4-5-20251001"
-    }
-  ]);
-  if (answers.ANTHROPIC_API_KEY) {
-    answers.ANTHROPIC_API_KEY = encrypt(answers.ANTHROPIC_API_KEY);
-  }
-  registries[name] = answers;
-  config2.set("registries", registries);
+  const answers = await promptForEnvironmentConfig(presetConfig);
+  registries[name] = applyPromptAnswers(normalizeEnvConfig(presetConfig), answers, false);
+  setRegistries(registries);
   console.log(chalk7.green(`Environment '${name}' added successfully.`));
 });
 program.command("del <name>").description("Delete an environment configuration").action((name) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[name]) {
     console.log(chalk7.red(`Environment '${name}' not found.`));
     return;
@@ -2588,7 +3329,7 @@ program.command("del <name>").description("Delete an environment configuration")
     return;
   }
   delete registries[name];
-  config2.set("registries", registries);
+  setRegistries(registries);
   const current = config2.get("current");
   if (current === name) {
     config2.set("current", "official");
@@ -2597,7 +3338,7 @@ program.command("del <name>").description("Delete an environment configuration")
   console.log(chalk7.green(`Environment '${name}' deleted.`));
 });
 program.command("rename <old> <new>").description("Rename an environment configuration").action((oldName, newName) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[oldName]) {
     console.log(chalk7.red(`Environment '${oldName}' not found.`));
     return;
@@ -2612,7 +3353,7 @@ program.command("rename <old> <new>").description("Rename an environment configu
   }
   registries[newName] = registries[oldName];
   delete registries[oldName];
-  config2.set("registries", registries);
+  setRegistries(registries);
   const current = config2.get("current");
   if (current === oldName) {
     config2.set("current", newName);
@@ -2620,7 +3361,7 @@ program.command("rename <old> <new>").description("Rename an environment configu
   console.log(chalk7.green(`Environment '${oldName}' renamed to '${newName}'.`));
 });
 program.command("cp <source> <target>").description("Copy an environment configuration").action(async (source, target) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   if (!registries[source]) {
     console.log(chalk7.red(`Environment '${source}' not found.`));
     return;
@@ -2630,7 +3371,7 @@ program.command("cp <source> <target>").description("Copy an environment configu
     return;
   }
   registries[target] = { ...registries[source] };
-  config2.set("registries", registries);
+  setRegistries(registries);
   console.log(chalk7.green(`Environment '${source}' copied to '${target}'.`));
   const { modify } = await inquirer.prompt([
     {
@@ -2642,37 +3383,9 @@ program.command("cp <source> <target>").description("Copy an environment configu
   ]);
   if (modify) {
     const current = registries[target];
-    const answers = await inquirer.prompt([
-      {
-        type: "input",
-        name: "ANTHROPIC_BASE_URL",
-        message: "ANTHROPIC_BASE_URL:",
-        default: current.ANTHROPIC_BASE_URL
-      },
-      {
-        type: "password",
-        name: "ANTHROPIC_API_KEY",
-        message: "ANTHROPIC_API_KEY (leave empty to keep current):"
-      },
-      {
-        type: "input",
-        name: "ANTHROPIC_MODEL",
-        message: "ANTHROPIC_MODEL:",
-        default: current.ANTHROPIC_MODEL
-      },
-      {
-        type: "input",
-        name: "ANTHROPIC_SMALL_FAST_MODEL",
-        message: "ANTHROPIC_SMALL_FAST_MODEL:",
-        default: current.ANTHROPIC_SMALL_FAST_MODEL
-      }
-    ]);
-    if (answers.ANTHROPIC_BASE_URL) current.ANTHROPIC_BASE_URL = answers.ANTHROPIC_BASE_URL;
-    if (answers.ANTHROPIC_API_KEY) current.ANTHROPIC_API_KEY = encrypt(answers.ANTHROPIC_API_KEY);
-    if (answers.ANTHROPIC_MODEL) current.ANTHROPIC_MODEL = answers.ANTHROPIC_MODEL;
-    if (answers.ANTHROPIC_SMALL_FAST_MODEL) current.ANTHROPIC_SMALL_FAST_MODEL = answers.ANTHROPIC_SMALL_FAST_MODEL;
-    registries[target] = current;
-    config2.set("registries", registries);
+    const answers = await promptForEnvironmentConfig(current, true);
+    registries[target] = applyPromptAnswers(current, answers, true);
+    setRegistries(registries);
     console.log(chalk7.green(`Environment '${target}' updated.`));
   }
 });
@@ -2681,25 +3394,22 @@ program.command("current").description("Show current environment name").action((
   console.log(chalk7.green(current));
 });
 program.command("env").description("Output environment variables for shell eval").option("--json", "Output as JSON").action((options) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const current = config2.get("current");
   const env = registries[current];
   if (!env) return;
   const outputEnv = { ...env };
-  if (outputEnv.ANTHROPIC_API_KEY) {
-    outputEnv.ANTHROPIC_API_KEY = decrypt(outputEnv.ANTHROPIC_API_KEY);
+  if (outputEnv.ANTHROPIC_AUTH_TOKEN) {
+    outputEnv.ANTHROPIC_AUTH_TOKEN = decrypt(outputEnv.ANTHROPIC_AUTH_TOKEN);
   }
   if (options.json) {
     console.log(JSON.stringify(outputEnv, null, 2));
   } else {
-    if (outputEnv.ANTHROPIC_BASE_URL) console.log(`export ANTHROPIC_BASE_URL="${outputEnv.ANTHROPIC_BASE_URL}"`);
-    if (outputEnv.ANTHROPIC_API_KEY) console.log(`export ANTHROPIC_API_KEY="${outputEnv.ANTHROPIC_API_KEY}"`);
-    if (outputEnv.ANTHROPIC_MODEL) console.log(`export ANTHROPIC_MODEL="${outputEnv.ANTHROPIC_MODEL}"`);
-    if (outputEnv.ANTHROPIC_SMALL_FAST_MODEL) console.log(`export ANTHROPIC_SMALL_FAST_MODEL="${outputEnv.ANTHROPIC_SMALL_FAST_MODEL}"`);
+    buildShellEnvCommands(env).forEach((cmd) => console.log(cmd));
   }
 });
 program.command("run <command...>").description("Run a command with the current environment variables").action((command) => {
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const current = config2.get("current");
   const envConfig = registries[current];
   if (!envConfig) {
@@ -2707,10 +3417,8 @@ program.command("run <command...>").description("Run a command with the current
     process.exit(1);
   }
   const env = { ...process.env };
-  if (envConfig.ANTHROPIC_BASE_URL) env.ANTHROPIC_BASE_URL = envConfig.ANTHROPIC_BASE_URL;
-  if (envConfig.ANTHROPIC_API_KEY) env.ANTHROPIC_API_KEY = decrypt(envConfig.ANTHROPIC_API_KEY || "");
-  if (envConfig.ANTHROPIC_MODEL) env.ANTHROPIC_MODEL = envConfig.ANTHROPIC_MODEL;
-  if (envConfig.ANTHROPIC_SMALL_FAST_MODEL) env.ANTHROPIC_SMALL_FAST_MODEL = envConfig.ANTHROPIC_SMALL_FAST_MODEL;
+  clearManagedClaudeEnv(env);
+  Object.assign(env, buildResolvedEnvVars(envConfig));
   const [cmd, ...args] = command;
   const child = spawn3(cmd, args, {
     env,
@@ -2763,20 +3471,21 @@ setupCmd.command("default-mode").description("\u8BBE\u7F6E\u9ED8\u8BA4\u6743\u96
   console.log(chalk7.gray("\u6E05\u9664\u9ED8\u8BA4\u6A21\u5F0F: ccem setup default-mode --reset"));
   console.log(chalk7.gray("\u53EF\u7528\u6A21\u5F0F: " + PERMISSION_MODES.join(", ")));
 });
-setupCmd.command("init").description("\u521D\u59CB\u5316 Claude Code \u5168\u5C40\u914D\u7F6E\uFF08\u8DF3\u8FC7 onboarding\u3001\u7981\u7528\u9065\u6D4B\u3001\u5B89\u88C5 MCP \u5DE5\u5177\uFF09").action(async () => {
-  await runSetupInit();
+setupCmd.command("init").description("\u521D\u59CB\u5316 Claude Code \u5168\u5C40\u914D\u7F6E\uFF08\u8DF3\u8FC7 onboarding\u3001\u7981\u7528\u9065\u6D4B\uFF09").option("--chrome", "\u540C\u65F6\u5B89\u88C5 chrome-devtools MCP \u5DE5\u5177").action(async function() {
+  const options = this.opts();
+  await runSetupInit({ chrome: !!options.chrome });
 });
 setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5230 ~/.ccem/").option("--clean", "\u8FC1\u79FB\u540E\u5220\u9664\u65E7\u914D\u7F6E\u6587\u4EF6").option("--force", "\u5F3A\u5236\u91CD\u65B0\u8FC1\u79FB\uFF08\u8986\u76D6\u73B0\u6709\u914D\u7F6E\uFF09").action(async function() {
   const options = this.opts();
   const newConfigPath = getCcemConfigPath();
   const legacyConfigPath = getLegacyConfigPath();
   console.log(chalk7.cyan("\n\u{1F504} \u914D\u7F6E\u8FC1\u79FB\n"));
-  if (!fs8.existsSync(legacyConfigPath)) {
+  if (!fs9.existsSync(legacyConfigPath)) {
     console.log(chalk7.yellow("\u672A\u627E\u5230\u65E7\u7248\u914D\u7F6E\u6587\u4EF6"));
     console.log(chalk7.gray(`  \u65E7\u8DEF\u5F84: ${legacyConfigPath}`));
     return;
   }
-  if (fs8.existsSync(newConfigPath) && !options.force) {
+  if (fs9.existsSync(newConfigPath) && !options.force) {
     console.log(chalk7.green("\u2713 \u914D\u7F6E\u5DF2\u5728\u65B0\u8DEF\u5F84"));
     console.log(chalk7.gray(`  \u8DEF\u5F84: ${newConfigPath}`));
     console.log(chalk7.gray("\n\u4F7F\u7528 --force \u5F3A\u5236\u91CD\u65B0\u8FC1\u79FB"));
@@ -2784,15 +3493,15 @@ setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5
   }
   try {
     ensureCcemDir();
-    fs8.copyFileSync(legacyConfigPath, newConfigPath);
+    fs9.copyFileSync(legacyConfigPath, newConfigPath);
     console.log(chalk7.green("\u2713 \u914D\u7F6E\u5DF2\u8FC1\u79FB"));
     console.log(chalk7.gray(`  \u4ECE: ${legacyConfigPath}`));
     console.log(chalk7.gray(`  \u5230: ${newConfigPath}`));
     if (options.clean) {
-      fs8.unlinkSync(legacyConfigPath);
-      const legacyDir = path6.dirname(legacyConfigPath);
+      fs9.unlinkSync(legacyConfigPath);
+      const legacyDir = path7.dirname(legacyConfigPath);
       try {
-        fs8.rmdirSync(legacyDir);
+        fs9.rmdirSync(legacyDir);
       } catch {
       }
       console.log(chalk7.green("\u2713 \u5DF2\u5220\u9664\u65E7\u914D\u7F6E\u6587\u4EF6"));
@@ -2803,13 +3512,13 @@ setupCmd.command("migrate").description("\u8FC1\u79FB\u65E7\u7248\u914D\u7F6E\u5
 });
 setupCmd.command("cron").description("\u5B89\u88C5 ccem-cron skill \u5230 Claude Code\uFF08~/.claude/skills/\uFF09").option("--force", "\u5F3A\u5236\u8986\u76D6\u5DF2\u6709\u6587\u4EF6").action(async function() {
   const options = this.opts();
-  const skillDir = path6.join(process.env.HOME || "~", ".claude", "skills");
-  const targetPath = path6.join(skillDir, "ccem-cron.md");
-  if (!fs8.existsSync(skillDir)) {
-    fs8.mkdirSync(skillDir, { recursive: true });
+  const skillDir = path7.join(process.env.HOME || "~", ".claude", "skills");
+  const targetPath = path7.join(skillDir, "ccem-cron.md");
+  if (!fs9.existsSync(skillDir)) {
+    fs9.mkdirSync(skillDir, { recursive: true });
     console.log(chalk7.gray(`\u521B\u5EFA\u76EE\u5F55: ${skillDir}`));
   }
-  if (fs8.existsSync(targetPath) && !options.force) {
+  if (fs9.existsSync(targetPath) && !options.force) {
     const { overwrite } = await inquirer.prompt([
       {
         type: "confirm",
@@ -2823,7 +3532,7 @@ setupCmd.command("cron").description("\u5B89\u88C5 ccem-cron skill \u5230 Claude
       return;
     }
   }
-  fs8.writeFileSync(targetPath, CCEM_CRON_SKILL_CONTENT, "utf-8");
+  fs9.writeFileSync(targetPath, CCEM_CRON_SKILL_CONTENT, "utf-8");
   console.log(chalk7.green(`\u2713 \u5DF2\u5B89\u88C5 ccem-cron skill`));
   console.log(chalk7.gray(`  \u8DEF\u5F84: ${targetPath}`));
   console.log(chalk7.cyan(`
@@ -2879,20 +3588,34 @@ skillCmd.command("ls").description("\u5217\u51FA\u5DF2\u5B89\u88C5\u7684 skills"
 skillCmd.command("rm <name>").description("\u5220\u9664\u5DF2\u5B89\u88C5\u7684 skill").action((name) => {
   removeSkill(name);
 });
-program.command("load <url>").description("\u4ECE\u8FDC\u7A0B\u670D\u52A1\u5668\u52A0\u8F7D\u73AF\u5883\u914D\u7F6E").requiredOption("--secret <secret>", "\u89E3\u5BC6\u5BC6\u94A5").action(async (url, options) => {
-  await loadFromRemote(url, options.secret);
+program.command("load <url>").description("\u4ECE\u8FDC\u7A0B\u670D\u52A1\u5668\u52A0\u8F7D\u73AF\u5883\u914D\u7F6E").requiredOption("--secret <secret>", "\u89E3\u5BC6\u5BC6\u94A5").option("--json", "\u4EE5 JSON \u683C\u5F0F\u8F93\u51FA\u7ED3\u679C\uFF08\u4F9B\u7A0B\u5E8F\u8C03\u7528\uFF09").action(async (url, options) => {
+  const results = await loadFromRemote(url, options.secret);
+  if (options.json) {
+    console.log(JSON.stringify({
+      count: results.length,
+      environments: results.map((r) => ({
+        name: r.name,
+        original_name: r.originalName,
+        // 使用 snake_case 匹配 Rust 结构体
+        renamed: r.renamed
+      }))
+    }));
+  }
 });
-program.command("launch").description(false).option("--env <name>", "\u73AF\u5883\u540D\u79F0").option("--perm <mode>", "\u6743\u9650\u6A21\u5F0F").option("--session-id <id>", "\u4F1A\u8BDD ID").option("--resume-session <id>", "\u6062\u590D\u4F1A\u8BDD ID").option("--working-dir <path>", "\u5DE5\u4F5C\u76EE\u5F55").action(async function() {
+program.command("launch").description(false).option("--env <name>", "\u73AF\u5883\u540D\u79F0").option("--perm <mode>", "\u6743\u9650\u6A21\u5F0F").option("--session-id <id>", "\u4F1A\u8BDD ID").option("--resume-session <id>", "\u6062\u590D\u4F1A\u8BDD ID").option("--working-dir <path>", "\u5DE5\u4F5C\u76EE\u5F55").option("--proxy-base-url <url>", "Desktop internal override for ANTHROPIC_BASE_URL").option("--anthropic-base-url <url>", "Deprecated alias for --proxy-base-url").action(async function() {
   const opts = this.opts();
   const envName = opts.env || config2.get("current");
-  const registries = config2.get("registries");
+  const registries = getRegistries();
   const envConfig = registries[envName];
   if (!envConfig) {
     console.error(chalk7.red(`Environment '${envName}' not found.`));
     process.exit(1);
   }
+  const proxyBaseUrl = opts.proxyBaseUrl || opts.anthropicBaseUrl;
+  const launchEnvConfig = proxyBaseUrl ? { ...envConfig, ANTHROPIC_BASE_URL: proxyBaseUrl } : envConfig;
   await launchClaude({
-    envConfig,
+    envName,
+    envConfig: launchEnvConfig,
     permMode: opts.perm,
     workingDir: opts.workingDir,
     sessionId: opts.sessionId,
@@ -2928,7 +3651,7 @@ program.action(async (options) => {
     showCurrentEnv(usageStats, usageLoading);
     console.log("");
     const defaultMode = config2.get("defaultMode");
-    const registries = config2.get("registries");
+    const registries = getRegistries();
     const current = config2.get("current");
     const envConfig = registries[current];
     const { action } = await inquirer.prompt([
@@ -2950,7 +3673,11 @@ program.action(async (options) => {
         msg.error("No environment configuration found.");
         process.exit(1);
       }
-      await launchClaude({ envConfig, permMode: defaultMode || void 0 });
+      await launchClaude({
+        envName: current,
+        envConfig,
+        permMode: defaultMode || void 0
+      });
       return;
     } else if (action === "usage") {
       console.clear();
@@ -2975,37 +3702,9 @@ program.action(async (options) => {
         const envToEdit = registries[result.name];
         console.log(chalk7.yellow(`
 Editing environment '${result.name}'`));
-        const answers = await inquirer.prompt([
-          {
-            type: "input",
-            name: "ANTHROPIC_BASE_URL",
-            message: "ANTHROPIC_BASE_URL:",
-            default: envToEdit.ANTHROPIC_BASE_URL
-          },
-          {
-            type: "password",
-            name: "ANTHROPIC_API_KEY",
-            message: "ANTHROPIC_API_KEY (leave empty to keep current):"
-          },
-          {
-            type: "input",
-            name: "ANTHROPIC_MODEL",
-            message: "ANTHROPIC_MODEL:",
-            default: envToEdit.ANTHROPIC_MODEL
-          },
-          {
-            type: "input",
-            name: "ANTHROPIC_SMALL_FAST_MODEL",
-            message: "ANTHROPIC_SMALL_FAST_MODEL:",
-            default: envToEdit.ANTHROPIC_SMALL_FAST_MODEL
-          }
-        ]);
-        if (answers.ANTHROPIC_BASE_URL) envToEdit.ANTHROPIC_BASE_URL = answers.ANTHROPIC_BASE_URL;
-        if (answers.ANTHROPIC_API_KEY) envToEdit.ANTHROPIC_API_KEY = encrypt(answers.ANTHROPIC_API_KEY);
-        if (answers.ANTHROPIC_MODEL) envToEdit.ANTHROPIC_MODEL = answers.ANTHROPIC_MODEL;
-        if (answers.ANTHROPIC_SMALL_FAST_MODEL) envToEdit.ANTHROPIC_SMALL_FAST_MODEL = answers.ANTHROPIC_SMALL_FAST_MODEL;
-        registries[result.name] = envToEdit;
-        config2.set("registries", registries);
+        const answers = await promptForEnvironmentConfig(envToEdit, true);
+        registries[result.name] = applyPromptAnswers(envToEdit, answers, true);
+        setRegistries(registries);
         msg.success(`Environment '${result.name}' updated.`);
         await new Promise((resolve2) => setTimeout(resolve2, 800));
       } else if (result.action === "rename") {
@@ -3027,7 +3726,7 @@ Editing environment '${result.name}'`));
           ]);
           registries[newName] = registries[result.name];
           delete registries[result.name];
-          config2.set("registries", registries);
+          setRegistries(registries);
           if (current === result.name) {
             config2.set("current", newName);
           }
@@ -3048,7 +3747,7 @@ Editing environment '${result.name}'`));
           }
         ]);
         registries[targetName] = { ...registries[result.name] };
-        config2.set("registries", registries);
+        setRegistries(registries);
         msg.success(`Environment '${result.name}' copied to '${targetName}'.`);
         const { modify } = await inquirer.prompt([
           {
@@ -3060,37 +3759,9 @@ Editing environment '${result.name}'`));
         ]);
         if (modify) {
           const envToEdit = registries[targetName];
-          const editAnswers = await inquirer.prompt([
-            {
-              type: "input",
-              name: "ANTHROPIC_BASE_URL",
-              message: "ANTHROPIC_BASE_URL:",
-              default: envToEdit.ANTHROPIC_BASE_URL
-            },
-            {
-              type: "password",
-              name: "ANTHROPIC_API_KEY",
-              message: "ANTHROPIC_API_KEY (leave empty to keep current):"
-            },
-            {
-              type: "input",
-              name: "ANTHROPIC_MODEL",
-              message: "ANTHROPIC_MODEL:",
-              default: envToEdit.ANTHROPIC_MODEL
-            },
-            {
-              type: "input",
-              name: "ANTHROPIC_SMALL_FAST_MODEL",
-              message: "ANTHROPIC_SMALL_FAST_MODEL:",
-              default: envToEdit.ANTHROPIC_SMALL_FAST_MODEL
-            }
-          ]);
-          if (editAnswers.ANTHROPIC_BASE_URL) envToEdit.ANTHROPIC_BASE_URL = editAnswers.ANTHROPIC_BASE_URL;
-          if (editAnswers.ANTHROPIC_API_KEY) envToEdit.ANTHROPIC_API_KEY = encrypt(editAnswers.ANTHROPIC_API_KEY);
-          if (editAnswers.ANTHROPIC_MODEL) envToEdit.ANTHROPIC_MODEL = editAnswers.ANTHROPIC_MODEL;
-          if (editAnswers.ANTHROPIC_SMALL_FAST_MODEL) envToEdit.ANTHROPIC_SMALL_FAST_MODEL = editAnswers.ANTHROPIC_SMALL_FAST_MODEL;
-          registries[targetName] = envToEdit;
-          config2.set("registries", registries);
+          const editAnswers = await promptForEnvironmentConfig(envToEdit, true);
+          registries[targetName] = applyPromptAnswers(envToEdit, editAnswers, true);
+          setRegistries(registries);
           msg.success(`Environment '${targetName}' updated.`);
         }
         await new Promise((resolve2) => setTimeout(resolve2, 800));
@@ -3109,7 +3780,7 @@ Editing environment '${result.name}'`));
           ]);
           if (confirm) {
             delete registries[result.name];
-            config2.set("registries", registries);
+            setRegistries(registries);
             if (current === result.name) {
               config2.set("current", "official");
               msg.warning(`Deleted current environment. Switched back to 'official'.`);
@@ -3131,7 +3802,7 @@ Editing environment '${result.name}'`));
         }
       ]);
       if (permMode !== "back") {
-        await runWithTempPermissions(permMode, envConfig);
+        await runWithTempPermissions(permMode, envConfig, current);
         return;
       }
     } else if (action === "setDefault") {