@epoch-agent/runtime 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,15 +1,15 @@
-import { loadCommandDefinitions, createToolScope, expandCommand, RecentWorkspaces, clearModelCache, discoverModels, ScheduleStore, isWithinWindow, acquireScheduleLock, triggerPeriodMs, ScheduleRecorder, pruneRecordings, suggestRuleFromApproval, needsAllowlist, isNonInteractive, loadPlugins, assertLevelAllowed, discoverProject, ProviderRouter, ProviderError, PROVIDER_NO_CREDENTIAL, SessionManager, GoalService, MemoryManager, MemoryReviewer, resolveSkillDirs, SkillSystem, SkillLearner, HookManager, loadHookSources, ApprovalCache, PermissionManager, resolvePolicyDirs, resolvePoliciesDir, loadPolicyFiles, checkShadowing, compileRuleLists, ContextCompressor, compressionOptions, TrackerDB, getConfigOrigins, mapOperationType, affectedPaths, workspaceDisplayPath, persistParts, persistToolResults, ToolRegistry, createTodoTool, createGoalTool, createMemoryTool, createCodeExecTool, createAskQuestionTool, resolveWorkspace, unloadedInstructionFiles, resolveProjectRoot, loadConfig, CodeSandbox, CheckpointManager, createDelegateTool, loadRoleDefinitions, mergeRoles, builtinRoles, unknownRoleTools, BLOCKED_TOOLS, blockedRoleTools, findRole, BudgetStore, mergeHeadlessPolicy, describeHeadlessPolicy, importSkills, previewSkillImport, gateForTool, managedSwitchNotes, originOf, EpochConfigSchema, defaultConfig, SettingsFileSchema, isWritableSettingKey, writeSettingValue, SETTING_WRITE_APPLY, resolveSettings, SETTING_WRITE_LAYERS, readProviderKeyEnv, validateSchedule, createAllowAllGate, setTrustGate, TrustManager, createTrustGate, createDenyAllGate, getImportGate, setImportGate, createAllowAllImportGate, ImportTrustStore, createDenyAllImportGate, createImportGate, getCapability, restoreParts, createSessionSearchTools, PlanModeState, createPlanModeTools, explainSetting, settingWriteTargets, createRoleFile, AgentLoop, roleScopedProvider, createRoleScope, withGoalPrompt, withGoalCompression, ScheduleRegistrar, resolveScheduleBackend, SETTINGS_LAYER_ORDER } from '@epoch-agent/core';
-export { SANDBOX_COVERS, SANDBOX_EXCLUDES, SCHEDULE_DEFAULTS, SCHEDULE_DEFAULT_ALLOWLIST, nextRunAt, readRecording, skillIndexDescription } from '@epoch-agent/core';
-import { projectCommandsDir, commandsDir, issueDetails, t, resolveHomeDir, configPath, readKey, setScalar, setSectionField, mcpConfigPath, workspacesPath, dbPath, automationLogsDir, pluginsStatePath, safeInit, memoriesDir, skillsDir, hooksPath, artifactsDir, resolveRipgrep, withTimeout, agentsDir, budgetStatePath, createSecretStore, setSecretStore, prefetchProviderSecrets, setSecretValues, migrateEnvSecrets, envPath, setDataKey, parseDataKey, generateDataKey, automationWorkDir, trustPath, trustedImportsPath, setShell, probeShell } from '@epoch-agent/infra';
+import { loadCommandDefinitions, SLASH_COMMANDS_DIAG_MODULE, createToolScope, expandCommand, RecentWorkspaces, clearModelCache, discoverModels, ScheduleStore, isWithinWindow, acquireScheduleLock, triggerPeriodMs, ScheduleRecorder, pruneRecordings, suggestRuleFromApproval, needsAllowlist, isNonInteractive, loadPlugins, assertLevelAllowed, discoverProject, ProviderRouter, ProviderError, PROVIDER_NO_CREDENTIAL, SessionManager, GoalService, MemoryManager, MemoryReviewer, resolveSkillDirs, SkillSystem, SkillLearner, HookManager, loadHookSources, ApprovalCache, PermissionManager, resolvePolicyDirs, resolvePoliciesDir, loadPolicyFiles, checkShadowing, compileRuleLists, ContextCompressor, compressionOptions, TrackerDB, getConfigOrigins, mapOperationType, affectedPaths, workspaceDisplayPath, persistParts, persistToolResults, ToolRegistry, createTodoTool, createGoalTool, createMemoryTool, createCodeExecTool, createRunCodeTool, createSkillViewTool, createToolSearchTool, createToolRevealState, createAskQuestionTool, resolveWorkspace, unloadedInstructionFiles, resolveProjectRoot, loadConfig, CodeSandbox, CheckpointManager, createDelegateTool, findRole, resolveInWorkspace, listWorkspaceFiles, loadRoleDefinitions, mergeRoles, AGENT_ROLE_DIAG_MODULE, builtinRoles, unknownRoleTools, BLOCKED_TOOLS, blockedRoleTools, unknownRoleSkills, BudgetStore, mergeHeadlessPolicy, describeHeadlessPolicy, importSkills, previewSkillImport, removeSessionArtifacts, gateForTool, managedSwitchNotes, originOf, EpochConfigSchema, defaultConfig, SettingsFileSchema, isWritableSettingKey, writeSettingValue, SETTING_WRITE_APPLY, resolveSettings, SETTING_WRITE_LAYERS, readProviderKeyEnv, validateSchedule, createAllowAllGate, setTrustGate, TrustManager, createTrustGate, createDenyAllGate, getImportGate, setImportGate, createAllowAllImportGate, ImportTrustStore, createDenyAllImportGate, createImportGate, getCapability, restoreParts, createSessionSearchTools, PlanModeState, createPlanModeTools, toolTableTokens, explainSetting, settingWriteTargets, uninstallPlugin, readMarketplaces, searchMarketplaces, resolveEntrySource, resolveSource, readPluginRecords, createRoleFile, AgentLoop, resolveArtifactRetention, roleScopedProvider, createRoleScope, revealScopedProvider, withGoalPrompt, withGoalCompression, ScheduleRegistrar, resolveScheduleBackend, updateMarketplace, addMarketplace, SETTINGS_LAYER_ORDER, resolveMarketplaceRef, BudgetGuard, installPlugin, currentEpochVersion } from '@epoch-agent/core';
+export { DEFAULT_GOAL_MAX_ROUNDS, MAX_GOAL_MAX_ROUNDS, MAX_OBJECTIVE_CHARS, MAX_REASON_CHARS, SANDBOX_COVERS, SANDBOX_EXCLUDES, SCHEDULE_DEFAULTS, SCHEDULE_DEFAULT_ALLOWLIST, nextRunAt, readRecording, skillIndexDescription } from '@epoch-agent/core';
+import { projectCommandsDir, commandsDir, t, issueDetails, resolveHomeDir, configPath, readKey, setScalar, setSectionField, mcpConfigPath, workspacesPath, dbPath, automationLogsDir, pluginsStatePath, safeInit, memoriesDir, skillsDir, claudeUserSettingsPath, hooksPath, artifactsDir, resolveRipgrep, withTimeout, createProcessTable, marketplacesPath, pluginsDir, agentsDir, budgetStatePath, createSecretStore, setSecretStore, prefetchProviderSecrets, setSecretValues, migrateEnvSecrets, envPath, setDataKey, parseDataKey, generateDataKey, i18nDiagnostics, automationWorkDir, trustPath, trustedImportsPath, setShell, probeShell } from '@epoch-agent/infra';
 export { t } from '@epoch-agent/infra';
 import { isAbsolute, dirname, delimiter, resolve, join } from 'path';
-import { AGENT_ROLE_NAME_PATTERN, isValidAgentRoleName, apiKeyEnvVar, getProviderInfo, PROVIDER_INFOS, parseModelRef, contentToText, systemNote, DiagnosticSink, METRIC, API_KEY_ENV_VARS, MCP_DATA_KEY_NAME, isPermissionLevel, NOOP_TELEMETRY, DEFAULT_AGENT_ROLE } from '@epoch-agent/protocol';
+import { AGENT_ROLE_NAME_PATTERN, isValidAgentRoleName, apiKeyEnvVar, getProviderInfo, PROVIDER_INFOS, parseModelRef, contentToText, assistantTurnText, systemNote, ToolExposure, isMentionableFilePath, DiagnosticSink, METRIC, API_KEY_ENV_VARS, MCP_DATA_KEY_NAME, isPermissionLevel, NOOP_TELEMETRY, DEFAULT_AGENT_ROLE } from '@epoch-agent/protocol';
 import { existsSync, mkdirSync, writeFileSync, readFileSync, statSync, renameSync, rmSync, appendFileSync } from 'fs';
-import { parseMcpConfig, McpRegistry, McpAuthStore, mcpAuthStatus, loginToMcpServer, logoutFromMcpServer } from '@epoch-agent/plugin-mcp';
 import { randomUUID, createHash } from 'crypto';
+import { parseMcpConfig, McpRegistry, McpAuthStore, mcpAuthStatus, loginToMcpServer, logoutFromMcpServer } from '@epoch-agent/plugin-mcp';
 import { filePlugin } from '@epoch-agent/plugin-file';
 import { lspPlugin } from '@epoch-agent/plugin-lsp';
-import { terminalPlugin, cleanupBackgroundProcesses, rekeyTasks, listTasks } from '@epoch-agent/plugin-terminal';
+import { terminalPlugin, rekeyTasks, listTasks } from '@epoch-agent/plugin-terminal';
 export { taskOutput as backgroundTaskOutput, listTasks as listBackgroundTasks } from '@epoch-agent/plugin-terminal';
 import { webPlugin, selectSearchProvider, createWebSearchTool } from '@epoch-agent/plugin-web';
 
@@ -53,18 +53,22 @@ function wireCommands(opts) {
   });
   if (summary.commands.length === 0 && summary.issues.length > 0) {
     diags.warn(
-      "\u659C\u6760\u547D\u4EE4",
-      `${issueDetails(summary.issues).length} \u4E2A\u6587\u4EF6\u90FD\u6CA1\u80FD\u52A0\u8F7D\uFF0C\u5F53\u524D\u6CA1\u6709\u53EF\u7528\u7684\u81EA\u5B9A\u4E49\u547D\u4EE4`,
+      SLASH_COMMANDS_DIAG_MODULE,
+      t("boot.commands_all_failed", { count: issueDetails(summary.issues).length }),
       "no-command-loaded"
     );
   }
-  const available = new Set(toolProvider.list().map((t13) => t13.name));
+  const available = new Set(toolProvider.list().map((t23) => t23.name));
   for (const cmd of summary.commands) {
     const unknown = (cmd.allowedTools ?? []).filter((name) => !available.has(name));
     if (unknown.length > 0) {
       diags.warn(
-        "\u659C\u6760\u547D\u4EE4",
-        `/${cmd.name} \u7684 allowed-tools \u91CC ${unknown.join(", ")} \u4E0D\u5B58\u5728\uFF0C\u5DF2\u5FFD\u7565`,
+        SLASH_COMMANDS_DIAG_MODULE,
+        (lang) => t(
+          "boot.command_allowed_tools",
+          { name: `/${cmd.name}`, tools: unknown.join(", ") },
+          lang
+        ),
         "unknown-tool"
       );
     }
@@ -87,6 +91,65 @@ var init_commands = __esm({
   "src/commands.ts"() {
   }
 });
+// src/events.ts
+function publishAgentEvent(sessionId, event) {
+  bus.publish(sessionId, event);
+}
+var ProcessEventBus, bus, processEventBus;
+var init_events = __esm({
+  "src/events.ts"() {
+    ProcessEventBus = class {
+      subscribers = /* @__PURE__ */ new Set();
+      failures = 0;
+      subscribe(fn) {
+        this.subscribers.add(fn);
+        let released = false;
+        return () => {
+          if (released) return;
+          released = true;
+          this.subscribers.delete(fn);
+        };
+      }
+      get subscriberCount() {
+        return this.subscribers.size;
+      }
+      get deliveryFailures() {
+        return this.failures;
+      }
+      publish(sessionId, event) {
+        if (this.subscribers.size === 0) return;
+        for (const fn of this.subscribers) {
+          try {
+            fn(event, sessionId);
+          } catch {
+            this.failures += 1;
+          }
+        }
+      }
+    };
+    bus = new ProcessEventBus();
+    processEventBus = bus;
+  }
+});
+function dropOverlongToolNames(tools, module, code, diags) {
+  const kept = [];
+  for (const tool of tools) {
+    if (tool.name.length > MAX_TOOL_NAME_LENGTH) {
+      diags.warn(
+        module,
+        (lang) => t(
+          "host_capabilities.tool_name_too_long",
+          { name: tool.name, limit: MAX_TOOL_NAME_LENGTH },
+          lang
+        ),
+        code
+      );
+      continue;
+    }
+    kept.push(tool);
+  }
+  return kept;
+}
 function wireHostCapabilities(caps, diags) {
   if (!caps) return EMPTY;
   const namespace = caps.namespace;
@@ -109,7 +172,8 @@ function wireHostCapabilities(caps, diags) {
   const roles = wireRoles(caps.roles ?? [], namespace, diags);
   const skillDirs = wireSkillDirs(caps.skillDirs ?? [], namespace, diags);
   const mcpServers = wireMcpServers(caps.mcpServers ?? [], namespace, diags);
-  if (roles.length > 0 || skillDirs.length > 0 || mcpServers.length > 0) {
+  const tools = wireTools(caps.tools ?? [], namespace, diags);
+  if (roles.length > 0 || skillDirs.length > 0 || mcpServers.length > 0 || tools.length > 0) {
     diags.ok(
       HOST_CAPABILITIES_MODULE,
       (lang) => t(
@@ -118,13 +182,14 @@ function wireHostCapabilities(caps, diags) {
           namespace,
           roles: roles.length,
           skillDirs: skillDirs.length,
-          mcpServers: mcpServers.length
+          mcpServers: mcpServers.length,
+          tools: tools.length
         },
         lang
       )
     );
   }
-  return { roles, skillDirs, mcpServers };
+  return { roles, skillDirs, mcpServers, tools };
 }
 function wireRoles(input, namespace, diags) {
   const seen = /* @__PURE__ */ new Set();
@@ -153,7 +218,6 @@ function wireRoles(input, namespace, diags) {
       ...role.prompt ? { prompt: role.prompt } : {},
       ...role.tools ? { tools: [...role.tools] } : {},
       ...role.maxTurns ? { maxTurns: role.maxTurns } : {},
-      // 宿主说不出这一格（`HostAgentRole` 上没有它），这一行是它唯一的来源
       source: "host"
     });
   }
@@ -199,11 +263,95 @@ function wireMcpServers(input, namespace, diags) {
   }
   return servers;
 }
-var HOST_CAPABILITIES_MODULE, EMPTY;
+function wireTools(input, namespace, diags) {
+  const seen = /* @__PURE__ */ new Set();
+  const tools = [];
+  for (const tool of input) {
+    if (!HOST_TOOL_NAME_PATTERN.test(tool.name)) {
+      diags.warn(
+        HOST_CAPABILITIES_MODULE,
+        (lang) => t("host_capabilities.bad_tool_name", { name: tool.name }, lang),
+        "host-tool-invalid-name"
+      );
+      continue;
+    }
+    if (seen.has(tool.name)) {
+      diags.warn(
+        HOST_CAPABILITIES_MODULE,
+        (lang) => t("host_capabilities.duplicate_tool", { name: tool.name }, lang),
+        "host-tool-duplicate"
+      );
+      continue;
+    }
+    seen.add(tool.name);
+    const describeTarget = tool.describeTarget;
+    tools.push({
+      ...tool,
+      name: `${namespace}__${tool.name}`,
+      execute: (args, ctx) => tool.execute(args, ctx),
+      ...describeTarget ? { describeTarget: (args) => describeTarget.call(tool, args) } : {}
+    });
+  }
+  return tools;
+}
+var HOST_CAPABILITIES_MODULE, HOST_TOOL_NAME_PATTERN, MAX_TOOL_NAME_LENGTH, EMPTY;
 var init_host_capabilities = __esm({
   "src/host-capabilities.ts"() {
     HOST_CAPABILITIES_MODULE = "HostCapabilities";
-    EMPTY = { roles: [], skillDirs: [], mcpServers: [] };
+    HOST_TOOL_NAME_PATTERN = /^[a-z0-9][a-z0-9_-]*$/;
+    MAX_TOOL_NAME_LENGTH = 128;
+    EMPTY = { roles: [], skillDirs: [], mcpServers: [], tools: [] };
+  }
+});
+async function wireHostMarketplaces(input) {
+  const { statePath, diagnostics: diags } = input;
+  const allowRemote = input.hostMarketplaces.allowRemote === true;
+  for (const raw of input.hostMarketplaces.sources) {
+    const source = raw.trim();
+    if (!source) {
+      diags.warn(HOST_MARKETPLACE_MODULE, (l) => t("plugin_control.market_empty", void 0, l));
+      continue;
+    }
+    if (!allowRemote && !isLocalSource(source)) {
+      diags.warn(
+        HOST_MARKETPLACE_MODULE,
+        (l) => t("plugin_control.market_remote_off", { source }, l),
+        "remote-disabled"
+      );
+      continue;
+    }
+    const outcome = await addOrRefresh(source, statePath);
+    if (!outcome.ok) {
+      diags.warn(
+        HOST_MARKETPLACE_MODULE,
+        (l) => t("plugin_control.market_failed", { source, reason: outcome.reason }, l),
+        "marketplace-unavailable"
+      );
+      continue;
+    }
+    diags.ok(
+      HOST_MARKETPLACE_MODULE,
+      (l) => t("plugin_control.market_ready", { name: outcome.name, count: outcome.count }, l)
+    );
+  }
+}
+function isLocalSource(source) {
+  return resolveSource(source)?.type === "local";
+}
+async function addOrRefresh(source, statePath) {
+  try {
+    const existing = readMarketplaces(statePath).records.find((r) => r.source === source);
+    const outcome = existing ? await updateMarketplace(existing.name, { statePath }) : await addMarketplace(source, { statePath });
+    return outcome.ok ? { ok: true, name: outcome.record.name, count: outcome.record.catalog.plugins.length } : outcome;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return { ok: false, reason: message.split("\n")[0] ?? message };
+  }
+}
+var HOST_MARKETPLACE_MODULE;
+var init_host_marketplaces = __esm({
+  "src/host-marketplaces.ts"() {
+    HOST_MARKETPLACE_MODULE = "HostMarketplaces";
   }
 });
 async function applyHostPreset(opts) {
@@ -441,6 +589,16 @@ var init_host_preset = __esm({
     HOST_PRESET_MODULE = "HostPreset";
   }
 });
+function providerLabel(info, lang) {
+  switch (info.type) {
+    case "ollama":
+      return t("provider.label_ollama", void 0, lang);
+    case "openai-compatible":
+      return t("provider.label_openai_compatible", void 0, lang);
+    default:
+      return info.label;
+  }
+}
 function buildModelCatalogControl(opts) {
   const { homeDir, configured } = opts;
   const keyOf = (envVar) => {
@@ -453,7 +611,6 @@ function buildModelCatalogControl(opts) {
         type: p.type,
         label: p.label,
         envVar: p.apiKeyEnv,
-        // 不需要 key 的那家（Ollama）恒 true —— 对它说「没配 key」是假话
         hasKey: p.apiKeyEnv === null || keyOf(p.apiKeyEnv) !== ""
       }));
     },
@@ -488,6 +645,209 @@ var init_model_catalog = __esm({
   "src/model-catalog.ts"() {
   }
 });
