aims-workstation 0.0.0-stage → 0.1.0

package/server.js

@@ -0,0 +1,2066 @@
+// AIMS 工作站（aims-workstation）
+// 链路: ARM员工库 → 下载物化本地 → 平台实例化(pi-ai + 工具注入 + 分级自主) → 工作台(DSL) → 经验回流ARM
+// Agent 层基于 @earendil-works/pi-ai（统一 LLM API），前端为 web/ 预构建的 shadcn/ui 应用（web/dist）
+'use strict';
+const http = require('http');
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const os = require('os');
+
+// ── Node 版本门槛（node:sqlite 为实验特性，需 ≥22.5）──
+(function checkNode() {
+  const [maj, min] = process.versions.node.split('.').map(Number);
+  if (maj < 22 || (maj === 22 && min < 5)) {
+    console.error(`[aims-workstation] 需要 Node ≥ 22.5（当前 ${process.versions.node}，node:sqlite 实验特性依赖）。请升级后重试。`);
+    process.exit(1);
+  }
+})();
+
+// ── 代码与数据分离：包目录只放代码与只读资产；全部运行时状态在 AIMS_HOME（缺省 ~/.aims-workstation）──
+const PKG_ROOT = __dirname;
+const AIMS_HOME = process.env.AIMS_HOME ? path.resolve(process.env.AIMS_HOME) : path.join(os.homedir(), '.aims-workstation');
+const moveIn = (from, to) => { // 首次升级迁移：包目录旁的旧运行时目录整体挪进 AIMS_HOME（跨卷降级为复制）
+  if (fs.existsSync(from) && !fs.existsSync(to)) {
+    try { fs.renameSync(from, to); }
+    catch { fs.cpSync(from, to, { recursive: true }); try { fs.rmSync(from, { recursive: true, force: true }); } catch { } }
+  }
+};
+(function ensureHome() {
+  const rels = ['data', 'arm-agents', 'workspace', 'config/deployments', 'config/workbenches', 'config/workbench-versions', 'config/panels', 'config/collections'];
+  for (const rel of rels) {
+    const to = path.join(AIMS_HOME, rel);
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    moveIn(path.join(PKG_ROOT, rel), to);
+    fs.mkdirSync(to, { recursive: true });
+  }
+  for (const f of ['config/platform.json', '.env']) moveIn(path.join(PKG_ROOT, f), path.join(AIMS_HOME, f));
+  // 工作区登记表存绝对路径：随迁移改写（旧包内路径 → AIMS_HOME；外部自定义目录不动）
+  const wsRegDir = path.join(AIMS_HOME, 'workspace');
+  if (fs.existsSync(wsRegDir)) {
+    const oldP = PKG_ROOT + path.sep + 'workspace' + path.sep, newP = AIMS_HOME + path.sep + 'workspace' + path.sep;
+    for (const agent of fs.readdirSync(wsRegDir)) {
+      const reg = path.join(wsRegDir, agent, 'registry.json');
+      try {
+        const s = fs.readFileSync(reg, 'utf8');
+        if (s.includes(oldP)) fs.writeFileSync(reg, s.split(oldP).join(newP));
+      } catch { }
+    }
+  }
+  // 种子资产：系统范本插件（存在即跳过——用户改动优先于包内版本）
+  const seedDir = path.join(PKG_ROOT, 'seed/panels');
+  if (fs.existsSync(seedDir)) {
+    for (const f of fs.readdirSync(seedDir).filter((x) => x.endsWith('.json'))) {
+      const to = path.join(AIMS_HOME, 'config/panels', f);
+      if (!fs.existsSync(to)) { try { fs.copyFileSync(path.join(seedDir, f), to); } catch { } }
+    }
+  }
+})();
+
+const ROOT = PKG_ROOT; // 兼容只读资产引用（web/dist、skills、scripts）；运行时状态一律用 AIMS_HOME 子目录
+// ── 配置（.env 可选：先包目录（开发仓），再 AIMS_HOME；npm 安装后仅靠系统设置页即可）──
+const env = {};
+for (const envFile of [path.join(PKG_ROOT, '.env'), path.join(AIMS_HOME, '.env')]) {
+  try {
+    for (const line of fs.readFileSync(envFile, 'utf8').split('\n')) {
+      const m = line.match(/^\s*([A-Z_]+)\s*=\s*(.*)\s*$/);
+      if (m && env[m[1]] === undefined) env[m[1]] = m[2];
+    }
+  } catch { /* .env 可选 */ }
+}
+const PORT = +(process.env.PORT || env.PORT || 5600);
+const HOST = process.env.AIMS_HOST || '127.0.0.1'; // 本机工具默认只绑回环（exec/目录浏览/面板动作不宜暴露局域网）
+const ARM_MCP_URL = process.env.ARM_MCP_URL || env.ARM_MCP_URL;
+// ── 运行时配置（ARM 源与 LLM 均可私有化部署：在「系统设置」页切换，存 AIMS_HOME/config/platform.json，优先级 运行时 > 环境变量 > .env）──
+const CFG_FILE = path.join(AIMS_HOME, 'config/platform.json');
+const cfg = { arm_api_base: '', arm_mcp_url: '', arm_token: '', llm_base_url: '', llm_api_key: '', llm_model: '', scene_profile: '' };
+function loadCfg() { try { Object.assign(cfg, JSON.parse(fs.readFileSync(CFG_FILE, 'utf8'))); } catch { } }
+loadCfg();
+function saveCfg() { fs.writeFileSync(CFG_FILE, JSON.stringify(cfg, null, 2)); }
+// 站点地址：运行时配置 > ARM_API_BASE(env) > 从 MCP URL 推导；MCP 端点：显式配置 > 跟随站点地址 > env
+const armApiBase = () => cfg.arm_api_base || process.env.ARM_API_BASE || env.ARM_API_BASE || String(env.ARM_MCP_URL || '').replace(/\/api\/mcp$/, '');
+const armMcpUrl = () => cfg.arm_mcp_url || (cfg.arm_api_base ? `${cfg.arm_api_base}/api/mcp` : ARM_MCP_URL);
+const armApiToken = () => cfg.arm_token || env.ARM_API_TOKEN || ARM_PAT;
+// LLM：OpenAI 兼容端点（baseUrl/模型/密钥），缺省智谱 coding plan
+const LLM_DEFAULT_BASE = 'https://open.bigmodel.cn/api/coding/paas/v4';
+const llmBaseUrl = () => cfg.llm_base_url || env.LLM_BASE_URL || LLM_DEFAULT_BASE;
+const llmApiKey = () => cfg.llm_api_key || env.LLM_API_KEY || '';
+const llmModelName = () => cfg.llm_model || env.LLM_MODEL || 'glm-5.3';
+// 场景画像：平台级、全局一份的用户场景描述（团队环境/系统清单/规范），注入所有助手；空则不注入。
+// 与知识检索互补（常驻事实 vs 按需检索）；凭据不进画像（放"凭据在哪、找谁要"）。
+const sceneProfile = () => String(cfg.scene_profile || '').trim();
+const SCENE_PROFILE_MAX = 4000;
+let ARM_PAT = env.ARM_PAT || '';
+if (!ARM_PAT) {
+  try { ARM_PAT = JSON.parse(fs.readFileSync(path.join(process.env.HOME, '.arm/config.json'), 'utf8')).token || ''; }
+  catch { /* 经验写入不可用 */ }
+}
+const DATA_DIR = path.join(AIMS_HOME, 'data');
+const DEPLOY_DIR = path.join(AIMS_HOME, 'config/deployments');
+const WB_DIR = path.join(AIMS_HOME, 'config/workbenches');
+const WB_VER_DIR = path.join(AIMS_HOME, 'config/workbench-versions');
+const ARM_AGENTS_DIR = path.join(AIMS_HOME, 'arm-agents'); // 本地助手库（07 设计：下载物化档案快照，离线可用）
+const WS_ROOT = path.join(AIMS_HOME, 'workspace');         // 工作区根目录（默认工作区在此动态新增）
+for (const d of [DATA_DIR, DEPLOY_DIR, WB_DIR, WB_VER_DIR, ARM_AGENTS_DIR, WS_ROOT]) fs.mkdirSync(d, { recursive: true });
+const AUDIT_LOG = path.join(DATA_DIR, 'audit.log');
+const METRICS_LOG = path.join(DATA_DIR, 'metrics.log');
+
+// ── pi-ai（Agent 层）─────────────────────────────────────
+let models, model, llmCatalog = [];
+async function applyLLMConfig() { // 可重复执行：设置页保存后热切换（在途请求沿用旧 model 引用，安全）
+  const { createModels, createProvider } = await import('@earendil-works/pi-ai/models');
+  const { zaiCodingCnProvider } = await import('@earendil-works/pi-ai/providers/zai-coding-cn');
+  const { openAICompletionsApi } = await import('@earendil-works/pi-ai/api/openai-completions.lazy'); // exports 通配符自动补 .js
+  const base = llmBaseUrl(), key = llmApiKey(), name = llmModelName();
+  // 官方模型条目为模板（compat/thinkingLevelMap 等字段不自行猜测）；任意模型名按 glm-5.3 克隆；条目 baseUrl 一并改写
+  const entries = zaiCodingCnProvider().getModels().map((m) => ({ ...m, provider: 'platform-llm', baseUrl: base }));
+  if (!entries.some((m) => m.id === name)) {
+    const tpl = entries.find((m) => m.id === 'glm-5.3') || entries[0];
+    entries.push({ ...tpl, id: name, name });
+  }
+  llmCatalog = [...new Set([...zaiCodingCnProvider().getModels().map((m) => m.id), name])];
+  const provider = createProvider({
+    id: 'platform-llm', name: 'Platform LLM（OpenAI 兼容）', baseUrl: base,
+    // 注意 pi-ai 的 auth 输入是包装结构 { apiKey: <ApiKeyAuth> }；凭证级 baseUrl 覆盖模型条目默认值
+    auth: { apiKey: { name: '平台设置 API Key', resolve: async () => (key ? { auth: { apiKey: key, baseUrl: base }, source: 'platform-config' } : undefined) } },
+    models: entries, api: openAICompletionsApi(),
+  });
+  models = createModels();
+  models.setProvider(provider);
+  model = models.getModel('platform-llm', name);
+  if (!model) throw new Error(`模型不可用: ${name}`);
+}
+async function llmProbe() { // 设置页「保存并测试」：一次极小补全验证连通性（pi-ai 把认证/请求失败表现为 stopReason=error 而非异常，须显式判定）
+  const t0 = Date.now();
+  const r = await Promise.race([
+    models.complete(model, { systemPrompt: '你是连通性探针，只回复 ok', messages: [{ role: 'user', content: 'ping', timestamp: Date.now() }], tools: [] }),
+    new Promise((_, rej) => setTimeout(() => rej(new Error('探针超时（20s）——模型或端点无响应')), 20000)),
+  ]);
+  const text = (r.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+  if (r.stopReason === 'error' || (!text && r.stopReason !== 'stop')) {
+    return { online: false, error: `模型服务拒绝或无响应（stop=${r.stopReason}${r.error ? '，' + JSON.stringify(r.error).slice(0, 100) : ''}）——请检查密钥/端点/模型名` };
+  }
+  return { online: true, latency_ms: Date.now() - t0, reply: (text || `stop=${r.stopReason}`).slice(0, 40) };
+}
+async function llmComplete(systemPrompt, userText) { // 无工具的一次性调用（起草/摘要）
+  const r = await models.complete(model, { systemPrompt, messages: [{ role: 'user', content: userText, timestamp: Date.now() }], tools: [] });
+  return (r.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+}
+
+// ── 现场数据容器：真实数据源（AIMS-MOS）未接入前保持为空——面板按空态渲染，不造假数据
+//（2026-10-15 MVP 打磨：移除模拟立库场景与工厂画像注入，见 README）
+const world = { devices: [], alarms: [], kpi: {}, work_orders: [], inspections: {} };
+
+// ── 审计与指标（自进化飞轮的数据原料）──────────────────
+function audit(entry) { entry.ts = new Date().toISOString(); fs.appendFileSync(AUDIT_LOG, JSON.stringify(entry) + '\n'); }
+function metric(entry) { entry.ts = new Date().toISOString(); fs.appendFileSync(METRICS_LOG, JSON.stringify(entry) + '\n'); }
+
+// ── ARM MCP 客户端（调用链 + 回流链）─────────────────────
+async function mcpCall(name, args, { pat = false, timeout_ms = 20000 } = {}) {
+  const headers = { 'Content-Type': 'application/json', 'Accept': 'application/json, text/event-stream' };
+  if (pat && ARM_PAT) headers['Authorization'] = `Bearer ${ARM_PAT}`;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeout_ms); // 离线快速失败（降级本地库）
+  let data;
+  try {
+    const res = await fetch(armMcpUrl(), {
+      method: 'POST', headers, signal: ctrl.signal,
+      body: JSON.stringify({ jsonrpc: '2.0', id: crypto.randomUUID(), method: 'tools/call', params: { name, arguments: args } }),
+    });
+    data = await res.json();
+  } finally { clearTimeout(timer); }
+  if (data.error) throw new Error(`ARM MCP ${name}: ${data.error.message}`);
+  if ((data.result || {}).isError) throw new Error(`ARM MCP ${name} 拒绝: ${((data.result).content || []).map(c => c.text).join('').slice(0, 150)}`);
+  return ((data.result || {}).content || []).map(c => c.text || '').join('\n');
+}
+
+// ARM REST 客户端（v2 开发版结构化通道；{ ok, data, msg } 包络，ok=false 抛错）
+async function armRest(pathname, init = {}, timeout_ms = 20000) {
+  const headers = { 'Content-Type': 'application/json', ...(init.headers || {}) };
+  const token = armApiToken();
+  if (token) headers.Authorization = `Bearer ${token}`;
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeout_ms);
+  try {
+    const res = await fetch(armApiBase() + pathname, { ...init, headers, signal: ctrl.signal });
+    const data = await res.json();
+    if (!res.ok || data.ok === false) throw new Error(`ARM REST ${pathname.split('?')[0]}: ${data.msg || res.status}`);
+    return data.data;
+  } finally { clearTimeout(timer); }
+}
+const vVer = (v) => (String(v || '').startsWith('v') ? String(v) : `v${v || '0.0.0'}`); // REST 无 v 前缀，统一内部表示
+
+const agentCache = new Map();
+async function getArmAgent(agentId) {
+  const lm = localManifest(agentId); // 本地档案优先（07 设计：实例化不依赖 ARM 在线）
+  if (lm) return { name: lm.name, version: lm.version, prompt: lm.prompt, knowledges: (lm.knowledges || []).map(k => k.ref) };
+  const hit = agentCache.get(agentId);
+  if (hit && Date.now() - hit.at < 5 * 60_000) return hit.data;
+  const text = await mcpCall('get_agent', { id: agentId });
+  const name = (text.match(/^#\s+(.+?)\s+\(/m) || [])[1] || agentId;
+  const version = (text.match(/^#\s+.+?\s+\((v[\d.]+)\)/m) || [])[1] || '';
+  const prompt = (text.match(/## Prompt\n([\s\S]*?)(\n## |\n*$)/) || [])[1]?.trim() || '';
+  const knowledges = [...text.matchAll(/^- (.+?) v[\d.]+（(\w+)）/gm)].map(m => m[1]);
+  const data = { name, version, prompt, knowledges };
+  agentCache.set(agentId, { data, at: Date.now() });
+  return data;
+}
+
+// search_agents 目录解析（大厅/同步共用）
+function parseAgentCards(raw) {
+  const cards = [];
+  for (const block of raw.split(/\n(?=## )/)) {
+    const m = block.match(/^## (.+?) \((v[\d.]+)\)\nID: ([0-9a-f-]{36})/);
+    if (!m) continue;
+    const bind = block.match(/绑定：(\d+) Skill \/ (\d+) Knowledge/);
+    const desc = (block.split('\n').filter(l => l && !l.startsWith('#') && !l.startsWith('ID:') && !l.startsWith('绑定'))[0] || '').trim();
+    cards.push({ name: m[1], version: m[2], agent_id: m[3], skills: +(bind?.[1] || 0), knowledges: +(bind?.[2] || 0), description: desc.slice(0, 120) });
+  }
+  return cards;
+}
+
+// 助手目录：REST 分页结构化优先（可全量），旧版 ARM 回落 MCP markdown 解析（limit 上限 20）
+async function armListAgents(keyword = '') {
+  const out = [];
+  for (let page = 1; page <= 5; page++) {
+    const d = await armRest(`/api/v1/agents?keyword=${encodeURIComponent(keyword)}&page=${page}&pageSize=50`);
+    out.push(...(d.agents || []));
+    if (!out.length || out.length >= +(d.total || 0)) break;
+  }
+  return out.map(a => ({ agent_id: a.id, name: a.name, version: vVer(a.version), skills: a.skillsCount || 0, knowledges: a.knowledgesCount || 0, description: String(a.description || '').slice(0, 120), status: a.status || 'active' }));
+}
+
+// 知识检索（全局经验库）：REST 混合检索（RAG 语义 ⊕ 关键词）优先，回落 MCP RAG
+async function searchKnowledgeItems(query, topK = 5) {
+  try {
+    const d = await armRest('/api/v1/knowledges/search', { method: 'POST', body: JSON.stringify({ query, topK }) });
+    return {
+      via: `rest:${d.mode || 'hybrid'}${d.degraded ? ':degraded' : ''}`,
+      items: (d.items || []).map(it => ({ title: it.name, similarity: it.score != null ? Math.round(it.score * 100) : null, snippet: String(it.snippet || '').slice(0, 320), id: it.knowledgeId })),
+    };
+  } catch {
+    const text = await mcpCall('search_knowledges', { query, limit: topK });
+    const items = text.split(/\n(?=## )/).filter(Boolean).map(b => {
+      const title = (b.match(/^## (.+?)(?:（相似度 (\d+)%）)?/) || [])[1] || b.slice(0, 40);
+      return { title: title.trim(), similarity: +((b.match(/相似度 (\d+)%/) || [])[1] || 0) || null, snippet: b.replace(/^## .*\n?/, '').split('[完整内容')[0].slice(0, 320) };
+    });
+    return { via: 'mcp', items };
+  }
+}
+
+// ── 本地助手库（07-助手本地化：下载物化 → 离线可用；按版本目录存档，升级原子切指针）──
+const armSourceTag = (base) => { try { return `arm://${new URL(base).host}`; } catch { return 'arm://unknown'; } };
+const regFile = () => path.join(ARM_AGENTS_DIR, 'registry.json');
+function loadRegistry() {
+  try { return JSON.parse(fs.readFileSync(regFile(), 'utf8')); } catch { return { agents: [], last_sync_at: null }; }
+}
+function saveRegistry(reg) { fs.writeFileSync(regFile(), JSON.stringify(reg, null, 2)); }
+function localAgent(agentId) { return loadRegistry().agents.find(a => a.agent_id === agentId) || null; }
+function localManifest(agentId, version) { // 缺省取当前安装版本
+  const e = localAgent(agentId);
+  const ver = version || e?.installed_version;
+  if (!ver) return null;
+  try { return JSON.parse(fs.readFileSync(path.join(ARM_AGENTS_DIR, agentId, 'versions', ver, 'manifest.json'), 'utf8')); } catch { return null; }
+}
+function agentProfileNow(agentId) { // 同步取档案：本地优先，退回内存缓存（工程师上下文/经验回流用）
+  const m = localManifest(agentId);
+  if (m) return { name: m.name, version: m.version, prompt: m.prompt, knowledges: (m.knowledges || []).map(k => k.ref) };
+  return agentCache.get(agentId)?.data || {};
+}
+function cmpVersion(a, b) { // 'v1.10.0' vs 'v1.9.3' 语义化比较
+  const pa = String(a || '').replace(/^v/, '').split('.').map(n => +n || 0);
+  const pb = String(b || '').replace(/^v/, '').split('.').map(n => +n || 0);
+  for (let i = 0; i < 3; i++) if ((pa[i] || 0) !== (pb[i] || 0)) return (pa[i] || 0) - (pb[i] || 0);
+  return 0;
+}
+const slug = (s) => String(s).trim().replace(/[\\/:*?"<>|\s]+/g, '-').slice(0, 60) || 'knowledge';
+
+// 下载物化：REST 主路径（结构化详情 + knowledgeId 直取全文），旧版 ARM 回落 MCP 解析
+async function downloadAgent(agentId) {
+  try { return await downloadAgentRest(agentId); }
+  catch { return await downloadAgentMcp(agentId); }
+}
+
+// 注册表提交（两路下载共用）：写版本目录后原子切指针
+function commitDownload(manifest) {
+  const reg = loadRegistry();
+  let e = reg.agents.find(a => a.agent_id === manifest.agent_id);
+  if (!e) { e = { agent_id: manifest.agent_id, name: manifest.name, installed_version: manifest.version, versions: [], origin: manifest.source, status: 'active', downloaded_at: manifest.downloaded_at }; reg.agents.push(e); }
+  e.name = manifest.name; e.description = manifest.description || ''; e.installed_version = manifest.version; e.last_sync_at = manifest.downloaded_at; e.delisted = false;
+  if (!e.versions.includes(manifest.version)) e.versions.push(manifest.version);
+  e.versions.sort(cmpVersion);
+  saveRegistry(reg);
+}
+
+async function downloadAgentRest(agentId) {
+  const d = await armRest(`/api/v1/agents/${agentId}`);
+  const version = vVer(d.version);
+  const verDir = path.join(ARM_AGENTS_DIR, agentId, 'versions', version);
+  fs.mkdirSync(path.join(verDir, 'knowledges'), { recursive: true });
+  const knowledges = [];
+  for (const kb of d.knowledges || []) { // 详情直接携带 knowledgeId——无需按名检索定位
+    let file = null, note = '';
+    const kid = kb.knowledgeId || (kb.knowledge && kb.knowledge.id);
+    const name = (kb.knowledge && kb.knowledge.name) || kid;
+    try {
+      const k = await armRest(`/api/v1/knowledges/${kid}`);
+      file = `knowledges/${slug(k.name || name)}.md`;
+      fs.writeFileSync(path.join(verDir, file), k.content || '');
+    } catch (e) { note = `知识拉取失败: ${String(e.message).slice(0, 80)}`; }
+    knowledges.push({ ref: name, version: vVer(kb.version), kind: kb.kind || '', file, note });
+  }
+  const manifest = {
+    agent_id: agentId, name: d.name, version, description: d.description || '',
+    downloaded_at: new Date().toISOString(), source: `arm-rest://${(armApiBase() || '').replace(/^https?:\/\//, '').split('/')[0]}`,
+    prompt: d.prompt || '',
+    skills: (d.skills || []).map(s => ({ ref: (s.skill && s.skill.name) || s.skillId || s.id, version: vVer(s.version), kind: 'skill', description: String((s.skill && s.skill.description) || '').slice(0, 200) })),
+    knowledges,
+  };
+  fs.writeFileSync(path.join(verDir, 'prompt.md'), manifest.prompt);
+  fs.writeFileSync(path.join(verDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+  commitDownload(manifest);
+  audit({ actor: 'arm-library', agentId, action: 'download', via: 'rest', version, knowledges_local: knowledges.filter(k => k.file).length });
+  return manifest;
+}
+
+// 旧版 ARM 兼容：get_agent markdown 解析 + 知识 ID 经检索定位
+async function downloadAgentMcp(agentId) {
+  const text = await mcpCall('get_agent', { id: agentId }, { timeout_ms: 25000 });
+  const section = (h) => (text.match(new RegExp(`## ${h}\\n([\\s\\S]*?)(\\n## |\\n*$)`)) || [])[1] || '';
+  const parseList = (s) => [...s.matchAll(/^- (.+?) (v[\d.]+)（(\w+)）/gm)].map(m => ({ ref: m[1].trim(), version: m[2], kind: m[3] }));
+  const name = (text.match(/^#\s+(.+?)\s+\(/m) || [])[1] || agentId;
+  const version = (text.match(/^#\s+.+?\s+\((v[\d.]+)\)/m) || [])[1] || 'v0.0.0';
+  const prompt = (text.match(/## Prompt\n([\s\S]*?)(\n## |\n*$)/) || [])[1]?.trim() || '';
+  const description = section('描述').trim();
+  const skills = parseList(section('Skills'));
+  const verDir = path.join(ARM_AGENTS_DIR, agentId, 'versions', version);
+  fs.mkdirSync(path.join(verDir, 'knowledges'), { recursive: true });
+  const knowledges = [];
+  for (const k of parseList(section('Knowledges'))) {
+    let file = null, note = '';
+    try { // 知识 ID 经检索定位（ARM 无按名直取接口），再拉全文。注意：知识正文自身含 "## " 内部标题，不可按标题切块——须按「标题→首个 [完整内容] 标记」成对匹配
+      const sres = await mcpCall('search_knowledges', { query: k.ref, limit: 5 }, { timeout_ms: 20000 });
+      const pairs = [...sres.matchAll(/^## (.+?)(?:（相似度 \d+%）)?\n[\s\S]*?\[完整内容: get_knowledge id=([0-9a-f-]{36})\]/gm)];
+      const kid = pairs.find(m => m[1].trim() === k.ref)?.[2];
+      if (kid) {
+        const full = await mcpCall('get_knowledge', { id: kid }, { timeout_ms: 20000 });
+        file = `knowledges/${slug(k.ref)}.md`;
+        fs.writeFileSync(path.join(verDir, file), full);
+      } else note = 'ARM 检索未命中该知识，离线不可用';
+    } catch (e) { note = `知识拉取失败: ${String(e.message).slice(0, 80)}`; }
+    knowledges.push({ ...k, file, note });
+  }
+  const manifest = {
+    agent_id: agentId, name, version, description,
+    downloaded_at: new Date().toISOString(), source: armSourceTag(armMcpUrl()), prompt,
+    skills, knowledges,
+  };
+  fs.writeFileSync(path.join(verDir, 'prompt.md'), prompt);
+  fs.writeFileSync(path.join(verDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+  commitDownload(manifest);
+  audit({ actor: 'arm-library', agentId, action: 'download', via: 'mcp', version, knowledges_local: knowledges.filter(k => k.file).length });
+  return manifest;
+}
+
+// 同步：比对远端目录与本地库，产出 new/update/delisted 事件；顺带冲账离线经验 outbox
+async function armSync() {
+  const remote = await armListAgents(); // REST 全量优先，旧版 ARM 内部回落 MCP（≤20）
+  const reg = loadRegistry();
+  const remoteIds = new Set(remote.map(r => r.agent_id));
+  const events = { new: [], update: [], delisted: [] };
+  for (const r of remote) {
+    const e = reg.agents.find(a => a.agent_id === r.agent_id);
+    if (!e) events.new.push({ agent_id: r.agent_id, name: r.name, version: r.version });
+    else if (cmpVersion(r.version, e.installed_version) > 0) events.update.push({ agent_id: r.agent_id, name: r.name, from: e.installed_version, to: r.version });
+    if (e) { e.remote_version = r.version; e.delisted = false; }
+  }
+  for (const e of reg.agents) {
+    if (!remoteIds.has(e.agent_id)) { if (!e.delisted) events.delisted.push({ agent_id: e.agent_id, name: e.name }); e.delisted = true; }
+  }
+  reg.last_sync_at = new Date().toISOString();
+  saveRegistry(reg);
+  const outbox_flushed = await flushExperienceOutbox();
+  audit({ actor: 'arm-library', action: 'sync', new: events.new.length, update: events.update.length, delisted: events.delisted.length, outbox_flushed });
+  return { at: reg.last_sync_at, remote_count: remote.length, events, outbox_flushed };
+}
+
+// 离线经验 outbox：ARM 不可达时缓写，恢复连接后冲账（07 设计 §2.4）
+const OUTBOX_FILE = path.join(DATA_DIR, 'outbox-experience.jsonl');
+function outboxCount() { try { return fs.readFileSync(OUTBOX_FILE, 'utf8').split('\n').filter(Boolean).length; } catch { return 0; } }
+async function flushExperienceOutbox() {
+  if (!fs.existsSync(OUTBOX_FILE)) return 0;
+  const lines = fs.readFileSync(OUTBOX_FILE, 'utf8').split('\n').filter(Boolean);
+  const remain = []; let ok = 0;
+  for (const line of lines) {
+    try { const it = JSON.parse(line); await mcpCall('create_knowledge', it.args, { pat: true }); ok++; }
+    catch { remain.push(line); }
+  }
+  fs.writeFileSync(OUTBOX_FILE, remain.length ? remain.join('\n') + '\n' : '');
+  if (ok) audit({ actor: 'experience-reflow', target: 'ARM', action: 'outbox-flush', count: ok });
+  return ok;
+}
+
+// 离线知识检索：对当前版本已物化的 knowledges/*.md 做关键词命中（降级路径，非 RAG）
+function cjkTokens(q) { // 中英混合分词：拉丁词整词，CJK 连续段切二元（覆盖无空格中文查询）
+  const toks = [];
+  for (const part of String(q).split(/[\s,，、;；。？?！!：:]+/).filter(Boolean)) {
+    for (const w of part.replace(/[\u4e00-\u9fff]+/g, ' ').split(/\s+/)) if (w.length >= 2) toks.push(w);
+    for (const seg of part.match(/[\u4e00-\u9fff]+/g) || []) for (let i = 0; i + 2 <= seg.length; i++) toks.push(seg.slice(i, i + 2));
+  }
+  return [...new Set(toks)];
+}
+function localKnowledgeSearch(agentId, query) {
+  const m = localManifest(agentId);
+  if (!m) return [];
+  const tokens = cjkTokens(query);
+  if (!tokens.length) return [];
+  const base = path.join(ARM_AGENTS_DIR, agentId, 'versions', m.version);
+  const hits = [];
+  for (const k of m.knowledges || []) {
+    if (!k.file) continue;
+    let content; try { content = fs.readFileSync(path.join(base, k.file), 'utf8'); } catch { continue; }
+    const score = tokens.reduce((s, t) => s + (content.split(t).length - 1) + (k.ref.includes(t) ? 3 : 0), 0);
+    if (score > 2) {
+      const idx = Math.max(0, content.search(new RegExp(tokens.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|'), 'i')));
+      hits.push({ title: k.ref, score, snippet: content.slice(idx, idx + 220).replace(/\n+/g, ' ') });
+    }
+  }
+  return hits.sort((a, b) => b.score - a.score).slice(0, 3);
+}
+
+// ── 工作区（07 设计：助手 1:N 工作区 = exec cwd + 私有数据集库 + 会话现场；工作台是 1:1 操作面，与此正交）──
+const wsDir = (agentId) => path.join(WS_ROOT, agentId);
+function saveWsRegistry(agentId, reg) {
+  fs.mkdirSync(wsDir(agentId), { recursive: true });
+  fs.writeFileSync(path.join(wsDir(agentId), 'registry.json'), JSON.stringify(reg, null, 2));
+}
+function loadWsRegistry(agentId) { // 读即保障：默认工作区固定在安装路径 workspace 目录下动态新增
+  let reg = null;
+  try { reg = JSON.parse(fs.readFileSync(path.join(wsDir(agentId), 'registry.json'), 'utf8')); } catch { }
+  if (!reg || !Array.isArray(reg.workspaces)) reg = { current: 'default', workspaces: [] };
+  if (!reg.workspaces.some(w => w.id === 'default')) {
+    fs.mkdirSync(path.join(wsDir(agentId), 'default'), { recursive: true });
+    reg.workspaces.unshift({ id: 'default', name: '默认工作区', path: path.join(wsDir(agentId), 'default'), external: false, created_at: new Date().toISOString(), last_opened_at: null });
+    saveWsRegistry(agentId, reg);
+  }
+  if (!reg.workspaces.some(w => w.id === reg.current)) reg.current = 'default';
+  return reg;
+}
+function getWs(agentId, wsId) { return loadWsRegistry(agentId).workspaces.find(w => w.id === wsId) || null; }
+function currentWs(agentId) {
+  const reg = loadWsRegistry(agentId);
+  return reg.workspaces.find(w => w.id === reg.current) || reg.workspaces[0];
+}
+function createWorkspace(agentId, { name, path: customPath }) {
+  const reg = loadWsRegistry(agentId);
+  const id = `ws_${crypto.randomUUID().slice(0, 4)}`;
+  let wsPath = customPath ? path.resolve(customPath) : null;
+  if (wsPath) { // 自定义路径 = 登记制：目录须已存在，平台不在用户目录建库（SQLite 留平台 data/）
+    const st = fs.existsSync(wsPath) ? fs.statSync(wsPath) : null;
+    if (!st || !st.isDirectory()) throw new Error(`目录不存在或不是文件夹: ${wsPath}`);
+  } else {
+    wsPath = path.join(wsDir(agentId), id);
+    fs.mkdirSync(wsPath, { recursive: true });
+  }
+  const ws = { id, name: name || `工作区 ${reg.workspaces.length}`, path: wsPath, external: !!customPath, created_at: new Date().toISOString(), last_opened_at: null };
+  reg.workspaces.push(ws);
+  saveWsRegistry(agentId, reg);
+  audit({ actor: 'workspace', agentId, action: 'create', ws: id, external: !!customPath, path: wsPath });
+  return { ws, reg };
+}
+function selectWorkspace(agentId, wsId) {
+  const reg = loadWsRegistry(agentId);
+  const ws = reg.workspaces.find(w => w.id === wsId);
+  if (!ws) throw new Error(`工作区 ${wsId} 不存在`);
+  reg.current = wsId; ws.last_opened_at = new Date().toISOString();
+  saveWsRegistry(agentId, reg);
+  audit({ actor: 'workspace', agentId, action: 'select', ws: wsId });
+  return reg;
+}
+function deleteWorkspace(agentId, wsId, purge) {
+  const reg = loadWsRegistry(agentId);
+  const ws = reg.workspaces.find(w => w.id === wsId);
+  if (!ws) throw new Error(`工作区 ${wsId} 不存在`);
+  if (wsId === 'default') throw new Error('默认工作区不可删除');
+  reg.workspaces = reg.workspaces.filter(w => w.id !== wsId);
+  if (reg.current === wsId) reg.current = 'default';
+  saveWsRegistry(agentId, reg);
+  if (purge && !ws.external && fs.existsSync(ws.path)) fs.rmSync(ws.path, { recursive: true, force: true }); // 自定义路径只删登记，不动用户文件
+  audit({ actor: 'workspace', agentId, action: 'delete', ws: wsId, purged: !!purge });
+  return reg;
+}
+
+// ── 通用计算原语与平台数据服务（pi-core 哲学：少量原语 + 组合，而非功能堆叠）──
+const { exec: cpExec } = require('node:child_process');
+const EXEC_DENY = [/\bsudo\b/, /\b(shutdown|reboot|halt|poweroff|mkfs)\b/, /\bdd\s+if=/, /rm\s+-[a-z]*[rf][a-z]*\s+\/(\s|$)/, /:\(\)\s*\{.*\};:/, /\bkill\s+-9\s+1\b/];
+const EXEC_RO = ['ls', 'cat', 'head', 'tail', 'wc', 'grep', 'find', 'file', 'stat', 'whoami', 'date', 'uname', 'uptime', 'df', 'du', 'ps', 'curl', 'ping', 'nc', 'netstat', 'dig', 'nslookup', 'sqlite3', 'echo', 'which', 'env'];
+function classifyExec(command, autonomy) {
+  const cmd = String(command || '').trim();
+  if (EXEC_DENY.some((re) => re.test(cmd))) return { status: 'blocked', reason: '【守护栏】命令命中危险清单（sudo/毁灭性操作等）' };
+  const noRedirect = cmd.replace(/2>&1/g, ''); // 重定向/tee 使白名单命令具备写能力，不再视为只读
+  const SQL_WRITE = /\b(INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|REPLACE)\b/i;
+  // 复合命令逐段判定：每个由 ; && || | 换行 分隔的段都须只读（控制关键字与 for 头部放行）
+  const segOk = (seg) => {
+    let s = seg.trim().replace(/^(do|then|else|done|fi|esac|\{|\})\s+/, '');
+    if (/^[A-Za-z_]\w*\s+in\b/.test(s)) return true; // for 循环头部（变量 in 值列表）
+    if (/^(for|while|until|if|case)\b/.test(s)) return true; // 控制关键字本身
+    const first = s.split(/\s+/)[0].split('/').pop();
+    return EXEC_RO.includes(first) && !(first === 'sqlite3' && SQL_WRITE.test(s));
+  };
+  const segments = cmd.split(/;|&&|\|\||\|\n?|\n/).map((s) => s.trim()).filter(Boolean);
+  const ro = segments.length > 0 && segments.every(segOk) && !/(>>|>)|\btee\b/.test(noRedirect);
+  if (ro) return { status: 'ok' }; // 只读白名单：任何级别免确认（取证不应有摩擦）
+  if (autonomy >= 2) return { status: 'pending' }; // 写命令：L2 可发起，执行前需人工确认
+  return { status: 'blocked', reason: `【守护栏】L${autonomy} 仅放行只读命令（ls/cat/grep/curl/ping/nc/sqlite3只读等）。写操作需 L2 并人工确认` };
+}
+const PRIMITIVE_TOOLS = {
+  exec: {
+    min_level: 0, confirm_required: false, // 确认由 classifyExec 按命令动态判定
+    desc: '通用终端命令执行。工作目录（cwd）= 当前工作区；连通性实测用 nc -vz -w 3 host port；平台日志用绝对路径 tail（见系统提示）。只读命令直接执行；写命令需 L2+人工确认；危险命令永久拒绝。不要期待专用工具，优先用命令组合能力',
+    schema: { command: { type: 'string', description: '要执行的 shell 命令' }, timeout_ms: { type: 'number', description: '超时毫秒，默认 15000' } },
+    required: ['command'],
+    run: async ({ command, timeout_ms = 15000 }, agentId) => {
+      const env = { ...process.env };
+      delete env.ZAI_CODING_CN_API_KEY; delete env.LLM_API_KEY; delete env.ARM_PAT; // 凭据不进子进程
+      const ws = agentId ? currentWs(agentId) : null; // 文件领地锚定工作区（07 设计 §4.3）
+      return await new Promise((resolve) => {
+        cpExec(command, { cwd: ws ? ws.path : ROOT, timeout: +timeout_ms, maxBuffer: 1024 * 512, env, shell: process.env.SHELL || '/bin/zsh' }, (err, stdout, stderr) => {
+          const out = String(stdout || '').slice(0, 4000);
+          const errOut = String(stderr || '').slice(0, 1500);
+          audit({ actor: 'assistant', tool: 'exec', command: String(command).slice(0, 200), ok: !err, ws: ws?.id });
+          resolve(`$ ${command}\n${out}${errOut ? '\n[stderr] ' + errOut : ''}${err && !out && !errOut ? '\n[错误] ' + err.message : ''}`);
+        });
+      });
+    },
+  },
+  data_describe: {
+    min_level: 0, confirm_required: false,
+    desc: '查看平台数据集字典（可见=本助手私有+共享；含字段 schema/归属/作用域）。不知道有什么数据时先调它',
+    schema: { name: { type: 'string', description: '数据集名；缺省列出全部可见数据集' } }, required: [],
+    run: async (args, agentId, wsId = 'default') => {
+      const list = loadCollections().filter((c) => scopeOf(c) === 'shared' || c.owner_agent === agentId);
+      if (args.name) {
+        const m = list.find((c) => c.name === args.name);
+        if (!m) throw new Error(`数据集 ${args.name} 不存在或不在你的可见范围（助手隔离）`);
+        return JSON.stringify({ ...m, workspace: wsId }, null, 1);
+      }
+      return JSON.stringify(list.map(({ name, title, description, scope, owner_agent, schema, required }) => ({ name, title, description, scope, owner: owner_agent?.slice(0, 8), fields: Object.keys(schema || {}), required })), null, 1);
+    },
+  },
+  data_query: {
+    min_level: 0, confirm_required: false,
+    desc: '查询平台数据集记录（服务端按助手隔离；字段见 data_describe）',
+    schema: { name: { type: 'string', description: '数据集名' }, filter: { type: 'object', description: '字段精确匹配对象' }, sort: { type: 'string', description: '排序字段，-前缀倒序' }, limit: { type: 'number', description: '默认 20' } },
+    required: ['name'],
+    run: async (args, agentId, wsId = 'default') => {
+      const m = loadCollection(args.name);
+      if (!m || (scopeOf(m) !== 'shared' && m.owner_agent !== agentId)) throw new Error(`数据集 ${args.name} 不存在或不在你的可见范围`);
+      const rows = collRecords(m, { filter: args.filter, sort: args.sort, limit: args.limit || 20 }, wsId);
+      metric({ kind: 'data_query', collection: m.name, hits: rows.length });
+      return rows.length ? JSON.stringify(rows, null, 1) : `（数据集 ${args.name} 无匹配记录）`;
+    },
+  },
+  data_write: {
+    min_level: 2, confirm_required: true,
+    desc: '向平台数据集写入/更新一条记录（写操作，需人工确认；doc 含 _id 则更新）',
+    schema: { name: { type: 'string', description: '数据集名' }, doc: { type: 'object', description: '记录内容（字段见 data_describe；含 _id 则为更新）' } },
+    required: ['name', 'doc'],
+    run: async ({ name, doc }, agentId, wsId = 'default') => {
+      const m = loadCollection(name);
+      if (!m || (scopeOf(m) !== 'shared' && m.owner_agent !== agentId)) throw new Error(`数据集 ${name} 不存在或不在你的可见范围`);
+      const saved = doc._id ? updateDoc(m, doc._id, doc, wsId) : insertDoc(m, doc, wsId);
+      audit({ actor: 'data-write', collection: name, id: saved._id, ws: wsId });
+      return `已写入（id=${saved._id}）：${JSON.stringify(saved)}`;
+    },
+  },
+};
+
+
+// ── 工具注册中心（L2 工具层）────────────────────────────
+const TOOLS = {
+  search_knowledge: {
+    min_level: 0, confirm_required: false,
+    schema: { query: { type: 'string', description: '检索词，建议用报错信息或问题主题' } }, required: ['query'],
+    desc: '检索企业知识库（ARM 混合检索：RAG 语义⊕关键词；离线时自动降级为本地已下载知识的关键词检索）——历史故障处置经验、SOP',
+    run: async ({ query }, agentId) => {
+      try {
+        const { via, items } = await searchKnowledgeItems(query, 3);
+        metric({ kind: 'kb_search', agentId, query, via, top_similarity: items.length ? items[0].similarity : null });
+        if (!items.length) return '（ARM 知识库无命中。可换更具体的现象/报错关键词再试。）';
+        return items.map(i => `## ${i.title}${i.similarity != null ? `（相关度 ${i.similarity}%）` : ''}\n${i.snippet}`).join('\n\n') + `\n\n（via ${via}）`;
+      } catch (e) { // 离线降级：本地已物化知识的关键词命中（07 设计 §2.4）
+        const hits = localKnowledgeSearch(agentId, query);
+        metric({ kind: 'kb_search', agentId, query, offline: true, hits: hits.length });
+        if (!hits.length) return `（离线模式：ARM 不可达且本地知识无命中——${String(e.message).slice(0, 60)}。可在助手大厅下载/升级助手以补充本地知识。）`;
+        return ['（离线模式：ARM 不可达，以下来自本助手已下载的本地知识）', ...hits.map(h => `## ${h.title}（本地知识 · 命中 ${h.score} 处）\n${h.snippet}…`)].join('\n\n');
+      }
+    },
+  },
+  // ──（已退役 2026-10-15）execute_device_reset / create_work_order / restart_service / run_environment_check：
+  //    四个 mock 编排工具（logic://…@mock，改内存状态）是"一个功能一个工具"反模式的幸存者，且 ARM 真实助手群体
+  //    （WMS/Jenkins/镜像/代码review）无一需要复位堆垛机。MVP 打磨移除；L2 确认流由 exec 写命令与 data_write 承担，
+  //    工作台按钮统一走 params.actions + runAction（随草稿人审）。logic-ide 接入后以通用编排工具（run_orchestration）回归。──
+  save_experience: {
+    min_level: 1, confirm_required: false,
+    schema: { title: { type: 'string', description: '经验标题，含设备与现象关键词' }, markdown: { type: 'string', description: '正文 markdown：现象/根因/处置步骤/验证' } }, required: ['title', 'markdown'],
+    desc: '把本次处置经验沉淀进企业知识库（ARM 经验库；离线时存本地待回流队列）',
+    run: async ({ title, markdown }, agentId) => {
+      const arm = agentProfileNow(agentId);
+      const content = ['---', 'kind: experience', 'source: aims-platform-mvp', `agent: ${arm.name || agentId}@${arm.version || ''}`, 'scenario: 立库A区智能运维@mvp', '---', '', markdown].join('\n');
+      const args = { name: title, description: `MVP回流：${title}`, content, tags: ['MVP回流'] };
+      let r;
+      try { r = await mcpCall('create_knowledge', args, { pat: true }); }
+      catch (e) { // 离线：入 outbox 缓写，恢复连接后经「检查更新」自动回流
+        fs.appendFileSync(OUTBOX_FILE, JSON.stringify({ at: new Date().toISOString(), agentId, args }) + '\n');
+        audit({ actor: 'experience-reflow', target: 'outbox', title });
+        return `ARM 不可达（${String(e.message).slice(0, 60)}），经验已存本地待回流队列；恢复连接后在助手大厅点「检查更新」将自动回流。`;
+      }
+      const kid = (r.match(/id:\s*([0-9a-f-]{36})/) || [])[1] || '';
+      metric({ kind: 'experience', agentId, title, knowledge_id: kid });
+      audit({ actor: 'experience-reflow', target: 'ARM', title });
+      return `经验已沉淀到 ARM 知识库：\n${r}`;
+    },
+  },
+};
+const LEVEL_NAME = { 0: 'L0 只读问答', 1: 'L1 诊断建议', 2: 'L2 确认执行', 3: 'L3 完全自主' };
+Object.assign(TOOLS, PRIMITIVE_TOOLS); // 原语与数据服务并入工具注册中心
+const getTool = (name) => TOOLS[name];
+
+// JSON Schema → pi-ai TypeBox（普通 object schema 直接透传即可）
+function piTools(deployment) {
+  const allow = new Set(deployment.toolset.map(t => t.tool));
+  return Object.entries(TOOLS).filter(([n]) => allow.has(n))
+    .map(([n, t]) => ({ name: n, description: t.desc, parameters: { type: 'object', properties: t.schema, required: t.required || [] } }));
+}
+
+// ── 守护栏（运行时强制，03-§2）──────────────────────────
+function guardCheck(toolName, autonomy, agentId, args = {}) {
+  const tool = getTool(toolName);
+  if (!tool) return { allowed: false, status: 'rejected', reason: `未知工具 ${toolName}` };
+  if (toolName === 'exec') { // 通用原语：按命令内容分级，而非枚举功能
+    const cls = classifyExec(args.command, autonomy);
+    if (cls.status === 'blocked') return { allowed: false, status: 'blocked', reason: cls.reason };
+    if (autonomy >= 3) return { allowed: true, status: 'ok', confirm_required: false }; // L3 完全自主：免确认
+    return { allowed: true, status: cls.status, confirm_required: cls.status === 'pending' };
+  }
+  if (tool.min_level > autonomy) {
+    return { allowed: false, status: 'blocked', reason: `【守护栏拦截】当前助手自主级别为 ${LEVEL_NAME[autonomy]}，该操作需要 ${LEVEL_NAME[tool.min_level]}。请在工作台操作区人工执行，或经评测升权后再试。` };
+  }
+  if (autonomy >= 3) return { allowed: true, status: 'ok', confirm_required: false }; // L3 完全自主：写操作不再挂起
+  return { allowed: true, status: tool.confirm_required ? 'pending' : 'ok', confirm_required: tool.confirm_required };
+}
+
+// ── 上岗配置 / 工作台 DSL 存储（版本化）────────────────
+function loadDeployment(agentId) {
+  const p = path.join(DEPLOY_DIR, `${agentId}.json`);
+  return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+}
+function saveDeployment(agentId, dep) {
+  fs.writeFileSync(path.join(DEPLOY_DIR, `${agentId}.json`), JSON.stringify(dep, null, 2));
+  audit({ actor: 'deployment', agentId, action: 'save' });
+}
+function loadWorkbench(agentId) {
+  const p = path.join(WB_DIR, `${agentId}.json`);
+  return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+}
+function saveWorkbench(agentId, dsl) {
+  fs.writeFileSync(path.join(WB_DIR, `${agentId}.json`), JSON.stringify(dsl, null, 2));
+  const vp = path.join(WB_VER_DIR, `${agentId}.json`);
+  const vers = fs.existsSync(vp) ? JSON.parse(fs.readFileSync(vp, 'utf8')) : [];
+  vers.push({ version: (dsl.version || '').replace(/^v/, '') || String(vers.length + 1), at: new Date().toISOString(), by: 'platform-user', dsl });
+  fs.writeFileSync(vp, JSON.stringify(vers, null, 2));
+  audit({ actor: 'workbench', agentId, action: 'save', version: dsl.version });
+}
+function workbenchVersions(agentId) {
+  const vp = path.join(WB_VER_DIR, `${agentId}.json`);
+  if (!fs.existsSync(vp)) return [];
+  return JSON.parse(fs.readFileSync(vp, 'utf8')).map(({ version, at, by }) => ({ version, at, by }));
+}
+
+// ── 数据集存储（按助手隔离：每个助手一个库文件 + 可选共享库；建表即建工具）──
+const { DatabaseSync } = require('node:sqlite');
+const _dbs = new Map();
+function openDb(file) {
+  if (!_dbs.has(file)) {
+    const db = new DatabaseSync(path.join(DATA_DIR, file));
+    db.exec('CREATE TABLE IF NOT EXISTS docs (collection TEXT NOT NULL, id TEXT PRIMARY KEY, data TEXT NOT NULL, created TEXT, updated TEXT)');
+    db.exec('CREATE INDEX IF NOT EXISTS idx_docs_collection ON docs(collection)');
+    _dbs.set(file, db);
+  }
+  return _dbs.get(file);
+}
+const DB = openDb('store.db'); // 兼容旧引用（迁移后即空）
+// 作用域语义：agent=助手私有（默认，存归属助手×工作区的独立库）；shared=跨助手共享（存共享库）
+const scopeOf = (m) => (m.scope === 'shared' || m.scope === 'global') ? 'shared' : 'agent'; // legacy global→shared, workbench→agent
+const dbFor = (m, wsId = 'default') => openDb(scopeOf(m) === 'shared' ? 'store-shared.db' : `ws-${m.owner_agent || 'orphan'}-${wsId}.db`);
+const COLL_DIR = path.join(AIMS_HOME, 'config/collections');
+fs.mkdirSync(COLL_DIR, { recursive: true });
+
+function loadCollections() {
+  return fs.readdirSync(COLL_DIR).filter(f => f.endsWith('.json'))
+    .map(f => JSON.parse(fs.readFileSync(path.join(COLL_DIR, f), 'utf8')));
+}
+function loadCollection(name) {
+  const p = path.join(COLL_DIR, `${name}.json`);
+  return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+}
+function saveCollection({ name, title, description, schema, required = [], scope = 'agent', owner_agent, owner_plugin }) {
+  if (!/^[a-z][a-z0-9_-]{1,40}$/.test(name)) throw new Error('数据集 name 须为小写字母开头的字母/数字/-_');
+  if (!schema || typeof schema !== 'object') throw new Error('schema 必须为 {字段:{type,description}} 对象');
+  if (scope !== 'shared' && !owner_agent) throw new Error('agent 作用域数据集必须声明 owner_agent（归属助手）');
+  const manifest = { name, title: title || name, description: description || '', schema, required, scope: scopeOf({ scope }), owner_agent: owner_agent || null, owner_plugin: owner_plugin || null, updated: new Date().toISOString() };
+  fs.writeFileSync(path.join(COLL_DIR, `${name}.json`), JSON.stringify(manifest, null, 2));
+  audit({ actor: 'collection', name, action: loadCollection(name) ? 'update' : 'create', scope });
+  return manifest;
+}
+const collKey = (m) => m.name; // 物理隔离已由分库保证，collection 名即键
+function validateDoc(m, doc) {
+  for (const f of m.required || []) if (doc[f] === undefined || doc[f] === null || doc[f] === '') throw new Error(`缺少必填字段: ${f}`);
+  for (const [f, def] of Object.entries(m.schema || {})) {
+    const v = doc[f]; if (v === undefined) continue;
+    const tp = { string: 'string', number: 'number', boolean: 'boolean' }[def.type];
+    if (tp && typeof v !== tp) throw new Error(`字段 ${f} 类型应为 ${def.type}`);
+  }
+}
+function collRecords(m, { filter, sort, limit } = {}, wsId = 'default') {
+  let rows = dbFor(m, wsId).prepare('SELECT id, data, created, updated FROM docs WHERE collection = ?').all(collKey(m))
+    .map(r => ({ ...JSON.parse(r.data), _id: r.id, _created: r.created, _updated: r.updated }));
+  if (filter && typeof filter === 'object') rows = rows.filter(d => Object.entries(filter).every(([k, v]) => String(d[k]) === String(v)));
+  if (sort) {
+    const desc = sort.startsWith('-'); const f = desc ? sort.slice(1) : sort;
+    rows.sort((a, b) => (a[f] > b[f] ? 1 : a[f] < b[f] ? -1 : 0) * (desc ? -1 : 1));
+  }
+  return rows.slice(0, Math.min(limit || 100, 500));
+}
+function insertDoc(m, doc, wsId = 'default') {
+  validateDoc(m, doc);
+  const id = doc._id || `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`;
+  const now = new Date().toISOString();
+  dbFor(m, wsId).prepare('INSERT OR REPLACE INTO docs (collection, id, data, created, updated) VALUES (?,?,?,?,?)')
+    .run(collKey(m), id, JSON.stringify(doc), now, now);
+  return { ...doc, _id: id, _created: now, _updated: now };
+}
+function updateDoc(m, id, patch, wsId = 'default') {
+  const row = dbFor(m, wsId).prepare('SELECT data FROM docs WHERE collection = ? AND id = ?').get(collKey(m), id);
+  if (!row) throw new Error(`记录 ${id} 不存在`);
+  const merged = { ...JSON.parse(row.data), ...patch };
+  validateDoc(m, merged);
+  dbFor(m, wsId).prepare('UPDATE docs SET data = ?, updated = ? WHERE collection = ? AND id = ?').run(JSON.stringify(merged), new Date().toISOString(), collKey(m), id);
+  return merged;
+}
+function deleteDoc(m, id, wsId = 'default') {
+  const r = dbFor(m, wsId).prepare('DELETE FROM docs WHERE collection = ? AND id = ?').run(collKey(m), id);
+  if (!r.changes) throw new Error(`记录 ${id} 不存在`);
+}
+
+// ── 一次性迁移：旧单库 → 按助手分库（按归属切分记录）──
+(function migrateLegacyStore() {
+  const legacy = path.join(DATA_DIR, 'store.db');
+  if (!fs.existsSync(legacy)) return;
+  const OWNERS = { server_accounts: '4d8f94ab-cfee-490f-8873-43c58ceefc0c', maintenance_records: 'de319700-4412-4d55-b3dd-7a14b7cb4566' };
+  try {
+    const old = new DatabaseSync(legacy);
+    const rows = old.prepare('SELECT collection, id, data, created, updated FROM docs').all();
+    for (const r of rows) {
+      const m = loadCollection(r.collection);
+      if (!m) continue;
+      if (!m.owner_agent && OWNERS[m.name]) { // 补归属并私有化
+        m.owner_agent = OWNERS[m.name]; m.scope = 'agent';
+        fs.writeFileSync(path.join(COLL_DIR, `${m.name}.json`), JSON.stringify(m, null, 2));
+      }
+      dbFor(m, 'default').prepare('INSERT OR REPLACE INTO docs (collection, id, data, created, updated) VALUES (?,?,?,?,?)')
+        .run(r.collection, r.id, r.data, r.created, r.updated);
+    }
+    fs.renameSync(legacy, legacy + '.migrated');
+    audit({ actor: 'migration', action: 'per-agent-split', moved: rows.length });
+    console.log(`[mvp] 数据已按助手分库迁移（${rows.length} 条）`);
+  } catch (e) { console.error('[mvp] 迁移失败:', e.message); }
+})();
+
+// ── 一次性迁移：按助手分库 → 按工作区分库（store-{agent}.db → ws-{agent}-default.db，07 设计 §7）──
+(function migrateStoreToWorkspace() {
+  let moved = 0;
+  for (const f of fs.readdirSync(DATA_DIR)) {
+    const m = f.match(/^store-([0-9a-f-]{36})\.db(-wal|-shm|-journal)?$/);
+    if (!m) continue;
+    const from = path.join(DATA_DIR, f);
+    const to = path.join(DATA_DIR, `ws-${m[1]}-default.db${m[2] || ''}`);
+    if (!fs.existsSync(to)) { try { fs.renameSync(from, to); moved++; } catch { } }
+    else try { fs.rmSync(from); } catch { }
+  }
+  if (moved) { audit({ actor: 'migration', action: 'per-workspace-split', moved }); console.log(`[mvp] 助手数据已迁移到默认工作区库（${moved} 个文件）`); }
+})();
+
+
+
+// ── 布局迁移：slot 三栏 → grid{x,y,w,h} 自由网格（一次性，幂等）──
+(function migrateSlotToGrid() {
+  const COL = { left: { x: 1, w: 3 }, center: { x: 4, w: 6 }, right: { x: 10, w: 3 } };
+  for (const f of fs.readdirSync(WB_DIR).filter((f) => f.endsWith('.json'))) {
+    const fp = path.join(WB_DIR, f);
+    let dsl; try { dsl = JSON.parse(fs.readFileSync(fp, 'utf8')); } catch { continue; }
+    if ((dsl.panels || []).every((p) => p.grid)) continue;
+    const y = { left: 1, center: 1, right: 1 };
+    let changed = false;
+    for (const p of dsl.panels || []) {
+      if (p.grid) continue;
+      const key = p.slot || (p.type === 'agent_dialog' ? 'center' : 'left');
+      const track = COL[key] || COL.left;
+      const h = p.type === 'agent_dialog' ? 3 : 1;
+      p.grid = { x: track.x, w: track.w, y: y[key] || 1, h };
+      y[key] = (y[key] || 1) + h;
+      delete p.slot;
+      changed = true;
+    }
+    if (changed) fs.writeFileSync(fp, JSON.stringify(dsl, null, 2));
+  }
+})();
+// 占位清理：旧类型残留保护
+(function migrateBuiltinPanels() {
+  const MAP = {
+    realtime_list: { plugin: 'system-alarm-stream', slot: 'left', keep: ['refresh', 'device_type'] },
+    status_grid: { plugin: 'system-device-grid', slot: 'center', keep: ['refresh', 'device_type', 'context_inject'] },
+    kpi_strip: { plugin: 'system-kpi-strip', slot: 'center', keep: [] },
+    inspection_report: { plugin: 'system-inspection-report', slot: 'left', keep: [] },
+    action_group: { plugin: 'system-action-group', slot: 'right', keep: ['actions'] },
+  };
+  let migrated = 0;
+  for (const f of fs.readdirSync(WB_DIR).filter((f) => f.endsWith('.json'))) {
+    const fp = path.join(WB_DIR, f);
+    let dsl; try { dsl = JSON.parse(fs.readFileSync(fp, 'utf8')); } catch { continue; }
+    let changed = false;
+    for (const p of dsl.panels || []) {
+      const m = MAP[p.type];
+      if (!m) continue;
+      const params = {};
+      for (const k of m.keep) if (p[k] !== undefined) params[k] = p[k];
+      const np = { id: p.id, type: 'custom_panel', panel: m.plugin, title: p.title, slot: p.slot || m.slot, params };
+      Object.assign(p, np); delete p.type; p.type = 'custom_panel'; // 原地替换保序
+      changed = true; migrated++;
+    }
+    if (changed) fs.writeFileSync(fp, JSON.stringify(dsl, null, 2));
+  }
+  if (migrated) { audit({ actor: 'migration', action: 'builtin-to-plugin', count: migrated }); console.log(`[mvp] 内置面板已迁移为系统范本插件（${migrated} 处）`); }
+})();
+
+// ── 面板插件库（PenguinHarness 模式：插件 = 数据 + 代码）──
+const PANELS_DIR = path.join(AIMS_HOME, 'config/panels');
+fs.mkdirSync(PANELS_DIR, { recursive: true });
+function loadPanelPlugin(id) {
+  const p = path.join(PANELS_DIR, `${id}.json`);
+  return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+}
+function savePanelPlugin({ id, name, description, code, author = 'ai' }) {
+  if (!/^[a-z0-9-]{2,40}$/.test(id)) throw new Error('插件 id 只允许小写字母/数字/连字符');
+  if (!code.includes('function Panel')) throw new Error('插件代码必须定义 function Panel(props)');
+  // 校验器（check-panel.mjs）：编译检查 + 契约 + 沙箱 + 模板完整性，拒绝错误代码入库
+  try {
+    const out = require('node:child_process').execFileSync('node', [path.join(ROOT, 'scripts/check-panel.mjs')], { input: code, encoding: 'utf8', timeout: 15000 });
+    if (out.includes('⚠️')) audit({ actor: 'check-panel', id, note: out.split('\n').filter(l => l.includes('⚠️')).join(' | ').slice(0, 200) });
+  } catch (e) {
+    throw new Error('插件代码未通过校验器：\n' + String(e.stdout || e.message).slice(0, 400));
+  }
+  const old = loadPanelPlugin(id);
+  const plugin = {
+    id, name: name || id, description: description || '', author,
+    version: old ? `v${(+(old.version || 'v0').replace('v', '') || 0) + 1}` : 'v1',
+    updated: new Date().toISOString(), code,
+    history: [...(old?.history || []), ...(old ? [{ version: old.version, code: old.code, at: old.updated }] : [])].slice(-5),
+  };
+  fs.writeFileSync(path.join(PANELS_DIR, `${id}.json`), JSON.stringify(plugin, null, 2));
+  audit({ actor: 'panel-plugin', id, action: old ? 'update' : 'create', version: plugin.version });
+  return plugin;
+}
+function listPanelPlugins() {
+  return fs.readdirSync(PANELS_DIR).filter(f => f.endsWith('.json'))
+    .map(f => JSON.parse(fs.readFileSync(path.join(PANELS_DIR, f), 'utf8')))
+    .map(({ id, name, description, version, author, updated }) => ({ id, name, description, version, author, updated }));
+}
+function panelCodeOf(p) { // 工作台面板引用解析为可执行代码
+  if (p.type === 'custom' && p.code) return p.code;
+  if (p.type === 'custom_panel' && p.panel) {
+    const plugin = loadPanelPlugin(p.panel);
+    if (!plugin) throw new Error(`插件 ${p.panel} 不存在`);
+    return plugin.code;
+  }
+  return null;
+}
+// 工作台草稿（Agent 的产出先进草稿，人审发布后生效——生成→审查→发布）
+const draftPath = (agentId) => path.join(WB_DIR, `${agentId}.draft.json`);
+function loadDraft(agentId) {
+  const p = draftPath(agentId);
+  return fs.existsSync(p) ? JSON.parse(fs.readFileSync(p, 'utf8')) : null;
+}
+function saveDraft(agentId, dsl) {
+  if (!Array.isArray(dsl.panels)) throw new Error('dsl.panels 必须为数组');
+  const prev = loadDraft(agentId) || loadWorkbench(agentId) || { panels: [] };
+  // 防护性合并：同 id 同类型的面板，Agent 遗漏的字段（如 action_group.actions）从上一版补全，防止全量重写丢配置
+  dsl.panels = dsl.panels.map(p => {
+    const old = prev.panels.find(x => x.id === p.id && x.type === p.type);
+    return old ? { ...old, ...p } : p;
+  });
+  for (const p of dsl.panels) {
+    if ((p.type === 'custom' || p.type === 'custom_panel') && !panelCodeOf(p)) throw new Error(`面板 ${p.id || p.title} 引用的代码/插件缺失`);
+  }
+  dsl.owner_agent = agentId;
+  fs.writeFileSync(draftPath(agentId), JSON.stringify(dsl, null, 2));
+  audit({ actor: 'dev-agent', agentId, action: 'draft', panels: dsl.panels.length });
+}
+
+// ── Skill 装载（Agent Skills 规范：SKILL.md frontmatter 注入描述，正文按需读取）──
+const SKILLS_DIR = path.join(ROOT, 'skills');
+function listSkills() {
+  if (!fs.existsSync(SKILLS_DIR)) return [];
+  return fs.readdirSync(SKILLS_DIR).filter((d) => fs.existsSync(path.join(SKILLS_DIR, d, 'SKILL.md')))
+    .map((d) => {
+      const raw = fs.readFileSync(path.join(SKILLS_DIR, d, 'SKILL.md'), 'utf8');
+      const fm = raw.match(/^---\n([\s\S]*?)\n---/);
+      const meta = {};
+      for (const line of (fm?.[1] || '').split('\n')) {
+        const m = line.match(/^(name|description|version|author):\s*(.+)$/);
+        if (m) meta[m[1]] = m[2].trim();
+      }
+      return { dir: d, name: meta.name || d, version: meta.version || '', description: (meta.description || '').slice(0, 200) };
+    });
+}
+function readSkill(name) {
+  const s = listSkills().find((x) => x.name === name || x.dir === name);
+  if (!s) return null;
+  const dir = path.join(SKILLS_DIR, s.dir);
+  const files = {};
+  const walk = (d, prefix = '') => {
+    for (const f of fs.readdirSync(d)) {
+      const fp = path.join(d, f);
+      if (fs.statSync(fp).isDirectory()) walk(fp, `${prefix}${f}/`);
+      else files[`${prefix}${f}`] = fs.readFileSync(fp, 'utf8').slice(0, 12000);
+    }
+  };
+  walk(dir);
+  return { ...s, files };
+}
+
+// ── 统一插件中心：系统面板与契约插件同一注册表，同一生命周期 ──
+const SYSTEM_PLUGINS = [
+  { id: 'agent_dialog', name: '诊断对话', author: 'system', status: 'active', note: '唯一编译内核：与助手对话。其余面板均为插件库范本（KISS）' },
+];
+const SYS_STATUS_FILE = path.join(DATA_DIR, 'system-plugin-status.json');
+function systemPluginStatus() {
+  let over = {};
+  try { over = JSON.parse(fs.readFileSync(SYS_STATUS_FILE, 'utf8')); } catch { }
+  return SYSTEM_PLUGINS.map((s) => ({ ...s, status: over[s.id] || s.status }));
+}
+function setSystemPluginStatus(id, status) {
+  let over = {};
+  try { over = JSON.parse(fs.readFileSync(SYS_STATUS_FILE, 'utf8')); } catch { }
+  over[id] = status;
+  fs.writeFileSync(SYS_STATUS_FILE, JSON.stringify(over, null, 2));
+  audit({ actor: 'plugin-center', kind: 'system', id, action: status === 'deprecated' ? 'deprecate' : 'restore' });
+}
+function pluginUsage() { // 引用统计：扫描所有工作台（线上+草稿）
+  const usage = {};
+  for (const f of fs.readdirSync(WB_DIR).filter((f) => f.endsWith('.json'))) {
+    const agentId = f.replace(/\.(draft\.)?json$/, '');
+    let dsl; try { dsl = JSON.parse(fs.readFileSync(path.join(WB_DIR, f), 'utf8')); } catch { continue; }
+    for (const p of dsl.panels || []) {
+      const key = p.type === 'custom_panel' ? `plugin:${p.panel}` : `system:${p.type}`;
+      (usage[key] = usage[key] || []).push({ agent: agentId.slice(0, 8), draft: f.includes('.draft.') });
+    }
+  }
+  return usage;
+}
+function pluginCenterData() {
+  const usage = pluginUsage();
+  return {
+    system: systemPluginStatus().map((s) => ({ ...s, usage: usage[`system:${s.id}`] || [] })),
+    library: listPanelPlugins().map((pl) => {
+      const full = loadPanelPlugin(pl.id);
+      return { ...pl, status: full?.status || 'active', usage: usage[`plugin:${pl.id}`] || [], lastCheck: full?.lastCheck || null };
+    }),
+  };
+}
+// 代理域名白名单：从在库插件代码中提取其声明访问的主机（含 deprecated，保守起见全量）
+function proxyAllowedHosts() {
+  const hosts = new Set(['localhost', '127.0.0.1']);
+  for (const f of fs.readdirSync(PANELS_DIR).filter((f) => f.endsWith('.json'))) {
+    try {
+      const code = JSON.parse(fs.readFileSync(path.join(PANELS_DIR, f), 'utf8')).code || '';
+      for (const m of code.matchAll(/https?:\/\/([a-z0-9.-]+(?::\d+)?)/gi)) hosts.add(m[1].toLowerCase());
+    } catch { }
+  }
+  return hosts;
+}
+
+// ── 工作台工程师 Agent（对话式开发工作台的 skill：工具即扩展点）──
+const DEV_TOOLS = {
+  list_workbench: {
+    desc: '查看当前工作台 DSL（live 与未发布草稿）',
+    schema: {}, required: [],
+    run: async () => JSON.stringify({ live: loadWorkbench(devCtx.agentId), draft: loadDraft(devCtx.agentId) }, null, 1),
+  },
+  list_panel_plugins: {
+    desc: '列出面析插件库（可复用的自定义面板插件）',
+    schema: {}, required: [],
+    run: async () => JSON.stringify(listPanelPlugins(), null, 1),
+  },
+  get_state_schema: {
+    desc: '获取现场实时数据样例（面板 props 的数据结构）',
+    schema: {}, required: [],
+    run: async () => JSON.stringify({ devices: [world.devices[0]], alarms: [world.alarms[0]], kpi: world.kpi, work_orders: world.work_orders.slice(-1), note: 'devices: [{id,name,type,status(normal|warning|alarm),detail}] alarms: [{id,device,level(高|中|低),text,ts,state(active|resolved)}]' }, null, 1),
+  },
+  write_panel_plugin: {
+    desc: '创建/更新面板插件（写入插件库）。代码必须定义 function Panel(props)',
+    schema: {
+      id: { type: 'string', description: '插件 id，小写字母数字连字符，如 alarm-by-type' },
+      name: { type: 'string', description: '插件显示名' },
+      description: { type: 'string', description: '一句话说明' },
+      code: { type: 'string', description: '面板代码，契约见系统提示' },
+    }, required: ['id', 'name', 'code'],
+    run: async ({ id, name, description, code }) => {
+      const plugin = savePanelPlugin({ id, name, description, code });
+      metric({ kind: 'plugin_write', agentId: devCtx.agentId, id });
+      return `插件已入库：${plugin.id}@${plugin.version}（${plugin.name}）。用 update_workbench 把它加入工作台草稿。`;
+    },
+  },
+  list_collections: {
+    desc: '列出平台数据集（含 schema），供面板绑定与助手查询',
+    schema: {}, required: [],
+    run: async () => JSON.stringify(loadCollections(), null, 1),
+  },
+  create_collection: {
+    desc: '创建数据集（建表即建工具：助手侧自动生成 query_/create_ 工具；面板侧通过 props.store 读写）。需要 CRUD 的面板应先建数据集',
+    schema: {
+      name: { type: 'string', description: '数据集名，小写字母开头，如 maintenance_records' },
+      title: { type: 'string', description: '显示名，如 保养记录' },
+      description: { type: 'string', description: '一句话用途说明（会成为助手工具描述）' },
+      schema: { type: 'object', description: '字段定义 {字段名:{type:string|number|boolean, description:...}}' } ,
+      required: { type: 'array', description: '必填字段名数组' },
+      scope: { type: 'string', description: 'agent（默认，仅归属助手及其面板可用）或 shared（跨助手共享）' },
+    }, required: ['name', 'title', 'schema'],
+    run: async (args) => {
+      const m = saveCollection({ ...args, owner_agent: devCtx.agentId });
+      metric({ kind: 'collection_create', name: m.name });
+      return `数据集「${m.title}」(${m.name}) 已创建，scope=${m.scope}${m.scope === 'agent' ? '（私有，仅本助手）' : '（跨助手共享）'}。本助手已自动获得 query_${m.name}/create_${m.name} 工具；面板用 props.store.list('${m.name}')/create('${m.name}', doc) 读写。`;
+    },
+  },
+  exec: {
+    desc: '终端命令执行（开发档）：读白名单直接放行；写文件/跑脚本/构建调试等开发动作放行（这是你的本职）；仅毁灭性命令（sudo/rm -rf //mkfs 等）被永久拒绝。用于探索 AGENT.md、写临时代码、运行测试、验证接口。全部调用入审计',
+    schema: { command: { type: 'string', description: '只读命令，如 grep -rl "Nexus" <目录>/*/AGENT.md' }, timeout_ms: { type: 'number' } },
+    required: ['command'],
+    run: async ({ command, timeout_ms = 30000 }) => {
+      // 工程师权限模型：写代码/调试是本职——仅毁灭性黑名单拦截（产出另受草稿审阅门治理），全程审计
+      const cls = classifyExec(command, 3);
+      if (cls.status === 'blocked') return `【拒绝】${cls.reason}`; // 开发档：只拦毁灭性黑名单；pending(写类)对工程师免确认
+      const env = { ...process.env };
+      delete env.ZAI_CODING_CN_API_KEY; delete env.LLM_API_KEY; delete env.ARM_PAT;
+      return await new Promise((resolve) => {
+        cpExec(command, { cwd: ROOT, timeout: +timeout_ms, maxBuffer: 1024 * 512, env, shell: process.env.SHELL || '/bin/zsh' }, (err, stdout, stderr) => {
+          audit({ actor: 'dev-agent', tool: 'exec', command: String(command).slice(0, 200), ok: !err });
+          resolve(`$ ${command}\n${String(stdout || '').slice(0, 5000)}${stderr ? '\n[stderr] ' + String(stderr).slice(0, 1000) : ''}${err && !stdout ? '\n[错误] ' + err.message : ''}`);
+        });
+      });
+    },
+  },
+  load_skill: {
+    desc: '装载技能全文（SKILL.md + references + scripts）。系统提示里只注入了技能描述；使用某技能前先装载它获得完整规范',
+    schema: { name: { type: 'string', description: '技能名，如 workbench-dev' } }, required: ['name'],
+    run: async ({ name }) => {
+      const s = readSkill(name);
+      if (!s) return `技能 ${name} 不存在。已装载：${listSkills().map((x) => x.name).join(', ')}`;
+      audit({ actor: 'dev-agent', skill: name, action: 'load' });
+      return JSON.stringify({ name: s.name, version: s.version, files: Object.keys(s.files), ...(s.files['SKILL.md'] ? { body: s.files['SKILL.md'] } : {}) }, null, 1).slice(0, 12000);
+    },
+  },
+  read_panel_plugin: {
+    desc: '读取插件库中某个插件的当前代码（修改/升级已有插件前必须先读）',
+    schema: { id: { type: 'string', description: '插件 id' } }, required: ['id'],
+    run: async ({ id }) => {
+      const plugin = loadPanelPlugin(id);
+      if (!plugin) return `插件 ${id} 不存在。现有：${listPanelPlugins().map(p => p.id).join(', ')}`;
+      return `插件 ${plugin.id}@${plugin.version}（${plugin.name}）：\n${plugin.code}`;
+    },
+  },
+  update_workbench: {
+    desc: '把完整的工作台 DSL 写入草稿（不会直接生效，需用户在编辑器审阅后发布）。基于当前 DSL 增量修改后整体提交',
+    schema: { dsl: { type: 'object', description: "完整工作台 DSL {workbench,version,panels:[...]}。panels 元素含 id/type/title；自定义面板用 type=custom_panel 且 panel=插件id，或 type=custom 且 code=面板代码" } },
+    required: ['dsl'],
+    run: async ({ dsl }) => {
+      saveDraft(devCtx.agentId, dsl);
+      return `草稿已保存（${dsl.panels.length} 个面板）。提醒用户在「定制工作台」审阅差异后点发布。`;
+    },
+  },
+};
+const devCtx = { agentId: null };
+const devSessions = new Map();
+
+function devSystemPrompt() {
+  const live = loadWorkbench(devCtx.agentId);
+  const plugins = listPanelPlugins();
+  const owner = agentProfileNow(devCtx.agentId); // 工作台所属助手档案：本地库优先（离线可用）
+  const localDir = localAgent(devCtx.agentId) ? path.join(ARM_AGENTS_DIR, devCtx.agentId, 'versions', localAgent(devCtx.agentId).installed_version) : null;
+  return [
+    '【本工作台所属助手（你的探索起点）】',
+    owner && owner.name ? `名称: ${owner.name} ${owner.version || ''}\n档案 prompt:\n${(owner.prompt || '').slice(0, 600)}\n绑定知识: ${(owner.knowledges || []).join('、') || '无'}` : '（ARM 档案未缓存，先让平台调用过该助手）',
+    localDir ? `助手本地档案（平台下载物化）: ${localDir} —— manifest.json 含技能/知识绑定清单，knowledges/ 为知识全文` : '',
+    `ARM 工作站助手目录（若配置）: ${process.env.ARM_WS_ROOT || '未配置'} —— 每个从 ARM 下载的助手有独立文件夹，AGENT.md 描述其定位与真实能力（含可用脚本/服务器/接口线索）。按名定位：grep -rl "助手名" <目录>/*/AGENT.md`,
+    '',
+    '你是 AIMS 工业智能体平台的「工作台工程师」，通过编写面板插件帮用户对话式定制工作台。',
+    '',
+    '【面板插件契约（扩展点）】',
+    '插件是一段 JS 代码，必须定义：function Panel(props) { return html`...` }',
+    '· html 是 htm 模板标签（绑定 React.createElement），写法：html`<div className="text-xs">${x}</div>`',
+    '· 可用 hooks：useState / useEffect / useRef / useMemo（已注入，直接用）',
+    '· props（实时现场数据 + 交互）：',
+    '  devices:[{id,name,type,status:normal|warning|alarm,detail}]  alarms:[{id,device,level:高|中|低,text,ts,state}]',
+    '  kpi:{出入库吞吐:...}  work_orders:[{id,device,priority,state}]  selected(当前选中设备id)  onSelect(id)(选中设备)',
+    '· 样式用 Tailwind className（暗色主题；卡片 bg-card border rounded-lg p-3；主色 text-primary；状态色 emerald/amber/red）',
+    '· 禁止 import/require/window 操作；需要更多数据可 fetch("/api/state")',
+    '· 面板渲染于工作台左栏（宽约 290px）或中栏（dsl 里 slot:"center"），布局要紧凑',
+    '',
+    '【参考实现（严格仿照此风格）】',
+    'function Panel({ devices, selected, onSelect }) {',
+    '  const bad = devices.filter(d => d.status !== "normal")',
+    '  return html`<div className="p-2 text-xs">',
+    '    <div className="mb-2 font-semibold">异常设备 ${bad.length} 台</div>',
+    '    ${devices.filter(d=>d.status!=="normal").map(d => html`',
+    '      <div key=${d.id} onClick=${() => onSelect(d.id)}',
+    '        className=${"mb-1 cursor-pointer rounded border p-1.5 " + (d.status==="alarm" ? "border-red-500/60 bg-red-500/10" : "border-amber-500/50 bg-amber-500/5")}>',
+    '        <span className="font-mono">${d.id}</span> <span className="text-muted-foreground">${d.name}</span>',
+    '        <div className="text-[10px] text-muted-foreground">${d.detail}</div>',
+    '      </div>`)}',
+    '  </div>`',
+    '}',
+    '',
+    '【当前工作台】', JSON.stringify(live ? { workbench: live.workbench, panels: live.panels.map(p => ({ id: p.id, type: p.type, title: p.title, panel: p.panel })) } : null),
+    '【插件库】', JSON.stringify(plugins.map(p => ({ id: p.id, name: p.name, version: p.version }))),
+    '',
+    '【修改已有插件】先 read_panel_plugin 看当前代码 → 需要持久数据就 create_collection → write_panel_plugin 同 id 覆盖（版本自增）→ 需要时 update_workbench 调整布局。同 id 写入即升级，工作台引用不受影响。',
+    '【自探索工作流（必须遵守）】理解需求 → 探索 → 规划 → 实现 → 提交草稿：',
+    '1. 探索：新需求涉及助手既有能力时，必须先 exec 读它的 AGENT.md（按名 grep 定位），必要时读其 skills/脚本与验证相关接口（curl 实测返回结构）。能推送通常就能搜索——从脚本/配置里找到真实的服务地址与 API。',
+    '2. 规划：把探索结论映射为面板方案（数据从哪来、经什么能力取、展示成什么），方案要说清"复用了助手的哪个既有能力"。',
+    '3. 实现：面板运行在浏览器，内网接口跨域受限——一律经平台代理取数：fetch("/api/proxy?url=" + encodeURIComponent(接口地址))，返回 {status, body}。',
+    '4. 提交：write_panel_plugin + update_workbench 草稿，明确告知用户审阅发布。',
+    '【工作方式】改已有面板时基于当前 DSL 增量修改；单一职责，先小后大。',
+    '【已装载技能（用前先 load_skill 读全文）】',
+    ...listSkills().map((s) => `- ${s.name}${s.version ? '@' + s.version : ''}: ${s.description}`),
+    '',
+    '【数据读写（props.store 契约）】需要 CRUD 的面板先 create_collection 建数据集，再用 store 读写：',
+    '· props.store.list(name, {filter, sort, limit}) → Promise<records[]>  （filter 为字段精确匹配对象）',
+    '· props.store.create(name, doc) / props.store.update(name, id, patch) / props.store.remove(name, id)',
+    '参考：const [rows, setRows] = useState([]); useEffect(() => { props.store.list("maintenance_records", { limit: 20 }).then(setRows) }, []);',
+    '添加记录：onClick 里 await props.store.create("maintenance_records", { device, date, item, worker }); 然后重新 list 刷新。',
+    '注意：数据集字段要贴合业务（设备/日期/项目/执行人）。数据默认私有（仅创建它的助手可查可用，物理上独立库文件隔离）；确需跨助手共享才用 scope=shared。',
+    '【区块几何感知】面板渲染在用户规划的自由网格区块中，params.grid={x,y,w,h}(12列)：',
+    '- 宽占比 = w/12：w<=3（窄条）用紧凑单列列表/迷你卡，禁表格与横向多列；w 4-8 用两列卡或紧凑表；w>=9 可用表格/仪表盘多列',
+    '- h>=2 的高区块可加滚动列表或上下分区；h=1 保持一眼可见',
+    '- 新增插件默认 params.grid 由工作台分配，不要自行假设宽度',
+    '【完成度准则（web-design 精要）】面板必须"交付即完整”：',
+    '- 异步数据要有 加载/空/错误 三态（空数据不空白，出错显示错误文案而不是静默）；',
+    '- 视觉：1px 边框分层，不用阴影/渐变；层级靠字号字重与留白；主色 text-primary 克制使用，状态色 emerald/amber/red 语义化；',
+    '- 交互：可点目标≥28px；输入法回车安全（onKeyDown 判断 e.isComposing 不触发）；键盘 Esc/Enter 可用。',
+    '【面板动作契约（按钮触发服务端命令）】需要"输入→执行→出结果"的面板（如推送镜像）：',
+    '1. 在面板 params.actions 声明：[{id:"push", label:"推送", exec:"命令模板 ${image}", confirm:"确认推送 ${image}？"}]（exec 中 ${key} 会被用户输入替换）',
+    '2. 面板代码：const r = await props.runAction("push", { image }); → r = {ok, output, error}',
+    '3. 服务端执行有黑名单与审计；命令绑定随工作台草稿走人工审阅。涉及凭据的命令把账号写进 exec 模板（人审时可见）。',
+    '【硬性约束】update_workbench 必须携带全部未修改面板的完整字段——尤其 action_group 的 actions 数组与 confirm 文案、status_grid 的 device_type——遗漏会导致配置丢失（平台会尽力从上一版补全，但不要依赖）。',
+  ].join('\n');
+}
+
+async function devChatLoop(session, emit) {
+  const events = [];
+  const tools = Object.entries(DEV_TOOLS).map(([n, t]) => ({ name: n, description: t.desc, parameters: { type: 'object', properties: t.schema, required: t.required || [] } }));
+  for (let round = 0; round < 24; round++) {
+    emit('status', { text: `第 ${round + 1}/24 轮` });
+    const stream = models.stream(model, session.context);
+    for await (const ev of stream) {
+      if (ev.type === 'text_delta') emit('text_delta', { delta: ev.delta });
+      else if (ev.type === 'toolcall_end') emit('status', { text: `调用工具 ${ev.toolCall?.name || ''}` });
+    }
+    const final = await stream.result();
+    session.context.messages.push(final);
+    const calls = (final.content || []).filter(b => b.type === 'toolCall');
+    const text = (final.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+    if (!calls.length) { emit('done', { reply: text, events }); return { reply: text, events }; }
+    for (const tc of calls) {
+      const args = tc.arguments || {};
+      emit('tool_start', { tool: tc.name, args });
+      let result, isErr = false;
+      try { result = await DEV_TOOLS[tc.name].run(args); }
+      catch (e) { result = `失败: ${e.message}`; isErr = true; }
+      events.push({ tool: tc.name, args, result: String(result).slice(0, 400), ok: !isErr });
+      emit('tool_end', { tool: tc.name, args, result: String(result).slice(0, 600), ok: !isErr });
+      session.context.messages.push({ role: 'toolResult', toolCallId: tc.id, toolName: tc.name, content: [{ type: 'text', text: String(result) }], isError: isErr, timestamp: Date.now() });
+    }
+  }
+  emit('done', { reply: '（达到轮次上限——请把结论性需求拆小，或继续对话续跑）', events });
+  return { reply: '（达到轮次上限）', events };
+}
+
+// ── 助手运行时（pi-ai Context + 守护栏 + SSE 事件流）────
+const sessions = new Map(); // sid -> { agentId, autonomy, context, pending }
+
+function systemPrompt(armAgent, deployment, autonomy, ws) {
+  // 工厂画像按 knowledge_slices 条件注入（02 设计：切片授权=上下文工程+权限治理）；
+  // 未声明画像切片的助手（现阶段的绝大多数）只有自己的档案 prompt——不注入硬编码场景（2026-10-15 MVP 打磨）
+  const slices = (deployment.knowledge_slices || []).map((s) => String(s));
+  const hasProfile = slices.some((s) => s.includes('工厂画像'));
+  const scene = sceneProfile();
+  return [
+    armAgent.prompt || '你是运维助手。',
+    '',
+    ...(scene ? ['【平台全局场景画像】（使用方环境事实，对所有助手共享）', scene, ''] : []),
+    '【当前工作区】',
+    ws ? `${ws.name}（${ws.path}）——exec 的工作目录（cwd），文件读写以此为根；平台文件用绝对路径（如 tail -50 ${path.join(ROOT, 'data/audit.log')}）` : '（默认）',
+    '',
+    '【自主级别策略】',
+    `当前级别 ${LEVEL_NAME[autonomy]}。L0=只读问答；L1=诊断建议+可沉淀经验；L2=可发起需人工确认的执行操作。`,
+    '执行类工具发起后会挂起等待用户在界面确认，确认后才真正执行。',
+    ...(hasProfile && world.devices.length ? ['', '【工厂画像（知识切片授权）】', `设备: ${world.devices.map(d => `${d.id}(${d.name},${d.type})`).join('；')}`, '高危操作必须人工确认'] : []), // 真实画像数据接入前（world 为空）诚实跳过
+    '',
+    '【能力哲学：少量原语 + 组合，而非功能堆叠】',
+    '你拥有通用终端 exec 和平台数据服务（data_describe/data_query/data_write）。不要期待每个功能都有专用工具——先用原语组合：',
+    '- 连通性实测：exec `nc -vz -w 3 <host> <port>`（"能否连接"必须实测）',
+    '- 平台数据：先 data_describe 看字典，再 data_query 查询（服务端按助手隔离）',
+    '- 现场若有已接入的数据面板，以工作台展示为准；没有就说没有，不猜测',
+    'exec 只读命令直接执行；写命令需 L2+人工确认；危险命令永久拒绝。',
+    '',
+    '【事实与推断分离（硬规则）】',
+    '- 连通性结论只能来自实测（nc/curl）；记录存在≠可达，设备状态在线≠可达',
+    '- 不同数据源的关联必须有显式字段，禁止按名称相似猜测对应；无依据时明说"未关联"',
+    '- 没有能力做到的事如实说"无法验证"，不允许编造结论',
+    '',
+    '【工作方式】',
+    'exec/data 取实时证据 → search_knowledge 检索历史经验对照 → 给结论。',
+    '回答精炼：结论先行 + 依据 + 建议动作。中文。处置成功且有价值时主动 save_experience 沉淀经验。',
+    '',
+    '【富回复块（a2ui）】当回复更适合组件而非长文本时，输出 ```a2ui 围栏块（内为严格 JSON，应用原生渲染）：',
+    '- choice：需要用户做一个决定（2-5 个选项，可标 recommended:true；块必须是回复结尾；用户点击后以纯文本回传）',
+    '- form：一次收集多个输入（1-6 字段 {id,label,kind,placeholder,required}；提交按"label: 答案"逐行回传）',
+    '- steps：手工操作步骤（每步一句祈使句；warning/caution 放在它保护的那一步上）',
+    '- callout：必须被注意的单一警示/提示（tone: note|tip|caution|warning）',
+    '- metrics：少量读数一览（items:[{label,value,unit,warn,danger}]，注明 asOf）',
+    '规则：块前要有一句引导语；choice/form 之后不再有文字；数据必须来自工具实测并注明 asOf，不得编造；一个回复最多 1-2 个块。用户说"给选项/怎么选/选哪个"时优先用 choice。',
+    '强化：凡回复包含 2 个及以上并列的可选动作时，一律用 choice 块呈现（不要用编号/短横线列表罗列选项）。需要采集多个参数（设备/日期/原因等）时用 form 块。示例：\n服务器 CPU 持续 90%，如何处置？\n```a2ui\n{"type":"choice","question":"服务器 CPU 90% 的处置方式","options":[{"label":"先持续观察 30 分钟","description":"短期可控"},{"label":"定位高 CPU 进程","description":"top 找出元凶再决定","recommended":true},{"label":"立即重启服务","description":"影响可用性，需值班确认"}]}\n```',
+  ].join('\n');
+}
+
+async function ensureSession(sessionId, agentId, autonomyLevel, wsId) {
+  let s = sessions.get(sessionId);
+  const deployment = loadDeployment(agentId);
+  if (!deployment) throw new Error('该助手未上岗（无 deployment）');
+  const armAgent = await getArmAgent(agentId);
+  if (!s || s.agentId !== agentId || (wsId && s.wsId !== wsId)) { // 切工作区 = 新会话上下文（旧会话留在原工作区）
+    s = { agentId, wsId: wsId || 'default', autonomy: { L0: 0, L1: 1, L2: 2 }[deployment.default_autonomy] ?? 1, context: null, pending: null };
+    sessions.set(sessionId, s);
+  }
+  const ws = getWs(agentId, s.wsId) || currentWs(agentId);
+  if (typeof autonomyLevel === 'number') s.autonomy = autonomyLevel;
+  if (!s.context) {
+    s.context = { systemPrompt: systemPrompt(armAgent, deployment, s.autonomy, ws), messages: [], tools: piTools(deployment) };
+  } else if (typeof autonomyLevel === 'number') {
+    s.context.systemPrompt = systemPrompt(armAgent, deployment, s.autonomy, ws);
+  }
+  return { s, deployment, armAgent };
+}
+
+// 运行一轮 Agent 循环，事件通过 emit(type, data) 推给 SSE；s.running/s.statusText 供跨页面进度跟踪
+async function agentLoop(s, deployment, emit, maxRounds = 16) {
+  for (let round = 0; round < maxRounds; round++) {
+    s.statusText = `第 ${round + 1}/${maxRounds} 轮 · 推理中`;
+    const stream = models.stream(model, s.context);
+    emit('status', { text: '推理中…' });
+    for await (const ev of stream) {
+      if (ev.type === 'text_delta') emit('text_delta', { delta: ev.delta });
+      else if (ev.type === 'thinking_start') emit('status', { text: '思考中…' });
+      else if (ev.type === 'toolcall_end') emit('status', { text: `准备调用工具 ${ev.toolCall?.name || ''}` });
+      else if (ev.type === 'error') throw new Error(`LLM 流错误: ${ev.error?.errorMessage || JSON.stringify(ev.error).slice(0, 200)}`);
+    }
+    const final = await stream.result();
+    s.context.messages.push(final);
+    const textNow = (final.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
+    const calls = (final.content || []).filter(b => b.type === 'toolCall');
+    if (!calls.length) return { reply: textNow, pending: null };
+
+    for (const tc of calls) {
+      const args = tc.arguments || {};
+      emit('tool_start', { tool: tc.name, args });
+      s.statusText = `调用工具 ${tc.name}`;
+      const g = guardCheck(tc.name, s.autonomy, s.agentId, tc.arguments || {});
+      if (!g.allowed) {
+        s.context.messages.push({ role: 'toolResult', toolCallId: tc.id, toolName: tc.name, content: [{ type: 'text', text: g.reason }], isError: false, timestamp: Date.now() });
+        emit('tool_end', { tool: tc.name, args, result: g.reason, status: g.status });
+        audit({ actor: 'guardrail', agent: deployment.agent_id, tool: tc.name, autonomy: s.autonomy, verdict: g.status });
+        continue;
+      }
+      if (g.confirm_required && !s.pending) { // 挂起等待人工确认（L2）
+        s.pending = { tool_call_id: tc.id, tool: tc.name, args };
+        s.statusText = `等待人工确认 ${tc.name}`;
+        emit('pending', { pending: s.pending, intro: textNow });
+        return { reply: textNow || `已准备好执行 ${tc.name}，请确认。`, pending: s.pending };
+      }
+      if (s.pending && s.pending.tool_call_id === tc.id) s.pending = null;
+      let result, isErr = false;
+      s.statusText = `执行工具 ${tc.name}`;
+      try { result = await getTool(tc.name).run(args, s.agentId, s.wsId || 'default'); }
+      catch (e) { result = `工具执行失败: ${e.message}`; isErr = true; }
+      s.context.messages.push({ role: 'toolResult', toolCallId: tc.id, toolName: tc.name, content: [{ type: 'text', text: String(result) }], isError: isErr, timestamp: Date.now() });
+      emit('tool_end', { tool: tc.name, args, result: String(result), status: 'ok' });
+      audit({ actor: 'assistant', agent: deployment.agent_id, tool: tc.name, autonomy: s.autonomy, ok: !isErr });
+    }
+  }
+  return { reply: '（达到工具调用轮次上限）', pending: null };
+}
+
+// ── HTTP ────────────────────────────────────────────────
+function json(res, code, data) { res.writeHead(code, { 'Content-Type': 'application/json; charset=utf-8' }); res.end(JSON.stringify(data)); }
+async function body(req) { let s = ''; for await (const c of req) s += c; return s ? JSON.parse(s) : {}; }
+function sseInit(req, res) {
+  res.writeHead(200, { 'Content-Type': 'text/event-stream; charset=utf-8', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
+  return (type, data) => res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`);
+}
+
+const server = http.createServer(async (req, res) => {
+  const url = new URL(req.url, `http://localhost:${PORT}`);
+  const pathname = url.pathname;
+  try {
+    // ── 静态前端（web/dist 生产构建）──
+    if (req.method === 'GET' && !pathname.startsWith('/api')) {
+      let p = path.join(ROOT, 'web/dist', pathname === '/' ? 'index.html' : pathname);
+      if (!p.startsWith(path.join(ROOT, 'web/dist')) || !fs.existsSync(p)) p = path.join(ROOT, 'web/dist/index.html');
+      if (fs.existsSync(p)) {
+        const mime = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.css': 'text/css', '.svg': 'image/svg+xml', '.png': 'image/png', '.ico': 'image/x-icon' }[path.extname(p)] || 'application/octet-stream';
+        res.writeHead(200, { 'Content-Type': mime });
+        return res.end(fs.readFileSync(p));
+      }
+      return json(res, 404, { error: '前端未构建：cd web && pnpm build' });
+    }
+    if (req.method === 'GET' && pathname === '/api/health') return json(res, 200, { ok: true, model: model?.id, arm: armMcpUrl(), pat: !!ARM_PAT, local_agents: loadRegistry().agents.length });
+
+    // ── ARM 连接与同步（07：大厅双视图 = 本地助手库 ∪ 远端目录）──
+    if (req.method === 'GET' && pathname === '/api/settings') {
+      const t = armApiToken();
+      const k = llmApiKey();
+      return json(res, 200, {
+        arm: {
+          api_base: armApiBase(), api_base_runtime: !!cfg.arm_api_base,
+          mcp_url: armMcpUrl(), mcp_explicit: !!cfg.arm_mcp_url,
+          token_set: !!t, token_masked: t ? `${t.slice(0, 10)}…${t.slice(-4)}` : '',
+          token_source: cfg.arm_token ? 'runtime' : (env.ARM_API_TOKEN ? 'env' : (ARM_PAT ? 'pat' : 'none')),
+        },
+        llm: {
+          base_url: llmBaseUrl(), base_url_runtime: !!cfg.llm_base_url, default_base: LLM_DEFAULT_BASE,
+          model: llmModelName(), model_runtime: !!cfg.llm_model, catalog: llmCatalog,
+          key_set: !!k, key_masked: k ? `${k.slice(0, 6)}…${k.slice(-4)}` : '',
+          key_source: cfg.llm_api_key ? 'runtime' : (env.LLM_API_KEY ? 'env' : 'none'),
+        },
+        scene: { profile: sceneProfile(), length: sceneProfile().length },
+      });
+    }
+    if (req.method === 'PUT' && pathname === '/api/settings') {
+      const { arm_api_base, arm_mcp_url, arm_token, llm_base_url, llm_api_key, llm_model, scene_profile } = await body(req);
+      const normUrl = (u) => { const s = String(u || '').trim().replace(/\/+$/, ''); return s; };
+      let sceneChanged = false;
+      if (scene_profile !== undefined) {
+        const sp = String(scene_profile || '').trim().slice(0, SCENE_PROFILE_MAX); // 置空 = 清除（不注入）
+        sceneChanged = sp !== sceneProfile();
+        cfg.scene_profile = sp;
+      }
+      if (arm_api_base !== undefined) {
+        const u = normUrl(arm_api_base);
+        if (u && !/^https?:\/\/[^\s/]+/.test(u)) return json(res, 400, { error: `站点地址须为 http(s) URL：${u}` });
+        cfg.arm_api_base = u;
+      }
+      if (arm_mcp_url !== undefined) {
+        const u = normUrl(arm_mcp_url);
+        if (u && !/^https?:\/\/[^\s/]+/.test(u)) return json(res, 400, { error: `MCP 端点须为 http(s) URL：${u}` });
+        cfg.arm_mcp_url = u;
+      }
+      if (arm_token !== undefined) cfg.arm_token = String(arm_token || '').trim(); // 置空 = 回落 env/PAT
+      if (llm_base_url !== undefined) {
+        const u = normUrl(llm_base_url);
+        if (u && !/^https?:\/\/[^\s/]+/.test(u)) return json(res, 400, { error: `LLM 端点须为 http(s) URL：${u}` });
+        cfg.llm_base_url = u; // 置空 = 回落默认（智谱 coding plan）
+      }
+      if (llm_model !== undefined) {
+        const m = String(llm_model || '').trim();
+        if (m && !/^[\w.:@\/-]{1,80}$/.test(m)) return json(res, 400, { error: `模型名不合法：${m}` });
+        cfg.llm_model = m;
+      }
+      if (llm_api_key !== undefined) cfg.llm_api_key = String(llm_api_key || '').trim();
+      // LLM 热切换：先应用验证，失败整体回滚（应用只是构建对象，无网络请求）
+      let llm_probe = null;
+      if ([llm_base_url, llm_model, llm_api_key].some((v) => v !== undefined)) {
+        const backup = { ...cfg };
+        try { await applyLLMConfig(); }
+        catch (e) {
+          Object.assign(cfg, backup);
+          try { await applyLLMConfig(); } catch { }
+          return json(res, 400, { error: `LLM 配置应用失败，已回滚保持原配置：${e.message}` });
+        }
+        try { llm_probe = await llmProbe(); } catch (e) { llm_probe = { online: false, error: String(e.message).slice(0, 150) }; }
+      }
+      saveCfg();
+      audit({ actor: 'settings', action: 'save', arm_api_base: cfg.arm_api_base, mcp_explicit: !!cfg.arm_mcp_url, llm_model: cfg.llm_model, llm_base_changed: llm_base_url !== undefined, token_changed: arm_token !== undefined || llm_api_key !== undefined, scene_profile_changed: sceneChanged, scene_profile_len: sceneProfile().length });
+      // ARM 保存后即时探测（失败不回滚：允许先配置后启动 ARM）
+      let probe = { online: false, error: '' };
+      if ([arm_api_base, arm_mcp_url, arm_token].some((v) => v !== undefined)) {
+        try {
+          const t0 = Date.now();
+          await armRest('/api/v1/agents?page=1&pageSize=1', {}, 6000);
+          probe = { online: true, latency_ms: Date.now() - t0 };
+        } catch (e) { probe = { online: false, error: String(e.message).slice(0, 120) }; }
+      }
+      const notes = [];
+      if (probe.error) notes.push('ARM 当前源不可达（目录/检索将回落 MCP 或本地库，源恢复后自动可用）');
+      if (llm_probe && !llm_probe.online) notes.push('LLM 已保存但探针未通过（密钥/端点/模型可用性待确认，对话可能失败，可再试或改回）');
+      return json(res, 200, { saved: true, probe, llm_probe, note: notes.join('；') });
+    }
+    if (req.method === 'GET' && pathname === '/api/arm/status') {
+      let online = false, latency_ms = null;
+      const t0 = Date.now();
+      try {
+        await armRest('/api/v1/agents?page=1&pageSize=1', {}, 6000);
+        online = true; latency_ms = Date.now() - t0;
+      } catch {
+        try { // 旧版 ARM 无 REST：回落 MCP 探测
+          await mcpCall('search_agents', { keyword: '', limit: 1 }, { timeout_ms: 6000 });
+          online = true; latency_ms = Date.now() - t0;
+        } catch { }
+      }
+      const reg = loadRegistry();
+      return json(res, 200, { online, latency_ms, url: armMcpUrl(), api: armApiBase(), pat: !!ARM_PAT, last_sync_at: reg.last_sync_at || null, local_count: reg.agents.length, outbox_pending: outboxCount() });
+    }
+    if (req.method === 'POST' && pathname === '/api/arm/sync') {
+      try { return json(res, 200, await armSync()); }
+      catch (e) { return json(res, 502, { error: `ARM 同步失败（离线模式可继续使用本地助手）: ${e.message}` }); }
+    }
+
+    // ── 助手目录（本地库 ∪ 远端目录；离线时仅本地）──
+    if (req.method === 'GET' && pathname === '/api/agents') {
+      const keyword = url.searchParams.get('keyword') || '';
+      const reg = loadRegistry();
+      let online = true, remoteCards = [];
+      try { remoteCards = await armListAgents(keyword); } // REST 全量优先，旧版回落 MCP
+      catch { online = false; }
+      const byId = new Map();
+      for (const e of reg.agents) {
+        const lm = localManifest(e.agent_id) || {};
+        byId.set(e.agent_id, {
+          agent_id: e.agent_id, name: e.name, version: e.installed_version,
+          skills: (lm.skills || []).length, knowledges: (lm.knowledges || []).length,
+          description: e.description || lm.description || '',
+          deployed: !!loadDeployment(e.agent_id), installed: true,
+          installed_version: e.installed_version, remote_version: e.remote_version || null,
+          update_available: !!(e.remote_version && cmpVersion(e.remote_version, e.installed_version) > 0),
+          delisted: !!e.delisted, downloaded_at: e.downloaded_at || null,
+        });
+      }
+      if (online) { // 静默刷新远端版本与下架标记（显式事件统计走 /api/arm/sync）
+        const ids = new Set(remoteCards.map(c => c.agent_id));
+        for (const c of remoteCards) {
+          const cur = byId.get(c.agent_id) || { agent_id: c.agent_id, installed: false, installed_version: null, downloaded_at: null };
+          byId.set(c.agent_id, {
+            ...cur, name: c.name, version: c.version, skills: c.skills, knowledges: c.knowledges,
+            description: c.description || cur.description, remote_version: c.version,
+            deployed: !!loadDeployment(c.agent_id),
+            update_available: cur.installed ? cmpVersion(c.version, cur.installed_version) > 0 : false,
+          });
+        }
+        for (const e of reg.agents) {
+          if (ids.has(e.agent_id)) { e.remote_version = byId.get(e.agent_id)?.remote_version || e.remote_version; e.delisted = false; }
+          else e.delisted = true;
+        }
+        reg.last_sync_at = new Date().toISOString();
+        saveRegistry(reg);
+      }
+      return json(res, 200, { online, last_sync_at: reg.last_sync_at || null, agents: [...byId.values()] });
+    }
+    // ── 本地助手库：下载 / 升级 / 版本历史 / 回滚 / 卸载 ──
+    let mAgt = pathname.match(/^\/api\/agents\/([0-9a-f-]{36})\/(download|upgrade|versions|rollback)$/);
+    if (mAgt && req.method === 'POST' && (mAgt[2] === 'download' || mAgt[2] === 'upgrade')) {
+      try {
+        const m = await downloadAgent(mAgt[1]); // 升级 = 下载新版 + 原子切指针（档案/配置分离：deployment/工作台/数据不动）
+        return json(res, 200, { manifest: { agent_id: m.agent_id, name: m.name, version: m.version, knowledges_local: m.knowledges.filter(k => k.file).length, skills: m.skills.length } });
+      } catch (e) { return json(res, 502, { error: `下载失败（需 ARM 在线）: ${e.message}` }); }
+    }
+    if (mAgt && req.method === 'GET' && mAgt[2] === 'versions') {
+      const reg = loadRegistry();
+      const e = reg.agents.find(a => a.agent_id === mAgt[1]);
+      if (!e) return json(res, 404, { error: '本地未安装该助手' });
+      return json(res, 200, {
+        installed_version: e.installed_version, remote_version: e.remote_version || null,
+        versions: e.versions.slice().reverse().map(v => {
+          const m = localManifest(mAgt[1], v);
+          return { version: v, current: v === e.installed_version, downloaded_at: m?.downloaded_at || null, knowledges: (m?.knowledges || []).length };
+        }),
+      });
+    }
+    if (mAgt && req.method === 'POST' && mAgt[2] === 'rollback') {
+      const { version } = await body(req);
+      const reg = loadRegistry();
+      const e = reg.agents.find(a => a.agent_id === mAgt[1]);
+      if (!e) return json(res, 404, { error: '本地未安装该助手' });
+      if (!e.versions.includes(version) || !localManifest(mAgt[1], version)) return json(res, 404, { error: `本地版本 ${version} 不存在。可用：${e.versions.join(', ')}` });
+      e.installed_version = version;
+      saveRegistry(reg);
+      audit({ actor: 'arm-library', agentId: mAgt[1], action: 'rollback', to: version });
+      return json(res, 200, { installed_version: version });
+    }
+    let mAgtDel = pathname.match(/^\/api\/agents\/([0-9a-f-]{36})$/);
+    if (mAgtDel && req.method === 'DELETE') {
+      const agentId = mAgtDel[1];
+      const { force, purge_workspaces } = await body(req);
+      if (loadDeployment(agentId) && !force) {
+        return json(res, 409, { error: '该助手在岗：卸载将同时删除上岗配置与工作台定义', hint: '确认卸载请带 force=true（可另带 purge_workspaces=true 清除工作区数据）' });
+      }
+      for (const p of [path.join(DEPLOY_DIR, `${agentId}.json`), path.join(WB_DIR, `${agentId}.json`), draftPath(agentId), path.join(WB_VER_DIR, `${agentId}.json`)]) {
+        try { fs.rmSync(p, { force: true }); } catch { }
+      }
+      try { fs.rmSync(path.join(ARM_AGENTS_DIR, agentId), { recursive: true, force: true }); } catch { }
+      const reg = loadRegistry(); reg.agents = reg.agents.filter(a => a.agent_id !== agentId); saveRegistry(reg);
+      if (purge_workspaces) {
+        try { fs.rmSync(wsDir(agentId), { recursive: true, force: true }); } catch { }
+        for (const f of fs.readdirSync(DATA_DIR)) if (f.startsWith(`ws-${agentId}-`)) { try { fs.rmSync(path.join(DATA_DIR, f), { force: true }); } catch { } }
+      }
+      audit({ actor: 'arm-library', agentId, action: 'uninstall', purged_workspaces: !!purge_workspaces });
+      return json(res, 200, { ok: true });
+    }
+    // ── 本地目录浏览（新建工作区的目录选择器；只读、仅目录名，与 exec 只读白名单同一信任域）──
+    if (req.method === 'GET' && pathname === '/api/fs/dirs') {
+      const os = require('node:os');
+      const raw = url.searchParams.get('path');
+      let p = path.resolve(raw || os.homedir());
+      try {
+        if (!fs.statSync(p).isDirectory()) throw new Error('不是目录');
+      } catch (e) { return json(res, 400, { error: `无法读取 ${p}: ${e.message}` }); }
+      let names = [];
+      try {
+        names = fs.readdirSync(p, { withFileTypes: true })
+          .filter((d) => d.isDirectory() && !d.isSymbolicLink())
+          .map((d) => d.name)
+          .sort((a, b) => a.localeCompare(b, 'zh'))
+          .slice(0, 500);
+      } catch (e) { return json(res, 400, { error: `无权列出 ${p}: ${e.message}` }); }
+      const parent = path.dirname(p) !== p ? path.dirname(p) : null;
+      return json(res, 200, { path: p, parent, dirs: names });
+    }
+    // ── 工作区（07：助手 1:N 运行现场）──
+    if (req.method === 'GET' && pathname === '/api/workspaces') {
+      const agentId = url.searchParams.get('agent_id');
+      if (!agentId) return json(res, 400, { error: 'agent_id 必填' });
+      const reg = loadWsRegistry(agentId);
+      return json(res, 200, { current: reg.current, workspaces: reg.workspaces });
+    }
+    if (req.method === 'POST' && pathname === '/api/workspaces') {
+      const { agent_id, name, path: customPath } = await body(req);
+      if (!agent_id) return json(res, 400, { error: 'agent_id 必填' });
+      try {
+        const { ws, reg } = createWorkspace(agent_id, { name, path: customPath });
+        return json(res, 200, { workspace: ws, current: reg.current, workspaces: reg.workspaces });
+      } catch (e) { return json(res, 400, { error: e.message }); }
+    }
+    if (req.method === 'POST' && pathname === '/api/workspaces/select') {
+      const { agent_id, ws_id } = await body(req);
+      if (!agent_id || !ws_id) return json(res, 400, { error: 'agent_id 与 ws_id 必填' });
+      try {
+        const reg = selectWorkspace(agent_id, ws_id);
+        return json(res, 200, { current: reg.current, workspaces: reg.workspaces });
+      } catch (e) { return json(res, 400, { error: e.message }); }
+    }
+    let mWsDel = pathname.match(/^\/api\/workspaces\/(default|ws_[a-z0-9]+)$/);
+    if (mWsDel && req.method === 'DELETE') {
+      const agentId = url.searchParams.get('agent_id');
+      const { purge } = await body(req);
+      if (!agentId) return json(res, 400, { error: 'agent_id 必填' });
+      try {
+        const reg = deleteWorkspace(agentId, mWsDel[1], purge);
+        return json(res, 200, { current: reg.current, workspaces: reg.workspaces });
+      } catch (e) { return json(res, 400, { error: e.message }); }
+    }
+    if (req.method === 'GET' && pathname === '/api/deployment' && url.searchParams.get('agent_id')) {
+      const dep = loadDeployment(url.searchParams.get('agent_id'));
+      return json(res, 200, { deployment: dep });
+    }
+    if (req.method === 'PUT' && pathname === '/api/deployment') {
+      const { agent_id, name, default_autonomy, toolset } = await body(req);
+      if (!agent_id) return json(res, 400, { error: 'agent_id 必填' });
+      if (!localAgent(agent_id)) { // 上岗前物化本地档案（07：之后实例化/离线不依赖 ARM）
+        try { await downloadAgent(agent_id); }
+        catch (e) { return json(res, 502, { error: `上岗失败：ARM 不可达且本地无该助手档案（${String(e.message).slice(0, 100)}）。可先在网络恢复后重试。` }); }
+      }
+      const dep = loadDeployment(agent_id) || { agent_id, toolset: [], knowledge_slices: ['ARM经验库(检索式注入)'], guardrail_hooks: [{ on: 'pre_tool_use', policy: '写操作需 L2 + 人工确认' }] };
+      Object.assign(dep, { name: name || dep.name, default_autonomy: default_autonomy || dep.default_autonomy || 'L2', toolset: toolset || dep.toolset });
+      saveDeployment(agent_id, dep);
+      if (!loadWorkbench(agent_id)) saveWorkbench(agent_id, defaultWorkbench(dep)); // 新上岗自动生成初版工作台
+      return json(res, 200, { deployment: dep });
+    }
+    if (req.method === 'GET' && pathname === '/api/tools') {
+      return json(res, 200, { tools: Object.entries(TOOLS).map(([n, t]) => ({ name: n, description: t.desc, min_level: t.min_level, confirm_required: t.confirm_required })) });
+    }
+
+    // ── 工作台 DSL ──
+    if (req.method === 'GET' && pathname === '/api/workbench') {
+      const id = url.searchParams.get('agent_id');
+      if (url.searchParams.get('draft') === '1') {
+        const draft = loadDraft(id);
+        return json(res, 200, { dsl: draft || loadWorkbench(id), isDraft: !!draft, versions: workbenchVersions(id) });
+      }
+      return json(res, 200, { dsl: loadWorkbench(id), versions: workbenchVersions(id) });
+    }
+    if (req.method === 'PUT' && pathname === '/api/workbench') {
+      const { agent_id, dsl } = await body(req);
+      if (!agent_id || !dsl?.panels) return json(res, 400, { error: 'agent_id 与 dsl.panels 必填' });
+      dsl.version = nextVersion(dsl.version, agent_id);
+      saveWorkbench(agent_id, dsl);
+      try { fs.rmSync(draftPath(agent_id), { force: true }); } catch { }
+      return json(res, 200, { dsl, versions: workbenchVersions(agent_id) });
+    }
+    if (req.method === 'POST' && pathname === '/api/workbench/rollback') {
+      const { agent_id, version } = await body(req);
+      const vp = path.join(WB_VER_DIR, `${agent_id}.json`);
+      const vers = fs.existsSync(vp) ? JSON.parse(fs.readFileSync(vp, 'utf8')) : [];
+      const hit = vers.find(v => v.version === String(version));
+      if (!hit) return json(res, 404, { error: `版本 ${version} 不存在` });
+      hit.dsl.version = nextVersion(hit.dsl.version, agent_id); // 回滚也前进一个版本号，保持单调
+      saveWorkbench(agent_id, hit.dsl);
+      audit({ actor: 'workbench', agentId: agent_id, action: 'rollback', to: version });
+      return json(res, 200, { dsl: loadWorkbench(agent_id), versions: workbenchVersions(agent_id) });
+    }
+    if (req.method === 'POST' && pathname === '/api/workbench/ai-draft') {
+      const { agent_id } = await body(req);
+      const dep = loadDeployment(agent_id);
+      if (!dep) return json(res, 400, { error: '助手未上岗' });
+      const arm = await getArmAgent(agent_id);
+      const toolsAvail = dep.toolset.map(t => t.tool).join(', ');
+      const sys = '你是工业智能体平台的工作台设计师。根据助手档案生成工作台 DSL（JSON）。面板类型只允许: realtime_list(实时告警流)/status_grid(设备状态矩阵)/agent_dialog(诊断对话)/action_group(操作区)/kpi_strip(指标条)/inspection_report(自检报告)。结构: {"workbench":"名称","owner_agent":"agentId","version":"v0.1-draft","layout":[...],"panels":[{"id","type","title","refresh"}...]}。action_group 的 panels 含 "actions":[{"id","label","orchestration","autonomy","confirm":{"text","double_check"}}]，orchestration 只能引用这些: logic://设备复位流程@mock / logic://告警派工@mock / logic://服务滚动重启@mock / logic://环境自检@mock。只输出 JSON，不要 markdown 代码围栏。';
+      const user = `助手: ${arm.name} ${arm.version}\n职责: ${arm.prompt}\n可用工具: ${toolsAvail}\n默认自主级别: ${dep.default_autonomy}\n请生成 4-6 个面板，含一个 agent_dialog 和一个 action_group。`;
+      const out = await llmComplete(sys, user);
+      const cleaned = out.replace(/```json|```/g, '').trim();
+      let draft;
+      try { draft = JSON.parse(cleaned); } catch (e) { return json(res, 502, { error: 'AI 草稿解析失败', raw: cleaned.slice(0, 500) }); }
+      draft.owner_agent = agent_id; draft.version = 'v0.1-draft';
+      metric({ kind: 'ai_draft', agentId: agent_id });
+      audit({ actor: 'workbench', agentId: agent_id, action: 'ai-draft' });
+      return json(res, 200, { dsl: draft });
+    }
+    function nextVersion(v, agentId) {
+      const nums = [v, ...workbenchVersions(agentId).map(x => x.version)]
+        .map(x => +String(x || '').replace(/^v/, '') || 0);
+      return `v${Math.max(...nums, 0) + 1}`;
+    }
+    function defaultWorkbench(dep) {
+      // KISS：默认只有诊断对话（唯一内核）；其余面板从插件库范本二开或让工程师定制
+      return { workbench: `${dep.name || '助手'}工作台`, owner_agent: dep.agent_id, version: 'v1', layout: ['agent_dialog'], panels: [
+        { id: 'agent_dialog', type: 'agent_dialog', title: '诊断对话' },
+      ] };
+    }
+
+    // ── 面板数据代理（面板运行于浏览器，内网接口跨域受限；平台代取只读 GET）──
+    if (req.method === 'GET' && pathname === '/api/proxy') {
+      const u = url.searchParams.get('url') || '';
+      if (!/^https?:\/\//.test(u)) return json(res, 400, { error: '仅支持 http/https' });
+      const host = (() => { try { return new URL(u).hostname.toLowerCase(); } catch { return ''; } })();
+      if (!proxyAllowedHosts().has(host)) {
+        return json(res, 403, { error: `主机 ${host} 未在任何插件中声明（代理仅允许插件代码中出现过的主机，防面板成为任意内网跳板）` });
+      }
+      try {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), 8000);
+        const r = await fetch(u, { signal: ctrl.signal });
+        clearTimeout(timer);
+        const body = (await r.text()).slice(0, 128 * 1024);
+        audit({ actor: 'panel-proxy', url: u.slice(0, 120), status: r.status });
+        return json(res, 200, { status: r.status, body });
+      } catch (e) { return json(res, 502, { error: `代理请求失败: ${e.message}` }); }
+    }
+
+    // ── 面板运行错误（debug 的眼睛：错误边界/编译失败上报，供 AI 调试取证）──
+    if (req.method === 'POST' && pathname === '/api/panel-error') {
+      const { agentId, panelId, pluginId, kind, message } = await body(req);
+      const f = path.join(DATA_DIR, 'panel-errors.json');
+      let list = []; try { list = JSON.parse(fs.readFileSync(f, 'utf8')); } catch { }
+      list.push({ ts: new Date().toISOString(), agentId, panelId, pluginId: pluginId || null, kind: kind || 'runtime', message: String(message || '').slice(0, 400) });
+      fs.writeFileSync(f, JSON.stringify(list.slice(-50), null, 1));
+      audit({ actor: 'panel-error', panelId, pluginId, kind, message: String(message).slice(0, 120) });
+      return json(res, 200, { ok: true });
+    }
+    if (req.method === 'GET' && pathname === '/api/panel-errors') {
+      const key = url.searchParams.get('key') || '';
+      let list = []; try { list = JSON.parse(fs.readFileSync(path.join(DATA_DIR, 'panel-errors.json'), 'utf8')); } catch { }
+      const hit = list.filter((e) => !key || e.panelId === key || e.pluginId === key).slice(-5);
+      return json(res, 200, { errors: hit });
+    }
+
+    // ── D) 插件版本回退 ──
+    if (req.method === 'POST' && pathname === '/api/panels/rollback') {
+      const { id, version } = await body(req);
+      const full = loadPanelPlugin(id);
+      if (!full) return json(res, 404, { error: `插件 ${id} 不存在` });
+      const hit = (full.history || []).find((h) => h.version === String(version));
+      if (!hit) return json(res, 404, { error: `版本 ${version} 不存在。历史：${(full.history || []).map((h) => h.version).join(', ') || '无'}` });
+      const cur = +String(full.version || 'v0').replace('v', '') || 0;
+      full.history = [...(full.history || []), { version: full.version, code: full.code, at: full.updated }].slice(-5);
+      full.code = hit.code; full.version = `v${cur + 1}`; full.updated = new Date().toISOString();
+      fs.writeFileSync(path.join(PANELS_DIR, `${id}.json`), JSON.stringify(full, null, 2));
+      audit({ actor: 'panel-plugin', id, action: 'rollback', to: String(version), newVersion: full.version });
+      return json(res, 200, { plugin: full });
+    }
+
+    // ── 面板动作：插件经 props.runAction 触发服务端命令（命令声明在 params.actions，随草稿人审）──
+    if (req.method === 'POST' && pathname === '/api/panel-action') {
+      const { agentId, panelId, actionId, args = {} } = await body(req);
+      const dsl = loadDraft(agentId) || loadWorkbench(agentId);
+      const panel = (dsl?.panels || []).find((p) => p.id === panelId);
+      const action = panel?.params?.actions?.find?.((a) => a.id === actionId);
+      if (!action || !action.exec) return json(res, 404, { error: `面板动作未声明: ${actionId}（须在工作台 params.actions 中配置 exec）` });
+      let cmd = String(action.exec);
+      for (const [k, v] of Object.entries(args)) cmd = cmd.split(`\${${k}}`).join(String(v));
+      const cls = classifyExec(cmd, 3);
+      if (cls.status === 'blocked') return json(res, 403, { error: `命令被黑名单拒绝：${cls.reason}` }); // 只拦毁灭性黑名单；写类命令(pending)由"人审声明+用户主动点击"授权
+      const env = { ...process.env };
+      delete env.ZAI_CODING_CN_API_KEY; delete env.LLM_API_KEY; delete env.ARM_PAT;
+      audit({ actor: 'panel-action', agentId, panelId, actionId, command: cmd.slice(0, 200) });
+      return await new Promise((resolve) => {
+        cpExec(cmd, { cwd: ROOT, timeout: +(action.timeout_ms || 120000), maxBuffer: 1024 * 1024, env, shell: process.env.SHELL || '/bin/zsh' }, (err, stdout, stderr) => {
+          const out = String(stdout || '');
+          audit({ actor: 'panel-action', agentId, panelId, actionId, command: cmd.slice(0, 200), ok: !err, output_tail: out.slice(-300), stderr_tail: String(stderr || '').slice(-200), err: err ? err.message.slice(0, 150) : undefined }); // 结果入审计：可查证
+          resolve(json(res, 200, { ok: !err, output: out.slice(0, 8000), error: err ? String(err.message).slice(0, 500) : String(stderr || '').slice(0, 1000) }));
+        });
+      });
+    }
+
+    // ── 数据集存储（Collection CRUD + 记录 CRUD）──
+    if (req.method === 'GET' && pathname === '/api/store') {
+      return json(res, 200, { collections: loadCollections() });
+    }
+    if (req.method === 'PUT' && pathname === '/api/store') {
+      try { const m = saveCollection(await body(req)); return json(res, 200, { collection: m }); }
+      catch (e) { return json(res, 400, { error: e.message }); }
+    }
+    let mStore = pathname.match(/^\/api\/store\/([a-z0-9_-]+)\/records$/);
+    if (mStore) {
+      const manifest = loadCollection(mStore[1]);
+      if (!manifest) return json(res, 404, { error: `数据集 ${mStore[1]} 不存在` });
+      const wb = url.searchParams.get('wb') || undefined;
+      const ws = url.searchParams.get('ws') || 'default';
+      if (scopeOf(manifest) === 'agent' && wb && wb !== manifest.owner_agent) {
+        return json(res, 403, { error: `数据集「${manifest.title}」为助手私有（归属 ${manifest.owner_agent?.slice(0, 8)}）` });
+      }
+      if (req.method === 'GET') {
+        let filter = {}; try { filter = JSON.parse(url.searchParams.get('filter') || '{}'); } catch { }
+        return json(res, 200, { records: collRecords(manifest, { filter, sort: url.searchParams.get('sort') || undefined, limit: +url.searchParams.get('limit') || 100 }, ws) });
+      }
+      if (req.method === 'POST') {
+        try { return json(res, 200, { record: insertDoc(manifest, await body(req), ws) }); }
+        catch (e) { return json(res, 400, { error: e.message }); }
+      }
+    }
+    let mRec = pathname.match(/^\/api\/store\/([a-z0-9_-]+)\/records\/([^/]+)$/);
+    if (mRec) {
+      const manifest = loadCollection(mRec[1]);
+      if (!manifest) return json(res, 404, { error: `数据集 ${mRec[1]} 不存在` });
+      const wb = url.searchParams.get('wb') || undefined;
+      const ws = url.searchParams.get('ws') || 'default';
+      if (scopeOf(manifest) === 'agent' && wb && wb !== manifest.owner_agent) {
+        return json(res, 403, { error: `数据集「${manifest.title}」为助手私有` });
+      }
+      if (req.method === 'PUT') {
+        try { return json(res, 200, { record: updateDoc(manifest, mRec[2], await body(req), ws) }); }
+        catch (e) { return json(res, 400, { error: e.message }); }
+      }
+      if (req.method === 'DELETE') {
+        try { deleteDoc(manifest, mRec[2], ws); return json(res, 200, { ok: true }); }
+        catch (e) { return json(res, 400, { error: e.message }); }
+      }
+    }
+
+    // ── 面板插件库 ──
+    if (req.method === 'GET' && pathname === '/api/panels') {
+      const detail = url.searchParams.get('id');
+      if (detail) {
+        const plugin = loadPanelPlugin(detail);
+        return plugin ? json(res, 200, { plugin }) : json(res, 404, { error: '插件不存在' });
+      }
+      if (url.searchParams.get('with_code') === '1') {
+        const list = fs.readdirSync(PANELS_DIR).filter(f => f.endsWith('.json'))
+          .map(f => JSON.parse(fs.readFileSync(path.join(PANELS_DIR, f), 'utf8')))
+          .map(({ id, name, description, version, author, code }) => ({ id, name, description, version, author, code }));
+        return json(res, 200, { plugins: list });
+      }
+      return json(res, 200, { plugins: listPanelPlugins() });
+    }
+    if (req.method === 'PUT' && pathname === '/api/panels') {
+      const { id, name, description, code } = await body(req);
+      try { return json(res, 200, { plugin: savePanelPlugin({ id, name, description, code, author: 'human' }) }); }
+      catch (e) { return json(res, 400, { error: e.message }); }
+    }
+    if (req.method === 'DELETE' && pathname === '/api/panels') {
+      const { id, force } = await body(req);
+      if (!loadPanelPlugin(id)) return json(res, 404, { error: `插件 ${id} 不存在` });
+      // 引用检查：哪些工作台（线上/草稿）在用它
+      const refs = [];
+      for (const f of fs.readdirSync(WB_DIR).filter(f => f.endsWith('.json'))) {
+        const agentId = f.replace(/\.(draft\.)?json$/, '');
+        const dsl = JSON.parse(fs.readFileSync(path.join(WB_DIR, f), 'utf8'));
+        if ((dsl.panels || []).some(p => p.panel === id)) refs.push({ agentId, draft: f.includes('.draft.') });
+      }
+      if (refs.length && !force) {
+        return json(res, 409, { error: `插件被 ${refs.length} 个工作台引用`, refs, hint: '先在编辑器移除后发布，或 force=true 自动摘除' });
+      }
+      for (const r of refs) { // force：从引用方摘除该面板（线上版走版本化保存，草稿直接改）
+        const target = r.draft ? draftPath(r.agentId) : path.join(WB_DIR, `${r.agentId}.json`);
+        const dsl = JSON.parse(fs.readFileSync(target, 'utf8'));
+        dsl.panels = dsl.panels.filter(p => p.panel !== id);
+        fs.writeFileSync(target, JSON.stringify(dsl, null, 2));
+        audit({ actor: 'panel-plugin', id, action: 'detach', from: r.agentId, draft: r.draft });
+      }
+      fs.rmSync(path.join(PANELS_DIR, `${id}.json`));
+      audit({ actor: 'panel-plugin', id, action: 'delete', detached: refs.length });
+      return json(res, 200, { ok: true, detached: refs.length });
+    }
+
+    // ── 插件中心 ──
+    if (req.method === 'GET' && pathname === '/api/plugins/center') {
+      return json(res, 200, pluginCenterData());
+    }
+    if (req.method === 'POST' && pathname === '/api/plugins/lifecycle') {
+      const { kind, id, status } = await body(req); // kind: system|plugin; status: active|deprecated
+      if (!['active', 'deprecated'].includes(status)) return json(res, 400, { error: 'status 须为 active|deprecated' });
+      if (kind === 'system') { setSystemPluginStatus(id, status); return json(res, 200, { ok: true }); }
+      if (kind === 'plugin') {
+        const full = loadPanelPlugin(id);
+        if (!full) return json(res, 404, { error: '插件不存在' });
+        full.status = status; full.lastCheck = full.lastCheck || null;
+        fs.writeFileSync(path.join(PANELS_DIR, `${id}.json`), JSON.stringify(full, null, 2));
+        audit({ actor: 'plugin-center', kind: 'plugin', id, action: status });
+        return json(res, 200, { ok: true });
+      }
+      return json(res, 400, { error: 'kind 须为 system|plugin' });
+    }
+
+    // ── 草稿管理 ──
+    if (req.method === 'DELETE' && pathname === '/api/workbench/draft') {
+      const { agent_id } = await body(req);
+      fs.rmSync(draftPath(agent_id), { force: true });
+      return json(res, 200, { ok: true });
+    }
+    // ── 工作台工程师：对话式开发（工具即扩展点）──
+    if (req.method === 'POST' && pathname === '/api/dev/chat') {
+      const { sessionId, agentId, message } = await body(req);
+      const emit = sseInit(req, res);
+      try {
+        devCtx.agentId = agentId;
+        if (!loadWorkbench(agentId)) return emit('error', { message: '该助手尚无工作台' }), res.end();
+        let s = devSessions.get(sessionId);
+        if (!s) {
+          s = { context: { systemPrompt: devSystemPrompt(), messages: [], tools: Object.entries(DEV_TOOLS).map(([n, t]) => ({ name: n, description: t.desc, parameters: { type: 'object', properties: t.schema, required: t.required || [] } })) } };
+          devSessions.set(sessionId, s);
+        } else {
+          s.context.systemPrompt = devSystemPrompt();
+        }
+        s.context.messages.push({ role: 'user', content: message, timestamp: Date.now() });
+        await devChatLoop(s, emit);
+        emit('meta', { hasDraft: !!loadDraft(agentId) });
+      } catch (e) { emit('error', { message: e.message }); }
+      return res.end();
+    }
+
+    // ── 现场状态 ──
+    if (req.method === 'GET' && pathname === '/api/state') {
+      return json(res, 200, { devices: world.devices, alarms: world.alarms, kpi: world.kpi, work_orders: world.work_orders, inspections: world.inspections });
+    }
+    // ── 对话（SSE 流式；会话绑定工作区：exec cwd / 数据集库 / 上下文随工作区走）──
+    if (req.method === 'POST' && pathname === '/api/chat') {
+      const { sessionId, agentId, message, autonomyLevel, context, ws_id } = await body(req);
+      const emit = sseInit(req, res);
+      try {
+        const { s, deployment, armAgent } = await ensureSession(sessionId, agentId, autonomyLevel, ws_id);
+        if (s.running) { // 会话在后台仍在处理上一条消息（跨页面进度跟踪）
+          emit('error', { message: `该会话正在后台处理（${s.statusText || '进行中'}）——可先切换其他助手，稍后回来进度会自动恢复` });
+          return res.end();
+        }
+        if (s.pending) {
+          emit('error', { message: '有一项写操作等待人工确认，请先处理对话中的确认卡（或点取消）' });
+          return res.end();
+        }
+        s.context.messages.push({ role: 'user', content: context ? `${message}\n（界面注入上下文：当前选中设备 ${context.device}）` : message, timestamp: Date.now() });
+        const wb = loadDraft(agentId) || loadWorkbench(agentId) || {};
+        s.running = true; s.sinceTs = Date.now();
+        const out = await agentLoop(s, deployment, emit, Math.max(1, +(wb.max_rounds) || 16));
+        emit('done', { reply: out.reply, pending: out.pending });
+      } catch (e) { emit('error', { message: e.message }); }
+      finally { const s = sessions.get(sessionId); if (s) { s.running = false; s.statusText = ''; } }
+      return res.end();
+    }
+    if (req.method === 'POST' && pathname === '/api/chat/confirm') {
+      const { sessionId, approved } = await body(req);
+      const emit = sseInit(req, res);
+      try {
+        const s = sessions.get(sessionId);
+        if (!s || !s.pending) return emit('error', { message: '无挂起操作' }), res.end();
+        const deployment = loadDeployment(s.agentId);
+        const { tool_call_id, tool, args } = s.pending; s.pending = null;
+        if (!approved) {
+          s.context.messages.push({ role: 'toolResult', toolCallId: tool_call_id, toolName: tool, content: [{ type: 'text', text: '用户取消了该操作。' }], isError: false, timestamp: Date.now() });
+          emit('tool_end', { tool, args, result: '用户取消了该操作。', status: 'cancelled' });
+        } else {
+          emit('tool_start', { tool, args });
+          let result, isErr = false;
+          try { result = await getTool(tool).run(args, s.agentId, s.wsId || 'default'); } catch (e) { result = `执行失败: ${e.message}`; isErr = true; }
+          s.context.messages.push({ role: 'toolResult', toolCallId: tool_call_id, toolName: tool, content: [{ type: 'text', text: String(result) }], isError: isErr, timestamp: Date.now() });
+          emit('tool_end', { tool, args, result: String(result), status: 'executed' });
+          audit({ actor: 'human-confirm', agent: s.agentId, tool, autonomy: s.autonomy, ok: !isErr });
+        }
+        const wb = loadDraft(s.agentId) || loadWorkbench(s.agentId) || {};
+        s.running = true; s.sinceTs = Date.now();
+        const out = await agentLoop(s, deployment, emit, Math.max(1, +(wb.max_rounds) || 16));
+        emit('done', { reply: out.reply, pending: out.pending });
+      } catch (e) { emit('error', { message: e.message }); }
+      finally { if (s) { s.running = false; s.statusText = ''; } }
+      return res.end();
+    }
+    // ── 会话历史与进度（切换助手后回来：上下文回放 + 后台运行状态；服务端为唯一事实源）──
+    if (req.method === 'GET' && pathname === '/api/chat/history') {
+      const sid = url.searchParams.get('sessionId');
+      const s = sid && sessions.get(sid);
+      if (!s) return json(res, 200, { exists: false });
+      const toolResults = {}; // toolCallId → 结果（回放时把调用与结果拼回事件卡）
+      for (const m of s.context.messages) {
+        if (m.role === 'toolResult' && m.toolCallId) toolResults[m.toolCallId] = { text: String((m.content || []).map(c => c.text || '').join('')), isError: !!m.isError };
+      }
+      const msgs = [];
+      for (const m of s.context.messages) {
+        if (m.role === 'user') { msgs.push({ kind: 'user', text: String(m.content) }); continue; }
+        if (!Array.isArray(m.content)) continue;
+        const text = m.content.filter(b => b.type === 'text').map(b => b.text).join('');
+        if (text) msgs.push({ kind: 'bot', text });
+        for (const tc of m.content.filter(b => b.type === 'toolCall')) {
+          const r = toolResults[tc.id];
+          msgs.push({ kind: 'evt', evt: { tool: tc.name, args: tc.arguments || {}, result: (r?.text || '…').slice(0, 700), status: r ? (r.isError ? 'rejected' : 'ok') : 'start' } });
+        }
+      }
+      return json(res, 200, {
+        exists: true, agentId: s.agentId, wsId: s.wsId || 'default',
+        running: !!s.running, statusText: s.statusText || '', since: s.sinceTs || null,
+        pending: s.pending || null, msgs,
+      });
+    }
+    // ── 顶栏快速切换数据源：在岗助手 + 各自会话运行状态（每 5s 轮询，纯内存）──
+    if (req.method === 'GET' && pathname === '/api/quick-switch') {
+      const live = {}; // agentId -> {running, pending, statusText}
+      for (const [, s] of sessions) {
+        if (!s.running && !s.pending) continue;
+        const cur = live[s.agentId];
+        if (!cur || s.running) live[s.agentId] = { running: s.running, pending: !!s.pending, statusText: s.pending ? `等待人工确认 ${s.pending.tool}` : (s.statusText || '进行中') };
+      }
+      const agents = fs.readdirSync(DEPLOY_DIR).filter(f => f.endsWith('.json')).map(f => {
+        const id = f.replace(/\.json$/, '');
+        const dep = loadDeployment(id);
+        return { agent_id: id, name: dep?.name || localAgent(id)?.name || id.slice(0, 8), ...(live[id] || { running: false, pending: false, statusText: '' }) };
+      });
+      return json(res, 200, { agents });
+    }
+    // ── 工作台操作区按钮（已退役：mock 编排四件套移除；按钮动作统一走 /api/panel-action 的 params.actions，随草稿人审）──
+    if (req.method === 'POST' && pathname === '/api/action') {
+      return json(res, 410, { error: 'mock 编排动作已退役（logic-ide 接入后将以通用编排工具回归）。面板按钮请使用 params.actions + props.runAction' });
+    }
+    // ── 经验回流（AI起草→人审→写入ARM）──
+    if (req.method === 'POST' && pathname === '/api/experience/draft') {
+      const { sessionId } = await body(req);
+      const s = sessions.get(sessionId);
+      if (!s) return json(res, 400, { error: '会话不存在' });
+      const convo = s.context.messages.filter(m => m.role === 'user' || m.role === 'assistant')
+        .slice(-12).map(m => `${m.role === 'user' ? '用户' : '助手'}: ${(m.content || []).filter?.(b => b.type === 'text').map(b => b.text).join('') ?? m.content}`).join('\n');
+      const md = await llmComplete('你是经验沉淀器。把运维对话提炼为一条结构化经验 markdown，章节固定：## 现象 / ## 根因 / ## 处置步骤 / ## 验证 / ## 预防。事实不确定就写"待确认"。只输出 markdown 正文。', convo || '（空会话）');
+      return json(res, 200, { markdown: md });
+    }
+    if (req.method === 'POST' && pathname === '/api/experience/commit') {
+      const { agentId, name, description, content } = await body(req);
+      const arm = agentProfileNow(agentId);
+      const full = ['---', 'kind: experience', 'source: aims-platform-mvp', `agent: ${arm.name || agentId}@${arm.version || ''}`, 'scenario: 立库A区智能运维@mvp', '---', '', content].join('\n');
+      const r = await mcpCall('create_knowledge', { name, description: description || `工作台人工审阅沉淀`, content: full, tags: ['MVP回流'] }, { pat: true });
+      const kid = (r.match(/id:\s*([0-9a-f-]{36})/) || [])[1] || '';
+      metric({ kind: 'experience', agentId, title: name, knowledge_id: kid });
+      audit({ actor: 'experience-reflow', target: 'ARM', name });
+      return json(res, 200, { result: r });
+    }
+    // ── 自进化看板 ──
+    if (req.method === 'GET' && pathname === '/api/evolution') {
+      const audits = fs.existsSync(AUDIT_LOG) ? fs.readFileSync(AUDIT_LOG, 'utf8').trim().split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean) : [];
+      const metrics = fs.existsSync(METRICS_LOG) ? fs.readFileSync(METRICS_LOG, 'utf8').trim().split('\n').filter(Boolean).map(l => { try { return JSON.parse(l); } catch { return null; } }).filter(Boolean) : [];
+      const toolCalls = audits.filter(a => a.actor === 'assistant');
+      const blocks = audits.filter(a => a.actor === 'guardrail' && a.verdict === 'blocked');
+      const confirms = audits.filter(a => a.actor === 'human-confirm');
+      const orchestrations = audits.filter(a => a.actor === 'orchestration');
+      const reflows = metrics.filter(m => m.kind === 'experience');
+      const searches = metrics.filter(m => m.kind === 'kb_search');
+      const aiDrafts = metrics.filter(m => m.kind === 'ai_draft');
+      const byTool = {}; toolCalls.forEach(a => { byTool[a.tool] = (byTool[a.tool] || 0) + 1; });
+      const byAgent = {}; audits.forEach(a => { if (a.agent || a.agentId) byAgent[a.agent || a.agentId] = (byAgent[a.agent || a.agentId] || 0) + 1; });
+      return json(res, 200, {
+        totals: { tool_calls: toolCalls.length, guardrail_blocks: blocks.length, human_confirms: confirms.length, orchestrations: orchestrations.length, experiences: reflows.length, kb_searches: searches.length, ai_drafts: aiDrafts.length },
+        by_tool: byTool, by_agent: byAgent,
+        similarity_trend: searches.filter(s => s.top_similarity != null).map(s => ({ ts: s.ts, query: s.query.slice(0, 40), similarity: s.top_similarity })),
+        experiences: reflows.map(r => ({ ts: r.ts, title: r.title, knowledge_id: r.knowledge_id, agent: r.agentId })),
+        recent_audit: audits.slice(-25).reverse(),
+        flywheel_note: '处置→沉淀→检索命中：对比 similarity_trend 中回流前后的相似度变化',
+      });
+    }
+    if (req.method === 'GET' && pathname === '/api/kb/search') {
+      const q = url.searchParams.get('q') || '';
+      if (!q) return json(res, 200, { items: [] });
+      try {
+        const { via, items } = await searchKnowledgeItems(q, 5);
+        metric({ kind: 'kb_search', agentId: 'evolution-view', query: q, via, top_similarity: items.length ? items[0].similarity : null });
+        return json(res, 200, { via, items });
+      } catch (e) { return json(res, 502, { error: `知识检索不可达: ${e.message}` }); }
+    }
+    json(res, 404, { error: 'not found' });
+  } catch (e) {
+    audit({ actor: 'server', error: e.message });
+    if (!res.headersSent) json(res, 500, { error: e.message }); else try { res.end(); } catch {}
+  }
+});
+
+// ── 单测: node server.js --test-guard ──
+if (process.argv.includes('--test-guard')) {
+  const cases = [
+    ['data_write', 0, {}, 'blocked'], ['data_write', 1, {}, 'blocked'], ['data_write', 2, {}, 'pending'],
+    ['save_experience', 0, {}, 'blocked'], ['save_experience', 1, {}, 'ok'],
+    ['search_knowledge', 0, {}, 'ok'],
+    ['exec', 0, { command: 'curl -s http://localhost:5600/api/state' }, 'ok'],
+    ['exec', 0, { command: 'nc -vz -w 3 192.0.2.1 22' }, 'ok'],
+    ['exec', 0, { command: 'sqlite3 data/store.db "SELECT 1"' }, 'ok'],
+    ['exec', 0, { command: 'rm -rf /tmp/x' }, 'blocked'],
+    ['exec', 0, { command: 'sudo reboot' }, 'blocked'],
+    ['exec', 0, { command: 'sqlite3 x.db "INSERT INTO t VALUES(1)"' }, 'blocked'],
+    ['exec', 2, { command: 'echo hi > /tmp/a.txt' }, 'pending'],
+    ['data_query', 0, {}, 'ok'], ['data_write', 0, {}, 'blocked'], ['data_write', 2, {}, 'pending'],
+    ['data_write', 3, {}, 'ok'],
+    ['exec', 3, { command: 'echo hi > /tmp/a.txt' }, 'ok'],
+    ['exec', 3, { command: 'sudo reboot' }, 'blocked'],
+  ];
+  let pass = true;
+  for (const [tool, lv, args, want] of cases) {
+    const g = guardCheck(tool, lv, null, args); const ok = g.status === want; if (!ok) pass = false;
+    console.log(`${ok ? '✅' : '❌'} guard(${tool}, L${lv}, ${String(args.command || '').slice(0, 30)}) -> ${g.status}（期望 ${want}）`);
+  }
+  console.log(pass ? '守护栏单元测试全部通过' : '守护栏单元测试存在失败');
+  process.exit(pass ? 0 : 1);
+}
+
+applyLLMConfig().then(() => {
+  server.listen(PORT, HOST, () => {
+    console.log(`[aims-workstation] http://localhost:${PORT}（绑定 ${HOST}） | 模型: ${model.id} @ ${model.baseUrl}`);
+    console.log(`[aims-workstation] 数据目录 AIMS_HOME: ${AIMS_HOME}`);
+    console.log(`[aims-workstation] ARM: ${armMcpUrl()} | REST: ${armApiBase()} | PAT: ${ARM_PAT ? '已加载' : '未配置'} | 已上岗助手: ${fs.readdirSync(DEPLOY_DIR).length} | 本地助手库: ${loadRegistry().agents.length}`);
+  });
+  // 已上岗助手后台物化为本地档案（best-effort；ARM 不可达时静默跳过，待手动同步）
+  (async () => {
+    for (const f of fs.readdirSync(DEPLOY_DIR).filter(f => f.endsWith('.json'))) {
+      const agentId = f.replace(/\.json$/, '');
+      if (localAgent(agentId)) continue;
+      try { const m = await downloadAgent(agentId); console.log(`[mvp] 已上岗助手已物化本地档案: ${m.name} ${m.version}`); }
+      catch { /* 离线，待恢复后同步 */ }
+    }
+  })();
+}).catch(e => { console.error('LLM 初始化失败:', e.message); process.exit(1); });