tianshu-harness 3.23.0

package/dist/serve-agent-KHSU6RVV.js

@@ -0,0 +1,965 @@
+#!/usr/bin/env -S node --expose-gc --max-old-space-size=4096
+import { createRequire as __rivetCreateRequire } from 'node:module'; const require = __rivetCreateRequire(import.meta.url);
+import {
+  buildDelegateSummary,
+  forgetSkillLoadErrors,
+  isModelSpecUsable,
+  partitionPluginTools,
+  pluginToolsSnapshot,
+  recordSkillLoadErrors,
+  resolveModelSpecWithReload,
+  resolveServeContext,
+  restoreHistoryMessages,
+  unconfiguredSpecMessage
+} from "./chunk-UTZYPKBF.js";
+import "./chunk-NGEWJ4DF.js";
+import "./chunk-MJQ55WZZ.js";
+import "./chunk-2EBWGAXD.js";
+import "./chunk-ZZAWNALS.js";
+import "./chunk-FHFKPGDO.js";
+import "./chunk-LQQ6XJ2Y.js";
+import {
+  buildCockpitSnapshot
+} from "./chunk-FFQSZJOO.js";
+import {
+  computeUsageCost,
+  findModelPricing
+} from "./chunk-5B2OCU5P.js";
+import "./chunk-ML3UKMH3.js";
+import "./chunk-AEWHC4WM.js";
+import "./chunk-OUWAC7AQ.js";
+import "./chunk-66JPZSGX.js";
+import {
+  FileHistory,
+  captureGitBaseline,
+  createAgentRuntime,
+  createFindReferencesTool,
+  createGotoDefinitionTool,
+  createInteractiveToolRegistry,
+  createMemoryTool,
+  createMultiLspManager,
+  loadProjectRules,
+  memoryBackfillEnabled,
+  resetLegacyMemoryIfNeeded,
+  runMemoryBackfill
+} from "./chunk-AOYHP3WI.js";
+import {
+  DEFAULT_COUNCIL_SEATS,
+  buildCouncilSessionEvent,
+  compileCouncilPlan,
+  persistCouncilRoutingShadow,
+  recordCouncilSession,
+  renderCouncilPlan,
+  runCouncil,
+  runCouncilDebate,
+  summarizeCouncilPlan
+} from "./chunk-4U2ET7ZY.js";
+import "./chunk-JBZHIC6T.js";
+import {
+  attachObligations,
+  extractObligations
+} from "./chunk-KWVTXT5B.js";
+import {
+  createTaskLedger
+} from "./chunk-2XN7PM4N.js";
+import {
+  createOwnershipLedger
+} from "./chunk-SAXK6LVF.js";
+import {
+  createWorktreeBaseline
+} from "./chunk-D2TCGRSX.js";
+import "./chunk-73NJ7IT7.js";
+import {
+  DomainKnowledgeStore
+} from "./chunk-5TQ3JYBU.js";
+import "./chunk-KX22RD6R.js";
+import "./chunk-BXHV3GSB.js";
+import "./chunk-FW3QKMFX.js";
+import "./chunk-WOE3D7JM.js";
+import "./chunk-B3YEBABJ.js";
+import "./chunk-UXXS53EA.js";
+import "./chunk-DWROHPXP.js";
+import "./chunk-ZDIFBJFT.js";
+import "./chunk-D54ZWG4T.js";
+import {
+  sealPlan
+} from "./chunk-R43HJCDX.js";
+import "./chunk-D4PTYFOG.js";
+import {
+  createDelegationActivityMapper
+} from "./chunk-AERM3VGP.js";
+import "./chunk-RK3JHWPT.js";
+import "./chunk-NH6VIOAR.js";
+import "./chunk-S4K4L6IM.js";
+import "./chunk-3VGD2FXB.js";
+import "./chunk-UXNLELW6.js";
+import {
+  deserializeUnifiedPlan,
+  serializeUnifiedPlan
+} from "./chunk-TVHW77C7.js";
+import {
+  SessionContext
+} from "./chunk-424AP7FM.js";
+import "./chunk-JCFWOULR.js";
+import "./chunk-2HKD2UFM.js";
+import "./chunk-5JRZPLI6.js";
+import "./chunk-JRF5L6OD.js";
+import "./chunk-EBJTVRQN.js";
+import "./chunk-J4U4AW46.js";
+import "./chunk-2HDP7RMR.js";
+import {
+  anchorsFromMessages,
+  runGateCompletion
+} from "./chunk-OTNHSAGN.js";
+import "./chunk-DZ6UOJ5D.js";
+import "./chunk-T3ED6BY2.js";
+import "./chunk-RAXBAWRN.js";
+import {
+  scheduleMeridianBackfill
+} from "./chunk-4J5TZGOE.js";
+import "./chunk-BUIMGNDD.js";
+import "./chunk-ZU7JZCVP.js";
+import "./chunk-JSS75KCG.js";
+import "./chunk-EHHUASO5.js";
+import "./chunk-LA6IPTGH.js";
+import "./chunk-HBVF6BWO.js";
+import "./chunk-UHGLFRZE.js";
+import "./chunk-4QJ3Y5JM.js";
+import "./chunk-CGOADM2X.js";
+import "./chunk-ZGGCEXDC.js";
+import "./chunk-ZMZCZNKU.js";
+import "./chunk-Z3QE7TZM.js";
+import "./chunk-GHVMWF2I.js";
+import {
+  MeridianIndexer
+} from "./chunk-J6ESSM47.js";
+import "./chunk-3C3R7JXY.js";
+import {
+  restoreGoalTracker
+} from "./chunk-TI4GSEL5.js";
+import "./chunk-OXMIV4WE.js";
+import "./chunk-4XPFLICE.js";
+import "./chunk-V5YIPMHV.js";
+import "./chunk-ILBCKAV6.js";
+import "./chunk-X2IK5LVR.js";
+import "./chunk-CEZNQVWM.js";
+import "./chunk-O5VZQKCB.js";
+import "./chunk-SEPGEJNK.js";
+import "./chunk-7RDOV3DF.js";
+import "./chunk-6HSVXHCZ.js";
+import "./chunk-RWA23GMM.js";
+import {
+  loadProjectSkills
+} from "./chunk-OHSV42QB.js";
+import "./chunk-ADIVZ2D5.js";
+import "./chunk-7FW3I7WC.js";
+import "./chunk-GD4ZNZ7W.js";
+import "./chunk-ZQKXBUB7.js";
+import "./chunk-Z5Z3JHJY.js";
+import "./chunk-KIOXTQQL.js";
+import "./chunk-35H7GVNR.js";
+import "./chunk-AE3P3F6W.js";
+import "./chunk-JSXWIWWJ.js";
+import "./chunk-BSECIPAQ.js";
+import "./chunk-2E6CK2RC.js";
+import "./chunk-ZO3I3A7O.js";
+import "./chunk-P6GJOVO6.js";
+import "./chunk-TPI73L57.js";
+import "./chunk-HV4YGVMS.js";
+import "./chunk-722LQO64.js";
+import "./chunk-GMKAXSYQ.js";
+import "./chunk-EPKTIOED.js";
+import "./chunk-2VYRLULP.js";
+import {
+  applyConfiguredPathGrants,
+  applyDefaultDependencyReadGrants,
+  applyRivetRuntimeReadGrants,
+  loadPersistedGrants
+} from "./chunk-SUJERP5I.js";
+import "./chunk-CI4R6P2B.js";
+import "./chunk-XU2YXCDL.js";
+import "./chunk-ETHFACAB.js";
+import "./chunk-THKDVSEC.js";
+import "./chunk-UFMN76QD.js";
+import "./chunk-EXUE5W2F.js";
+import {
+  SessionPersist,
+  getSessionDir
+} from "./chunk-LH5VCGLB.js";
+import "./chunk-6S5FPUS7.js";
+import "./chunk-EXXICUIW.js";
+import "./chunk-QARAGUXX.js";
+import {
+  TodoStore
+} from "./chunk-DEBI37QB.js";
+import "./chunk-YJG5HIX5.js";
+import {
+  findProjectConfig,
+  proRegistry
+} from "./chunk-ER5JW2QZ.js";
+import "./chunk-CGFZGR7G.js";
+import "./chunk-P5KJURUR.js";
+import "./chunk-WMUWEO2C.js";
+import "./chunk-BKTQAYO2.js";
+import "./chunk-OO3TAHO5.js";
+import "./chunk-EGEI2RQA.js";
+import "./chunk-ZTRINFM2.js";
+import "./chunk-ZNC5T65N.js";
+import {
+  isProjectTrusted,
+  notifyUntrustedOnce
+} from "./chunk-7KUCBNLB.js";
+import "./chunk-A5MNH4ER.js";
+import "./chunk-BCQXEZPJ.js";
+import {
+  init_esm_shims
+} from "./chunk-5GGOGLSN.js";
+
+// src/server/serve-agent.ts
+init_esm_shims();
+import { join, dirname } from "path";
+import { randomUUID } from "crypto";
+import { readFileSync } from "fs";
+var sparkReviewProfiles = {
+  reviewer: { provider: "deepseek-spark", model: "deepseek-v4-flash" },
+  verifier: { provider: "deepseek-spark", model: "deepseek-v4-flash" },
+  adversarial_verifier: { provider: "deepseek-spark", model: "deepseek-v4-flash" }
+};
+function getOrCreateDomainStore(shared, cwd) {
+  const existing = shared.domainStores.get(cwd);
+  if (existing) return existing;
+  const store = new DomainKnowledgeStore(join(cwd, ".rivet", "knowledge"));
+  shared.domainStores.set(cwd, store);
+  return store;
+}
+function getOrCreateMeridianIndexer(shared, cwd) {
+  const existing = shared.meridianIndexers.get(cwd);
+  if (existing) return existing;
+  const indexer = new MeridianIndexer(cwd);
+  try {
+    resetLegacyMemoryIfNeeded(cwd, {
+      clearMistakeEntries: () => indexer.getDb().clearMistakeEntries()
+    });
+  } catch {
+  }
+  shared.meridianIndexers.set(cwd, indexer);
+  setImmediate(() => {
+    scheduleMeridianBackfill(indexer, cwd, { reason: "startup" });
+  });
+  return indexer;
+}
+function getOrCreateLspEntry(shared, cwd) {
+  const existing = shared.lspManagers.get(cwd);
+  if (existing) return existing;
+  const manager = createMultiLspManager(cwd);
+  const ready = manager.initialize().then(() => manager.isReady()).catch(() => false);
+  const entry = { manager, ready };
+  shared.lspManagers.set(cwd, entry);
+  return entry;
+}
+function attachLspTools(entry, toolRegistry, refs, updateTools) {
+  return entry.ready.then((ok) => {
+    if (!ok) return;
+    toolRegistry.register(createGotoDefinitionTool(entry.manager));
+    toolRegistry.register(createFindReferencesTool(entry.manager));
+    refs.lspManager = entry.manager;
+    updateTools();
+  });
+}
+function disposeSharedCwdResources(shared) {
+  for (const indexer of shared.meridianIndexers.values()) {
+    try {
+      indexer.close();
+    } catch {
+    }
+  }
+  shared.meridianIndexers.clear();
+  for (const entry of shared.lspManagers.values()) {
+    try {
+      entry.manager.dispose();
+    } catch {
+    }
+  }
+  shared.lspManagers.clear();
+}
+var sessionStoresById = /* @__PURE__ */ new Map();
+function resolveGoalHandles(sessionId, config) {
+  const entry = sessionStoresById.get(sessionId);
+  if (!entry) return void 0;
+  return {
+    goalTrackerRef: entry.stores.refs.goalTrackerRef,
+    sessionDir: getSessionDir(entry.cwd),
+    ...config?.workers?.profiles?.cheap ? { cheapProfile: config.workers.profiles.cheap } : {},
+    ...config?.provider?.providers ? { allProviders: config.provider.providers } : {}
+  };
+}
+function forgetSessionStores(sessionId) {
+  sessionStoresById.delete(sessionId);
+  forgetSkillLoadErrors(sessionId);
+}
+function resolveReviewGateRef(sessionId) {
+  return sessionStoresById.get(sessionId)?.stores.refs.reviewGateRef;
+}
+function resolveReviewGate(ctx) {
+  const isSpark = ctx.provider.name === "deepseek-spark";
+  const flag = isSpark ? ctx.config.agent.review.skipAutoSpark : ctx.config.agent.review.skipAuto;
+  return flag ? "off" : "auto";
+}
+function buildSessionStores(ctx, cwd, sessionId, registry, shared) {
+  const persist = new SessionPersist(sessionId, cwd);
+  const claimStore = persist.createClaimStore();
+  persist.injectDurableClaims(claimStore, cwd);
+  for (const rule of loadProjectRules(cwd)) claimStore.propose(rule);
+  loadPersistedGrants(cwd);
+  applyConfiguredPathGrants(ctx.config.agent.permissions);
+  applyDefaultDependencyReadGrants();
+  applyRivetRuntimeReadGrants();
+  const skillLoad = loadProjectSkills(cwd, { importFromClaude: ctx.config.skills?.importFromClaude });
+  recordSkillLoadErrors(sessionId, skillLoad.errors);
+  const fileHistory = new FileHistory(persist.getBackupDir(), sessionId);
+  const session = new SessionContext();
+  const historyRestore = restoreHistoryMessages(persist, session, cwd);
+  const refs = {
+    coordinator: null,
+    fileHistory,
+    claimStore,
+    sessionId,
+    sessionRegistry: registry ?? null,
+    taskLedger: null,
+    ownershipLedger: null,
+    verificationSnapshotManager: null,
+    deliveryGate: null,
+    // Wave G: per-cwd 共享 Meridian——repo_graph/related_tests 惰性读 refs，
+    // 但在 createInteractiveToolRegistry 之前设值（代码清晰）。legacy /prompt
+    // 路径（无 shared）保持 null。
+    meridianIndexer: shared ? getOrCreateMeridianIndexer(shared, cwd) : null,
+    // 对称性回写：sidecar 无功能性消费者（服务器级 MCP 走 SharedRuntime），
+    // 但避免 refs 硬编码 null 造成读到假状态。
+    mcpManager: shared?.mcpManager ?? null,
+    // Wave G: LSP 是异步 init——assembleAgentLoop 在 entry.ready 后回写。
+    lspManager: null,
+    banditState: null,
+    promptEngine: null,
+    // Wave F: 通过 SharedRuntime → RuntimeSessionManager.sameCwdRunningCount
+    // 注入真实计数；shared 缺失或 manager 未就绪退化为 0（保持 TUI 兼容行为）。
+    getSameCwdRunningSessions: shared ? () => shared.sameCwdRunningCount?.(cwd, sessionId) ?? 0 : void 0,
+    goalTrackerRef: { current: null },
+    // 域知识库引用：buildAgentLoop 解析 store（SharedRuntime.domainStores 优先）
+    // 后回写——galaxy 路由学习经此存取。
+    domainKnowledgeStoreRef: { current: null },
+    obligationTrackerRef: { current: null },
+    // 会话级审查门开关：初始值取 review.skipAuto / skipAutoSpark 配置快照。
+    // spark provider 默认开（skipAutoSpark=false），标准 deepseek 默认关（skipAuto=true）。
+    // 用户可在桌面端 Settings 中独立控制两路。RIVET_REVIEW_DISCIPLINE=0 仍全局关闭。
+    reviewGateRef: { current: resolveReviewGate(ctx) },
+    // 插件 hooks/commands：sidecar 暂不加载插件（TUI bootstrap 专属装配链），
+    // 保持空数组与 RuntimeRefs 契约对齐——消费方按空集处理，不影响会话。
+    pluginHooks: [],
+    pluginCommands: [],
+    // 多会话隔离：每会话独立内存态 TodoStore，杜绝并发会话清单串台（提示词注入污染）。
+    // 不做磁盘持久化（按决策），展示与跨重启恢复靠事件日志重放。
+    todoStore: new TodoStore()
+  };
+  const sessionDir = getSessionDir(cwd);
+  try {
+    const restored = restoreGoalTracker(sessionDir, sessionId, { maxJudgeRuns: ctx.config.agent?.goal?.judge?.maxRuns });
+    if (restored) refs.goalTrackerRef.current = restored;
+  } catch {
+  }
+  const { registry: toolRegistry } = createInteractiveToolRegistry(refs, ctx.config, cwd);
+  const pluginSnap = pluginToolsSnapshot();
+  if (pluginSnap) {
+    const { accepted, blocked } = partitionPluginTools(pluginSnap.tools, new Set(toolRegistry.getAllNames()));
+    if (blocked.length > 0) {
+      console.warn(`[plugins] \u4EE5\u4E0B\u63D2\u4EF6\u5DE5\u5177\u4E0E\u5DF2\u88C5\u914D\u5DE5\u5177\u540C\u540D\uFF0C\u5DF2\u8DF3\u8FC7\uFF1A${blocked.join(", ")}`);
+    }
+    for (const tool of accepted) toolRegistry.register(tool);
+    for (const name of pluginSnap.suppressTools) toolRegistry.remove(name);
+    refs.pluginHooks = pluginSnap.hooks;
+    refs.pluginCommands = pluginSnap.commands;
+  }
+  if (ctx.provider.name === "deepseek-spark") {
+    const sparkConfig = ctx.config.agent.review;
+    for (const [profileName, entry] of Object.entries(sparkReviewProfiles)) {
+      if (!sparkConfig.profiles[profileName]) {
+        sparkConfig.profiles[profileName] = entry;
+      }
+    }
+  }
+  const deepRecallAgentRef = {};
+  toolRegistry.register(createMemoryTool(claimStore, {
+    sessionId,
+    getTurn: () => session.getTurnCount(),
+    cwd,
+    deepRecallComplete: async (prompt, timeoutMs) => {
+      const client = deepRecallAgentRef.current?.config.compactClient ?? deepRecallAgentRef.current?.config.primaryClient ?? deepRecallAgentRef.current?.config.client;
+      if (!client) throw new Error("deep recall: no client");
+      return runGateCompletion(client, () => {
+      }, prompt, timeoutMs);
+    },
+    sessionDir,
+    excludeSessionId: sessionId
+  }));
+  const taskLedger = refs.taskLedger ?? createTaskLedger({ taskId: sessionId });
+  const ownershipLedger = refs.ownershipLedger ?? createOwnershipLedger({
+    baseline: createWorktreeBaseline(captureGitBaseline(cwd)),
+    taskLedger
+  });
+  const mcpMgr = shared?.mcpManager;
+  if (mcpMgr) {
+    const mcpTools = mcpMgr.getAllTools();
+    for (const tool of mcpTools) {
+      toolRegistry.register(tool);
+    }
+  }
+  return { persist, claimStore, fileHistory, toolRegistry, session, taskLedger, ownershipLedger, refs, historyRestore, deepRecallAgentRef };
+}
+function resolveSessionBaseConfig(ctx, reload) {
+  return reload ? reload().config : ctx.config;
+}
+function mergeProjectAgentConfig(startupConfig, cwd) {
+  try {
+    const projectPath = findProjectConfig(cwd);
+    if (!projectPath) return startupConfig;
+    if (!isProjectTrusted(dirname(projectPath))) {
+      notifyUntrustedOnce("config", dirname(projectPath));
+      return startupConfig;
+    }
+    const raw = JSON.parse(readFileSync(projectPath, "utf-8"));
+    const agent = raw?.agent;
+    if (!agent || typeof agent !== "object" || Array.isArray(agent)) return startupConfig;
+    const projectAgent = agent;
+    const projectTG = projectAgent.toolGating;
+    const projectToolGating = projectTG && typeof projectTG === "object" && !Array.isArray(projectTG) ? projectTG : void 0;
+    return {
+      ...startupConfig,
+      agent: {
+        ...startupConfig.agent,
+        ...projectAgent,
+        ...projectToolGating ? {
+          toolGating: {
+            ...startupConfig.agent?.toolGating,
+            ...projectToolGating
+          }
+        } : {}
+      }
+    };
+  } catch {
+    return startupConfig;
+  }
+}
+function assembleAgentLoop(ctx, cwd, sessionId, stores, spec, approvalMode, registry, shared, allowedTools, reload) {
+  const domainKnowledgeStore = shared ? getOrCreateDomainStore(shared, cwd) : new DomainKnowledgeStore(join(cwd, ".rivet", "knowledge"));
+  if (stores.refs.domainKnowledgeStoreRef) stores.refs.domainKnowledgeStoreRef.current = domainKnowledgeStore;
+  if (registry) stores.refs.sessionRegistry = registry;
+  const mergedConfig = mergeProjectAgentConfig(resolveSessionBaseConfig(ctx, reload), cwd);
+  const { agent } = createAgentRuntime({
+    provider: spec.provider,
+    apiKey: spec.apiKey,
+    auth: spec.auth,
+    config: mergedConfig,
+    sessionId,
+    cwd,
+    toolRegistry: stores.toolRegistry,
+    persist: stores.persist,
+    claimStore: stores.claimStore,
+    fileHistory: stores.fileHistory,
+    refs: stores.refs,
+    domainKnowledgeStore,
+    modelId: spec.model.id,
+    session: stores.session,
+    // Wave J: 跨 session 复用 ProviderHealthTracker，让 switchModel 不丢
+    // provider 健康累积；coordinator 冷层路由有正确依据。
+    sharedProviderHealth: shared?.providerHealth,
+    // I4: user hook results → desktop event stream via the session manager.
+    emitHookResult: (results, meta) => shared?.sessions?.emitHookResult(sessionId, results, meta),
+    // Per-session 工具白名单（蒸馏回放等自动化场景）。
+    allowedTools
+  });
+  stores.deepRecallAgentRef.current = agent;
+  if (memoryBackfillEnabled()) {
+    const backfillTimer = setTimeout(() => {
+      const client = agent.config.compactClient ?? agent.config.primaryClient ?? agent.config.client;
+      if (!client) return;
+      void runMemoryBackfill({
+        cwd,
+        sessionDir: getSessionDir(cwd),
+        currentSessionId: sessionId,
+        complete: (prompt, timeoutMs) => runGateCompletion(client, () => {
+        }, prompt, timeoutMs)
+      }).catch(() => {
+      });
+    }, 3e4);
+    backfillTimer.unref?.();
+  }
+  if (approvalMode) {
+    agent.setApprovalMode(approvalMode);
+    if (approvalMode === "dangerously-skip-permissions") {
+      agent.config.maxTurns = 0;
+    }
+  }
+  stores.refs.getImpactedTests = () => [...agent.getEvidenceState().impactedTests];
+  if (shared) {
+    void attachLspTools(
+      getOrCreateLspEntry(shared, cwd),
+      stores.toolRegistry,
+      stores.refs,
+      () => agent.updateTools()
+    );
+  }
+  shared?.sessions?.setCoordinatorRef(sessionId, () => stores.refs.coordinator ?? void 0);
+  const priorMessages = stores.session.getMessages();
+  if (priorMessages.length > 0) {
+    const anchorExtractor = proRegistry.getAnchorExtractor(spec.provider.name);
+    if (anchorExtractor) {
+      const anchors = anchorsFromMessages(priorMessages, anchorExtractor, spec.model.id, agent.config.wireContext);
+      if (anchors.length > 0) agent.config.promptEngine.appendExcludedPathAnchors(anchors);
+    }
+  }
+  const goalExtractor = proRegistry.getGoalExtractor(spec.provider.name);
+  if (goalExtractor) {
+    const frozen = stores.persist.loadMetadata()?.goalAnchor;
+    let goalFromHistory = null;
+    if (frozen) {
+      agent.config.promptEngine.setGoalAnchor(frozen);
+    } else if (priorMessages.length > 0) {
+      goalFromHistory = goalExtractor(priorMessages);
+      if (goalFromHistory) {
+        agent.config.promptEngine.setGoalAnchor(goalFromHistory);
+        try {
+          stores.persist.updateMetadata({ goalAnchor: goalFromHistory });
+        } catch {
+        }
+      }
+    }
+    const baseline = frozen ?? goalFromHistory;
+    stores.session.setGoalTracking(
+      (msgs) => goalExtractor(msgs),
+      (next) => {
+        agent.config.promptEngine.setGoalAnchor(next);
+        if (next !== null) {
+          try {
+            stores.persist.updateMetadata({ goalAnchor: next });
+          } catch {
+          }
+        }
+      },
+      baseline
+    );
+  }
+  return agent;
+}
+function specOfContext(ctx) {
+  return {
+    provider: ctx.provider,
+    apiKey: ctx.apiKey,
+    auth: ctx.auth,
+    model: { id: ctx.model.id, maxTokens: ctx.model.maxTokens, contextWindow: ctx.model.contextWindow, reasoningEffort: ctx.model.reasoningEffort, capabilities: ctx.model.capabilities }
+  };
+}
+function resolveInitialSpec(ctx, reload) {
+  if (reload) {
+    try {
+      const fresh = reload();
+      if (fresh.configured) return specOfContext(fresh);
+    } catch {
+    }
+  }
+  if (ctx.configured) return specOfContext(ctx);
+  return specOfContext(resolveServeContext());
+}
+function buildAgentLoop(ctx, cwd, sessionId = randomUUID(), registry, approvalMode, shared, reload) {
+  const stores = buildSessionStores(ctx, cwd, sessionId, registry, shared);
+  const spec = resolveInitialSpec(ctx, reload);
+  const agent = assembleAgentLoop(ctx, cwd, sessionId, stores, spec, approvalMode, registry, shared, void 0, reload);
+  return { agent, sessionId };
+}
+function buildManagedAgent(ctx, cwd, sessionId, registry, approvalMode, shared, reload, preferredModelId, allowedTools) {
+  const stores = buildSessionStores(ctx, cwd, sessionId, registry, shared);
+  sessionStoresById.set(sessionId, { stores, cwd });
+  let spec = (preferredModelId ? reload ? resolveModelSpecWithReload(ctx, preferredModelId, reload) : resolveModelSpecWithReload(ctx, preferredModelId) : null) ?? resolveInitialSpec(ctx, reload);
+  let agent = assembleAgentLoop(ctx, cwd, sessionId, stores, spec, approvalMode, registry, shared, allowedTools, reload);
+  const rebuildOnSpec = (next) => {
+    const oldCoordinator = stores.refs.coordinator;
+    const oldAgent = agent;
+    void oldAgent.cancelIdleCompaction();
+    spec = next;
+    const liveApprovalMode = oldAgent.config.approvalMode;
+    agent = assembleAgentLoop(ctx, cwd, sessionId, stores, spec, liveApprovalMode, registry, shared, allowedTools, reload);
+    if (oldCoordinator && oldCoordinator !== stores.refs.coordinator) {
+      try {
+        oldCoordinator.shutdown();
+      } catch {
+      }
+    }
+    return oldAgent;
+  };
+  return {
+    run: (prompt, callbacks, images) => {
+      if (!isModelSpecUsable(spec)) {
+        const healed = reload ? resolveModelSpecWithReload(ctx, spec.model.id, reload) : null;
+        if (healed && isModelSpecUsable(healed)) {
+          rebuildOnSpec(healed);
+        } else {
+          return Promise.reject(new Error(unconfiguredSpecMessage(spec)));
+        }
+      }
+      return agent.run(prompt, callbacks, images);
+    },
+    abort: () => agent.abort(),
+    setApprovalMode: (mode) => {
+      agent.setApprovalMode(mode);
+      agent.config.maxTurns = mode === "dangerously-skip-permissions" ? 0 : 200;
+    },
+    enterPlanMode: () => agent.enterPlanMode(),
+    exitPlanMode: () => agent.exitPlanMode(),
+    setActivePlan: (plan) => agent.setActivePlan(plan),
+    listArtifacts: () => agent.artifactStore?.list() ?? [],
+    readArtifact: (artifactId) => agent.artifactStore?.readRaw(artifactId) ?? Promise.resolve(null),
+    getMessages: () => agent.session.getMessages(),
+    getHistoryRestore: () => stores.historyRestore,
+    replaceMessages: (msgs) => {
+      agent.session.replaceMessages(msgs);
+      agent.config.promptEngine.resetAppendixBaseline();
+    },
+    rewindToMessages: (msgs) => {
+      agent.session.rewindToMessages(msgs);
+      agent.config.promptEngine.resetAppendixBaseline();
+    },
+    getFileHistory: () => agent.getFileHistory(),
+    // PlusMenu — star domain (delegate to the live agent).
+    setSessionDomain: (domain) => agent.setSessionDomain(domain),
+    resetSessionDomain: () => agent.resetSessionDomain(),
+    restoreAutoResolvedDomain: (domain) => agent.restoreAutoResolvedDomain(domain),
+    getSessionDomain: () => agent.getSessionDomain(),
+    // PlusMenu — skills (per-session discovery filter on the live agent).
+    setDisabledSkills: (names) => agent.setDisabledSkills(names),
+    // PlusMenu — model hot-switch (rebuild on the same SessionContext).
+    // Wave C-followup P0: createAgentRuntime 在 refs 上原地装新 coordinator/
+    // providerHealth/runtimeFactory，但旧 coordinator 的 stallSweep 定时器与
+    // 在途 worker AbortController 仍持有句柄。sidecar 长驻进程 + 频繁
+    // switchModel 会累积泄漏。先 capture old，装新后调 shutdown 释放。
+    // Wave J: 透传 shared 让 switchModel 后仍复用 providerHealth/domainStore，
+    // 健康数据不丢、knowledge 不重 load。
+    switchModel: (modelId) => {
+      const next = resolveModelSpecWithReload(ctx, modelId);
+      if (!next) return null;
+      const oldAgent = rebuildOnSpec(next);
+      let fromModel;
+      try {
+        fromModel = oldAgent.config.promptEngine.getModel();
+      } catch {
+      }
+      const modelRef = spec.keyId ? `${spec.provider.name}:${spec.keyId}:${spec.model.id}` : `${spec.provider.name}:${spec.model.id}`;
+      try {
+        stores.persist.updateMetadata({ model: spec.model.id, provider: spec.provider.name });
+        stores.persist.appendModelSwitch({ from: fromModel, to: spec.model.id, provider: spec.provider.name });
+      } catch {
+      }
+      return modelRef;
+    },
+    // Context usage display (desktop header progress bar) — real occupancy
+    // (last API prompt_tokens + tail estimate), provider-agnostic.
+    getEstimatedTokens: () => agent.session.getRealOccupancy(),
+    getContextWindow: () => spec.model.contextWindow,
+    getReasoningEffort: () => agent.getReasoningEffort(),
+    // 识图桥真实状态（供桌面端准确显示，而非只看 config 有没有 visionModel 键）。
+    // 依赖当前会话模型，故取活 agent 的 config 而非静态 config。
+    getVisionBridge: () => agent.config.visionBridge,
+    // Cockpit snapshot for the desktop cockpit panel. Assembles the full
+    // runtime state (safety/verify/context/model/advisory) via the pure
+    // buildCockpitSnapshot function — same source the TUI uses (main.ts:706).
+    // try/catch: the agent may be mid-rebuild (switchModel) — degrade to null
+    // instead of 500'ing the cockpit poll.
+    getCockpitSnapshot: () => {
+      try {
+        const usage = agent.session.getTotalUsage();
+        const pricing = findModelPricing(ctx.config.provider?.providers, spec.provider.name, spec.model.id);
+        const cost = computeUsageCost(usage, pricing).total;
+        return buildCockpitSnapshot({
+          agent,
+          session: agent.session,
+          model: spec.model.id,
+          cacheHitRate: agent.session.getRecentTurnHitRate(3) ?? agent.session.getCacheHitRate(),
+          cost,
+          mcpManager: shared?.mcpManager ?? null,
+          reasoningEffort: agent.getReasoningEffort()
+          // claimCounts / advisoryStatusNotices omitted — safe degradation
+          // (claimCounts defaults to zero counts, statusNotices to []).
+        });
+      } catch {
+        return null;
+      }
+    },
+    // Wave L: 进程退出释放本 session 的 coordinator timer + in-flight worker
+    // 句柄。abort() 仅中止当前 turn；shutdown() 是终结性操作。
+    shutdown: async () => {
+      try {
+        agent.stopConfigWatcher();
+      } catch {
+      }
+      try {
+        void agent.cancelIdleCompaction();
+      } catch {
+      }
+      try {
+        await agent.drainPostSession(5e3);
+      } catch {
+      }
+      try {
+        await stores.claimStore.flushWrites(2e3);
+      } catch {
+      }
+      const coordinator = stores.refs.coordinator;
+      let settled = !coordinator;
+      try {
+        if (coordinator?.shutdownAndWait) settled = await coordinator.shutdownAndWait();
+        else if (coordinator) {
+          coordinator.shutdown();
+          settled = false;
+        }
+      } catch {
+        settled = false;
+      }
+      shared?.sessions?.clearCoordinatorRef(sessionId);
+      return settled;
+    },
+    // I1: 桌面端议事会入口，直接评审 artifact 中的 council-plan-json。
+    conveneCouncil: (input) => conveneCouncilOnCoordinator(agent, stores.refs.coordinator, stores.refs, input),
+    // 用户主动派后台子代理：独立 AbortSignal，跑在隔离子会话，不碰主历史。
+    delegateWorker: (input, opts) => delegateWorkerOnCoordinator(stores.refs.coordinator, input, opts),
+    // P0-2: plan_task 成功后 onToolResult 通过此方法读取 TodoStore 发 todo_state SSE
+    getTodos: () => stores.refs.todoStore.read(),
+    // Hot-inject MCP tools discovered after this agent was built (mid-session
+    // connector enable). register is Map.set-idempotent; updateTools refreshes
+    // the prompt tool list the same way attachLspTools does for LSP tools.
+    registerExternalTools: (tools) => {
+      for (const tool of tools) {
+        stores.toolRegistry.register(tool);
+      }
+      agent.updateTools();
+    }
+  };
+}
+var CouncilError = class extends Error {
+  constructor(message, statusCode) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "CouncilError";
+  }
+  statusCode;
+};
+async function conveneCouncilOnCoordinator(agent, coordinator, refs, input) {
+  if (agent.isRunning()) {
+    throw new CouncilError("Session is already running a turn", 409);
+  }
+  if (!coordinator) {
+    throw new Error("DelegationCoordinator not initialized");
+  }
+  const raw = await agent.artifactStore?.readRaw(input.artifactId);
+  if (!raw) {
+    throw new CouncilError("Artifact not found", 404);
+  }
+  const planJson = extractCouncilPlanJson(raw);
+  if (!planJson) {
+    throw new CouncilError("Artifact does not contain a valid council-plan-json block", 400);
+  }
+  const draftItems = planJson.tasks.map((t) => ({
+    id: t.id,
+    title: t.title,
+    detail: t.objective,
+    files: t.files
+  }));
+  const seats = input.seats && input.seats.length > 0 ? input.seats.map((s) => ({ authority: s.authority, ...s.charter ? { charter: s.charter } : {} })) : [...DEFAULT_COUNCIL_SEATS];
+  const abortController = new AbortController();
+  const councilInput = {
+    draft: { objective: input.objective ?? planJson.objective, items: draftItems },
+    seats,
+    abortSignal: abortController.signal,
+    ...typeof input.rounds === "number" ? { maxRounds: input.rounds } : {}
+  };
+  const now = Date.now();
+  const deps = {
+    delegateBatch: async (requests, policy, signal, onProgress) => {
+      const delegationReqs = requests.map((r) => ({
+        parentTurnId: r.parentTurnId,
+        objective: r.objective,
+        kind: r.kind,
+        profile: r.profile,
+        scope: r.scope,
+        // 席位路由字段透传：曾在此处丢弃，桌面路由的异构席/瑶光门失效。
+        authority: r.authority,
+        ...r.modelOverride ? { modelOverride: r.modelOverride } : {},
+        ...r.tierFloor ? { tierFloor: r.tierFloor } : {}
+      }));
+      const run = await coordinator.delegateBatch(
+        delegationReqs,
+        policy,
+        signal,
+        onProgress
+      );
+      return { results: run.results, workerModels: run.workerModels };
+    },
+    now: () => now,
+    sessionId: refs.sessionId ?? "unknown",
+    recordRoutingShadow: (event) => persistCouncilRoutingShadow(refs.meridianIndexer?.getDb(), event)
+  };
+  const runner = councilInput.maxRounds && councilInput.maxRounds >= 2 ? runCouncilDebate : runCouncil;
+  const plan = await runner(councilInput, deps);
+  const planMarkdown = renderCouncilPlan(plan);
+  const compiled = plan.aggregate.mergedItems.length > 0 ? compileCouncilPlan(plan) : void 0;
+  const sealed = compiled?.ok && compiled.plan ? sealPlan(attachObligations(compiled.plan, extractObligations(plan))) : void 0;
+  const outputRaw = sealed ? [planMarkdown, "", "```council-plan-json", serializeUnifiedPlan(sealed), "```"].join("\n") : compiled && !compiled.ok ? [planMarkdown, "", "## \u26D4 \u8BAE\u4E8B\u4F1A\u5426\u51B3\uFF08blocking challenge \u672A\u5316\u89E3\uFF09", ...compiled.vetoes.map((v) => `- ${v.description}: ${v.left}`)].join("\n") : planMarkdown;
+  const savedArtifactId = await agent.artifactStore?.save({
+    tool: "council_convene",
+    target: `council:${plan.meta.objectiveHash}`,
+    rawContent: outputRaw,
+    summary: summarizeCouncilPlan(plan),
+    sections: []
+  });
+  try {
+    recordCouncilSession(refs.meridianIndexer?.getDb(), buildCouncilSessionEvent({
+      sessionId: refs.sessionId ?? "unknown",
+      plan,
+      timestamp: Date.now()
+    }));
+  } catch {
+  }
+  if (!savedArtifactId) {
+    throw new Error("Failed to save council plan artifact");
+  }
+  const councilPanel = {
+    schemaVersion: 1,
+    objective: plan.objective,
+    seats: plan.contributions.map((c) => ({
+      authority: c.authority,
+      status: "passed",
+      round: c.round ?? 1,
+      modelUsed: c.modelUsed
+    })),
+    verdict: {
+      accepted: plan.aggregate.decisions.filter((d) => d.verdict === "accepted").length,
+      rejected: plan.aggregate.decisions.filter((d) => d.verdict === "rejected").length,
+      deferred: plan.aggregate.decisions.filter((d) => d.verdict === "deferred").length,
+      conflicts: plan.aggregate.conflicts.length
+    },
+    sealVersion: sealed?.seal?.version,
+    pillarsMode: false,
+    failedSeats: plan.meta.failedSeats,
+    qliphothCount: plan.meta.qliphoth?.length
+  };
+  return { planMarkdown, artifactId: savedArtifactId, councilPanel };
+}
+function extractCouncilPlanJson(raw) {
+  const match = raw.match(/```council-plan-json\n([\s\S]*?)\n```/);
+  if (!match) return null;
+  return deserializeUnifiedPlan(match[1]);
+}
+function kindForProfile(profile) {
+  switch (profile) {
+    case "patcher":
+      return "patch_proposal";
+    case "reviewer":
+      return "review";
+    case "verifier":
+    case "adversarial_verifier":
+      return "verify";
+    case "planner":
+    case "perspective_planner":
+      return "plan";
+    case "doc_scout":
+      return "doc_research";
+    default:
+      return "code_search";
+  }
+}
+async function delegateWorkerOnCoordinator(coordinator, input, opts) {
+  if (!coordinator) throw new Error("DelegationCoordinator not initialized");
+  const profile = input.profile && input.profile.trim() ? input.profile.trim() : "code_scout";
+  const activityMapper = createDelegationActivityMapper(opts.workerId, (a) => {
+    opts.onActivity({
+      workOrderId: opts.workerId,
+      parentToolId: a.parentToolId,
+      ...a.dispatchId ? { dispatchId: a.dispatchId } : {},
+      ...a.attemptId ? { attemptId: a.attemptId } : {},
+      ...a.parentAttemptId ? { parentAttemptId: a.parentAttemptId } : {},
+      profile: a.profile ?? profile,
+      authority: a.authority,
+      status: a.status,
+      progressLine: a.progressLine,
+      toolUseCount: a.toolUseCount,
+      tokenCount: a.tokenCount,
+      eventKind: a.eventKind,
+      eventDetail: a.eventDetail,
+      contract: a.contract
+    });
+  });
+  const request = {
+    // Use the manager-owned workerId as the stable node key (parentTurnId derives
+    // the work order id), so every activity update merges into the same panel node.
+    parentTurnId: opts.workerId,
+    objective: input.objective,
+    kind: kindForProfile(profile),
+    profile,
+    scope: input.files && input.files.length ? { files: input.files } : {},
+    delegationDepth: 0,
+    // Reuse the shared mapper so user-dispatched workers get the same live
+    // counters (toolUseCount/tokenCount) and eventKind/eventDetail passthrough
+    // as agent-initiated delegations.
+    onActivity: activityMapper
+  };
+  if (input.authority) request.authority = input.authority;
+  if (input.resume) request.resumeWorkOrderId = input.resume;
+  try {
+    const run = await coordinator.delegate(request, opts.signal);
+    const result = run.results[0];
+    if (result) {
+      const identity = result;
+      const terminal = {
+        workOrderId: result.workOrderId,
+        parentToolId: opts.workerId,
+        ...identity.dispatchId ? { dispatchId: identity.dispatchId } : {},
+        ...identity.attemptId ? { attemptId: identity.attemptId } : {},
+        ...identity.parentAttemptId ? { parentAttemptId: identity.parentAttemptId } : {},
+        profile,
+        status: result.status === "passed" ? "completed" : result.status,
+        progressLine: result.summary ? result.summary.slice(0, 120) : void 0,
+        failureReason: result.failureReason,
+        summary: buildDelegateSummary(input, run),
+        changedFiles: result.changedFiles.length > 0 ? result.changedFiles : void 0,
+        artifactId: result.diffArtifactId,
+        model: run.selectedModel ?? result.model,
+        provider: result.provider,
+        usage: result.usage,
+        // 终态证据摘要（与 delegate_task 的 emitTerminal 对齐）。
+        findingsCount: result.findings.length > 0 ? result.findings.length : void 0,
+        topFinding: result.findings[0]?.claim,
+        verificationBrief: result.verification ? { status: result.verification.status, passed: result.verification.passed, failed: result.verification.failed } : void 0,
+        evidenceStatus: result.evidenceStatus
+      };
+      activityMapper.finish(terminal);
+    } else {
+      activityMapper.finish({
+        workOrderId: opts.workerId,
+        parentToolId: opts.workerId,
+        profile,
+        status: run.status === "skipped" ? "blocked" : "completed",
+        summary: buildDelegateSummary(input, run)
+      });
+    }
+  } finally {
+    activityMapper.dispose();
+  }
+}
+export {
+  attachLspTools,
+  buildAgentLoop,
+  buildManagedAgent,
+  disposeSharedCwdResources,
+  forgetSessionStores,
+  getOrCreateMeridianIndexer,
+  mergeProjectAgentConfig,
+  resolveGoalHandles,
+  resolveReviewGateRef,
+  resolveSessionBaseConfig
+};