+function createInstallFlow(deps) {
+  const locations = () => ({
+    pluginsDir: deps.pluginsDir,
+    statePath: deps.statePath,
+    epochVersion: currentEpochVersion()
+  });
+  return {
+    preview: async (source, extra, lang) => {
+      let seen;
+      const outcome = await installPlugin(source, {
+        ...locations(),
+        ...extra,
+        confirm: async (preview) => {
+          seen = preview;
+          return false;
+        }
+      });
+      if (seen) return { ok: true, preview: seen, token: previewToken(seen) };
+      return refuse(outcome, lang);
+    },
+    install: async (source, token, extra, lang) => {
+      let matched;
+      const outcome = await installPlugin(source, {
+        ...locations(),
+        ...extra,
+        confirm: async (preview) => {
+          matched = previewToken(preview) === token;
+          return matched;
+        }
+      });
+      if (outcome.ok) return { ok: true, record: outcome.record, preview: outcome.preview };
+      if (matched === false) {
+        return {
+          ok: false,
+          reason: "stale-token",
+          detail: t("plugin_control.stale_token", void 0, lang),
+          ...outcome.preview ? { preview: outcome.preview } : {}
+        };
+      }
+      return refuse(outcome, lang);
+    }
+  };
+}
+function replaceOpts(record) {
+  return {
+    replace: record.name,
+    ...record.marketplace ? { marketplace: record.marketplace } : {}
+  };
+}
+function refuse(outcome, lang) {
+  if (outcome.ok) {
+    return {
+      ok: false,
+      reason: "failed",
+      detail: t("plugin_control.unexpected_commit", { name: outcome.record.name }, lang)
+    };
+  }
+  return {
+    ok: false,
+    reason: outcome.preview?.conflict ? "conflict" : "failed",
+    detail: outcome.reason,
+    ...outcome.preview ? { preview: outcome.preview } : {}
+  };
+}
+function previewToken(preview) {
+  const inv = preview.inventory;
+  const hash = createHash("sha256");
+  hash.update(`${preview.manifest.name}@${preview.manifest.version}
+`);
+  hash.update(`${preview.source.type} ${preview.source.raw}
+`);
+  for (const list of [inv.commands, inv.roles, inv.skills, inv.mcpServers, inv.ignoredBuckets]) {
+    hash.update(`${[...list].sort().join(",")}
+`);
+  }
+  for (const tally of [...inv.hooks].sort((a, b) => a.type.localeCompare(b.type))) {
+    hash.update(`${tally.type}=${tally.count};`);
+  }
+  hash.update(`
+${inv.denyRules}|${inv.jsTools ? 1 : 0}
+`);
+  hash.update(`${preview.versionUnmet?.required ?? "-"}
+`);
+  return hash.digest("hex").slice(0, 32);
+}
+var init_plugin_install = __esm({
+  "src/plugin-install.ts"() {
+  }
+});
+function createPluginControl(deps) {
+  let pendingRestart = false;
+  const live = new Map(deps.loaded.map((p) => [p.name, p.counts]));
+  const flow = createInstallFlow({ pluginsDir: deps.pluginsDir, statePath: deps.statePath });
+  const mark = (outcome) => {
+    if (outcome.ok) pendingRestart = true;
+    return outcome;
+  };
+  const resolveRef = (ref, lang) => {
+    const hit = resolveMarketplaceRef(ref, deps.marketplacesPath);
+    if (!hit) {
+      return {
+        ok: false,
+        reason: "unknown-ref",
+        detail: t("plugin_control.not_a_ref", { ref }, lang)
+      };
+    }
+    if (!hit.ok) return { ok: false, reason: "unknown-ref", detail: hit.reason };
+    if (!deps.allowRemote && !isLocalSource(hit.ref.source)) {
+      return {
+        ok: false,
+        reason: "remote-disabled",
+        detail: t("plugin_control.entry_remote_off", { ref, source: hit.ref.source }, lang)
+      };
+    }
+    return { ok: true, source: hit.ref.source, marketplace: hit.ref.marketplace };
+  };
+  const recordOf = (name, lang) => {
+    const record = readPluginRecords(deps.statePath).records.find((r) => r.name === name);
+    if (!record) {
+      return {
+        ok: false,
+        reason: "not-installed",
+        detail: t("plugin_control.not_installed", { name }, lang)
+      };
+    }
+    if (record.linked) {
+      return {
+        ok: false,
+        reason: "nothing-to-do",
+        detail: t("plugin_control.linked_no_update", { name, source: record.source }, lang)
+      };
+    }
+    if (!deps.allowRemote && !isLocalSource(record.source)) {
+      return {
+        ok: false,
+        reason: "remote-disabled",
+        detail: t("plugin_control.update_remote_off", { name, source: record.source }, lang)
+      };
+    }
+    return { ok: true, record };
+  };
+  return {
+    list: () => readPluginRecords(deps.statePath).records.map((r) => ({
+      ...r,
+      active: live.has(r.name),
+      ...live.get(r.name) ? { counts: live.get(r.name) } : {}
+    })),
+    search: (keyword = "") => {
+      const markets = new Map(
+        readMarketplaces(deps.marketplacesPath).records.map((r) => [r.name, r.source])
+      );
+      return searchMarketplaces(keyword, deps.marketplacesPath).map((hit) => {
+        const market = markets.get(hit.marketplace);
+        const absolute = market === void 0 ? void 0 : resolveEntrySource(hit.entry.source, market);
+        const kind = absolute === void 0 ? void 0 : resolveSource(absolute)?.type;
+        return {
+          marketplace: hit.marketplace,
+          entry: hit.entry,
+          ref: hit.ref,
+          ...kind ? { sourceType: kind } : {},
+          installable: deps.allowRemote ? kind !== void 0 : kind === "local"
+        };
+      });
+    },
+    preview: async (ref, lang) => {
+      const target = resolveRef(ref, lang);
+      return target.ok ? flow.preview(target.source, { marketplace: target.marketplace }, lang) : target;
+    },
+    install: async (ref, token, lang) => {
+      const target = resolveRef(ref, lang);
+      return target.ok ? mark(await flow.install(target.source, token, { marketplace: target.marketplace }, lang)) : target;
+    },
+    previewUpdate: async (name, lang) => {
+      const found = recordOf(name, lang);
+      return found.ok ? flow.preview(found.record.source, replaceOpts(found.record), lang) : found;
+    },
+    update: async (name, token, lang) => {
+      const found = recordOf(name, lang);
+      return found.ok ? mark(await flow.install(found.record.source, token, replaceOpts(found.record), lang)) : found;
+    },
+    uninstall: async (name, lang) => {
+      const outcome = await uninstallPlugin(name, { statePath: deps.statePath });
+      if (!outcome.ok) {
+        return {
+          ok: false,
+          reason: "not-installed",
+          detail: t("plugin_control.not_installed", { name }, lang)
+        };
+      }
+      pendingRestart = true;
+      return { ok: true, detail: outcome.message };
+    },
+    get pendingRestart() {
+      return pendingRestart;
+    }
+  };
+}
+var init_plugin_control = __esm({
+  "src/plugin-control.ts"() {
+    init_host_marketplaces();
+    init_plugin_install();
+  }
+});
 function wirePluginMcpServers(mcpPaths, diags) {
   const out = [];
   for (const ref of mcpPaths) {
@@ -550,9 +910,6 @@ function createRoleWriteControl(deps) {
         return {
           ok: false,
           reason: "duplicate",
-          // 把**哪一层**占着这个名字说出来：内置和项目级的出路不同（前者只能换名字，
-          // 后者他还可以去改自己仓库里那一份）。只说「重名了」的话，一个撞上
-          // `general` 的人会以为自己的 `~/.epoch/agents/` 里躺着一份看不见的文件
           detail: t(
             "role_write.dup_in_table",
             { name, layer: t(LAYER_KEY[clash.source], void 0, lang) },
@@ -588,6 +945,7 @@ function createRoleWriteControl(deps) {
           description: input.description,
           ...input.prompt === void 0 ? {} : { prompt: input.prompt },
           ...input.tools === void 0 ? {} : { tools: input.tools },
+          ...input.skills === void 0 ? {} : { skills: input.skills },
           ...input.maxTurns === void 0 ? {} : { maxTurns: input.maxTurns }
         },
         { dir: deps.userDir, source: "user" }
@@ -597,10 +955,6 @@ function createRoleWriteControl(deps) {
       return {
         ok: true,
         path: written.path,
-        // 回**重载之后那张表**里的那一份，不是 core 刚从文件里读出来的那个：
-        // 两者在 `tools` 上真会不同（`mergeRoles` 的交集语义）。撞名已经在上面
-        // 拦掉了，所以今天这两份恒等 —— `??` 那一支是给「没有 provider、
-        // 角色表恒空」的那种进程用的，那时表里找不到它，而文件确实写了
         role: findRole(deps.roles(), name) ?? written.role
       };
     }
@@ -645,32 +999,11 @@ var ApprovalRelay, QuestionRelay;
 var init_serialize = __esm({
   "src/serialize.ts"() {
     ApprovalRelay = class {
-      /**
-       * `requestId` → 请求内容 + 答复闭包 + 登记那一刻。
-       *
-       * 存了 `request` 而不只是闭包，是为了 `listPending()` —— 见它的注释。
-       * Map 的插入序 = 请求发生的时间序，`listPending()` 靠它给出稳定顺序。
-       *
-       * ⚠️ **`since` 是 2026-08-16 补的，在那之前这张表「顺序有了、时刻没有」**：
-       * 插入序答得出「谁先谁后」，答不出「第一条是几点挂上的」，而界面上那一格要说
-       * 「已等多久」只能问后者。判据在 {@link ApprovalRelay.pendingSince} 上。
-       */
       pendingMap = /* @__PURE__ */ new Map();
-      /** 登记时刻从哪儿读。见 {@link RelayClock} */
       clock;
       constructor(clock = Date.now) {
         this.clock = clock;
       }
-      /**
-       * 登记一个刚发给 renderer 的审批。
-       *
-       * 直接吃 `toSerializable()` 的产出：非审批事件（没有 `respond`）传进来是空操作，
-       * 于是宿主的消费循环里不用先判类型。
-       *
-       * ⚠️ 时钟**只在真的要插一条时才读**（在 `return` 后面）。写在函数头上的话，
-       * 每一条流过的事件都会读一次挂钟 —— 而这张表是被 `serializeStream()` 就着
-       * **每一个**事件调的，注入过时钟的宿主那边会当场看见自己的脚本被走空。
-       */
       track(serialized) {
         const { event, respond } = serialized;
         if (event.type !== "approval-request" || !respond) return;
@@ -680,13 +1013,6 @@ var init_serialize = __esm({
           since: this.clock()
         });
       }
-      /**
-       * 答复。
-       *
-       * @returns 是否真的接回了引擎。`false` 意味着这个 `requestId` 不认识 ——
-       *          重复答复、或者 renderer 拿着一个上一轮的 ID 回来了。宿主该把它
-       *          当成日志而不是错误：用户在窗口上双击一下审批按钮就会走到这里。
-       */
       respond(requestId, outcome, note) {
         const pending = this.pendingMap.get(requestId);
         if (!pending) return false;
@@ -694,52 +1020,13 @@ var init_serialize = __esm({
         pending.respond(outcome, note);
         return true;
       }
-      /** 还有多少个审批挂在 renderer 那边没回来 */
       get pendingCount() {
         return this.pendingMap.size;
       }
-      /**
-       * **最早**那一条还挂着的审批是什么时候登记的（epoch 毫秒）；一条都没挂着时 null。
-       *
-       * 存在的理由只有一个：界面上要说得出「**已等**多久」。`pendingCount` 答的是
-       * 「有几条」，而那一格问的是「等了多久」—— 两者之间差的正是这个时刻，
-       * 而在它之前网线上**没有任何一个字段答得出来**（全文在
-       * `WireSessionSummary.pendingSince` 上，包括「为什么 `updatedAt` 顶不了它」）。
-       *
-       * ## 为什么是**最早**那一条，不是最近那一条
-       *
-       * 消费它的那一格挑的是「晾得最久的那个会话」。报最近那一条的话，一个已经卡了
-       * 两小时、刚刚又多挂上一条的会话会说「已等 3 秒」—— 屏幕上那个数会和它被挑中
-       * 的理由互相打脸。「最早」还有一条硬性质：它**只在这个会话彻底不卡了之后才动**
-       * （表清空 → null），而「最近」每多挂一条就往前跳一次，读起来像是等待被重置了。
-       *
-       * ## 取的是表里第一条，靠的正是上面那条插入序不变量
-       *
-       * `pendingMap` 的插入序 = 请求发生的时间序（见它自己的注释），所以第一条就是
-       * 最早那一条，答完出账之后自然轮到下一条。**刻意不遍历取 `Math.min`**：
-       * 那等于给「最早」立第二个定义，而两个定义哪天对不上时，症状是屏幕上一个
-       * 说不出来历的数字 —— 没有任何一处会红。
-       *
-       * **只读**：这张表的时刻由 `track()` 一处写死，宿主不许改。一个能被外面拨的
-       * 「已等多久」等于让每个宿主自己发明一套等待口径。
-       */
       get pendingSince() {
         const first = this.pendingMap.values().next();
         return first.done ? null : first.value.since;
       }
-      /**
-       * 列出还挂着的审批，按发生的先后顺序。
-       *
-       * 给「**新连上来的宿主要补拉**」用：浏览器刷新一次页面，SSE 是新连接，
-       * 之前推过去的 `approval-request` 就没人接了 —— 而引擎那侧还阻塞在等答复。
-       * 没有这个方法，新页面只能干等到超时（对标 OpenCode 的
-       * `session.permission.list`，`packages/server/src/handlers/permission.ts`）。
-       *
-       * 返回的形状**与 SSE 上推的那一条完全一致**（`SerializableApprovalRequest`），
-       * 于是客户端的「收到一条审批」只有一条代码路径，不用为补拉再写一份解析。
-       *
-       * `pendingCount` 不能替代它：数字告诉你有几条挂着，但补拉需要的是内容。
-       */
       listPending() {
         return [...this.pendingMap].map(([requestId, { request }]) => ({
           type: "approval-request",
@@ -747,16 +1034,6 @@ var init_serialize = __esm({
           request
         }));
       }
-      /**
-       * 界面没了：把挂起的审批全部**放弃**，返回放弃的个数。
-       *
-       * 刻意**不** resolve 任何 promise —— 那会变成一串「用户拒绝」。调用方拿到非 0
-       * 返回值后该做的是 `abort()` 掉这一轮（`session.run(msg, { signal })` 的那个
-       * signal）：流一结束，`AgentSession` 的 finally 会把剩下的请求兜底成 deny，
-       * 引擎不会永久挂住，而模型看到的是「这一轮被中止了」而不是「用户否了我五次」。
-       *
-       * 接法见 [docs/EMBEDDING.md](../../../docs/EMBEDDING.md) 的「窗口关掉了怎么办」。
-       */
       abandon() {
         const count = this.pendingMap.size;
         this.pendingMap.clear();
@@ -764,24 +1041,11 @@ var init_serialize = __esm({
       }
     };
     QuestionRelay = class {
-      /**
-       * `requestId` → 请求内容 + 答复闭包 + 登记那一刻。
-       * Map 的插入序 = 提问发生的时间序。`since` 见 {@link QuestionRelay.pendingSince}
-       */
       pendingMap = /* @__PURE__ */ new Map();
-      /** 登记时刻从哪儿读。见 {@link RelayClock} */
       clock;
       constructor(clock = Date.now) {
         this.clock = clock;
       }
-      /**
-       * 登记一个刚发给宿主的提问。
-       *
-       * 直接吃 `toSerializable()` 的产出：非提问事件传进来是空操作，
-       * 于是宿主的消费循环里不用先判类型（同 `ApprovalRelay.track`）。
-       *
-       * 时钟同样只在真要插一条时才读，理由逐字同 `ApprovalRelay.track`。
-       */
       track(serialized) {
         const { event, respondQuestion } = serialized;
         if (event.type !== "question" || !respondQuestion) return;
@@ -791,13 +1055,6 @@ var init_serialize = __esm({
           since: this.clock()
         });
       }
-      /**
-       * 答复。
-       *
-       * @returns 是否真的接回了引擎。`false` = 这个 `requestId` 不认识
-       *          （重复答复、上一轮的 ID、或者已经被 `abandon()` 掉了）。
-       *          调用方该把它当日志而不是错误。
-       */
       respond(requestId, answer) {
         const pending = this.pendingMap.get(requestId);
         if (!pending) return false;
@@ -805,25 +1062,13 @@ var init_serialize = __esm({
         pending.respond(answer);
         return true;
       }
-      /** 还有多少个提问挂在宿主那边没回来 */
       get pendingCount() {
         return this.pendingMap.size;
       }
-      /**
-       * **最早**那一条还挂着的提问是什么时候登记的；一条都没挂着时 null。
-       *
-       * 与 {@link ApprovalRelay.pendingSince} 逐字同构、同三条判据（最早不是最近、
-       * 取表里第一条、只读）。写在那一个上，别在这儿再判一遍。
-       *
-       * ⚠️ **两张表各给一个，网线上却只有一格**：合并成「这个会话从什么时候起被拦住」
-       * 是消费方（Hub）的事，不是这一层的 —— 这一层只知道自己这张表。
-       * 判据在 `WireSessionSummary.pendingSince` 的第一节。
-       */
       get pendingSince() {
         const first = this.pendingMap.values().next();
         return first.done ? null : first.value.since;
       }
-      /** 列出还挂着的提问，按发生的先后顺序。给「新连上来的宿主要补拉」用（验收 9） */
       listPending() {
         return [...this.pendingMap].map(([requestId, { request }]) => ({
           type: "question",
@@ -831,13 +1076,6 @@ var init_serialize = __esm({
           request
         }));
       }
-      /**
-       * 界面没了：把挂起的提问全部**放弃**，返回放弃的个数（验收 8）。
-       *
-       * 刻意**不** resolve 任何 promise —— 那会变成一串编出来的答案。调用方拿到非 0
-       * 返回值后该 `abort()` 掉这一轮：流一结束，`AgentSession` 的 finally 会把剩下的
-       * 请求兜底成 `skipped`（那是实话：确实没人答），引擎不会永久挂住。
-       */
       abandon() {
         const count = this.pendingMap.size;
         this.pendingMap.clear();
@@ -947,12 +1185,7 @@ async function runOnce(store, def, opts, startedAt, now) {
   const runtime = await build({
     homeDir: opts.homeDir,
     workDir: def.workDir,
-    // **显式 false**：不靠 TTY 探测。OS 调度器起的进程天然没有 TTY，
-    // 但嵌入宿主那条路（`headless.js` 由宿主起）可能有，而那时按交互处理
-    // 会让整个「没人可问」的语义塌掉 —— 预授权清单不生效、审批挂着等一个不在的人
     interactive: false,
-    // 任务级清单是**取代**不是叠加：一个任务的授权面必须只由任务自己说清，
-    // 否则用户改一次 `~/.epoch/config.yaml` 就静默放宽了全部十个定时任务
     headless: { allowTools: [...def.allowTools], allowOperations: [...def.allowOperations] },
     sessionSource: "schedule",
     installSignalHandlers: true
@@ -1137,37 +1370,50 @@ var init_executor = __esm({
   }
 });
 function createScheduleControl(opts) {
-  const store = new ScheduleStore(dbPath(opts.homeDir));
+  let opened = null;
+  let openError = null;
+  try {
+    opened = new ScheduleStore(dbPath(opts.homeDir));
+  } catch (err) {
+    openError = err instanceof Error ? err : new Error(String(err));
+  }
+  const store = () => {
+    if (!opened) {
+      throw new Error(
+        `schedule store unavailable: ${openError?.message ?? "unknown"} (see ScheduleControl.storeAvailable)`
+      );
+    }
+    return opened;
+  };
   let backendPromise = null;
   const backendOf = () => {
     backendPromise ??= resolveScheduleBackend(opts.platform ?? process.platform);
     return backendPromise;
   };
   const registrarOf = async () => new ScheduleRegistrar({
-    store,
+    store: store(),
     backend: await backendOf(),
     homeDir: opts.homeDir,
     ...opts.runner ? { runner: opts.runner } : {}
-    // ⚠️ **刻意不给 `cli`**：这一层不知道宿主怎么被唤起，猜的代价见文件头
   });
   const save = async (def, register) => {
     if (!register) return { schedule: def, issues: [] };
     const registrar = await registrarOf();
     const registration = await registrar.register(def);
-    return { schedule: store.get(def.id) ?? def, issues: [], registration };
+    return { schedule: store().get(def.id) ?? def, issues: [], registration };
   };
   const control = {
-    list: () => store.list(),
-    get: (id) => store.get(id),
-    runs: (id, limit) => store.listRuns(id, limit),
-    recentRuns: (limit) => store.listRecentRuns(limit),
+    storeAvailable: opened !== null,
+    list: () => store().list(),
+    get: (id) => store().get(id),
+    runs: (id, limit) => store().listRuns(id, limit),
+    recentRuns: (limit) => store().listRecentRuns(limit),
     capability: async () => {
       const backend = await backendOf();
       return {
         backend: backend?.kind ?? null,
-        // 没有后端（Linux）或者没有无界面入口（嵌入宿主没给 runner）都注册不了。
-        // 两者的措辞不一样，所以宿主还要看 `backend` 那一格
-        canRegister: backend !== null && opts.runner !== void 0
+        canRegister: backend !== null && opts.runner !== void 0,
+        storeAvailable: opened !== null
       };
     },
     create: async (input, saveOpts) => {
@@ -1188,12 +1434,12 @@ function createScheduleControl(opts) {
         homeDir: opts.homeDir
       }).issues;
       if (issues.length > 0) return { issues };
-      const created = store.create({ ...input, workDir: workDir || opts.homeDir });
-      const def = workDir ? created : store.update(created.id, { workDir: automationWorkDir(created.id, opts.homeDir) }) ?? created;
+      const created = store().create({ ...input, workDir: workDir || opts.homeDir });
+      const def = workDir ? created : store().update(created.id, { workDir: automationWorkDir(created.id, opts.homeDir) }) ?? created;
       return save(def, saveOpts?.register !== false);
     },
     update: async (id, patch, saveOpts) => {
-      const current = store.get(id);
+      const current = store().get(id);
       if (!current) return { issues: [] };
       const merged = { ...current, ...patch };
       const issues = validateSchedule({
@@ -1212,18 +1458,18 @@ function createScheduleControl(opts) {
         homeDir: opts.homeDir
       }).issues;
       if (issues.length > 0) return { issues };
-      const next = store.update(id, patch);
+      const next = store().update(id, patch);
       if (!next) return { issues: [] };
       return save(next, saveOpts?.register !== false);
     },
     remove: async (id) => {
-      const def = store.get(id);
+      const def = store().get(id);
       if (!def) return false;
       if (def.osTaskId) await (await registrarOf()).unregister(def);
-      return store.remove(id);
+      return store().remove(id);
     },
     setEnabled: async (id, enabled) => {
-      const def = store.get(id);
+      const def = store().get(id);
       if (!def) return { ok: false, reason: "backend-error", detail: "schedule-not-found" };
       return (await registrarOf()).setEnabled(def, enabled);
     },
@@ -1235,7 +1481,7 @@ function createScheduleControl(opts) {
     }),
     needsAllowlist
   };
-  return { control, dispose: () => store.close() };
+  return { control, dispose: () => opened?.close(), openError };
 }
 var init_control = __esm({
   "src/schedule/control.ts"() {
@@ -1244,7 +1490,7 @@ var init_control = __esm({
 });
 function resolvePermissionLevel(raw, diags) {
   if (isPermissionLevel(raw)) return raw;
-  diags.warn("Perm", `\u672A\u8BC6\u522B\u7684\u6743\u9650\u7EA7\u522B "${raw}"\uFF0C\u56DE\u9000\u5230 default`, "bad-permission-level");
+  diags.warn("Perm", t("boot.bad_permission_level", { raw }), "bad-permission-level");
   return "default";
 }
 function resolveModelCapability(config, diags) {
@@ -1258,7 +1504,7 @@ function resolveModelCapability(config, diags) {
   } catch {
     diags.warn(
       "Capability",
-      `${config.model} \u5143\u6570\u636E\u7F3A\u5931\uFF0CcontextLength \u7528\u914D\u7F6E\u503C`,
+      t("boot.no_model_metadata", { model: config.model }),
       "no-model-metadata"
     );
     return { contextLength: config.contextLength, supportsImages: false };
@@ -1266,21 +1512,26 @@ function resolveModelCapability(config, diags) {
 }
 function reportUtilityModel(info, diags) {
   if (!info.configured) {
-    diags.skipped("Utility \u6A21\u578B", "\u672A\u914D\u7F6E\uFF0C\u5185\u90E8\u4EFB\u52A1\uFF08\u4E0A\u4E0B\u6587\u538B\u7F29\uFF09\u8DDF\u7740\u5F53\u524D\u6A21\u578B\u8D70");
+    diags.skipped("UtilityModel", (lang) => t("boot.utility_model_none", void 0, lang));
     return;
   }
   if (info.issue) {
-    diags.warn("Utility \u6A21\u578B", info.issue, "bad-model-ref");
+    diags.warn("UtilityModel", info.issue, "bad-model-ref");
     return;
   }
-  diags.ok("Utility \u6A21\u578B", `\u5185\u90E8\u4EFB\u52A1\u8D70 ${info.selection.provider}/${info.selection.model}`);
+  diags.ok(
+    "UtilityModel",
+    (lang) => t(
+      "boot.utility_model_selected",
+      { provider: info.selection.provider, model: info.selection.model },
+      lang
+    )
+  );
 }
 function buildTrust(config, workDir, diags, interactive) {
   const root = resolveProjectRoot(workDir);
   if (config.trust?.enabled === false) {
-    const gate2 = createAllowAllGate(
-      "\u4FE1\u4EFB\u95F8\u95E8\u5DF2\u5173\u95ED\uFF08config.trust.enabled=false\uFF09\uFF1A\u4EFB\u4F55\u76EE\u5F55\u7684\u9879\u76EE\u6307\u4EE4\u90FD\u4F1A\u52A0\u8F7D"
-    );
+    const gate2 = createAllowAllGate(t("boot.trust_disabled"));
     setTrustGate(gate2);
     const trust2 = gate2.decide(workDir);
     diags.warn("Trust", trust2.reason, "trust-disabled");
@@ -1290,7 +1541,7 @@ function buildTrust(config, workDir, diags, interactive) {
   }
   const manager = safeInit("Trust", () => new TrustManager(trustPath(config.homeDir)), diags);
   for (const err of manager?.loadErrors ?? []) diags.warn("Trust", err, "trust-load-error");
-  const gate = manager ? createTrustGate({ manager, interactive }) : createDenyAllGate("\u4FE1\u4EFB\u8BB0\u5F55\u4E0D\u53EF\u7528\uFF0C\u6309\u4E0D\u4FE1\u4EFB\u5904\u7406\uFF1A\u672C\u6B21\u4E0D\u52A0\u8F7D\u4EFB\u4F55\u9879\u76EE\u7EA7\u914D\u7F6E");
+  const gate = manager ? createTrustGate({ manager, interactive }) : createDenyAllGate(t("boot.trust_unavailable"));
   setTrustGate(gate);
   const trust = gate.decide(root);
   if (trust.trusted) diags.ok("Trust", trust.reason);
@@ -1299,11 +1550,11 @@ function buildTrust(config, workDir, diags, interactive) {
 }
 function buildImportGate(config, diags) {
   if (getImportGate()) {
-    diags.ok("Instructions", "\u9879\u76EE\u5916\u7684 @import \u7528\u5BBF\u4E3B\u5DF2\u6CE8\u518C\u7684\u95F8\u95E8\uFF08\u542F\u52A8\u65F6\u95EE\u8FC7\u4E00\u6B21\uFF09");
+    diags.ok("Instructions", t("boot.import_host_gate"));
     return;
   }
   if (config.trust?.enabled === false) {
-    setImportGate(createAllowAllImportGate("\u4FE1\u4EFB\u95F8\u95E8\u5DF2\u5173\u95ED\uFF1A\u9879\u76EE\u5916\u7684 @import \u4E5F\u4E00\u5F8B\u52A0\u8F7D"));
+    setImportGate(createAllowAllImportGate(t("boot.import_trust_disabled")));
     return;
   }
   const store = safeInit(
@@ -1312,7 +1563,7 @@ function buildImportGate(config, diags) {
     diags
   );
   if (!store) {
-    setImportGate(createDenyAllImportGate("import \u653E\u884C\u8BB0\u5F55\u4E0D\u53EF\u7528\uFF0C\u9879\u76EE\u5916\u7684 @import \u4E00\u5F8B\u4E0D\u52A0\u8F7D"));
+    setImportGate(createDenyAllImportGate(t("boot.import_store_unavailable")));
     return;
   }
   for (const err of store.loadErrors) diags.warn("Instructions", err, "import-trust-load-error");
@@ -1359,7 +1610,7 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
   for (const p of projectContext.skippedInstructions) {
     diags.warn(
       "Instructions",
-      `${p} \u672A\u52A0\u8F7D\uFF08\u5DE5\u4F5C\u533A\u672A\u4FE1\u4EFB\uFF0Cepoch trust add \u53EF\u653E\u884C\uFF09`,
+      t("boot.instructions_untrusted", { path: p }),
       "workspace-untrusted"
     );
   }
@@ -1369,7 +1620,7 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
     diags.ok("Provider");
   } catch (err) {
     if (err instanceof ProviderError && err.code === PROVIDER_NO_CREDENTIAL) {
-      diags.skipped("Provider", `${err.message}\uFF08\u8DD1 epoch model \u914D\u7F6E\uFF0C\u6216\u8BBE <PROVIDER>_API_KEY\uFF09`);
+      diags.skipped("Provider", t("boot.provider_no_credential", { message: err.message }));
     } else {
       diags.failed(
         "Provider",
@@ -1406,19 +1657,20 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
   }
   const skillDirs = resolveSkillDirs({
     userDir: skillsDir(config.homeDir),
-    // 插件技能排在最前（优先级最低）且全部带前缀，见 core 的 skill/sources.ts
     pluginDirs: plugins.skillDirs,
-    // 宿主注入的紧跟在插件之后（方案 44 §2.1），同样全部带前缀、同样不过工作区
-    // 闸门 —— 它的信任来自「宿主就是跑我们这个库的那个进程」，和 secretStore 同一档
     ...opts.hostSkillDirs ? { hostDirs: opts.hostSkillDirs } : {},
     projectRoot: projectContext.rootDir,
     trusted: trust.trusted,
     diags
   });
-  const skill = safeInit("Skill", () => new SkillSystem(skillDirs.dirs), diags);
+  const skill = safeInit(
+    "Skill",
+    () => new SkillSystem(skillDirs.dirs, { maxIndexed: config.skills?.maxIndexed }),
+    diags
+  );
   if (skill) {
     for (const detail of issueDetails(skill.getIssues())) {
-      diags.warn("Skill", `\u6280\u80FD ${detail}`, "invalid-skill-file");
+      diags.warn("Skill", t("boot.skill_issue", { detail }), "invalid-skill-file");
     }
   }
   let skillLearner;
@@ -1442,15 +1694,17 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
     () => new HookManager(opts.logger ? { log: opts.logger } : {}),
     diags
   );
+  const hookStatus = { sources: [], projectSkipped: false };
   if (hookManager && managedPolicy.allowManagedHooksOnly) {
     diags.warn(
       "Hook",
-      `\u4F01\u4E1A\u6258\u7BA1\u8BBE\u7F6E\u5F00\u542F\u4E86 allowManagedHooksOnly\uFF0C\u7528\u6237\u7EA7\u4E0E\u9879\u76EE\u7EA7 hook \u90FD\u4E0D\u52A0\u8F7D\uFF08${managedPolicy.path}\uFF09`,
+      t("boot.managed_hooks_only", { path: managedPolicy.path }),
       "managed-hooks-only"
     );
   } else if (hookManager) {
     const hooks = loadHookSources({
       userPath: hooksPath(config.homeDir),
+      claudeUserPath: claudeUserSettingsPath(),
       pluginPaths: plugins.hookPaths,
       ...projectContext.rootDir ? { projectRoot: projectContext.rootDir } : {},
       trusted: trust.trusted,
@@ -1458,6 +1712,8 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
       diags
     });
     hookManager.loadEntries(hooks.entries);
+    hookStatus.sources = [...hooks.sources];
+    hookStatus.projectSkipped = hooks.projectSkipped;
   }
   const cache = new ApprovalCache(config.homeDir);
   const permission = safeInit("Perm", () => new PermissionManager(permLevel, cache), diags);
@@ -1484,7 +1740,7 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
       policyStatus.projectSkipped = policyDirs.projectSkipped;
       policyStatus.skippedDir = policyDirs.skippedDir ?? null;
     } catch {
-      diags.warn("Policy", "\u52A0\u8F7D\u5931\u8D25\uFF08\u8DF3\u8FC7\uFF09", "policy-load-failed");
+      diags.warn("Policy", t("boot.policy_load_failed"), "policy-load-failed");
     }
     const lists = config.permissions;
     const counts = {
@@ -1497,7 +1753,12 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
       permission.setPermissionRules(lists);
       diags.ok(
         "Perm",
-        `\u6743\u9650\u89C4\u5219 ${ruleCount} \u6761\uFF08allow ${counts.allow} / ask ${counts.ask} / deny ${counts.deny}\uFF09`
+        t("boot.perm_rules", {
+          total: ruleCount,
+          allow: counts.allow,
+          ask: counts.ask,
+          deny: counts.deny
+        })
       );
       for (const finding of checkShadowing(compileRuleLists(lists))) {
         diags.warn("Perm", finding.message, `rule-${finding.kind}`);
@@ -1510,10 +1771,6 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
     contextEngine = safeInit(
       "Context",
       () => new ContextCompressor({
-        // 2026-08-16 合并时收的一笔（compressor.ts 文件头那张 📮 的第一条）：
-        // `compression.enabled` / `compression.threshold` 两个键的装配点在这儿，
-        // 而写它们的那一轮禁区正是 `runtime/**`。不接这一行的后果不是少一个功能，
-        // 是**一句谎话** —— 配得进、设置页印得出来、还标着「② 用户级」，而压缩照压。
         ...compressionOptions(config),
         summarize: async (prompt) => {
           const utility = provider.getUtilityInfo().selection;
@@ -1534,8 +1791,6 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
   const capability = resolveModelCapability(config, diags);
   return {
     config,
-    // 合并**之前**那一份，连同「哪个键是谁写的」那本账 —— 两样都只给设置页的
-    // 来源标注用（判据在 `Services.baseConfig` 上）
     baseConfig,
     configOrigins: opts.configOrigins ?? getConfigOrigins(),
     provider,
@@ -1559,6 +1814,7 @@ function buildServices(baseConfig, diags, workDir = process.cwd(), opts = {}) {
     settingsLayers: merged.layers,
     managedPolicy,
     policy: policyStatus,
+    hook: hookStatus,
     plugins,
     cleanups
   };
@@ -1567,7 +1823,6 @@ var init_services = __esm({
   "src/services.ts"() {
   }
 });
-
 // src/turn-steps.ts
 function draft() {
   return { text: "", reasoning: "", toolCalls: [], toolResults: [] };
@@ -1586,12 +1841,6 @@ var TurnStepCollector;
 var init_turn_steps = __esm({
   "src/turn-steps.ts"() {
     TurnStepCollector = class {
-      /**
-       * @param startedAt 这一轮开跑的毫秒时间戳，用来算 `durationMs`。
-       * @param now 取当下时间。**注进来只为让用例能钉一个确定的耗时** ——
-       *   生产路径上就是 `Date.now()`，而这一层是服务端，用本机钟是对的
-       *   （web 那边不许用 `Date.now()`，因为它得用服务端信封上的 `ts`）。
-       */
       constructor(startedAt, now = Date.now) {
         this.startedAt = startedAt;
         this.now = now;
@@ -1600,11 +1849,8 @@ var init_turn_steps = __esm({
       now;
       steps = [];
       current = null;
-      /** 当前这一步已经收口，下一笔内容另开一步。见文件头那条 ⚠️ */
       sealed = false;
-      /** 这一轮发过几次工具调用。**跨步累计**，`toolCalls` 那一格要的是整轮的数 */
       calls = 0;
-      /** `finish` 那一帧带回来的账。没收到那一帧就没有 —— 中止 / 报错时就是这样 */
       finish = null;
       observe(event) {
         switch (event.type) {
@@ -1627,8 +1873,6 @@ var init_turn_steps = __esm({
               toolCallId: event.callId,
               toolName: event.toolName,
               output: event.output,
-              // artifact 原样带走（含 `data`）。剥 base64 是落盘那一层的事
-              // （`persistToolResults()`）—— 内存里的宿主要那份数据渲染缩略图
               ...event.artifacts ? { artifacts: event.artifacts } : {}
             });
             return;
@@ -1646,27 +1890,10 @@ var init_turn_steps = __esm({
             return;
         }
       }
-      /** 冲掉最后一步，交出整轮。空步已经在 {@link seal} 里滤掉 */
       take() {
         this.flush();
         return this.steps;
       }
-      /**
-       * 这一轮的账（决定 8 第三个时刻），落在最后一条 assistant 行上。
-       *
-       * ## 三格各自可以没有，而且**都不补 0**
-       *
-       * - `usage` 没有 = provider 这一轮没上报用量。写 0 会读成「这一轮没花钱」，
-       *   而真相是「不知道」（同 `SessionDB.recordUsage` 那条「宁可少记」）。
-       * - `model` 没有 = 引擎没告诉我们这一轮跑的是谁。**不许拿配置里那个顶上** ——
-       *   降级和 `switch_model` 之后那是个从没跑过的模型名，比不显示更糟。
-       * - `durationMs` 没有 = 起点未知（没给 `startedAt`）。写 0 是「0s」，那是假事实。
-       *
-       * `toolCalls` 反过来 —— 它**必有**，因为 `0` 在这一格是真的 0（「这一轮没动手」）。
-       *
-       * 整帧 `finish` 都没收到（中止 / 报错）时返回 `undefined`：那一轮**没有**账，
-       * 而不是一笔全是空格的账。
-       */
       facts() {
         if (!this.finish) return void 0;
         const durationMs = this.startedAt === void 0 ? void 0 : Math.max(0, this.finish.at - this.startedAt);
@@ -1700,46 +1927,20 @@ function settleAbandoned(pending) {
 var AgentSession;
 var init_agent_session = __esm({
   "src/agent-session.ts"() {
+    init_events();
     init_turn_steps();
     AgentSession = class {
-      /**
-       * 当前会话 id。
-       *
-       * **不再是 `readonly`**（方案 25 PR-4 的 `/resume`）：换会话时它必须跟着换，
-       * 否则接下来 `store.record()` 会把新对话记到**旧会话**名下 ——
-       * 症状是「我明明 resume 了另一段，怎么两段混在一起」。
-       * 换的入口只有 `resume()` 一个，不要在别处赋值。
-       */
       sessionId;
       agent;
       store;
       checkpoints;
       goals;
       currentRole;
-      /**
-       * 上一轮是谁在跑（方案 57 §3.5）。`null` = 这段会话此刻没有角色，**那也是一个值**
-       * —— 从「有」变成「没有」（用户点掉 chip 退回一段本来就没有角色的会话）同样
-       * 要留痕。
-       *
-       * ⚠️ **它只在进程内有效，从历史里恢复不出来。** 构造时拿的是这个会话**默认**
-       * 那个专家，于是重启之后第一条不带 chip 的消息**不插标记** —— 那是对的：
-       * 上一条标记还在历史里，语义没断。
-       *
-       * 别去做一次「从历史里反推上一轮是谁」的解析：那要 parse 我们自己印的那句
-       * 中文，而它是可翻译的（catalog 真源 `locales/*.yaml`）—— 换一次界面语言，
-       * 那个解析器就静默失灵。
-       */
       lastRole;
-      /** 不是 `readonly` 的数组内容 —— `compact()` 和 `resume()` 会整体换掉它 */
+      currentWorkDir;
+      lastWorkDir = null;
       history;
-      /** 待交给宿主的请求队列（审批 + 提问）+ 「有新请求」的唤醒信号 */
       queue = [];
-      /**
-       * 已经交给宿主、但还没答复的请求。
-       *
-       * 必须单独记：请求一旦 yield 给宿主就已经出了 queue，如果宿主提前 break
-       * 走了，只看 queue 是空的，那个挂在 await 上的引擎就永久等下去。
-       */
       inFlight = /* @__PURE__ */ new Set();
       notify = null;
       constructor(opts) {
@@ -1749,15 +1950,10 @@ var init_agent_session = __esm({
         this.checkpoints = opts.checkpoints;
         this.goals = opts.goals;
         this.currentRole = opts.currentRole;
+        this.currentWorkDir = opts.currentWorkDir;
         this.lastRole = opts.currentRole?.() ?? null;
         this.history = [...opts.history ?? []];
       }
-      /**
-       * 传给 AgentLoop 的审批回调。
-       *
-       * 必须在构造 AgentLoop **之前**拿到（它是构造参数），所以这里做成静态工厂：
-       * 先建 pending 队列，再建 AgentLoop，最后建 AgentSession。
-       */
       static createApprovalBridge() {
         let target = null;
         const buffered = [];
@@ -1783,49 +1979,24 @@ var init_agent_session = __esm({
           }
         };
       }
-      /** 当前累积的历史（只读快照） */
       getHistory() {
         return this.history;
       }
-      /**
-       * 往上下文里记一句话，**不跑模型**（方案 25 §2.3 的 `!` 走这条）。
-       *
-       * 用户在 TUI 里敲 `!git status` 时，输出得让模型看得见 —— 「你看一下这个命令的
-       * 输出」正是 `!` 存在的意义。但它不该触发一轮对话：用户只是想让它知道，
-       * 不是想让它现在就说点什么。
-       *
-       * 角色是 `user` 而不是 `system`：这**确实是用户做的事**，把它标成系统消息会让
-       * 模型以为是我们的指令。也**不落盘** —— `run()` 那条路才管持久化，
-       * 而这里没有一轮可以归属；resume 之后丢掉一条「我刚跑了 ls」是可以接受的，
-       * 把它塞进 DB 反而会让会话回放里出现一条没有回答的用户消息。
-       */
       note(text) {
         if (!text.trim()) return;
         this.history.push({ role: "user", content: text });
       }
-      /**
-       * 手动压缩一次上下文（`/compact`，方案 25 §2.6）。
-       *
-       * 和自动压缩共用引擎里同一段实现，区别只有两个：**不看阈值**（用户敲这条命令
-       * 就是要它现在压），以及可以带一句「这次帮我留住什么」。
-       *
-       * 压缩本身是一次真实的 LLM 请求，那笔钱进的是同一个会话预算 —— 账单由
-       * `AgentLoop` 抛出来，这里原样转给调用方，别在这一层吞掉。
-       *
-       * 历史只有一条（或空）时直接不压：压一条消息拿不到任何收益，
-       * 却要花一次 utility 模型的请求。
-       */
       async compact(instruction) {
         const before = this.history.length;
         if (before <= 1) {
-          return { ran: false, before, after: before, reason: "\u5386\u53F2\u592A\u77ED\uFF0C\u6CA1\u4EC0\u4E48\u53EF\u538B\u7684" };
+          return { ran: false, before, after: before, reason: t("boot.compact_too_short") };
         }
         const result = await this.agent.compactNow(
           this.history.map((m) => ({ role: m.role, content: m.content })),
           instruction
         );
         if (!result.ran) {
-          return { ran: false, before, after: before, reason: "\u4E0A\u4E0B\u6587\u538B\u7F29\u6A21\u5757\u6CA1\u8D77\u6765\uFF0C\u770B\u8BCA\u65AD" };
+          return { ran: false, before, after: before, reason: t("boot.compact_unavailable") };
         }
         this.history = result.messages.map((m) => ({
           role: m.role === "assistant" ? "assistant" : "user",
@@ -1838,23 +2009,6 @@ var init_agent_session = __esm({
           ...result.usage ? { usage: result.usage } : {}
         };
       }
-      /**
-       * 把某个会话落盘的那段历史装进内存 —— **「模型看到的」那一份只有这一个装法**。
-       *
-       * 三处共用：{@link resume}（换到另一段对话）、{@link rewindConversation}
-       * （回退之后重装），以及 web 的复活（`SessionRuntimeFactory.revive()`：
-       * 引擎装好之后把落盘的那段接上）。抄成三份的代价不是「重复」，
-       * 而是**它们一旦分叉，症状就是「屏幕上和模型看到的对不上」** ——
-       * 下面 {@link resume} 那段注释骂的正是这个。
-       *
-       * 没有 store（纯内存模式）就装成空的：没有 DB 就没有历史可言。
-       *
-       * ⚠️ **不改 `this.sessionId`。** 换会话是 {@link resume} 的事 ——
-       * 复活装的就是自己这一段，那儿本来就不该动。
-       *
-       * @param sessionId 从哪个会话读
-       * @returns 装进去的那一份，供宿主回放进屏幕
-       */
       reloadHistory(sessionId) {
         const restored = this.store?.loadHistory(sessionId) ?? [];
         this.history = restored.map((m) => ({
@@ -1864,38 +2018,11 @@ var init_agent_session = __esm({
         }));
         return this.history;
       }
-      /**
-       * 换到另一个会话（`/resume`，方案 25 §2.6）。
-       *
-       * **模型真的接上那段上下文**，不只是把历史打印到屏幕上 —— 后者在终端里
-       * 和真恢复长得一模一样，而用户会照着屏幕上那段去问「你刚才说的那个方案」，
-       * 然后收到一句完全对不上的回答。
-       *
-       * 两样都要换：历史（模型看的）和 `sessionId`（往哪儿记）。只换前者的话，
-       * 接下来这一轮会被记进**上一个**会话里 —— 所以这儿在
-       * {@link reloadHistory} 之外还多一步。
-       *
-       * 内存模式下装出来是空的，但 `sessionId` 仍然换：调用方已经决定
-       * 「这是另一段对话」了。
-       *
-       * @returns 恢复出来的历史，供宿主回放进屏幕
-       */
       resume(sessionId) {
         const restored = this.reloadHistory(sessionId);
         this.sessionId = sessionId;
         return restored;
       }
-      /**
-       * 对话回退（方案 27）：删掉水位线之后的消息，然后把内存历史重新装一遍。
-       *
-       * **重装而不是自己在内存里 splice**：DB 是唯一真源，重装出来的历史天然和它一致。
-       * 自己截内存的话就有两套截断逻辑，而它们一旦分叉，症状是「屏幕上和模型看到的
-       * 对不上」—— `resume()` 那段注释骂过的正是这个。
-       *
-       * 没有 store（纯内存模式）就什么都不做并返回 `null`：没有 DB 就没有水位线可言。
-       *
-       * @returns 删掉几条消息；失败或不支持时 `null`
-       */
       rewindConversation(lastKeptId) {
         if (!this.store || lastKeptId < 0) return null;
         const removed = this.store.rewindTo(this.sessionId, lastKeptId);
@@ -1903,13 +2030,6 @@ var init_agent_session = __esm({
         this.reloadHistory(this.sessionId);
         return removed;
       }
-      /**
-       * 一条排队的请求 → 一个带答复闭包的事件。
-       *
-       * **答复一次就出账**：先从 `inFlight` 里删掉，再 resolve。重复调用 respond
-       * 是无害的（promise 已 settle），但漏了这一步 `finally` 会再对它补一个兜底答复，
-       * 于是「用户明明点了允许」和「引擎收到拒绝」同时成立。
-       */
       toEvent(pending) {
         if (pending.kind === "question") {
           return {
@@ -1924,26 +2044,12 @@ var init_agent_session = __esm({
         return {
           type: "approval-request",
           request: pending.req,
-          // 没带 `note` 时原样传裸出口而不是包成 `{outcome}`：两者语义相同，
-          // 但裸串是既有形态，包一层会让所有断言 `resolve` 参数的用例白红一次
           respond: (outcome, note) => {
             this.inFlight.delete(pending);
             pending.resolve(note === void 0 ? outcome : { outcome, note });
           }
         };
       }
-      /**
-       * 跑一轮对话，产出 AgentEvent 流（含 approval-request / question）。
-       *
-       * 宿主只要 for-await 这个流，把 approval-request 交给用户点选即可 ——
-       * 不用关心阻塞回调、不用自己拼历史、不用自己写持久化。
-       *
-       * @param opts.signal 中止信号。`AgentLoop` 一直支持 `input.signal`（轮次之间
-       *        和工具执行处都会检查），但这个签名以前不透传，于是宿主唯一的中止手段
-       *        是硬杀进程 —— `dispose()` 跑不到，SQLite 连接和子进程都留着。
-       *        TUI 的 Esc 就靠它：只靠 `break` 退出 for-await 要等下一个事件到达
-       *        才生效，模型正在长考时按 Esc 完全没反应。
-       */
       async *run(userMessage, opts = {}) {
         let assistantText = "";
         const userText = contentToText(userMessage);
@@ -1955,13 +2061,11 @@ var init_agent_session = __esm({
         });
         if (userText.trim()) this.goals?.beginRound(this.sessionId);
         this.markRoleHandoff();
+        this.markWorkspaceHandoff();
         const iter = this.agent.stream({
           userMessage,
           sessionId: this.sessionId,
           history: this.history,
-          // 逐轮把真实用量累进 `sessions` 表（方案 42 PR-0）。
-          // 收的是**本轮增量** —— 事件流里的 `usage.cumulative` 会被 BudgetStore
-          // 从上次会话恢复，减不出干净的增量（见 `RunInput.onTurnUsage`）
           ...this.store ? {
             onTurnUsage: (usage) => void this.store?.recordUsage(this.sessionId, usage)
           } : {},
@@ -1980,7 +2084,9 @@ var init_agent_session = __esm({
               while (this.queue.length > 0) {
                 const pending = this.queue.shift();
                 this.inFlight.add(pending);
-                yield this.toEvent(pending);
+                const request = this.toEvent(pending);
+                publishAgentEvent(this.sessionId, request);
+                yield request;
               }
               continue;
             }
@@ -1989,6 +2095,7 @@ var init_agent_session = __esm({
             pendingNext = iter.next();
             if (event.type === "text-delta") assistantText += event.text;
             turn.observe(event);
+            publishAgentEvent(this.sessionId, event);
             yield event;
           }
         } finally {
@@ -1997,47 +2104,20 @@ var init_agent_session = __esm({
           this.inFlight.clear();
           this.notify = null;
         }
-        this.history.push({ role: "user", content: userText, ...parts ? { parts } : {} });
-        if (assistantText) this.history.push({ role: "assistant", content: assistantText });
         const steps = turn.take();
         const facts = turn.facts();
+        const assistantHistory = assistantTurnText(
+          assistantText,
+          steps.flatMap((s) => s.toolResults ?? [])
+        );
+        this.history.push({ role: "user", content: userText, ...parts ? { parts } : {} });
+        if (assistantHistory) this.history.push({ role: "assistant", content: assistantHistory });
         this.store?.record(this.sessionId, userText, assistantText, {
           ...parts ? { parts } : {},
           ...steps.length > 0 ? { steps } : {},
-          // 这一轮的账（决定 8 第三个时刻）。不落它的话刷新之后每一轮的
-          // 「共 N token · 哪个模型 · 花了几秒」全部消失 —— 那是网线补不回来的
           ...facts ? { facts } : {}
         });
       }
-      /**
-       * 换专家的那一刻，往历史里插一条 `[系统]` 消息（方案 57 §2.3 / §3.5）。
-       *
-       * ## 为什么在这一层，不在 `loop.ts` 里
-       *
-       * 循环里那个 `messages` 是 **per-run** 的数组，往那儿 push 的东西不进 DB 历史
-       * （后台任务通知就是这么设计的 —— 它不该被回放）。而这一条要的**恰恰是落盘**：
-       * 身份行活在那一次请求里、chip 活在浏览器里，历史是唯一会落盘的那一份，
-       * 而「这段对话里谁干的」正是重开会话回放时才会被问的问题。
-       *
-       * ## 三条形状判据
-       *
-       * 1. **`role: 'user'` + `[系统]` 前缀，不是 `role: 'system'`** —— AI SDK v7 不许
-       *    `messages` 里出现 system，会抛 `AI_InvalidPromptError`。这条坑 `loop.ts`
-       *    已经踩过一次并逐字记下来了，别重踩。⚠️ 前缀**由这里拼**（{@link systemNote}），
-       *    catalog 里 `agent_role` 那两条是光正文：前缀是全仓共用的一条契约，真源在
-       *    `protocol/src/system-note.ts`，烤进句子里就会跟着译者走；
-       * 2. **两条连续的 `user` 消息是安全的** —— 后台任务通知今天就是这么挂的，
-       *    而它在真 provider 上跑通了。⚠️ `message-utils.ts` 里那个
-       *    `validateAlternation()` 看起来禁止这件事，但它**全仓只有自己的用例调用，
-       *    生产路径上一个调用点都没有**（2026-08-17 复核）。别为了让它自洽去「修」
-       *    这条路，那会连后台通知一起打挂；
-       * 3. **只在真的换人那一条上插**（含「从有到无」）。每条都插等于往历史里灌噪音，
-       *    还会让压缩器把预算花在这上面。
-       *
-       * ⚠️ 落盘走 {@link SessionStore.recordNote} 而不是 `record()`：后者写的是**一轮
-       * 问答**（user + assistant + tool×N），拿它写一条孤零零的 user 行是在赌
-       * 「assistantText 为空时它恰好不写第二行」——那是一个实现细节，不是一条承诺。
-       */
       markRoleHandoff() {
         if (!this.currentRole) return;
         const now = this.currentRole() ?? null;
@@ -2048,14 +2128,24 @@ var init_agent_session = __esm({
         this.history.push({ role: "user", content: text });
         this.store?.recordNote(this.sessionId, text);
       }
-      /** 一次性执行并拿最终文本（CLI 单次问答用） */
+      markWorkspaceHandoff() {
+        if (!this.currentWorkDir) return;
+        const now = this.currentWorkDir();
+        const previous = this.lastWorkDir;
+        this.lastWorkDir = now;
+        if (previous === null || previous === now) return;
+        if (this.history.length === 0) return;
+        const text = systemNote(t("workspace.handoff", { root: now }));
+        this.history.push({ role: "user", content: text });
+        this.store?.recordNote(this.sessionId, text);
+      }
       async once(userMessage, opts = {}) {
         let text = "";
         let reasoning = "";
         for await (const ev of this.run(userMessage, opts)) {
           if (ev.type === "text-delta") text += ev.text;
           else if (ev.type === "reasoning-delta") reasoning += ev.text;
-          else if (ev.type === "error") text = `\u9519\u8BEF: ${ev.message}`;
+          else if (ev.type === "error") text = t("boot.error", { message: ev.message });
         }
         return { text, ...reasoning ? { reasoning } : {} };
       }
@@ -2065,8 +2155,6 @@ var init_agent_session = __esm({
 function createRoleControl(scope, roles) {
   return {
     has: (name) => findRole(roles(), name) !== void 0,
-    // `findRole` 找不到时回 `undefined`，而 `enter(undefined)` 的语义正好是
-    // 「退回会话默认角色」—— 上面那段 ⚠️ 说的就是这一格，不用再判一次
     enterTurn: (name) => scope.enter(findRole(roles(), name))
   };
 }
@@ -2086,7 +2174,6 @@ var init_role_scope = __esm({
   "src/role-scope.ts"() {
   }
 });
-
 // src/session-goal.ts
 function buildGoalControl(service, sessionId) {
   return {
@@ -2100,20 +2187,47 @@ function buildGoalControl(service, sessionId) {
     clear: () => service.clear(sessionId())
   };
 }
+function buildGoalCatalog(service) {
+  return {
+    current: (sessionId) => service.current(sessionId),
+    create: (sessionId, objective, maxRounds) => service.create(sessionId, objective, maxRounds),
+    edit: (sessionId, objective) => service.edit(sessionId, objective),
+    setBudget: (sessionId, maxRounds) => service.setBudget(sessionId, maxRounds),
+    pause: (sessionId) => service.pause(sessionId),
+    resume: (sessionId) => service.resume(sessionId),
+    complete: (sessionId, evidence) => service.complete(sessionId, evidence),
+    clear: (sessionId) => service.clear(sessionId)
+  };
+}
 var init_session_goal = __esm({
   "src/session-goal.ts"() {
   }
 });
 function buildSessionGuards(input) {
-  const { permission, planState, managed, startLevel, requestApproval, interactive } = input;
-  const scopeOf = (perm, state, own) => ({
-    permission: perm,
-    permissions: perm ? buildSessionPermissions(perm, managed, state) : null,
-    plan: state ? buildPlanControl(state) : null,
-    planState: state,
-    // 引导会话不盖（注册表里那两个就是它的），别的会话盖上自己那一对
-    tools: own && state ? createPlanModeTools({ state, ...interactive ? { requestApproval } : {} }) : []
-  });
+  const {
+    permission,
+    planState,
+    managed,
+    startLevel,
+    requestApproval,
+    interactive,
+    deferredTools
+  } = input;
+  const bootstrapReveal = input.bootstrapReveal;
+  const scopeOf = (perm, state, own) => {
+    const reveal = own ? createToolRevealState() : bootstrapReveal;
+    return {
+      permission: perm,
+      permissions: perm ? buildSessionPermissions(perm, managed, state) : null,
+      plan: state ? buildPlanControl(state) : null,
+      planState: state,
+      tools: own ? [
+        ...state ? createPlanModeTools({ state, ...interactive ? { requestApproval } : {} }) : [],
+        ...deferredTools().length > 0 ? [createToolSearchTool({ deferred: deferredTools, reveal })] : []
+      ] : [],
+      reveal
+    };
+  };
   const bootstrapScope = scopeOf(permission, planState, false);
   return {
     bootstrap: () => bootstrapScope,
@@ -2216,19 +2330,6 @@ var init_session_store = __esm({
   "src/session-store.ts"() {
     init_session_file_changes();
     SessionStore = class {
-      /**
-       * @param artifactsRoot artifact 目录的**家目录**（即 `~/.epoch` 那一层），
-       *        缺省按 `EPOCH_HOME` / profile 解析。只有测试和多 profile 场景要显式给。
-       * @param cwd 这段会话归属的**项目根**，落进 `sessions.cwd` 列（方案 29 §2.1）。
-       *
-       * `cwd` 在方案 29 之前从来没人写过：列是有的（v1 基线里就在，还带着
-       * `idx_sessions_cwd` 索引），但 `ensure()` 只传了 id，于是全库的 cwd 都是 NULL、
-       * `epoch -c`「接上本目录最近一个会话」压根无从判起。
-       *
-       * 传项目根而不是 `process.cwd()`：在子目录里敲 `epoch -c` 要接上同一个仓库的
-       * 会话。读取侧（`SessionManager.getLatestByCwd`）用的是同一个口径。
-       * 不给就仍然写 NULL —— 那段会话只是不参与 `-c` 匹配，别的一切照旧。
-       */
       constructor(sessions, artifactsRoot, cwd, source, decision) {
         this.sessions = sessions;
         this.artifactsRoot = artifactsRoot;
@@ -2241,40 +2342,10 @@ var init_session_store = __esm({
       cwd;
       source;
       decision;
-      /** 已经确认存在的会话 id，避免每轮都试着 create */
       known = /* @__PURE__ */ new Set();
-      /** 这个会话的 artifact 目录 */
       artifactDir(sessionId) {
         return this.artifactsRoot ? artifactsDir(sessionId, this.artifactsRoot) : artifactsDir(sessionId);
       }
-      /**
-       * 记录一轮问答。持久化失败不该影响对话本身，所以吞异常但返回是否成功。
-       *
-       * `userMessage` / `assistantText` 收的是**文本投影**：`Message.content` 是
-       * SQLite 里的一个 TEXT 列，把 base64 灌进去会让 sessions.db 以每张截图几百 KB
-       * 的速度膨胀，而且 `epoch sessions list` 的预览、标题截取、全文检索全会被那串
-       * 字符污染。图片本身走 `detail.parts` —— 落进 artifact 目录，列里只留路径。
-       *
-       * 落盘的行顺序是 **user →（assistant → tool×k）× 步数**，不是时间序：这是
-       * `EpochMessage` 的规范顺序（assistant 声明 `toolCalls`，tool 行携带
-       * `toolResults`）。宿主按 `toolCallId` 配对分组渲染，**不要依赖行序**去猜
-       * 哪个结果属于哪次调用 —— 那正是 `AgentEvent` 加 `callId` 时骂过的病
-       * （靠「工具名 + 调用顺序 FIFO」猜，并行工具必然串台）。
-       *
-       * ## ⚠️ 一轮不再只有**一条** assistant 行（2026-08-18）
-       *
-       * 以前是「整轮正文拼成一条 + 全部 toolCalls 挂上去 + 所有 tool 行垫在最后」。
-       * 那个形状丢掉了步序，直接后果是**刷新页面之后屏幕上的顺序和刚才不一样**：
-       * 回放只能照行序重建，于是「先调工具、后回答」被画成「先回答、后工具卡」。
-       *
-       * 现在按 {@link TurnDetail.steps} 一步一行。这不是新发明的形状 —— `loop.ts`
-       * 自己往上下文里 push 的就是它，只是那一份是 per-run 的、从不落盘。
-       *
-       * 两个连带的地方，改这里时别忘了：
-       *   - {@link loadHistory} 要把连续的 assistant 行**合并回一条**再喂模型；
-       *   - `web/src/state/replay.ts` 和假服务端的 `toReplayMessages()` 是读侧的
-       *     两份实现，形状变了两边都要跟。
-       */
       record(sessionId, userMessage, assistantText, detail = {}) {
         try {
           this.ensure(sessionId);
@@ -2298,8 +2369,6 @@ var init_session_store = __esm({
             for (const result of persistToolResults(step.toolResults ?? [])) {
               this.sessions.appendMessage(sessionId, {
                 role: "tool",
-                // content 列存输出的文本投影：FTS 索引和 `epoch sessions search`
-                // 靠它才搜得到工具输出。结构化的那份在 toolResults 里
                 content: result.output,
                 toolCallId: result.toolCallId,
                 toolName: result.toolName,
@@ -2312,18 +2381,6 @@ var init_session_store = __esm({
           return false;
         }
       }
-      /**
-       * 记一条**孤立的 `user` 行**，没有与之配对的回答（方案 57 §3.5 那条换人留痕）。
-       *
-       * 和 {@link record} 分开而不是拿 `record(id, text, '')` 顶：那个方法写的是**一轮
-       * 问答**，「assistantText 为空时它恰好只写一行」是一个实现细节而不是一条承诺 ——
-       * 哪天它改成「assistant 行无条件写」（那是一个合理的改动），这条留痕后面就会
-       * 凭空多出一条空回答，而没有任何东西会红。
-       *
-       * **要 `ensure()`**，判据同 `recordUsage()`：这一行写在轮次开始那一刻，
-       * 比 `record()`（整轮结束才写）早。不建会话行的话 `appendMessage` 会失败，
-       * 而这条留痕正是重开会话回放时唯一说得出「从这里起换人了」的东西。
-       */
       recordNote(sessionId, text) {
         try {
           this.ensure(sessionId);
@@ -2333,15 +2390,6 @@ var init_session_store = __esm({
           return false;
         }
       }
-      /**
-       * 累加一轮模型请求的真实用量（方案 42 PR-0）。持久化失败照旧不影响对话。
-       *
-       * **这里要 `ensure()`**，和 `lastMessageId()` 的克制正相反：用量是逐轮来的，
-       * 比 `record()`（整轮对话结束才写）早，新会话的第一条消息还没落盘。
-       * 不建会话行的话那条 UPDATE 影响 0 行 —— 一段全新会话的用量会**整段丢掉**。
-       * 而且这里的触发条件比那边硬：能走到这儿说明模型请求已经发出去、钱已经花了，
-       * 那就是一段值得记录的会话，不是「点开又退出」。
-       */
       recordUsage(sessionId, usage) {
         try {
           this.ensure(sessionId);
@@ -2351,17 +2399,6 @@ var init_session_store = __esm({
           return false;
         }
       }
-      /**
-       * 记下（或清掉）这段会话当前生效的那份已批准计划（方案 35 PR-2 验收 9）。
-       *
-       * **要 `ensure()`**，和 `recordUsage()` 同一个理由、比它更硬：计划被批准
-       * 通常发生在第一轮对话**结束之前**（模型 `enter_plan_mode` → 调研 →
-       * `exit_plan_mode` → 用户批），那时 `record()` 还一条都没写。不建会话行的话
-       * 那条 UPDATE 影响 0 行 —— 用户刚点完「批准并执行」，计划就已经没落盘。
-       *
-       * 传 `null` 是**清掉**（用户拒绝了计划）。这里不做「空串当没给」的归一：
-       * 调用方是 `PlanModeState`，它给的只会是一份正文或者 `null`。
-       */
       savePlan(sessionId, markdown) {
         try {
           this.ensure(sessionId);
@@ -2371,12 +2408,6 @@ var init_session_store = __esm({
           return false;
         }
       }
-      /**
-       * 读回这段会话的已批准计划；没有（或会话不存在）时 `null`。
-       *
-       * **不 `ensure()`**：这是查询。`--resume` 指着一个不存在的 id 时该回「没有」，
-       * 而不是顺手建一段空会话。
-       */
       loadPlan(sessionId) {
         try {
           return this.sessions.get(sessionId)?.meta.plan ?? null;
@@ -2384,13 +2415,6 @@ var init_session_store = __esm({
           return null;
         }
       }
-      /**
-       * 这个会话最后一条消息的 DB id（方案 27 的检查点水位线）。
-       *
-       * 会话还没建出来时是 0 —— **不 `ensure()`**：开轮是每条用户消息都要做的事，
-       * 为它去建一个可能马上就没有任何内容的会话行，等于让「只是聊了两句就退出」
-       * 也在 DB 里留一条空会话。
-       */
       lastMessageId(sessionId) {
         try {
           return this.sessions.lastMessageId(sessionId);
@@ -2398,13 +2422,6 @@ var init_session_store = __esm({
           return 0;
         }
       }
-      /**
-       * 对话回退：删掉水位线之后的消息（方案 27）。返回删了几条，失败时 `null`。
-       *
-       * 吞异常的口径和 `record()` 一致 —— 但这里返回 `null` 而不是 `false`：
-       * 调用方要据此决定还要不要重装内存历史，而「删了 0 条」和「没删成」
-       * 对那个决定是两回事。
-       */
       rewindTo(sessionId, lastKeptId) {
         try {
           return this.sessions.rewindTo(sessionId, lastKeptId);
@@ -2412,23 +2429,14 @@ var init_session_store = __esm({
           return null;
         }
       }
-      /**
-       * 会话不存在就建。create 对已存在的 id 会抛错，这里按「已存在」处理。
-       *
-       * `cwd` 只在**新建**时写，不去 update 已存在的那一行：一段会话属于哪个项目
-       * 是它开始那一刻的事实，`epoch -c` 之后在别的目录里接着聊也不该把它改籍。
-       *
-       * ⚠️ 工作区决定（v7 那两格）走的是同一条「只在新建时写」，但**理由不同**：
-       * 不是「不该改」，而是「改它的路在别处」—— 那一格的 update 归
-       * `SessionWorkspaces` 的 `decisions.record()`（判据在构造函数的 `decision` 上）。
-       */
       ensure(sessionId) {
         if (this.known.has(sessionId)) return;
         const decision = this.decision?.(sessionId) ?? null;
+        const cwd = this.cwd?.();
         try {
           this.sessions.create({
             id: sessionId,
-            ...this.cwd ? { cwd: this.cwd } : {},
+            ...cwd ? { cwd } : {},
             ...this.source ? { source: this.source } : {},
             ...decision ? {
               workspaceState: decision.state,
@@ -2439,61 +2447,42 @@ var init_session_store = __esm({
         }
         this.known.add(sessionId);
       }
-      /**
-       * 恢复一个会话的历史消息，**喂给模型用**。
-       *
-       * 只取 user / assistant：tool 行是给宿主回放的，单独一条没有配对 tool-call 的
-       * tool 消息会被 provider 拒掉。图片部件在这里被**读回 base64**，所以恢复出来的
-       * 会话里模型仍然看得见上一轮那张图 —— 这就是方案 12 留下的「resume 恢复图片」。
-       *
-       * 图片文件找不到（artifact 清理跑过、用户手删）时退化成一句占位文本，不抛。
-       *
-       * ## ⚠️ 连续的 assistant 行在这里被**合并回一条**（2026-08-18）
-       *
-       * `record()` 改成一步一行之后，一轮在 DB 里会留下多条 assistant，中间垫着
-       * tool 行。上面那道 user/assistant 过滤把 tool 行滤掉，剩下的就是**连着的几条
-       * assistant**，其中还有「只调工具没说话」那种正文为空的。
-       *
-       * 两样都是没人验过的形状：`sdk-adapter` 会把 `content: ''` 原样发出去，而连着
-       * 两条同角色消息在各家 provider 上的行为各不相同（仓里那个
-       * `validateAlternation()` 干脆直接抛 —— 它今天没有生产调用方，但它写下的
-       * 顾虑是真的）。
-       *
-       * 合并口径**按直播那一份来**：文本直接相接、不插分隔符（`run()` 里就是
-       * `assistantText += event.text`），合完是空就整条不发（那边也是
-       * `if (assistantText)`）。判据是 resume 回来的上下文必须和刚才在内存里的那份
-       * **逐字相同** —— 差一个换行，模型看到的就是另一段历史。
-       */
       loadHistory(sessionId) {
         const prev = this.sessions.get(sessionId);
         if (!prev) return [];
         this.known.add(sessionId);
         const out = [];
+        let text = "";
+        let results = [];
+        let open = false;
+        const flush = () => {
+          if (!open) return;
+          const content = assistantTurnText(text, results);
+          if (content) out.push({ role: "assistant", content });
+          text = "";
+          results = [];
+          open = false;
+        };
         for (const m of prev.messages) {
           if (m.role === "user") {
+            flush();
             const parts = toParts(m.parts, true);
             out.push({ role: "user", content: m.content, ...parts ? { parts } : {} });
             continue;
           }
-          if (m.role !== "assistant") continue;
-          const last = out[out.length - 1];
-          if (last?.role === "assistant") last.content += m.content;
-          else if (m.content) out.push({ role: "assistant", content: m.content });
+          if (m.role === "assistant") {
+            open = true;
+            text += m.content;
+            continue;
+          }
+          if (m.role === "tool") {
+            if (open) results.push(...m.toolResults ?? []);
+            continue;
+          }
         }
+        flush();
         return out;
       }
-      /**
-       * 恢复一个会话的**全部**消息，用于宿主回放（web 刷新页面、会话详情页）。
-       *
-       * 与 `loadHistory()` 的三点区别，都是「给人看」和「给模型看」的差别：
-       *   1. 带 tool 行 —— 工具调用和 artifact 就挂在那上面
-       *   2. 带 `id` / `timestamp`
-       *   3. **图片不内联 base64**：`EpochImagePart.image` 里是绝对文件路径。
-       *      宿主拿它拼自己的 artifact 端点，把几百 KB 的 base64 塞进一次 REST 响应
-       *      或 SSE 是纯粹的浪费。工具产物同理：`ToolArtifact` 有 `path`、**没有** `data`。
-       *
-       * ⚠️ 因此这个方法的返回值**不能**直接喂给 provider。
-       */
       loadMessages(sessionId) {
         const prev = this.sessions.get(sessionId);
         if (!prev) return [];
@@ -2504,13 +2493,8 @@ var init_session_store = __esm({
             id: m.id,
             timestamp: m.timestamp,
             role: m.role,
-            // protocol 的约定：tool 消息 content 为空串，内容在 toolResults 里，
-            // 「取这条消息的文本」才永远不用判类型。DB 里那份是给 FTS 用的
             content: m.role === "tool" ? "" : m.content,
             ...parts ? { parts } : {},
-            // 思考原文和这一轮的账（2026-08-18）。**两样都只有回放这一支带** ——
-            // `loadHistory()` 那份是喂模型的，模型不需要（也不该）看自己上一轮
-            // 想过什么、花了多少钱
             ...m.reasoning ? { reasoning: m.reasoning } : {},
             ...m.turnFacts ? { turnFacts: m.turnFacts } : {},
             ...m.toolCalls ? { toolCalls: m.toolCalls } : {},
@@ -2518,15 +2502,6 @@ var init_session_store = __esm({
           };
         });
       }
-      /**
-       * 这个会话在工作区里改过哪些文件（方案 42 PR-4）。
-       *
-       * @param workDir 相对路径按哪个根算。**这个会话绑定的工作区主根**（决定 18），
-       *   不是服务进程的工作目录 —— 后者在多会话下只会是其中一个的，而它不说是哪个。
-       *
-       * 读不出来（SQLite 起不来 / 会话不存在）时是空数组，不抛：这是一个展示用的
-       * 汇总，它自己坏了不该让整屏 500。
-       */
       fileChanges(sessionId, workDir) {
         try {
           return collectFileChanges(this.loadMessages(sessionId), workDir);
@@ -2534,6 +2509,12 @@ var init_session_store = __esm({
           return [];
         }
       }
+      ftsHealth() {
+        return this.sessions.ftsHealth();
+      }
+      reclaimFts(vacuum = true) {
+        return this.sessions.reclaimFts(vacuum);
+      }
     };
   }
 });
@@ -2655,8 +2636,6 @@ async function applyMcpConfig(mcp, sync, opts) {
     return {
       ok: false,
       reason: "no-servers",
-      // 只带**第一条**诊断：屏幕上那句话后面已经跟着完整的诊断列表了，
-      // 把十条拼成一行只会把它挤出去
       detail: issues[0]?.message ?? ""
     };
   }
@@ -2882,8 +2861,6 @@ function writeMcpServer(input, opts = {}) {
     return {
       ok: false,
       reason: "invalid-config",
-      // 分隔符用 ASCII 的 `; `：这几条 message 本身是 plugin-mcp 那边的原文，
-      // 我们只是把它们串起来，不该在中间插一个由**我们**的语言决定的标点
       detail: probe.issues.map((i) => i.message).join("; ") || t("mcp_write.invalid")
     };
   }
@@ -2933,6 +2910,11 @@ var init_mcp_config_write = __esm({
     EMPTY_CONFIG = '{\n  "servers": {}\n}\n';
   }
 });
+function foldToolMode(mode) {
+  if (mode === "both") return "both";
+  if (mode === "code") return "code";
+  return "tools";
+}
 function applyShell(kind, diags) {
   if (!kind || kind === "cmd") {
     setShell(kind ?? null);
@@ -2945,29 +2927,34 @@ function applyShell(kind, diags) {
     return;
   }
   setShell(kind);
-  diags.ok("Shell", `${kind}\uFF08terminal \u5DE5\u5177\u7684\u547D\u4EE4\u4EA4\u7ED9\u5B83\u6267\u884C\uFF09`);
+  diags.ok("Shell", t("boot.shell_kind", { kind }));
 }
 function registerLocalTools(input) {
-  const { trackerDb, goals, memory, sandbox, diags } = input;
-  const registry = new ToolRegistry();
+  const { trackerDb, goals, memory, sandbox, skills, diags } = input;
+  const registry = new ToolRegistry({ codeMode: input.toolMode === "code" });
   for (const plugin of [filePlugin, terminalPlugin, webPlugin, lspPlugin]) {
     try {
       registry.registerPlugin(plugin);
     } catch (err) {
       diags.failed(
         `Plugin ${plugin.name}`,
-        `\u6CE8\u518C\u5931\u8D25 (${err instanceof Error ? err.message : err})`,
+        t("boot.plugin_register_failed", {
+          reason: err instanceof Error ? err.message : String(err)
+        }),
         "plugin-register-failed"
       );
     }
   }
   const rg = resolveRipgrep();
   if (rg.mode === "missing") {
-    diags.warn("Ripgrep", `\u672A\u5B89\u88C5\uFF0Cfile_search \u4E0D\u53EF\u7528\uFF08${rg.hint}\uFF09`, "ripgrep-missing");
+    diags.warn("Ripgrep", t("boot.ripgrep_missing", { hint: rg.hint ?? "" }), "ripgrep-missing");
   } else if (rg.mode === "system") {
-    diags.ok("Ripgrep", "\u7528\u7CFB\u7EDF\u5B89\u88C5\u7684 rg");
+    diags.ok("Ripgrep", t("boot.ripgrep_system"));
   } else {
-    diags.ok("Ripgrep", `\u7528\u5185\u7F6E\u7684 rg${rg.version ? ` ${rg.version}` : ""}`);
+    diags.ok(
+      "Ripgrep",
+      t("boot.ripgrep_builtin", { version: rg.version === void 0 ? "" : ` ${rg.version}` })
+    );
   }
   const search = selectSearchProvider(input.search);
   if (search.provider) {
@@ -2977,16 +2964,46 @@ function registerLocalTools(input) {
         input.search?.maxResults ? { defaultMaxResults: input.search.maxResults } : {}
       )
     );
-    diags.ok("Web \u641C\u7D22", search.detail);
+    diags.ok("WebSearch", search.detail);
   } else {
-    diags.skipped("Web \u641C\u7D22", search.detail);
+    diags.skipped("WebSearch", search.detail);
   }
   if (trackerDb) registry.registerTool(createTodoTool(trackerDb));
   if (goals) registry.registerTool(createGoalTool({ service: goals }));
   if (memory) registry.registerTool(createMemoryTool(memory));
   if (sandbox) registry.registerTool(createCodeExecTool(sandbox));
+  if (input.toolMode === "both" || input.toolMode === "code") {
+    registry.registerTool(createRunCodeTool());
+  }
+  if (skills) registry.registerTool(createSkillViewTool({ skills }));
+  if (input.deferMcp === true) {
+    registry.registerTool(
+      createToolSearchTool({
+        deferred: () => registry.byExposure(ToolExposure.Deferred),
+        reveal: input.bootstrapReveal ?? createToolRevealState()
+      })
+    );
+  }
   return registry;
 }
+function reportToolCost(registry, diags) {
+  const exposed = registry.exposed();
+  const mcp = exposed.filter(
+    (tool) => (registry.sourceOf(tool.name) ?? "").startsWith("mcp:")
+  ).length;
+  const local = exposed.length - mcp;
+  const tokens = Math.round(toolTableTokens(exposed).total / 100) / 10;
+  const split = (lang) => mcp > 0 ? t("boot.tools_split_mixed", { local, mcp }, lang) : t("boot.tools_split_local", { local }, lang);
+  const deferred = registry.byExposure(ToolExposure.Deferred).length;
+  diags.ok(
+    TOOLS_MODULE,
+    (lang) => deferred > 0 ? t(
+      "boot.tools_cost_deferred",
+      { count: exposed.length, split: split(lang), tokens, deferred },
+      lang
+    ) : t("boot.tools_cost", { count: exposed.length, split: split(lang), tokens }, lang)
+  );
+}
 function registerSessionSearch(registry, input) {
   if (!input.session) {
     input.diags.skipped(
@@ -3030,7 +3047,13 @@ function registerAskQuestion(registry, onQuestionRequest, interactive) {
     createAskQuestionTool(interactive ? { requestQuestion: onQuestionRequest } : {})
   );
 }
-function createToolSync(mcp, registry) {
+function registerMcpBatch(registry, tools, server, defer) {
+  registry.registerTools(
+    defer ? tools.map((tool) => ({ ...tool, exposure: ToolExposure.Deferred })) : [...tools],
+    `mcp:${server}`
+  );
+}
+function createToolSync(mcp, registry, defer) {
   let queue = Promise.resolve();
   const replace = (server) => {
     queue = queue.then(async () => {
@@ -3038,9 +3061,11 @@ function createToolSync(mcp, registry) {
         const fresh = await withTimeout(mcp.refresh(server), MCP_LIST_BUDGET_MS, null) ?? [];
         const prefix = `mcp__${server}__`;
         registry.unregisterBySource(`mcp:${server}`);
-        registry.registerTools(
-          fresh.filter((t13) => t13.name.startsWith(prefix)),
-          `mcp:${server}`
+        registerMcpBatch(
+          registry,
+          fresh.filter((t23) => t23.name.startsWith(prefix)),
+          server,
+          defer
         );
       } catch {
       }
@@ -3049,7 +3074,7 @@ function createToolSync(mcp, registry) {
   };
   return { settled: () => queue, replace };
 }
-function wireToolRefresh(mcp, registry, sync = createToolSync(mcp, registry)) {
+function wireToolRefresh(mcp, registry, sync = createToolSync(mcp, registry, false)) {
   mcp.onToolsChanged = (server) => void sync.replace(server);
   return sync;
 }
@@ -3098,8 +3123,6 @@ async function addServer(mcp, sync, input, homeDir) {
   return {
     ok: true,
     configPath: written.configPath,
-    // `connectAll` 恒回一台一条，兜底那一支是给类型系统看的 —— 真走到了说明
-    // registry 那边变了形状，那时报一台「连不上、没说为什么」比崩掉强
     status: status ?? mcp.getStatus(input.name) ?? {
       name: input.name,
       connected: false,
@@ -3142,9 +3165,9 @@ function reportTaken(source, name, diags) {
     "host-mcp-name-taken"
   );
 }
-async function registerMcpTools(registry, homeDir, diags, injected = []) {
+async function registerMcpTools(registry, homeDir, diags, injected = [], defer = false) {
   const mcp = new McpRegistry({ homeDir });
-  const sync = createToolSync(mcp, registry);
+  const sync = createToolSync(mcp, registry, defer);
   const live = () => ({
     dispose: () => void mcp.disconnectAll().catch(() => {
     }),
@@ -3176,19 +3199,19 @@ async function registerMcpTools(registry, homeDir, diags, injected = []) {
   try {
     const { servers, issues } = mcp.loadFromConfig(mcpConfigPath(homeDir));
     for (const issue of issues) {
-      diags.warn(`MCP \u914D\u7F6E ${issue.path}`, issue.message, "mcp-config-invalid");
+      diags.warn(`MCPConfig ${issue.path}`, issue.message, "mcp-config-invalid");
     }
     const extra = dropTakenNames(injected, new Set(servers.map((s) => s.name)), diags);
     const injectedCount = extra.reduce((sum, b) => sum + b.servers.length, 0);
     if (servers.length === 0 && injectedCount === 0) {
-      diags.skipped("MCP", "\u672A\u914D\u7F6E\uFF08~/.epoch/mcp.json \u4E0D\u5B58\u5728\u6216\u4E3A\u7A7A\uFF09");
+      diags.skipped("MCP", t("boot.mcp_none"));
       return live();
     }
     const statuses = await connectAllServers(mcp, [{ source: "user", servers }, ...extra]);
     if (statuses === null) {
       diags.failed(
         "MCP",
-        `\u8FDE\u63A5\u8D85\u65F6\uFF08>${MCP_CONNECT_BUDGET_MS / 1e3}s\uFF09\uFF0C\u5DF2\u8DF3\u8FC7`,
+        t("boot.mcp_connect_timeout", { seconds: MCP_CONNECT_BUDGET_MS / 1e3 }),
         "mcp-connect-timeout"
       );
       return live();
@@ -3198,14 +3221,22 @@ async function registerMcpTools(registry, homeDir, diags, injected = []) {
       if (!st.connected) {
         diags.failed(
           `MCP ${st.name}`,
-          `\u8FDE\u63A5\u5931\u8D25${st.lastError ? ` (${st.lastError})` : ""}`,
+          t("boot.mcp_connect_failed", {
+            detail: st.lastError ? t("boot.mcp_connect_failed_detail", { detail: st.lastError }) : ""
+          }),
           "mcp-connect-failed"
         );
         continue;
       }
-      const own = mcpTools.filter((t13) => t13.name.startsWith(`mcp__${st.name}__`));
-      registry.registerTools(own, `mcp:${st.name}`);
-      diags.ok(`MCP ${st.name}`, `${own.length} \u4E2A\u5DE5\u5177`);
+      const own = mcpTools.filter((t23) => t23.name.startsWith(`mcp__${st.name}__`));
+      const registered = dropOverlongToolNames(
+        own,
+        `MCP ${st.name}`,
+        "mcp-tool-name-too-long",
+        diags
+      );
+      registerMcpBatch(registry, registered, st.name, defer);
+      diags.ok(`MCP ${st.name}`, t("boot.mcp_tools", { count: registered.length }));
       if (st.lastError) diags.warn(`MCP ${st.name}`, st.lastError, "mcp-degraded");
     }
     wireToolRefresh(mcp, registry, sync);
@@ -3213,13 +3244,15 @@ async function registerMcpTools(registry, homeDir, diags, injected = []) {
   } catch (err) {
     diags.failed(
       "MCP",
-      `\u521D\u59CB\u5316\u5931\u8D25 (${err instanceof Error ? err.message : String(err)})`,
+      t("boot.mcp_init_failed", {
+        reason: err instanceof Error ? err.message : String(err)
+      }),
       "mcp-init-failed"
     );
     return live();
   }
 }
-var MCP_CONNECT_BUDGET_MS, MCP_LIST_BUDGET_MS, SESSION_SEARCH_MODULE;
+var MCP_CONNECT_BUDGET_MS, MCP_LIST_BUDGET_MS, TOOLS_MODULE, SESSION_SEARCH_MODULE;
 var init_tools = __esm({
   "src/tools.ts"() {
     init_host_capabilities();
@@ -3228,6 +3261,7 @@ var init_tools = __esm({
     init_mcp_config_write();
     MCP_CONNECT_BUDGET_MS = 15e3;
     MCP_LIST_BUDGET_MS = 1e4;
+    TOOLS_MODULE = "Tools";
     SESSION_SEARCH_MODULE = "SessionSearch";
   }
 });
@@ -3271,11 +3305,6 @@ var init_session_factory = __esm({
     SessionBridges = class {
       byId = /* @__PURE__ */ new Map();
       override;
-      /**
-       * @param override 宿主自己实现的阻塞式确认（`BuildRuntimeOptions.onApprovalRequest`）。
-       *   给了就**所有会话都走它**：那种宿主（CLI 的 inquirer）本来就是单会话的，
-       *   它的回调签名里也没有 sessionId 的位置。
-       */
       constructor(override) {
         this.override = override;
       }
@@ -3285,32 +3314,11 @@ var init_session_factory = __esm({
       release(sessionId) {
         this.byId.delete(sessionId);
       }
-      /*
-       * ⚠️ 这儿原来有一个 `planOwner()`（记「最后一次交计划的是谁」），
-       * 2026-08-16 **删掉**了。它存在的唯一理由是 `PlanModeState.onChange` 上没有
-       * 会话 id —— 因为那时候 plan 模式是**进程级**的一个状态对象。现在一个会话一个
-       * 状态，`onChange` 的宿主自己就知道自己是谁。
-       *
-       * **不是留着不调，是必须删**：两个会话各自挂着落盘 hook、而引导会话那一份还
-       * 按 `planOwner()` 决定写到谁名下的话，会话 B 交过一次计划之后，引导会话再批
-       * 一份就会把 A 的正文写到 B 名下。判据全文在 `session-guard.ts` 的文件头末节。
-       */
-      /**
-       * 转一条审批给它该去的那个会话。
-       *
-       * 认不出这个 sessionId（会话刚被删 / 被冷却，而它那一轮还在收尾）时回 `deny` ——
-       * 方向逐字同 `AgentSession` 的 `settleAbandoned`：审批的安全侧就是拒绝。
-       * 挂着不答的话，那个孤儿 `AgentLoop` 会永远停在 await 上，进程退不掉。
-       */
       approve(sessionId, req) {
         if (this.override) return this.override(req);
         const bridge = this.byId.get(sessionId);
         return bridge ? bridge.approve(req) : Promise.resolve("deny");
       }
-      /**
-       * 转一条提问。认不出时回 `skipped` —— 那是**实话**（确实没人答），
-       * 而替用户挑一个 label 才是伪造（方案 34 §2.4）。
-       */
       ask(sessionId, req) {
         const bridge = this.byId.get(sessionId);
         return bridge ? bridge.ask(req) : Promise.resolve({ answers: {}, skipped: true });
@@ -3334,82 +3342,27 @@ var init_session_factory = __esm({
       get(sessionId) {
         return this.live.get(sessionId) ?? null;
       }
-      /**
-       * 把**引导会话**装进表里。装配层专用，`bind()` 那两道门在这条路上不走 ——
-       * 它的工作区已经 `seed()` 进去了（判据见 workspace.ts 的 `seed`）。
-       *
-       * @returns 建不出 `AgentLoop`（provider 没起来）时 null。那不是错误：
-       *   一台还没配 API key 的机器上跑 `epoch doctor` 走的就是这条路
-       */
       adopt(sessionId, history) {
         this.bootstrap = sessionId;
-        const live = this.assemble(sessionId, this.opts.workspaces.of(sessionId), history, false);
+        const live = this.assemble(sessionId, history, false);
         if (live) this.live.set(sessionId, live);
         return live;
       }
-      /**
-       * `/resume` 换了 id 之后把表跟着改一下（`SessionControl.resume`）。
-       *
-       * `AgentSession.resume()` 自己会把 `sessionId` 换掉，但**这张表的键不会跟着变** ——
-       * 不补这一步的话 `get(新 id)` 是 null，于是浏览器刚 resume 过去的那个会话
-       * 在这个进程眼里不存在。
-       *
-       * ## ⚠️ 搬的是**两格**，桥那一格 2026-08-18 才补上
-       *
-       * 原来这儿只有 `bridges.release(from)`，没有按新键 `register` 一次
-       * （`register` 只出现在建会话那一条路上，见 {@link assemble}）。于是 resume
-       * 之后新 id 在路由表里是空的，而**后果是静默答错不是报错**：
-       * `ask_user_question` 回 `skipped`、plan 审批回 `deny` —— 模型问不出问题、
-       * 批不了计划，屏幕上只是「它没问」。
-       *
-       * **这不是 2026-08-17 那轮 `from` 取早一步的修复改出来的**：那之前
-       * `ToolContext.sessionId` 已经是新 id 而桥登记在旧 id 上，一样查不到。
-       * 两种情形下新 id 都无桥，那一轮既没让它变坏也没变好。
-       *
-       * ⚠️ **不是「只有 web 才踩」**（2026-08-18 实测修正的一处口径）。`/resume`
-       * 今天确实只有 TUI 走得到，而 TUI 上三条路**分成两档**：
-       *
-       * - 普通工具的权限审批 **不走**这一层（`onApprovalRequest` 直接给这个会话
-       *   自己那座桥，见 {@link assemble} 那条注释）—— 那一档确实没事；
-       * - `ask_user_question` 和 `exit_plan_mode` 交计划 **走**（`build.ts` 里
-       *   那两句 `(req, sid) => bridges.ask/approve(sid, req)`）—— 这两样 TUI
-       *   `/resume` 之后一样是坏的。判据：`ToolContext.sessionId` 来自
-       *   `AgentLoop` 的 `input.sessionId`，也就是换过之后那个新 id。
-       *
-       * ## 判了哪条治法：**把建会话那一刻那份桥原样 register 到新键上**
-       *
-       * 判据只有一条，而它是**读出来的不是推的**：{@link
-       * AgentSession.createApprovalBridge} 那两个回调闭的是 `target`（那个
-       * `AgentSession` **实例**）和一个 `buffered` 数组，**一个 id 都没闭** ——
-       * 没有 sessionId、没有工作区、没有 workDir。而 `AgentSession.resume()` 是
-       * **就地**改 `this.sessionId`（实例不换、`attach` 过的 `target` 还是它）。
-       * 所以「同一份桥」指的就是「用户此刻在看的那一段会话」，不是一个过期快照。
-       *
-       * 这也顺带答了「resume 过去之后这些回调该指向谁」——**照旧指向这一头**。
-       * 判据同 `build.ts` 那个回调里 `workspaces.seed` / `rekeyBackgroundTasks`
-       * 两行（2026-08-17 写的）：`/resume` 只是把另一段对话接上**这个进程的这个
-       * 引擎**，问答通道的另一头照旧是这个进程的宿主（TUI 的屏幕 / 浏览器那条 SSE）。
-       * 「那段会话当初那个宿主」根本不存在 —— 那个进程早退了。
-       *
-       * **被否掉的另一条：在这里 `createApprovalBridge()` 新建一座登记上去。**
-       * 它比今天更坏，两处：① `attach()` 绑的是新闭包里那个 `target`，而正在跑的
-       * 那个 `AgentSession` 已经和旧桥绑好了 —— 新桥的请求会落进一条**没有消费者**
-       * 的 `buffered`，于是 `ask` 从「回 `skipped`」变成「永远不返回」，那个
-       * `AgentLoop` 挂在 await 上，进程退不掉；② 旧桥上**已经在飞**的请求
-       * （`inFlight` 里那些）连带失去归属。一句话：桥不是按 id 建的，
-       * 所以换 id 这件事上它压根不该重建。
-       */
       rekey(from, to) {
         const live = this.live.get(from);
         if (!live || from === to) return;
         this.live.delete(from);
         this.opts.bridges.release(from);
+        const workspaces = this.opts.workspaces;
         const moved = {
           ...live,
           sessionId: to,
-          workspace: this.opts.workspaces.of(to)
+          get workspace() {
+            return workspaces.of(to);
+          }
         };
         this.live.set(to, moved);
+        this.opts.processes.claim(to);
         this.opts.bridges.register(to, moved.bridge);
         if (this.bootstrap === from) this.bootstrap = to;
       }
@@ -3425,15 +3378,13 @@ var init_session_factory = __esm({
           if (hit) return { ok: true, live: hit, created: false };
         }
         const sessionId = this.newId();
-        let bound = null;
         if (input.workspace !== null) {
           const outcome = this.opts.workspaces.bind(sessionId, input.workspace, input.lang);
           if (!outcome.ok) return { ok: false, reason: outcome.reason, detail: outcome.detail };
-          bound = outcome.bound;
         } else {
           this.opts.workspaces.decideNone(sessionId);
         }
-        const live = this.assemble(sessionId, bound, [], true, role);
+        const live = this.assemble(sessionId, [], true, role);
         if (!live) {
           this.opts.workspaces.release(sessionId);
           return { ok: false, reason: "unavailable" };
@@ -3441,7 +3392,6 @@ var init_session_factory = __esm({
         this.live.set(sessionId, live);
         return { ok: true, live, created: true };
       }
-      /** 判据全文在 {@link SessionFactory.revive} 上 */
       revive(input) {
         const { sessionId } = input;
         const already = this.live.get(sessionId);
@@ -3451,15 +3401,13 @@ var init_session_factory = __esm({
         const decision = remembered ?? input.decision;
         const awaitingPick = this.opts.workspaces.stateOf(sessionId) === "unbound";
         if (!decision && !awaitingPick) return { ok: false, reason: "no-decision" };
-        let bound = null;
         if (decision?.state === "bound") {
           const outcome = this.opts.workspaces.bind(sessionId, decision.root, input.lang);
           if (!outcome.ok) return { ok: false, reason: outcome.reason, detail: outcome.detail };
-          bound = outcome.bound;
         } else if (decision) {
           this.opts.workspaces.decideNone(sessionId);
         }
-        const live = this.assemble(sessionId, bound, [], true);
+        const live = this.assemble(sessionId, [], true);
         if (!live) {
           if (!remembered && !awaitingPick) this.opts.workspaces.release(sessionId);
           return { ok: false, reason: "unavailable" };
@@ -3472,67 +3420,40 @@ var init_session_factory = __esm({
         this.live.delete(sessionId);
         this.opts.bridges.release(sessionId);
       }
-      /**
-       * 一个 `delegate_task` 子跑手。**全进程一个**，按 `parentSessionId` 现查现配。
-       *
-       * 三处 id 必须都是**派活那个会话**的，缺一处就是 §6.3 第 3 条那个洞：
-       * `budgetSessionId`（钱记谁头上）、两个 `checkpoints` 回调（快照落谁的目录）、
-       * 以及审批弹给谁看。在这里现查而不是装配时闭包一个，正是因为那个闭包
-       * 捕获的是引导会话。
-       *
-       * @param provider **收参数而不是读 `this.opts.provider`**：`delegate_task`
-       *   只在 provider 起得来时才注册，收进来之后这条路上就没有「provider 是 null」
-       *   这个状态了 —— 少一个只能靠一句话解释的不可达分支。
-       *
-       *   ⚠️ 它今天只是**兜底**（派活的会话已经被冷却掉了）：2026-08-16 起子 agent
-       *   跑在**派活那个会话**的 provider 门面上，理由见下面那两行注释
-       */
       subRunner(provider) {
         return async (goal, context, subSessionId, roleName, parentSessionId) => {
           const { services, config } = this.opts;
           const parent = this.live.get(parentSessionId);
           const workDir = parent?.workspace?.workspace.root ?? this.opts.defaultWorkDir;
           const projectContext = parent?.workspace?.projectContext ?? services.projectContext;
-          const checkpoints = new CheckpointManager({ workDir, homeDir: config.homeDir });
+          const checkpoints = new CheckpointManager({
+            workDir: () => workDir,
+            homeDir: config.homeDir
+          });
           const role = findRole(this.opts.roles(), roleName ?? DEFAULT_AGENT_ROLE);
           const permission = parent?.permission ?? services.permission;
           const sub = new AgentLoop({
-            // 跑在**派活那个会话**的模型上（2026-08-16）。和下面 `budgetSessionId` /
-            // `checkpoints` / `onApprovalRequest` 是同一条判据：子任务是那个会话的
-            // 一部分。读进程那一份的话，会话 B 明明换到了别的模型，它派出去的活
-            // 还在打引导会话那个 —— 而账是记在 B 头上的
             provider: parent?.provider ?? provider,
             toolProvider: roleScopedProvider(this.opts.rawToolProvider, role, BLOCKED_TOOLS),
+            codeModeTools: this.opts.codeModeTools,
             telemetry: this.opts.telemetry,
             workDir,
-            // 复用父会话那份：信任判定和指令文件已经算过、也已经进过诊断，
-            // 每个子 agent 再算一遍只是重复读盘和重复跑 git
             projectContext,
-            // 角色说了算，没说才回落到「父的一半」——避免单个子任务吃掉全部预算
             maxTurns: role?.maxTurns ?? Math.max(4, Math.floor(config.maxTurns / 2)),
             contextLength: services.contextLength,
-            // **不给 `scope`**：它缺省就是 `'delegate'`，而这条路正是那个缺省值
-            // 存在的理由（见 `AgentRoleScope`）。显式写一遍也对，但那会让这一行
-            // 和它上面十几行「原样透传」的写法长得不一样，反而像在做别的事
-            //
-            // 这条路上**没有槽**（方案 57 §3.2 只换了 `assemble()` 那一行）：一个子任务
-            // 从派出去到跑完就是一次 run，中途没有「下一条消息」这个概念。写成函数
-            // 只是跟着 `AgentConfig.role` 的形状走，它每次都回同一份对象
+            artifactRetention: resolveArtifactRetention(config.artifacts),
+            sandboxTerminal: config.sandbox?.terminal !== false,
             ...role ? { role: () => ({ name: role.name, ...role.prompt ? { prompt: role.prompt } : {} }) } : {},
             ...permission ? { permissionManager: permission } : {},
             ...services.hookManager ? { hookManager: services.hookManager } : {},
+            skillSystem: services.skill ?? void 0,
+            roleSkills: () => role?.skills,
             ...this.opts.budget,
-            // 子任务的花费记到**派活的那个会话**头上。不这么做的话 `delegate_task`
-            // 就是一条绕过成本上限的通道；而记到引导会话头上（工厂之前那样）更糟 ——
-            // 那是**另一个人**的预算
             budgetSessionId: parentSessionId,
-            // 同上：子 agent 改的文件要能被派活那个会话的 `/rewind` 看见
             checkpoints: {
               capture: (_sub, paths) => checkpoints.capture(parentSessionId, paths),
               record: (_sub, paths) => checkpoints.record(parentSessionId, paths)
             },
-            // 审批弹给派活那个会话的界面。`BLOCKED_TOOLS` 挡掉了 plan 和提问那几个，
-            // 剩下的写类工具照样要问人
             onApprovalRequest: (req) => this.opts.bridges.approve(parentSessionId, req)
           });
           let r;
@@ -3554,23 +3475,9 @@ ${context}` : goal,
           };
         };
       }
-      // -------------------------------------------------------------------------
-      // 私有：全仓唯一一处「主会话的 `new AgentLoop` + `new AgentSession`」
-      // -------------------------------------------------------------------------
-      /**
-       * @param own 这个会话要不要**自己开一份**模型 / 权限档 / plan 模式
-       *   （2026-08-16）。引导会话是 `false` —— 它拿的就是进程那两份本体。
-       *
-       *   **收一个布尔而不是在这里判 `sessionId === this.bootstrap`**：`adopt()`
-       *   恰好在给 `this.bootstrap` 赋值的那一行之后调进来，照那个字段判的话，
-       *   这段代码的正确性靠的是两行之间的时序 —— 而下一个人挪一行就会把它挪坏
-       * @param role **这个会话**的专家（决定 20 ②）。不给就回落到 `--agent` 那一份
-       *   （`opts.mainRole`，进程级）—— 两者形状完全一样，走的也是同一条收窄路，
-       *   区别只在作用域。回落而不是二选一：`epoch web --agent explore` 之后新建的
-       *   会话仍然该是 explore，那是用户在命令行上说过的话。
-       */
-      assemble(sessionId, bound, history, own, role) {
+      assemble(sessionId, history, own, role) {
         const opts = this.opts;
+        opts.processes.claim(sessionId);
         const { services, config, provider, models } = opts;
         if (!provider || !models) return null;
         const scope = {
@@ -3579,14 +3486,26 @@ ${context}` : goal,
         };
         const active = role ?? opts.mainRole ?? void 0;
         const roleScope = createRoleScope(
-          withSessionTools(opts.toolProvider, scope.guard.tools),
+          withSessionTools(
+            revealScopedProvider(opts.toolProvider, opts.deferredTools, scope.guard.reveal),
+            scope.guard.tools
+          ),
           active,
           []
         );
         const planState = scope.guard.planState;
-        const workDir = bound?.workspace.root ?? opts.defaultWorkDir;
-        const projectContext = bound?.projectContext ?? services.projectContext;
-        const checkpoints = new CheckpointManager({ workDir, homeDir: config.homeDir });
+        const live = {};
+        const site = () => {
+          const now = opts.workspaces.of(live.session?.sessionId ?? sessionId);
+          return {
+            workDir: now?.workspace.root ?? opts.defaultWorkDir,
+            projectContext: now?.projectContext ?? services.projectContext
+          };
+        };
+        const checkpoints = new CheckpointManager({
+          workDir: () => site().workDir,
+          homeDir: config.homeDir
+        });
         const loopProvider = opts.goals ? withGoalPrompt(
           scope.model.provider,
           () => opts.goals.promptView(live.session?.sessionId ?? sessionId)
@@ -3594,59 +3513,18 @@ ${context}` : goal,
         const bridge = AgentSession.createApprovalBridge();
         const routed = { approve: bridge.onApprovalRequest, ask: bridge.onQuestionRequest };
         opts.bridges.register(sessionId, routed);
-        const live = {};
         const agent = safeInit(
           "AgentLoop",
           () => new AgentLoop({
-            // **这个会话自己那份门面**，不是 `opts.provider`（那是引导会话的）。
-            // 拿错的表现是：第二个会话换完模型，界面上写着新的、引擎下一轮打的
-            // 还是旧的 —— 判据在 `SessionModelScope.provider` 上
             provider: loopProvider,
-            // **给 provider 而不是 `exposed()` 的快照**：MCP server 发
-            // list_changed / 断线重连 / login 解锁新工具时，正在跑的这个 loop
-            // 下一轮就能看到新表（方案 15）。这里给的是**包了两层收窄的那个** ——
-            // 命令那一层（方案 23）在 `opts.toolProvider` 里，角色那一层是槽
-            // （方案 57 §3.2）。两层都是可变的，上面那条性质仍然成立。
-            //
-            // 收窄**不再按 `active` 分支**：槽在 `active` 缺席时是一层透明包装
-            // （`roleScopedProvider(base, undefined, [])` 一个工具都不减），
-            // 所以这一行的字节行为和改造前逐字相同。分支留着的话，身份那一半会在
-            // 建 loop 那一刻定死「有没有角色」，而工具那一半是活的 —— 那正是
-            // 方案 57 §1.3 那个劈叉，只是换了个更不容易看出来的位置
             toolProvider: roleScope.provider,
+            codeModeTools: opts.codeModeTools,
             telemetry: opts.telemetry,
-            workDir,
-            projectContext,
-            // artifact 落在**这次实际生效的数据目录**下，而不是全局 `~/.epoch`
-            // （方案 54 §二）。给 `config.homeDir` 而不是 `opts.homeDir`：
-            // 不传时它是引擎探测出来的结果，只有它是真源
+            site,
             multimodal: { homeDir: config.homeDir },
-            // 角色的 maxTurns 压过配置：它是「这个角色干这类活要几轮」的判断。
-            //
-            // ⚠️ **读的是 `active`（这段会话默认那个专家）而不是槽 —— 逐条换专家
-            // 不换轮次预算**，这是一个答案不是一笔欠账（方案 57 §3.2.1，2026-08-17）。
-            // 判据一句话：身份和工具必须同作用域是因为它们**同时被模型读到**、
-            // 劈叉了看不出来；而轮次预算是宿主侧的一个上界，它劈叉的表现是
-            // `finish` 上那个 `max-turns`，屏幕上说得清。真要换只能走
-            // `RunInput.maxTurns`，而那一格已经有调用方了（`--max-turns`），
-            // 「谁压过谁」是另一次判断。全文在 `agent-role/scope.ts` 的 `current` 上
+            artifactRetention: resolveArtifactRetention(config.artifacts),
+            sandboxTerminal: config.sandbox?.terminal !== false,
             maxTurns: active?.maxTurns ?? config.maxTurns,
-            // 工具白名单**不传**：它已经被上面的 `roleScopedProvider` 消化掉了，
-            // loop 里不该存在「工具表和角色不一致」这种状态。
-            //
-            // `scope: 'session'` 是这一轮加的那一格，而且**必须显式给** ——
-            // 它缺省是 `'delegate'`（老调用方的 prompt 要逐字节不变），不给的话
-            // 顶层会话会收到一句「由主智能体派来完成一个独立子任务」的假话，
-            // 而这一条从 `--agent` 落地那天起就错着（判据见 `AgentRoleScope`）。
-            //
-            // `source` 纯展示，进不了 prompt —— 它是 `run-start` 事件上那枚来源
-            // 徽标的唯一来路（决定 8 第一个时刻）。这一层是全仓唯一同时握着
-            // 「完整 AgentRole」和「这个会话的 loop」的地方，不在这儿给就没人给得出
-            //
-            // **从槽里读，而且这一格不再按 `active` 分支**（方案 57 §3.2）：
-            // 工具那一半已经是活的了，身份这一半再钉死在建 loop 那一刻，就是
-            // §1.3 那个劈叉。槽空着时函数回 `undefined`，loop 那边整个键缺席 ——
-            // 和改造前 `active` 缺席时**逐字节等价**
             role: () => {
               const now = roleScope.current;
               if (!now) return void 0;
@@ -3658,28 +3536,11 @@ ${context}` : goal,
               };
             },
             contextLength: services.contextLength,
-            // 已批准的计划（方案 35 PR-2 验收 8）。给函数不给快照 —— 计划是这一轮
-            // 跑到一半才被批准的，快照恒为 null。
-            //
-            // ⚠️ 读的是**这个会话自己那份** plan 状态（2026-08-16）：原来这儿是一个
-            // 进程级闭包，于是会话 B 的 system prompt 附加段里挂的是会话 A 批准的
-            // 那份纲 —— 模型照着一份不属于这段对话的计划干活，而屏幕上什么都看不出来
             ...planState ? { approvedPlan: () => planState.approvedPlan() } : {},
-            // 宿主给了阻塞式确认就用它的（单会话宿主），否则走这个会话自己那座桥。
-            // **不绕 `bridges.approve`**：那一层是给共享工具路由用的，而 `AgentLoop`
-            // 本来就知道自己是谁 —— 多绕一圈只多一处能对错的地方
             onApprovalRequest: opts.hostApproval ?? bridge.onApprovalRequest,
-            // 只给**这个会话**那一批（2026-08-15）。会话 id 走 `live` 而不是入参，
-            // 理由见它的声明
             backgroundTasks: () => opts.backgroundTasks(live.session?.sessionId ?? sessionId),
-            // 写类工具动手前留一份旧内容（方案 27）。开轮在 `AgentSession.run()`，
-            // 循环自己不认识这个东西 —— 所以上面那条「同一个实例」是硬约束
             checkpoints,
             ...services.memory ? { memory: services.memory } : {},
-            // 压缩时把当前目标递给摘要模型（方案 52 PR-3 / 验收 3 后半句）。
-            // **包的是同一个进程级实例**，不是新建一个 —— 冷却期、熔断计数、
-            // 上一版摘要都在那份状态里，复制一份等于每个会话各有一套闸门。
-            // 判据全文在 `goal/engine.ts`
             ...services.contextEngine ? {
               contextEngine: opts.goals ? withGoalCompression(
                 services.contextEngine,
@@ -3687,11 +3548,9 @@ ${context}` : goal,
               ) : services.contextEngine
             } : {},
             ...services.hookManager ? { hookManager: services.hookManager } : {},
-            ...services.skill ? { skillSystem: services.skill } : {},
+            skillSystem: services.skill ?? void 0,
+            roleSkills: () => roleScope.current?.skills,
             ...services.skillLearner ? { skillLearner: services.skillLearner } : {},
-            // **这个会话自己那一档**（2026-08-16）。规则表 / 审批缓存 / 审计流水
-            // 照旧是同一份（core 的 `PermissionManager.scoped()` 共享它们），
-            // 分家的只有「此刻是哪一档」
             ...scope.guard.permission ? { permissionManager: scope.guard.permission } : {},
             ...opts.budget
           }),
@@ -3704,7 +3563,7 @@ ${context}` : goal,
         const store = opts.sessions ? new SessionStore(
           opts.sessions,
           config.homeDir,
-          projectContext.rootDir,
+          () => site().projectContext.rootDir,
           opts.sessionSource,
           (id) => opts.workspaces.decisionOf(id)
         ) : void 0;
@@ -3714,15 +3573,9 @@ ${context}` : goal,
           ...store ? { store } : {},
           history: [...history],
           checkpoints,
-          // 一轮开始时给目标 +1 并检查预算（方案 52 PR-2）。**接在轮次边界上，
-          // 而 `loop.ts` 一行没改** —— 判据在方案 52 §四：一次 `run()` 恰好是一条
-          // 被接纳的用户消息，而循环内部那个 `for (turn = 1..maxTurns)` 数的是模型
-          // 请求次数。挂在这儿和 `checkpoints` 是同一个位置、同一条理由
           ...opts.goals ? { goals: opts.goals } : {},
-          // 换人那一刻在历史里留一条 `[系统]` 消息（方案 57 §3.5）。**给函数不给名字**：
-          // 槽是可变的，快照拿到的是装配那一刻那个专家，于是每一条消息都会被判成
-          // 「没换人」—— 而那正是这条留痕唯一会坏的方式（不报错、只是永远不出现）
-          currentRole: () => roleScope.current?.name
+          currentRole: () => roleScope.current?.name,
+          currentWorkDir: () => site().workDir
         });
         bridge.attach(session);
         live.session = session;
@@ -3734,38 +3587,17 @@ ${context}` : goal,
           session,
           agent,
           model: scope.model.control,
-          // 这个会话那个角色槽的宿主面（方案 57 §3.4）。**在这儿包而不是把 `roleScope`
-          // 整个交出去**：`enter()` 收的是 `AgentRole` 对象，而服务端不许 import core
-          // ——它手里只有网线上那个字符串。判据全文在 `role-scope.ts` 文件头
           roles: createRoleControl(roleScope, opts.roles),
-          /*
-           * 会话级那一份身份（2026-08-18）。**取 `active` 而不是入参 `role`**：
-           * 那个变量已经把「没带就退到 `--agent`」算过一次，而上面那句「全函数只算
-           * 这一次」正是为了不让两处给出不同答案。判据全文在 {@link LiveSession.role}。
-           *
-           * 只带 `name` + `source` 两格（`ActiveAgentRole`），不把整个 `AgentRole`
-           * 交出去：服务端不许 import core，而它要的就是这两个字段
-           * —— 同 `roles` 那一格「包成两个动词」的判据。
-           */
           role: toActiveRole(active),
           provider: scope.model.provider,
           permission: scope.guard.permission,
           permissions: scope.guard.permissions,
           plan: scope.guard.plan,
-          // 会话 id 走 `session.sessionId` 而不是入参，判据同下面那个
-          // `buildCheckpointControl`：`/resume` 会把它换掉
           goals: opts.goals ? buildGoalControl(opts.goals, () => session.sessionId) : null,
-          // **同一个 `checkpoints` 实例**再包一层交出去，不是新建一个管理器：
-          // 上面那条「`AgentSession` 和它的 `AgentLoop` 必须共用同一个实例」
-          // 对宿主这一侧同样成立 —— 另建一个的表现是回退列表读得出、
-          // 而「这一轮开过没有」是另一本账。
-          //
-          // 会话 id 走 `session.sessionId` 而不是上面那个入参：`/resume` 会把它换掉
-          // （`rekey` 只换工厂表里的键，换不了一个拍过快照的闭包）
           checkpoints: buildCheckpointControl(checkpoints, session, () => session.sessionId),
-          workspace: bound,
-          // **同一个对象**，不是重新拼一遍那两个回调 —— 判据在 `rekey` 上。
-          // 它只在这张表里，`get()` / `list()` 的类型里没有这一格
+          get workspace() {
+            return opts.workspaces.of(live.session?.sessionId ?? sessionId);
+          },
           bridge: routed
         };
       }
@@ -3823,7 +3655,6 @@ var init_file = __esm({
       opts;
       now;
       ready = false;
-      /** 自增的 span id。同一个进程内唯一就够 —— 这文件本来就是单机看的 */
       seq = 0;
       startSpan(name, attrs, parent) {
         const startedAt = this.now();
@@ -3957,8 +3788,6 @@ async function tryCreateOtelTelemetry(endpoint) {
   };
   return {
     telemetry,
-    // 退出时必须 flush（批量导出器手上压着最后一轮的 span），但**必须有上限** ——
-    // 见 SHUTDOWN_BUDGET_MS
     shutdown: async () => {
       await withTimeout(
         Promise.allSettled([tracerProvider.shutdown(), meterProvider.shutdown()]).then(() => {
@@ -3982,7 +3811,7 @@ async function buildTelemetry(input) {
   const noop = { telemetry: NOOP_TELEMETRY, dispose: () => {
   } };
   if (!config?.enabled) {
-    diags.skipped("Telemetry", "\u672A\u5F00\u542F\uFF08epoch config set telemetry.enabled true \u5F00\u542F\uFF09");
+    diags.skipped("Telemetry", t("boot.telemetry_off"));
     return noop;
   }
   const target = config.target ?? "file";
@@ -3995,7 +3824,7 @@ async function buildTelemetry(input) {
     }
     diags.warn(
       "Telemetry",
-      "target=otlp \u4F46\u6CA1\u88C5 OpenTelemetry \u4F9D\u8D56\uFF0C\u5DF2\u964D\u7EA7\u4E3A file\u3002\u88C5\u6CD5\uFF1Apnpm add @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/sdk-metrics @opentelemetry/exporter-trace-otlp-http @opentelemetry/exporter-metrics-otlp-http @opentelemetry/resources",
+      (lang) => t("boot.telemetry_otlp_missing", { command: OTLP_INSTALL_COMMAND }, lang),
       "otlp-deps-missing"
     );
   }
@@ -4009,7 +3838,6 @@ async function buildTelemetry(input) {
   return {
     telemetry: new FileTelemetry({
       path,
-      // 写不进去要说出来，但只说一次 —— 每条记录报一次会把诊断刷爆
       onError: onceWarn(diags, path)
     }),
     dispose: () => {
@@ -4023,7 +3851,11 @@ function onceWarn(diags, path) {
     reported = true;
     diags.warn(
       "Telemetry",
-      `\u5199\u5165\u5931\u8D25\uFF08${err instanceof Error ? err.message : String(err)}\uFF09\uFF1A${path}`,
+      (lang) => t(
+        "boot.telemetry_write_failed",
+        { reason: err instanceof Error ? err.message : String(err), path },
+        lang
+      ),
       "telemetry-write-failed"
     );
   };
@@ -4050,16 +3882,18 @@ function consoleTelemetry() {
     histogram: (name, value, attrs) => line({ t: "histogram", name, v: value, attrs })
   };
 }
+var OTLP_INSTALL_COMMAND;
 var init_telemetry = __esm({
   "src/telemetry/index.ts"() {
     init_file();
     init_otel();
     init_file();
     init_otel();
+    OTLP_INSTALL_COMMAND = "pnpm add @opentelemetry/api @opentelemetry/sdk-trace-base @opentelemetry/sdk-metrics @opentelemetry/exporter-trace-otlp-http @opentelemetry/exporter-metrics-otlp-http @opentelemetry/resources";
   }
 });
 function missing(tool) {
-  return { output: `${tool} \u5DE5\u5177\u4E0D\u53EF\u7528\uFF08\u6A21\u5757\u6CA1\u8D77\u6765\uFF0C\u770B /diagnostics\uFF09`, ok: false };
+  return { output: t("boot.tool_unavailable", { tool: `${tool} ` }), ok: false };
 }
 function toResult(result) {
   const output = typeof result.output === "string" ? result.output : JSON.stringify(result.output, null, 2);
@@ -4078,7 +3912,11 @@ function createUserActions(deps) {
     const type = mapOperationType(toolName);
     const decision = pm.check({ type, detail, workDir: deps.workDir, target, toolName });
     if (decision.allowed) return null;
-    if (!decision.requireApproval) return `\u64CD\u4F5C\u88AB\u62E6\u622A [\u6743\u9650]: ${decision.reason || "\u9700\u8981\u6388\u6743"}`;
+    if (!decision.requireApproval) {
+      return t("boot.blocked_by_permission", {
+        reason: decision.reason || t("boot.needs_authorization")
+      });
+    }
     const outcome = await approve({
       toolName,
       type,
@@ -4087,7 +3925,7 @@ function createUserActions(deps) {
       ...decision.reason ? { reason: decision.reason } : {}
     });
     pm.auditUserDecision?.({ type, target, toolName }, outcome);
-    if (outcome === "deny") return "\u5DF2\u53D6\u6D88";
+    if (outcome === "deny") return t("boot.cancelled");
     pm.recordApproval(toolName, target, outcome);
     return null;
   };
@@ -4128,6 +3966,139 @@ var init_user_shell = __esm({
   "src/user-shell.ts"() {
   }
 });
+function utilityBudgetKey(input) {
+  const owner = input.sessionId?.trim();
+  if (owner) return owner;
+  const label = input.label !== void 0 && LABEL_SHAPE.test(input.label) ? input.label : ANONYMOUS;
+  return `${BUCKET_PREFIX}${label}`;
+}
+function buildUtilityControl(opts) {
+  const { provider, store, pricingOf } = opts;
+  const record = (input, out) => {
+    if (!store || !out.usage) return;
+    const pricing = pricingOf?.(out.model);
+    new BudgetGuard({ store, sessionId: utilityBudgetKey(input) }).add(out.usage, {
+      model: out.model,
+      ...pricing ? { pricing } : {}
+    });
+  };
+  return {
+    async generate(input) {
+      if (input.signal?.aborted === true) throw new Error(t("utility.aborted"));
+      const wanted = input.model ?? refOf(provider.getUtilityInfo());
+      const out = await provider.generate({
+        messages: input.messages,
+        ...input.system !== void 0 ? { system: input.system } : {},
+        ...input.maxTokens !== void 0 ? { maxTokens: input.maxTokens } : {},
+        ...wanted.provider ? { provider: wanted.provider } : {},
+        model: wanted.model,
+        ...input.responseFormat ? { responseFormat: input.responseFormat } : {},
+        ...input.providerOptions ? { providerOptions: input.providerOptions } : {}
+      });
+      record(input, out);
+      return {
+        text: out.text,
+        ...out.usage ? { usage: out.usage } : {},
+        model: out.model,
+        provider: out.provider,
+        ...out.responseFormatApplied === void 0 ? {} : { responseFormatApplied: out.responseFormatApplied },
+        ...out.warnings ? { warnings: out.warnings } : {}
+      };
+    }
+  };
+}
+function refOf(info) {
+  return { provider: info.selection.provider, model: info.selection.model };
+}
+var BUCKET_PREFIX, ANONYMOUS, LABEL_SHAPE;
+var init_utility = __esm({
+  "src/utility.ts"() {
+    BUCKET_PREFIX = "utility:";
+    ANONYMOUS = "anonymous";
+    LABEL_SHAPE = /^[a-z0-9_-]{1,32}$/;
+  }
+});
+function withinWorkspace(resolveInWorkspace2, root, rel) {
+  return resolveInWorkspace2(root, rel) !== null;
+}
+function buildWorkspaceFilesControl(deps, permission) {
+  let cache = null;
+  const now = () => Date.now();
+  function computeList(root) {
+    const { files, truncated } = deps.listFiles(root);
+    return { files, truncated, at: now(), root };
+  }
+  function listFor(root) {
+    const t23 = now();
+    if (!cache || cache.root !== root) cache = computeList(root);
+    else if (t23 - cache.at > LIST_TTL_MS) cache = computeList(root);
+    return cache;
+  }
+  return {
+    candidates(query, limit, root) {
+      const q = query.trim().toLowerCase();
+      let base;
+      try {
+        base = listFor(root);
+      } catch {
+        return null;
+      }
+      const mentionable = [];
+      let unmentionable = 0;
+      for (const rel of base.files) {
+        if (!withinWorkspace(deps.resolveInWorkspace, root, rel)) continue;
+        const hit = q.length === 0 || rel.toLowerCase().includes(q);
+        if (!hit) continue;
+        if (isMentionableFilePath(rel)) {
+          mentionable.push({ rel, depth: rel.split("/").length });
+        } else {
+          unmentionable += 1;
+        }
+      }
+      mentionable.sort((a, b) => a.depth - b.depth || (a.rel < b.rel ? -1 : a.rel > b.rel ? 1 : 0));
+      return {
+        candidates: mentionable.slice(0, limit).map((row) => row.rel),
+        unmentionable,
+        truncated: base.truncated
+      };
+    },
+    readFile(path, root) {
+      const full = deps.resolveInWorkspace(root, path);
+      if (!full) return { ok: false, reason: "denied" };
+      const decision = permission?.check({
+        type: "file_read",
+        detail: path,
+        workDir: root,
+        target: full,
+        toolName: "file_read"
+      });
+      if (permission && !decision?.allowed) return { ok: false, reason: "denied" };
+      let stat;
+      try {
+        stat = statSync(full);
+        if (!stat.isFile()) return { ok: false, reason: "unreadable" };
+      } catch {
+        return { ok: false, reason: "unreadable" };
+      }
+      let raw;
+      try {
+        raw = readFileSync(full);
+      } catch {
+        return { ok: false, reason: "unreadable" };
+      }
+      if (raw.subarray(0, 8192).includes(0)) {
+        return { ok: false, reason: "binary", bytes: stat.size };
+      }
+      return { ok: true, text: raw.toString("utf8"), bytes: stat.size };
+    }
+  };
+}
+var LIST_TTL_MS;
+var init_workspace_files = __esm({
+  "src/workspace-files.ts"() {
+    LIST_TTL_MS = 6e4;
+  }
+});
 function splitDirList(value) {
   if (!value) return [];
   return value.split(delimiter).map((s) => s.trim()).filter((s) => s.length > 0);
@@ -4137,20 +4108,23 @@ function wireWorkspace(input) {
   input.permission?.setExtraRoots(workspace.extra);
   if (input.addDir.length === 0) return workspace;
   for (const issue of issues) {
-    if (issue.kind === "redundant") input.diags.skipped("\u989D\u5916\u76EE\u5F55", issue.detail);
-    else input.diags.warn("\u989D\u5916\u76EE\u5F55", issue.detail, `add-dir-${issue.kind}`);
+    if (issue.kind === "redundant") input.diags.skipped("ExtraDirs", issue.detail);
+    else input.diags.warn("ExtraDirs", issue.detail, `add-dir-${issue.kind}`);
   }
   if (workspace.extra.length > 0) {
     input.diags.ok(
       WORKSPACE_MODULE,
-      `${workspace.extra.length} \u4E2A\u989D\u5916\u6839: ${workspace.extra.join(", ")}`
+      t("boot.workspace_extra", {
+        count: workspace.extra.length,
+        dirs: workspace.extra.join(", ")
+      })
     );
   }
   const unloaded = unloadedInstructionFiles(workspace);
   if (unloaded.length > 0) {
     input.diags.skipped(
-      "\u989D\u5916\u76EE\u5F55\u6307\u4EE4\u6587\u4EF6",
-      `\u672A\u52A0\u8F7D\uFF08\u989D\u5916\u76EE\u5F55\u7684\u6307\u4EE4\u6587\u4EF6\u8981\u5355\u72EC\u8FC7\u4FE1\u4EFB\u5224\u5B9A\uFF0C\u672C\u7248\u4E0D\u652F\u6301\uFF09: ${unloaded.join(", ")}`
+      "ExtraDirInstructions",
+      t("boot.workspace_extra_instructions", { paths: unloaded.join(", ") })
     );
   }
   return workspace;
@@ -4161,10 +4135,6 @@ function workspaceDecisionLog(sessions, diags) {
       try {
         sessions.updateMeta(sessionId, {
           workspaceState: decision.state,
-          // `none` 那一档**不带路径**。写 `undefined` 在 `updateSessionMeta()` 里
-          // 是「这一列不进 SET」（那儿第一行就 `if (v === undefined) continue`），
-          // 不是「清空它」—— 而 `bound → none` 这条路被 server 那道 409 挡着，
-          // 所以「留着一个陈旧的 root」在今天不可达
           ...decision.state === "bound" ? { workspaceRoot: decision.root } : {}
         });
       } catch (err) {
@@ -4210,51 +4180,10 @@ function inspectRoot(dir, lang) {
 var WORKSPACE_MODULE, SessionWorkspaces;
 var init_workspace = __esm({
   "src/workspace.ts"() {
-    WORKSPACE_MODULE = "\u5DE5\u4F5C\u533A";
+    WORKSPACE_MODULE = "Workspace";
     SessionWorkspaces = class {
-      /**
-       * 谁绑在哪儿。**一张内存 Map，进程退出就没了 —— 这一条 2026-08-19 之后仍然成立。**
-       *
-       * 变的是它旁边多了一份 {@link WorkspaceDecisionLog}：绑成功的那一刻**另外**
-       * 往会话库记一笔「用户当初选了哪儿」。两者不是一份数据的两个副本，时态不同 ——
-       * 这张表答的是「它**现在**绑在哪儿」（因此 {@link bind} 那道闸门：路径校验 +
-       * 信任判定），落盘那份答的是「用户**当初**决定了什么」（只读的事实，不带闸门，
-       * 因为决定本身不需要重新判定）。
-       *
-       * 于是原来那两条反对理由，一条仍然拦着、一条被那个时态差绕开了：
-       *
-       * 1. **仍然成立**：落盘成一条**自动生效**的绑定，会和 [build.ts](./build.ts) 里
-       *    `/resume` 那一行 {@link seed} 顶上 —— 那儿的规矩是「接回来的会话跑在
-       *    **这个进程**的工作区里」。侧栏画着 A、引擎跑在 B 就是这么来的。所以装配时
-       *    **没有任何东西读那份记录去 `bind()`**；绑定发生在用户点开旧会话、敲下第一句
-       *    话那一刻（`SessionFactory.revive()`），走的是这个类完整的 {@link bind}；
-       * 2. **不再成立**：「只读的事实不属于这张表」是对的，但结论错了 —— 它属于
-       *    **会话库那一行**，而不是「所以谁都别记」。不记的代价是重启之后一段会话
-       *    说不出自己在哪儿干过活，判据全文（含哪条过期、哪条原样成立）在 web 的
-       *    `shell/session-list.tsx` 文件头。
-       */
       bindings = /* @__PURE__ */ new Map();
-      /**
-       * 「建出来了，但还没选地盘」的那几个会话（方案 55 PR-1，2026-08-17）。
-       *
-       * **一个 `Set<sessionId>`，不是第二张绑定表**：这一档的全部内容就是「它在等
-       * 一次选择」，没有路径、没有信任判定、没有 `ProjectContext`。用一张 Map 存的话
-       * 那些格子只能是 null，而一个到处是 null 的绑定会被下一个人当成「绑了个空的」。
-       *
-       * 出集合有且只有两条路：{@link bind} 成功（转成 `bound`）、
-       * 以及 {@link release}（会话没了）。「明确选不使用工作区」那一下在宿主那一层
-       * 也走 `release` —— 判据见它。
-       */
       deferred = /* @__PURE__ */ new Set();
-      /**
-       * 明确选过「不使用工作区」的那几个（会话库 v7，2026-08-19）。
-       *
-       * **{@link stateOf} 不看它**，那一档的语义一个字没变。这个集合存在只为回答
-       * {@link decisionOf} 的第三种答案 `null`：`stateOf()` 把「明确不使用」和
-       * 「这个进程从没听说过这个 id」都报成 `none`（那条 ⚠️ 就写在它的文档上），
-       * 而落盘的时候这两者天差地别 —— 前者是一次决定，后者写下去就是**替用户
-       * 编了一个他没做过的决定**。
-       */
       noWorkspace = /* @__PURE__ */ new Set();
       gate;
       recent;
@@ -4266,51 +4195,17 @@ var init_workspace = __esm({
         this.decisions = opts.decisions ?? null;
         this.now = opts.now ?? Date.now;
       }
-      /** 这个会话绑在哪儿。没绑过 `null` —— 「不使用工作区」是真的一档，不是缺省值 */
       of(sessionId) {
         return this.bindings.get(sessionId) ?? null;
       }
-      /**
-       * 记一笔「建出来了、还没选地盘」。判据全文在 {@link WorkspaceControl.defer}。
-       *
-       * **已经绑上的会话调它是空操作**，不是把它退回未选：那等于绕过决定 18 的
-       * 「绑定后不给改」—— 一个宿主只要先 `defer()` 再 `bind()`，就能给一段跑过
-       * 一整轮活的会话换地盘，而 `bind()` 那道 `locked` 闸拦的正是这件事。
-       */
       defer(sessionId) {
         if (this.bindings.has(sessionId)) return;
         this.deferred.add(sessionId);
       }
-      /** 这个会话是哪一档。判据见 {@link WorkspaceBindingState} */
       stateOf(sessionId) {
         if (this.bindings.has(sessionId)) return "bound";
         return this.deferred.has(sessionId) ? "unbound" : "none";
       }
-      /**
-       * 装配时把**引导会话**的绑定记进来。
-       *
-       * 和 {@link bind} 分开是因为这一份已经算好了：`buildRuntime()` 手里的
-       * `workspace`（含 `--add-dir`）、`services.trust`、`services.projectContext`
-       * 就是引擎**真在用**的那三样。走 bind() 会重新 `discoverProject()`（要跑 git）
-       * 算出第二份 —— 那第二份哪怕只差一个字节，界面上写的就不是引擎真在用的那个。
-       *
-       * `unloadedInstructions` **由这里补**，不要调用方给：它是 `workspace` 的纯函数，
-       * 而让两个 `seed()` 调用点各算一遍的失败形态是其中一个漏了 ——
-       * 结果是「resume 之后那条『额外目录的 CLAUDE.md 没加载』的提示凭空消失」。
-       *
-       * @param opts.decision 顺带把这一份**落盘**成用户的工作区决定（会话库 v7）。
-       *   **两个调用点一个给一个不给，这正是这个参数存在的全部理由**：
-       *
-       *   - `buildRuntime()` 里引导会话那一句 —— **给**。用户在哪个目录里敲的
-       *     `epoch` / `epoch web`，那就是他为这段会话选的地盘，和在 picker 里点一下
-       *     没有区别。不给的话「直接 `epoch web` 聊两句」这条最短路径重启后一律
-       *     掉进「早先的会话」，而那正是这一轮要修的；
-       *   - `/resume` 那一句（`build.ts` 的 `SessionControl.resume` 回调）——
-       *     **不给**。那儿的规矩是「接回来的会话跑在**这个进程**的工作区里」，
-       *     它是一次**临时接管**，不是那段会话的主人改了主意。落盘它的后果是：
-       *     随手在 `/tmp` 里 `epoch --resume` 一段三周前的会话，就把它在库里的
-       *     地盘永久改成了 `/tmp`。
-       */
       seed(sessionId, bound, opts) {
         this.bindings.set(sessionId, {
           ...bound,
@@ -4322,17 +4217,6 @@ var init_workspace = __esm({
           this.decisions?.record(sessionId, { state: "bound", root: bound.workspace.root });
         }
       }
-      /**
-       * 把一个目录绑到会话上。
-       *
-       * 顺序是**先校验路径、再看有没有被锁**：一个写错的路径不管会话锁没锁都是写错的，
-       * 而反过来的话「路径不存在」这条永远被 `locked` 盖住 —— 于是调用方收到的是
-       * 「不能改」，而他真正的问题是「这个目录我打错了」。
-       *
-       * **只认绝对路径。** 相对路径要么相对服务进程的 cwd、要么相对用户以为的某个
-       * 目录，两者不一致时没有任何迹象；而这条路的入口是网线（浏览器传字符串进来），
-       * 那儿压根没有「当前目录」这个概念。
-       */
       bind(sessionId, dir, lang) {
         const invalid = inspectRoot(dir, lang);
         if (invalid) return invalid;
@@ -4358,75 +4242,28 @@ var init_workspace = __esm({
         this.decisions?.record(sessionId, { state: "bound", root });
         return { ok: true, bound, changed: true };
       }
-      /** 记一笔「明确不使用工作区」。判据全文在 {@link WorkspaceControl.decideNone} */
       decideNone(sessionId) {
         if (this.bindings.has(sessionId)) return;
         this.deferred.delete(sessionId);
         this.noWorkspace.add(sessionId);
         this.decisions?.record(sessionId, { state: "none" });
       }
-      /**
-       * 用户为这个会话做过的工作区决定；**没做过是 `null`**。
-       *
-       * 这是 `SessionStore.ensure()` 建行那一刻要问的那一句（判据在
-       * {@link WorkspaceDecisionLog.record} 的「实现方不许建行」那一节）。
-       *
-       * ⚠️ 和 {@link stateOf} 的差别只有一处，但那一处是全部意义所在：
-       * `stateOf()` 把「明确不使用」和「没听说过这个 id」都答成 `none`，
-       * 这里前者是 `{state:'none'}`、后者是 `null`。
-       */
       decisionOf(sessionId) {
         const bound = this.bindings.get(sessionId);
         if (bound) return { state: "bound", root: bound.workspace.root };
         return this.noWorkspace.has(sessionId) ? { state: "none" } : null;
       }
-      /**
-       * 解绑（会话被删掉时）。
-       *
-       * **不动「已知工作区」清单**：那份记的是「我最近在哪几个目录里干过活」，
-       * 删掉一段会话不代表那件事没发生过。
-       *
-       * ⚠️ 2026-08-17 起它也把 {@link defer} 那一笔清掉，于是「删掉一段还没选地盘的
-       * 会话」不会在集合里留一个永远等不到选择的 id（方案 55 验收第 8 条）。
-       *
-       * ⚠️ **「明确选不使用工作区」那一下 2026-08-19 起不再走这里**，改走
-       * {@link decideNone}。原来两者在内存里等价（摘掉 `defer` 那一笔之后
-       * {@link stateOf} 就是 `none`），但落盘之后不再等价：这个方法**同时**是
-       * 建会话失败的回滚路径和删会话的路径，在它里面记一次决定，等于让一段建到
-       * 一半失败的会话在库里留下「用户选了不使用工作区」。判据全文在 `decideNone` 上。
-       *
-       * **它照旧把 `noWorkspace` 那一笔也摘掉** —— 会话都没了，那个决定连同它一起走。
-       * ⚠️ 摘的只是内存这一份：库里那一行由 `DELETE /api/sessions/:id` 整行删掉，
-       * 不是在这儿改字段。
-       */
       release(sessionId) {
         this.bindings.delete(sessionId);
         this.deferred.delete(sessionId);
         this.noWorkspace.delete(sessionId);
       }
-      /** 本机「已知工作区」清单，最近使用的在前 */
       known() {
         return this.recent.list();
       }
-      /**
-       * 一个目录的信任判定。
-       *
-       * 和 {@link resolveBinding} 一样先归一到**项目根**再判 —— 两处分叉的表现是
-       * 「清单里说未信任、绑上去之后指令文件却加载了」。
-       *
-       * 只查不写：`decide()` 是纯读（`TrustManager.check` + 降级规则），
-       * 不往清单里记账，也不建绑定。
-       */
       trustOf(dir) {
         return this.gate.decide(resolveProjectRoot(dir));
       }
-      /**
-       * 一个目录 → 完整的绑定。
-       *
-       * 信任按**项目根**判而不是按传进来那个目录判，和 `discoverProject()` 内部
-       * 保持一致（在仓库子目录里绑定会继承仓库根的信任决定）。两处判据分叉的表现是
-       * 「界面说未信任、指令文件却加载了」，或者反过来。
-       */
       resolveBinding(root) {
         const trust = this.gate.decide(resolveProjectRoot(root));
         const { workspace } = resolveWorkspace(root);
@@ -4434,26 +4271,25 @@ var init_workspace = __esm({
           workspace,
           trust,
           projectContext: discoverProject(root, trust),
-          // 照旧探一遍而不是写死 `[]`：今天没有额外根所以它必然是空的，
-          // 但「为什么是空的」这件事不该由一个字面量来记住
           unloadedInstructions: unloadedInstructionFiles(workspace)
         };
       }
     };
   }
 });
-
 // src/build.ts
 var build_exports = {};
 __export(build_exports, {
   AgentRoleError: () => AgentRoleError,
+  buildGoalCatalog: () => buildGoalCatalog,
   buildRuntime: () => buildRuntime,
   ensureSecretsReady: () => ensureSecretsReady
 });
 async function buildRuntime(opts = {}) {
   const opened = { cleanups: null };
+  const processes = createProcessTable();
   try {
-    return await assembleRuntime(opts, opened);
+    return await assembleRuntime(opts, opened, processes);
   } catch (err) {
     for (const fn of [...opened.cleanups ?? []].reverse()) {
       try {
@@ -4462,16 +4298,17 @@ async function buildRuntime(opts = {}) {
       }
     }
     try {
-      await cleanupBackgroundProcesses();
+      await processes.release();
     } catch {
     }
     throw err;
   }
 }
-async function assembleRuntime(opts, opened) {
+async function assembleRuntime(opts, opened, processes) {
   const startedAt = Date.now();
   const workDir = opts.workDir ?? process.cwd();
   const sessionId = opts.resumeId || randomUUID();
+  processes.claim(sessionId);
   const diagnostics = new DiagnosticSink();
   if (opts.hostPreset) {
     await applyHostPreset({
@@ -4499,14 +4336,8 @@ async function assembleRuntime(opts, opened) {
     ...opts.interactive === void 0 ? {} : { interactive: opts.interactive },
     ...opts.logger ? { logger: opts.logger } : {},
     ...settingsPath ? { settingsPath } : {},
-    // 宿主注入的技能目录（方案 44）。空数组也照传：`resolveSkillDirs` 对空数组
-    // 和不给这个键的处理逐字相同，多一个分支只是多一处会走散的地方
     hostSkillDirs: hostCaps.skillDirs,
-    // 没有 `?? process.env.*` 的兜底，理由见 `BuildRuntimeOptions.managedSettingsPath`
     ...opts.managedSettingsPath ? { managedSettingsPath: opts.managedSettingsPath } : {},
-    // **这一行必须紧跟着上面那次 `loadConfig()`**：`getConfigOrigins()` 报的是
-    // 最近一次加载的账，中间隔一次别人的 `loadConfig()` 就串台了。递进去而不是
-    // 让 `buildServices` 自己去问，判据写在 `ServiceOptions.configOrigins` 上
     configOrigins
   });
   const config = services.config;
@@ -4545,21 +4376,25 @@ async function assembleRuntime(opts, opened) {
   if (sandbox) {
     cleanups.push(() => sandbox.destroy());
     isolation = sandbox.getIsolation();
-    diagnostics.ok("Sandbox \u9694\u79BB", isolation.detail);
+    diagnostics.ok("SandboxIsolation", isolation.detail);
     services.permission?.setSandboxIsolation(isolation.level);
   }
   if (services.permission) {
     applyHeadless(services.permission, config, opts.headless, diagnostics, opts.interactive);
   }
   const budgetWiring = wireBudget(config, services.modelPricing, diagnostics);
+  const bootstrapReveal = createToolRevealState();
   const registry = registerLocalTools({
     homeDir: config.homeDir,
+    deferMcp: config.tools?.deferMcp === true,
+    toolMode: foldToolMode(config.tools?.mode),
+    bootstrapReveal,
     trackerDb: services.trackerDb,
     goals: services.goals,
     memory: services.memory,
     sandbox,
+    skills: services.skill,
     diags: diagnostics,
-    // 合并后那份 config —— 项目级设置将来若放开 search 段，这里天然跟着走
     ...config.search ? { search: config.search } : {}
   });
   registerSessionSearch(registry, {
@@ -4568,10 +4403,16 @@ async function assembleRuntime(opts, opened) {
     ...config.sessionSearch ? { sessionSearch: config.sessionSearch } : {},
     diags: diagnostics
   });
-  const mcpWiring = await registerMcpTools(registry, config.homeDir, diagnostics, [
-    { source: "host", servers: hostCaps.mcpServers },
-    { source: "plugin", servers: wirePluginMcpServers(services.plugins.mcpPaths, diagnostics) }
-  ]);
+  const mcpWiring = await registerMcpTools(
+    registry,
+    config.homeDir,
+    diagnostics,
+    [
+      { source: "host", servers: hostCaps.mcpServers },
+      { source: "plugin", servers: wirePluginMcpServers(services.plugins.mcpPaths, diagnostics) }
+    ],
+    config.tools?.deferMcp === true
+  );
   cleanups.push(mcpWiring.dispose);
   const bridges = new SessionBridges(opts.onApprovalRequest);
   const interactive = !services.permission?.isNonInteractive();
@@ -4586,35 +4427,36 @@ async function assembleRuntime(opts, opened) {
     permission: services.permission,
     planState,
     managed: services.managedPolicy,
-    // 「这次启动那一档」，不是「引导会话此刻那一档」——判据在 `SessionGuards.open`
+    deferredTools: () => registry.byExposure(ToolExposure.Deferred),
+    bootstrapReveal,
     startLevel: services.permissionLevel,
-    // **和上面那两个进程级工具收的是同一个回调**：「弹给谁看」由
-    // `ToolContext.sessionId` 决定，在这儿另写一个闭包等于把那条路由绕过去
     requestApproval: requestPlanApproval,
     interactive
   });
   const bootstrapGuard = guards.bootstrap();
   registerAskQuestion(registry, (req, sessionId2) => bridges.ask(sessionId2, req), interactive);
+  registry.registerTools(
+    dropOverlongToolNames(
+      hostCaps.tools,
+      HOST_CAPABILITIES_MODULE,
+      "host-tool-name-too-long",
+      diagnostics
+    ),
+    "host"
+  );
   const commands = wireCommands({
     homeDir: config.homeDir,
     projectRoot: services.projectContext.rootDir,
     trusted: services.trust.trusted,
     pluginDirs: services.plugins.commandDirs,
     toolProvider: registry.asProvider(),
-    // 传的是**函数**：命令展开发生在用户敲下那一刻，而这之前他可能已经
-    // `/model` 换过了。取值钉住就等于永远解析成启动时那个模型
-    //
-    // 只递 provider + model 两段：`origin` 讲的是**当前选择**怎么来的，
-    // 而这里回答的是「工具模型是谁」。原样带过去，命令会展开出一个
-    // `origin: 'config'` 的 ref，随后 `enterTurn` 再按 `command-frontmatter`
-    // 盖一次 —— 同一个字段有两个说法，出事时看哪个都不对
     utilityModel: () => {
       const s = services.provider?.getUtilityInfo().selection;
       return s ? { provider: s.provider, model: s.model } : void 0;
     },
     diags: diagnostics
   });
-  const checkpoints = new CheckpointManager({ workDir, homeDir: config.homeDir });
+  const checkpoints = new CheckpointManager({ workDir: () => workDir, homeDir: config.homeDir });
   const { providerBridge } = services;
   const agentRoles = [];
   const agentRoleNotices = [];
@@ -4633,8 +4475,11 @@ async function assembleRuntime(opts, opened) {
     mainRole = pickMainRole(opts.agent ?? process.env.EPOCH_AGENT, roles);
     if (mainRole) {
       diagnostics.ok(
-        "\u4E3B agent \u89D2\u8272",
-        `${mainRole.name}${mainRole.tools ? `\uFF08${mainRole.tools.length} \u4E2A\u5DE5\u5177\uFF09` : "\uFF08\u5DE5\u5177\u8868\u4E0D\u6536\u7A84\uFF09"}`
+        "MainAgentRole",
+        t("boot.main_role", {
+          name: mainRole.name,
+          tools: mainRole.tools ? t("boot.main_role_tools", { count: mainRole.tools.length }) : t("boot.main_role_no_narrow")
+        })
       );
     }
   }
@@ -4652,34 +4497,24 @@ async function assembleRuntime(opts, opened) {
     provider: providerBridge,
     models,
     guards,
-    // 引导会话的工作目录。**不能拿 `projectContext.rootDir` 顶替** ——
-    // 在仓库子目录里启动是常态，顶替等于悄悄换了相对路径的解析基准
     defaultWorkDir: workDir,
-    // 收窄过的那一层（方案 23）；未收窄那份给子 agent，判据见工厂的选项注释
     toolProvider: commands.toolProvider,
     rawToolProvider: registry.asProvider(),
+    deferredTools: () => registry.byExposure(ToolExposure.Deferred),
+    codeModeTools: () => registry.codeModeDeclared(),
     telemetry,
     budget: budgetWiring,
     ...opts.onApprovalRequest ? { hostApproval: opts.onApprovalRequest } : {},
     workspaces,
     bridges,
     sessions: services.session,
-    // 目标（方案 52）。**进程一份**，收窄成「这一段会话」发生在工厂里
-    // （`buildGoalControl(…, () => session.sessionId)`）
     goals: services.goals,
     ...opts.sessionSource ? { sessionSource: opts.sessionSource } : {},
     mainRole: mainRole ?? null,
     roles: () => agentRoles,
-    // 后台任务的状态变化（方案 36 PR-2）。给函数不给数组 —— 任务状态每时每刻
-    // 在变，快照拿到的是装配那一刻的。
-    //
-    // ⚠️ 2026-08-15 起它**按会话取**：工厂给每个会话拿它自己那一批（判据在
-    // plugin-terminal 的 `background.ts` 文件头）。收窄之前每个会话每轮都被告知
-    // 一批**它没起过**的命令在跑，而那条通知是直接进模型上下文的
     backgroundTasks: (id) => listTasks(id),
-    // 子任务跑完之后把它起的后台任务归还给派活的会话（判据在 `subRunner` 末尾）。
-    // 这里是全仓唯一一处知道「任务表由 plugin-terminal 提供」的地方
     rekeyBackgroundTasks: rekeyTasks,
+    processes,
     diags: diagnostics
   });
   if (providerBridge) {
@@ -4689,19 +4524,22 @@ async function assembleRuntime(opts, opened) {
     for (const c of registry.getConflicts()) {
       diagnostics.warn(
         `Tool ${c.name}`,
-        `${c.droppedFrom} \u4E0E ${c.keptFrom} \u649E\u540D\uFF0C\u5DF2\u5FFD\u7565\u524D\u8005`,
+        t("boot.tool_conflict", { dropped: c.droppedFrom, kept: c.keptFrom }),
         "tool-name-conflict"
       );
     }
   }
+  reportToolCost(registry, diagnostics);
   const store = services.session ? new SessionStore(
     services.session,
     config.homeDir,
-    services.projectContext.rootDir,
+    () => services.projectContext.rootDir,
     opts.sessionSource
   ) : void 0;
   const history = opts.resumeId && store ? store.loadHistory(opts.resumeId) : [];
-  if (history.length > 0) diagnostics.ok("History", `${history.length} \u6761\u6D88\u606F\u5DF2\u52A0\u8F7D`);
+  if (history.length > 0) {
+    diagnostics.ok("History", t("boot.history_loaded", { count: history.length }));
+  }
   const bootstrap = factory.adopt(sessionId, history);
   const session = bootstrap?.session ?? null;
   const agent = bootstrap?.agent ?? null;
@@ -4728,7 +4566,7 @@ async function assembleRuntime(opts, opened) {
       }
     }
     try {
-      await cleanupBackgroundProcesses();
+      await processes.release();
     } catch {
     }
   };
@@ -4737,10 +4575,6 @@ async function assembleRuntime(opts, opened) {
   const provider = services.provider;
   const listTools = () => commands.toolProvider.list().map((tool) => ({
     tool,
-    // 注册表一直记着「谁注册的这个工具」，只是以前没人往外传。能力页的
-    // 「内置连接器」那一组要按它分（方案 42 PR-1）—— 按工具名前缀猜
-    // （`file_*` 归 plugin-file）会在第一个不按前缀命名的工具上错。
-    // 取不到只可能是收窄层放进来一个 registry 没见过的名字，那时说 `builtin`
     source: registry.sourceOf(tool.name) ?? "builtin"
   }));
   const schedules = createScheduleControl({
@@ -4748,30 +4582,35 @@ async function assembleRuntime(opts, opened) {
     ...opts.scheduleRunner ? { runner: opts.scheduleRunner } : {}
   });
   cleanups.push(schedules.dispose);
+  if (schedules.openError) {
+    diagnostics.failed("Schedules", `FAILED (${schedules.openError.message})`, "init-failed");
+  } else {
+    diagnostics.ok("Schedules");
+  }
+  const hostMarketplaces = opts.hostMarketplaces;
+  if (hostMarketplaces) {
+    await wireHostMarketplaces({
+      hostMarketplaces,
+      statePath: marketplacesPath(config.homeDir),
+      diagnostics
+    });
+  }
+  reportI18nHealth(diagnostics);
   return {
     agent,
     session,
-    // 多会话工厂（方案 30 §6.3）。`SessionFactory` 是收窄过的那一面 ——
-    // `adopt` / `subRunner` 是装配层的特权，宿主拿到它就等于能绕过 `bind()`
-    // 那两道门（判据同 `WorkspaceControl` 上刻意不露 `seed` 的那一条）
     sessionFactory: factory,
+    events: processEventBus,
     sessionStore: store ?? null,
-    // **引导会话自己那一份**，从工厂手里拿 —— 不在这儿再包一个。工厂给每个会话
-    // 各建了一个 `CheckpointManager`（作用域表里它是会话级），在这边照着上面那个
-    // 进程级管理器另包一层，等于给同一段会话的安全网第二个说法，而两者的
-    // `workDir` 只在「引导会话没换过工作区」时恰好相等（方案 30 §9.5）。
-    //
-    // `??` 那一支只在 provider 没起来时走得到（那时一个会话都装配不出来）：
-    // 这个字段不可为 null，而一个读得出空列表的控制面是那时唯一诚实的答案
+    sessionReferences: services.session?.references ?? null,
+    workspaceFiles: buildWorkspaceFilesControl(
+      { listFiles: listWorkspaceFiles, resolveInWorkspace },
+      services.permission
+    ),
     checkpoints: bootstrap?.checkpoints ?? buildCheckpointControl(checkpoints, null, () => sessionId),
-    // **引导会话自己那一份**，判据逐字同上面的 `checkpoints`：从工厂手里拿，
-    // 不在这儿再包一个。`??` 那一支同理只在 provider 没起来时走得到 ——
-    // 那时候没有会话，而目标是会话的状态，`null` 是那一刻唯一诚实的答案
     goals: bootstrap?.goals ?? (services.goals ? buildGoalControl(services.goals, () => sessionId) : null),
+    goalCatalog: services.goals ? buildGoalCatalog(services.goals) : null,
     config,
-    // 这次实际生效的数据目录，以及从它派生的 artifact 根目录（方案 54 §二）。
-    // **调 `paths.ts` 而不是 `join(homeDir, 'artifacts')`**：路径真源只有一处，
-    // 在这里拼字符串就是给同一个目录第二个说法 —— 而那正是这一节要修的病
     homeDir: config.homeDir,
     artifactsRoot: artifactsDir(void 0, config.homeDir),
     sessionId,
@@ -4779,22 +4618,11 @@ async function assembleRuntime(opts, opened) {
     schedules: schedules.control,
     workspace,
     workspaces,
-    // 装配过程里到处在用的那个布尔（指令文件、角色文件、自定义命令都问它），
-    // 原样露出来给 doctor —— 别在宿主侧重新判一遍，见字段的 JSDoc
     trusted: services.trust.trusted,
-    // 信任记录的读写口（方案 54 §五）。**零新逻辑** —— 转的就是装配时那个
-    // manager 实例本身，宿主 `record()` 之后本进程新绑的工作区立刻按新判定走
-    // （闸门每次现问 `check()`，中间没有缓存）。
-    //
-    // 转实例而不是包一层收窄：四个方法就是 protocol 的 `TrustManager` 契约，
-    // 包一层只会多出一处「哪天签名变了这里忘了跟」。
     trust: services.trustManager,
     isolation,
     policy: services.policy,
-    // **读收窄之后那一层**（方案 23），不是 `registry.exposed()`：这个字段的口径是
-    // 「模型现在看得见什么」，而一条写了 `allowed-tools` 的自定义命令正在跑的时候，
-    // 模型看得见的就是白名单里那几个。读原始 registry 的话 `/tools` 会在收窄期间说假话。
-    // getter 而不是快照：MCP 刷新（方案 15）和收窄进出都要能立刻反映出来
+    hook: services.hook,
     get tools() {
       return listTools().map(({ tool, source }) => ({
         name: tool.name,
@@ -4804,19 +4632,10 @@ async function assembleRuntime(opts, opened) {
     },
     usageScope: budgetWiring.budgetStore ? "session" : "run",
     compression: compressionLine(config, services),
-    // **getter 而不是快照**（和上面的 `tools` 同一个理由）：方案 26 之后
-    // `/model` 能在运行期换 provider，拍一张快照的话 `/model` 会一直显示
-    // 启动时那家和那把 key —— 一个专门用来"确认我现在用的是什么"的面板在说假话
     get providerInfo() {
       return provider ? { provider: provider.getProviderType(), apiKeyHint: provider.getApiKeyHint() } : null;
     },
-    // **引导会话那一份**（2026-08-16）——它就是这个进程那个 router 的出口本体，
-    // 所以 TUI 的 `/model`、CLI 的 `--model` 一个字节都没变。别的会话走
-    // `sessionFactory.get(id).model`，判据见 [session-model.ts](./session-model.ts)
     model: bootstrapModel?.control ?? null,
-    // **不吃 `provider`**，所以 provider 层起不来时它照样在（判据在字段上）。
-    // `configured` 写成 getter 而不是拍下来的两个值：base URL 只对配置里那一家
-    // 有效，而那条判断住在 `model-catalog.ts` 里，不在这儿
     modelCatalog: buildModelCatalogControl({
       homeDir: config.homeDir,
       configured: () => ({
@@ -4824,51 +4643,46 @@ async function assembleRuntime(opts, opened) {
         ...config.provider.baseUrl ? { baseUrl: config.provider.baseUrl } : {}
       })
     }),
+    utility: provider ? buildUtilityControl({
+      provider,
+      ...budgetWiring.budgetStore ? { store: budgetWiring.budgetStore } : {},
+      ...budgetWiring.pricingOf ? { pricingOf: budgetWiring.pricingOf } : {}
+    }) : null,
     agentRoles,
     agentRoleNotices,
     get skills() {
       return services.skill?.list() ?? [];
     },
-    // 不计数的那条读（方案 56 §1.2）。`?? null` 而不是 `?? ''`：技能系统没起来
-    // 和「这个技能的正文是空的」是两件事，合成同一个值之后界面画不出前者
     skillBody: (name) => services.skill?.body(name) ?? null,
-    // 收窄过的导入口（方案 42 §六）。**转的是两个函数，不是 `services.skill`
-    // 本身** —— 判据在 `SkillControl` 的文档上，同 `McpControl` 只露 reconnect
+    skillIndexResidency: (role) => services.skill?.indexResidency({
+      only: role === null ? void 0 : findRole(agentRoles, role)?.skills
+    }) ?? /* @__PURE__ */ new Map(),
     skillImport: buildSkillControl(services),
-    // 身份那一栏的写口（2026-08-18）。**只露一个 `add`**，同上面那两条。
-    // ⚠️ `reload` 递的是上面那个 `reloadRoles` —— 建完当场重载，判据在
-    // `role-write.ts` 文件头第二节（不重载的话这一下只做了一半）
     roleWrite: createRoleWriteControl({
       userDir: agentsDir(config.homeDir),
       roles: () => agentRoles,
-      // 给函数不给快照：MCP 连上 / 掉线都会让工具表变，而工具名要按**用户按下
-      // 那一刻**的那份判（同 `mcpServers` 是个 getter 的判据）
       tools: () => registry.asProvider(),
       reload: reloadRoles
     }),
-    // getter：MCP 会掉线重连，快照就是启动那一刻的谎话
+    plugins: hostMarketplaces ? createPluginControl({
+      pluginsDir: pluginsDir(config.homeDir),
+      statePath: pluginsStatePath(config.homeDir),
+      marketplacesPath: marketplacesPath(config.homeDir),
+      loaded: services.plugins.loaded,
+      allowRemote: hostMarketplaces.allowRemote === true
+    }) : null,
     get mcpServers() {
       return mcpWiring.status();
     },
-    // 收窄过的那一面（方案 56 §1.1）。**转的是 `McpWiring.control` 而不是
-    // registry 本身** —— 判据在 `McpControl` 的文档上，同 `WorkspaceControl`
-    // 刻意不露 `seed()` 那一条
     mcp: mcpWiring.control,
     memory: services.memory ? buildMemoryControl(services.memory) : null,
-    // 引导会话那一份档位（`level` / `setLevel`）+ 三样进程级的读
-    // （规则表 / 遮蔽 / 审计流水）。⚠️ 换档那三步（托管挡 bypass → `setLevel` →
-    // `plan.forget()`）**不在这个函数里**：它们住在 `session-guard.ts`，
-    // 因为它们现在要按会话跑 N 遍，而那条判定只能有一个实现
     permissions: buildPermissionsControl(services, bootstrapGuard.permissions, listTools),
-    // 设置页那一片。**收 `workspaces`** 是这一轮补的那笔账：③④ 跟着工作区走，
-    // 而工作区一个会话绑一个（决定 18）—— 判据在 `SettingsControl` 的文档上
     settings: buildSettingsControl(services, workspaces, {
       ...settingsPath ? { settingsPath } : {},
       ...opts.managedSettingsPath ? { managedSettingsPath: opts.managedSettingsPath } : {}
     }),
-    // 同 `model`：**引导会话那一份**，而它就是进程那个 `PlanModeState` 的出口本体
     plan: bootstrapGuard.plan,
-    sessions: services.session ? buildSessionControl(services.session, session, checkpoints, (from, id) => {
+    sessions: services.session ? buildSessionControl(services.session, session, checkpoints, config.homeDir, (from, id) => {
       planState?.restore(store?.loadPlan(id) ?? null);
       workspaces.seed(id, {
         workspace,
@@ -4879,7 +4693,6 @@ async function assembleRuntime(opts, opened) {
       factory.rekey(source, id);
       rekeyTasks(source, id);
     }) : null,
-    // getter 而不是快照，理由同 `tools` / `providerInfo`
     get contextBreakdown() {
       if (!agent) return null;
       const historyText = (session?.getHistory() ?? []).map((m) => m.content).join("\n");
@@ -4889,18 +4702,12 @@ async function assembleRuntime(opts, opened) {
       });
     },
     commands: commands.control,
-    // 用 `registry` 而不是 `commands.toolProvider`：`!` 是**用户**敲的，
-    // 不该被一条自定义命令的 `allowed-tools` 收窄掉（那条收窄的语义是
-    // 「这一轮**模型**能用什么」）
     userActions: createUserActions({
       registry,
       permission: services.permission,
       workDir,
       sessionId
     }),
-    // 三个通道，**一个真源**（那个 sink）：字符串那份和「换个语言说一遍」那份
-    // 都是投影，不可能漂移。前两个是快照（装配到这一步就定了），
-    // 第三个是函数 —— 它要等请求到了才知道用哪个语言
     diagnostics: diagnostics.toStrings(),
     diagnosticList: diagnostics.toList(),
     diagnosticsIn: (lang) => diagnostics.toList(lang),
@@ -4933,9 +4740,9 @@ function wireAgentRoles(config, services, registry, diags, hostRoles = []) {
   });
   const external = [...services.plugins.roles, ...hostRoles, ...load.overrides];
   const { roles, notices } = mergeRoles(external);
-  for (const n of notices) diags.warn("Agent \u89D2\u8272", n.detail, n.code);
+  for (const n of notices) diags.warn(AGENT_ROLE_DIAG_MODULE, n.detail, n.code);
   if (!load.projectSkipped) {
-    diags.ok("Agent \u89D2\u8272", (lang) => {
+    diags.ok(AGENT_ROLE_DIAG_MODULE, (lang) => {
       const parts = [
         t("agent_roles.tally_builtin", { count: builtinRoles().length }, lang),
         t("agent_roles.tally_user", { count: load.userCount }, lang),
@@ -4955,19 +4762,27 @@ function wireAgentRoles(config, services, registry, diags, hostRoles = []) {
     const unknown = unknownRoleTools(provider, role, BLOCKED_TOOLS);
     if (unknown.length > 0) {
       diags.warn(
-        "Agent \u89D2\u8272",
-        `${role.name} \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684\u5DE5\u5177 ${unknown.join(", ")}\uFF0C\u5DF2\u5FFD\u7565`,
+        AGENT_ROLE_DIAG_MODULE,
+        t("boot.role_unknown_tools", { role: role.name, tools: unknown.join(", ") }),
         "unknown-tool"
       );
     }
     const hitBlocked = blockedRoleTools(role, BLOCKED_TOOLS);
     if (hitBlocked.length > 0) {
       diags.warn(
-        "Agent \u89D2\u8272",
-        `${role.name} \u8981\u4E86 ${hitBlocked.join(", ")}\uFF0C\u4F46\u4EFB\u4F55\u89D2\u8272\u90FD\u62FF\u4E0D\u5230\u8FD9\u4E9B\u5DE5\u5177`,
+        AGENT_ROLE_DIAG_MODULE,
+        t("boot.role_blocked_tools", { role: role.name, tools: hitBlocked.join(", ") }),
         "role-blocked-tool"
       );
     }
+    const unknownSkills = unknownRoleSkills(services.skill?.getNames() ?? [], role);
+    if (unknownSkills.length > 0) {
+      diags.warn(
+        AGENT_ROLE_DIAG_MODULE,
+        t("boot.role_unknown_skills", { role: role.name, skills: unknownSkills.join(", ") }),
+        "unknown-skill"
+      );
+    }
   }
   return { roles, notices };
 }
@@ -4977,7 +4792,9 @@ function pickMainRole(wanted, roles) {
   const role = findRole(roles, name);
   if (role) return role;
   const available = roles.map((r) => r.name).join(", ");
-  throw new AgentRoleError(`\u6CA1\u6709\u540D\u4E3A "${name}" \u7684 agent \u89D2\u8272\u3002\u53EF\u7528\uFF1A${available || "\uFF08\u65E0\uFF09"}`);
+  throw new AgentRoleError(
+    t("boot.role_not_found", { name, available: available || t("boot.role_none") })
+  );
 }
 function makePricingLookup(homeDir) {
   const cache = /* @__PURE__ */ new Map();
@@ -5005,18 +4822,18 @@ function wireBudget(config, modelPricing, diagnostics) {
   );
   const { maxCostUsd, maxTokens } = config.budget ?? {};
   if (maxCostUsd === void 0 && maxTokens === void 0) {
-    diagnostics.skipped("Budget", "\u672A\u914D\u7F6E\u4E0A\u9650\uFF08epoch config set budget.maxCostUsd <\u91D1\u989D> \u5F00\u542F\uFF09");
+    diagnostics.skipped("Budget", t("boot.budget_none"));
   } else {
     const limits = [
-      maxCostUsd !== void 0 ? `\u6210\u672C $${maxCostUsd}` : "",
+      maxCostUsd !== void 0 ? t("boot.budget_cost", { amount: maxCostUsd }) : "",
       maxTokens !== void 0 ? `token ${maxTokens}` : ""
     ].filter(Boolean).join(" / ");
-    diagnostics.ok("Budget", `\u4F1A\u8BDD\u4E0A\u9650 ${limits}`);
+    diagnostics.ok("Budget", t("boot.budget_limits", { limits }));
   }
   if (maxCostUsd !== void 0 && !modelPricing) {
     diagnostics.warn(
       "Budget",
-      `${config.model} \u6CA1\u6709\u5B9A\u4EF7\u6570\u636E\uFF0C\u6210\u672C\u4E0A\u9650\u4E0D\u751F\u6548\uFF08token \u4E0A\u9650\u4ECD\u6709\u6548\uFF09`,
+      t("boot.budget_no_pricing", { model: config.model }),
       "no-pricing-data"
     );
   }
@@ -5024,8 +4841,6 @@ function wireBudget(config, modelPricing, diagnostics) {
     ...config.budget ? { budget: config.budget } : {},
     ...modelPricing ? { modelPricing } : {},
     ...budgetStore ? { budgetStore } : {},
-    // **无条件给**，不看有没有配上限：闸门就算不拦截也要算钱（usage 事件里的
-    // costUsd 有消费方），算错了一样是错的
     pricingOf: makePricingLookup(config.homeDir)
   };
 }
@@ -5037,7 +4852,7 @@ function applyHeadless(permission, config, override, diagnostics, interactive) {
   if (nonInteractive) {
     diagnostics.warn(
       "Headless",
-      `\u975E\u4EA4\u4E92\u73AF\u5883\uFF0C\u9884\u6388\u6743 ${describeHeadlessPolicy(merged)}`,
+      t("boot.headless_preauth", { policy: describeHeadlessPolicy(merged) }),
       "headless-preauthorized"
     );
   }
@@ -5062,16 +4877,17 @@ async function migrateOnce(store, diagnostics, override) {
     envFilePath: envPath(homeDir),
     store,
     names: API_KEY_ENV_VARS,
-    // 只到天：同一天多跑几次不该产生一堆备份文件，真重名时由 migrate.ts 自己让路
     stamp: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10).replace(/-/g, "")
   });
   if (result.warning) diagnostics.warn("Secret", result.warning, "secret-migrate");
   if (result.migrated.length > 0) {
     diagnostics.ok(
       "Secret",
-      // `store.detail` 是「Windows DPAPI（已加密，绑定当前用户账户）」这种整句描述，
-      // 「迁入」和它之间要留一个空格 —— 少了就是「迁入Windows DPAPI」（2026-08-19 实测）
-      `\u5DF2\u628A ${result.migrated.length} \u4E2A key \u8FC1\u5165 ${store.detail}` + (result.backupPath ? `\uFF0C\u539F\u6587\u4EF6\u5907\u4EFD\u4E3A ${result.backupPath}` : "")
+      t("boot.secret_migrated", {
+        count: result.migrated.length,
+        backend: store.detail,
+        backup: result.backupPath ? t("boot.secret_migrated_backup", { path: result.backupPath }) : ""
+      })
     );
   }
 }
@@ -5093,7 +4909,7 @@ async function setupMcpDataKey(store, diagnostics) {
     const why = err instanceof Error ? err.message : String(err);
     diagnostics.warn(
       "Secret",
-      `WARN MCP \u6570\u636E\u5BC6\u94A5\u53D6\u4E0D\u5230\uFF0Cmcp-auth.json \u4ECD\u662F\u660E\u6587\uFF08${why}\uFF09`,
+      t("boot.mcp_key_unavailable", { reason: why }),
       "mcp-key-unavailable"
     );
   }
@@ -5136,19 +4952,25 @@ function buildMemoryControl(memory) {
   return {
     list: () => memory.getAllEntries().map((e) => ({
       content: e.content,
-      // `getAllEntries` 不带 target，而这一层要显示「记在哪一级」。
-      // 拿不到就说 unknown，不猜 —— 猜错会让用户去错的文件里找
       target: e.target ?? "unknown"
     })),
     remove: async (content) => {
       const trimmed = content.trim();
       const hit = memory.getAllEntries().find((e) => e.content.includes(trimmed));
-      if (!hit) return { ok: false, message: `\u6CA1\u6709\u627E\u5230\u5305\u542B\u300C${trimmed}\u300D\u7684\u8BB0\u5FC6` };
+      if (!hit) return { ok: false, message: t("boot.memory_not_found", { query: trimmed }) };
       try {
         await memory.remove("memory", hit.content);
-        return { ok: true, message: `\u5DF2\u5220\u9664\uFF1A${hit.content.slice(0, 60)}` };
+        return {
+          ok: true,
+          message: t("boot.memory_removed", { content: hit.content.slice(0, 60) })
+        };
       } catch (err) {
-        return { ok: false, message: `\u5220\u9664\u5931\u8D25\uFF1A${err instanceof Error ? err.message : err}` };
+        return {
+          ok: false,
+          message: t("boot.memory_remove_failed", {
+            reason: err instanceof Error ? err.message : String(err)
+          })
+        };
       }
     }
   };
@@ -5163,14 +4985,11 @@ function toSessionSummary(meta) {
     messageCount: meta.messageCount,
     model: meta.model,
     costUsd: meta.estimatedCostUsd,
-    // 两格原样转发，这一层**不判也不补**：库里是 NULL 就是 `undefined`
-    // （`rowToMeta()` 在那两格上专门做了 `?? undefined` 的归一，判据写在那儿），
-    // 而「没记过」和「明确不使用」在宿主那一侧是两个组
     workspaceState: meta.workspaceState,
     workspaceRoot: meta.workspaceRoot
   };
 }
-function buildSessionControl(sessions, session, checkpoints, onResumed) {
+function buildSessionControl(sessions, session, checkpoints, homeDir, onResumed) {
   return {
     resume: (sessionId) => {
       const from = session?.sessionId ?? null;
@@ -5178,10 +4997,6 @@ function buildSessionControl(sessions, session, checkpoints, onResumed) {
       onResumed?.(from, sessionId);
       return restored;
     },
-    // ⚠️ `sortKey: 'updatedAt'` 这一行**没改，但含义变了**（会话库 v4）：它以前
-    // 在 `SessionDB.listSessions` 里静默退化成 `started_at`，现在真的按最后活动排。
-    // 于是这个 `limit` 截出来的那批也变了 —— 一段两年前建、今天还在聊的会话
-    // 从此进得了列表，而它以前必然被一批「新建但没说过话」的会话挤掉
     list: (limit = 20) => sessions.list({ limit, sortKey: "updatedAt", direction: "desc" }).sessions.map(toSessionSummary),
     get: (sessionId) => {
       const found = sessions.get(sessionId);
@@ -5201,7 +5016,13 @@ function buildSessionControl(sessions, session, checkpoints, onResumed) {
       } catch {
         checkpointsRemoved = false;
       }
-      return { deleted, checkpointsRemoved };
+      let artifactsRemoved = true;
+      try {
+        await removeSessionArtifacts(sessionId, homeDir);
+      } catch {
+        artifactsRemoved = false;
+      }
+      return { deleted, checkpointsRemoved, artifactsRemoved };
     },
     search: (query, limit = 20) => sessions.search({ query, limit, scope: "all" }).results.flatMap(
       (r) => r.matches.map((m) => ({
@@ -5238,15 +5059,17 @@ function buildPermissionsControl(services, bootstrap, tools) {
     rules: effectiveRules,
     shadows: () => checkShadowing(compileRuleLists(services.config.permissions)),
     level: () => bootstrap?.level() ?? services.config.permission,
-    // 配置里那一档 + 它赢在哪一层（方案 56 §1.3）。**和上面那一格是两个值** ——
-    // 判据在接口上。读 `baseConfig` 是因为 `configOrigins` 记的就是它那一份
-    // （而 `permission` 不在 `SettingsFileSchema` 白名单里，两份在这个键上恒等）
     configured: () => ({
       level: services.baseConfig.permission,
       layer: originOf(services.configOrigins, "permission")
     }),
-    // 权限层起不来 = 什么都没判过，回空账而不是 null（见接口上那段注释）
     audit: (scope) => services.permission?.getAudit(scope) ?? { entries: [], dropped: 0 },
+    approvals: () => services.permission?.listApprovals() ?? [],
+    revokeApproval: (id) => {
+      const perm = services.permission;
+      if (!perm) return { ok: false, reason: "no-permission-layer" };
+      return perm.revokeApproval(id) ? { ok: true } : { ok: false, reason: "unknown-id" };
+    },
     managed: () => {
       const p = services.managedPolicy;
       return {
@@ -5257,9 +5080,6 @@ function buildPermissionsControl(services, bootstrap, tools) {
         bypassDisabled: p.disableBypassPermissionsMode
       };
     },
-    // 三步判定**整个转发**，一行都不在这里重写（判据见上面那个参数的注释）。
-    // 权限层没起来时回 `{ok:true}` 而不是拒绝：那时 `level()` 读的是
-    // `config.permission`，一个纯展示值，改它没有任何意义也没有任何危害
     setLevel: (level) => bootstrap?.setLevel(level) ?? { ok: true },
     gates: (level) => {
       const rules = compileRuleLists(services.config.permissions);
@@ -5283,12 +5103,7 @@ function compressionLine(config, services) {
   const resolved = compressionOptions(config);
   return {
     contextLength: services.contextLength,
-    // `.parse({})` 而不是 `defaultConfig()`：后者的返回类型标注成 `EpochConfig`，
-    // 而那上面 `compression` 是可选的（嵌入宿主手搓那一份走的就是这条），
-    // 于是这个回落自己又需要一个回落。schema 的产出类型上它是必有的（`.prefault({})`）
     threshold: resolved.threshold ?? EpochConfigSchema.parse({}).compression.threshold,
-    // `!== false` 而不是裸真值：判据同 `compressionOptions()` 里那一行 ——
-    // 只有显式的 false 才关得掉，而这一条要写在脸上
     auto: services.contextEngine !== null && resolved.enabled !== false
   };
 }
@@ -5313,11 +5128,6 @@ function buildSettingsControl(services, workspaces, opts) {
       return {
         ...chain,
         overridable,
-        // 「写进去会不会生效」整个判断在 core，这一层只递参数 —— 它必须和
-        // `write()` 里那一次用同一个函数算，否则界面警告和落盘结论会分叉。
-        //
-        // ⚠️ `paths` 和 `trusted` **来自同一个 `scope`**，那是硬约束不是巧合：
-        // 判据在 `SettingsControl` 的文档和 core 的 `config/write.ts` 第四节
         writes: scope.paths === null ? [] : settingWriteTargets({
           winner: chain.layer,
           overridable,
@@ -5409,13 +5219,25 @@ function isSettingValue(value) {
 function maybeValue(key, value) {
   return value === void 0 ? {} : { [key]: value };
 }
+function reportI18nHealth(diagnostics) {
+  void t("i18n.locales_missing");
+  const issues = i18nDiagnostics();
+  if (issues.length === 0) {
+    diagnostics.ok("I18n", "OK");
+    return;
+  }
+  for (const issue of issues) diagnostics.warn("I18n", issue.detail, issue.code);
+}
 var AgentRoleError, SETTING_ROWS;
 var init_build = __esm({
   "src/build.ts"() {
     init_commands();
+    init_events();
     init_host_capabilities();
+    init_host_marketplaces();
     init_host_preset();
     init_model_catalog();
+    init_plugin_control();
     init_plugin_mcp_servers();
     init_role_write();
     init_control();
@@ -5428,7 +5250,10 @@ var init_build = __esm({
     init_telemetry();
     init_tools();
     init_user_shell();
+    init_utility();
+    init_workspace_files();
     init_workspace();
+    init_session_goal();
     AgentRoleError = class extends Error {
       constructor(message) {
         super(message);
@@ -5442,15 +5267,6 @@ var init_build = __esm({
       { key: "fallback.providers" },
       { key: "contextLength" },
       { key: "maxTurns", scalar: "maxTurns" },
-      // 2026-08-16 合并时收的一笔（`web/src/settings/context-memory.tsx` 文件头那张 📮）。
-      // 数组顺序就是界面上的顺序，所以紧挨着 `contextLength` —— 那一块要拿这三行
-      // 算「压缩在多少 token 上开始」，缺一行整块不画。
-      //
-      // ⚠️ **两行都不带 `scalar`**，不是漏了：带 `scalar` 的含义是「这个键在
-      // `SettingsFileSchema` 白名单里、项目级压得回去」，而 `compression.*` 判过
-      // 不进那张白名单（三条判据在 `core/src/config/sources.ts` 文件头）。
-      // 📮 那条还提醒了：顺手写 `scalar: 'compression.enabled'` 编译不过，
-      // `ScalarKey` 是从 `SCALAR_KEYS` 派生的闭集合。那道闸是对的。
       { key: "compression.enabled" },
       { key: "compression.threshold" },
       { key: "budget.maxCostUsd" },
@@ -5460,12 +5276,12 @@ var init_build = __esm({
     ];
   }
 });
-
 // src/index.ts
 init_build();
 init_host_capabilities();
 init_host_preset();
 init_workspace();
+init_workspace_files();
 init_executor();
 init_control();
 init_agent_session();
@@ -5475,11 +5291,12 @@ init_services();
 init_user_shell();
 init_commands();
 init_role_scope();
+init_host_marketplaces();
 init_serialize();
 init_tools();
 init_model_catalog();
+init_utility();
 init_plugin_mcp_servers();
-
 // src/mcp-admin.ts
 init_build();
 init_mcp_config_write();
@@ -5498,7 +5315,7 @@ async function listMcpServers(opts = {}) {
 async function mcpLogin(name, opts = {}) {
   const config = await requireServer(name, opts);
   if (!config.url) {
-    throw new Error(`MCP server "${name}" \u662F stdio \u4F20\u8F93\uFF0C\u672C\u5730\u5B50\u8FDB\u7A0B\u4E0D\u9700\u8981 OAuth \u767B\u5F55`);
+    throw new Error(t("boot.mcp_stdio_no_oauth", { name: `MCP server "${name}` }));
   }
   const result = await loginToMcpServer({
     server: name,
@@ -5522,7 +5339,7 @@ async function probeMcpServer(name, opts = {}) {
     const tools = status?.connected ? await registry.getAllTools() : [];
     return {
       connected: status?.connected ?? false,
-      toolNames: tools.map((t13) => t13.name),
+      toolNames: tools.map((t23) => t23.name),
       ...status?.lastError ? { error: status.lastError } : {},
       needsLogin: status?.needsLogin ?? false
     };
@@ -5535,14 +5352,13 @@ async function requireServer(name, opts) {
   const { servers, configPath: configPath2 } = await listMcpServers(opts);
   const found = servers.find((s) => s.config.name === name);
   if (!found) {
-    const known = servers.map((s) => s.config.name).join(", ") || "(\u7A7A)";
-    throw new Error(`${configPath2} \u91CC\u6CA1\u6709\u540D\u4E3A "${name}" \u7684 MCP server\u3002\u5DF2\u914D\u7F6E\uFF1A${known}`);
+    const known = servers.map((s) => s.config.name).join(", ") || t("boot.mcp_list_empty");
+    throw new Error(t("boot.mcp_no_such_server", { path: configPath2, name, known }));
   }
   return found.config;
 }
-
 // src/index.ts
 init_mcp_config_file();
 init_mcp_config_apply();
 
-export { AgentRoleError, AgentSession, ApprovalRelay, HOST_CAPABILITIES_MODULE, HOST_PRESET_MODULE, QuestionRelay, SCHEDULE_EXIT_CODES, SessionStore, SessionWorkspaces, applyHostPreset, applyMcpConfig, buildModelCatalogControl, buildRuntime, buildServices, collectFileChanges, createScheduleControl, createUserActions, ensureSecretsReady, exitCodeFor, fireSchedule, listMcpServers, mcpConfigRevision, mcpLogin, mcpLogout, probeMcpServer, readMcpConfigFile, registerAskQuestion, registerLocalTools, registerMcpTools, serializeStream, splitDirList, toSerializable, wireCommands, wireHostCapabilities, wirePluginMcpServers, wireWorkspace, withModelScope, withRoleScope, withToolScope, writeMcpConfigFile, writeMcpServer };
+export { AgentRoleError, AgentSession, ApprovalRelay, HOST_CAPABILITIES_MODULE, HOST_MARKETPLACE_MODULE, HOST_PRESET_MODULE, QuestionRelay, SCHEDULE_EXIT_CODES, SessionStore, SessionWorkspaces, applyHostPreset, applyMcpConfig, buildModelCatalogControl, buildRuntime, buildServices, buildWorkspaceFilesControl, collectFileChanges, createScheduleControl, createUserActions, ensureSecretsReady, exitCodeFor, fireSchedule, listMcpServers, mcpConfigRevision, mcpLogin, mcpLogout, probeMcpServer, providerLabel, readMcpConfigFile, registerAskQuestion, registerLocalTools, registerMcpTools, serializeStream, splitDirList, toSerializable, utilityBudgetKey, wireCommands, wireHostCapabilities, wirePluginMcpServers, wireWorkspace, withModelScope, withRoleScope, withToolScope, writeMcpConfigFile, writeMcpServer };