aims-workstation 0.1.7 → 0.1.9

package/.env.example

@@ -9,7 +9,6 @@ LLM_MODEL=def
 
 # ARM 系统（助手档案 + 经验库）：站点地址缺省公司内网 http://arm.agent-platform.dev.aimstek.cn，留空即用默认
 # 匿名可浏览目录；下载/上岗/新建/经验回流需令牌——到 ARM 生成访问令牌（arm_pat_…）后填入，或在「系统设置 · ARM 源」粘贴
-# ARM_MCP_URL=https://your-arm-host/api/mcp        # 可选：私有化部署时覆盖
 # ARM_API_BASE=http://localhost:3001               # 可选：本地联调 ARM 时启用
 # PAT 留空则自动读取 ~/.arm/config.json 的 token
 ARM_PAT=

package/package.json

@@ -13,7 +13,7 @@
     "@earendil-works/pi-ai": "^1.2.0"
   },
   "packageManager": "pnpm@11.21.0+sha512.521705bce689924eac72f5a3587122f362689ef6571e55ba80076fd637c11132ecffada26fad4ea79c485bfddbfd3d5a2a5b05805a77e893de71ec8a6cca3bb1",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "AIMS 工作站：本地智能体工作站——ARM 助手本地化（下载/离线/升级）、工作台对话式定制、多工作区隔离、分级自主与审计",
   "bin": {
     "aims-workstation": "bin/aims-workstation.js"

package/server.js

@@ -3,7 +3,7 @@
 // Agent 层基于 @earendil-works/pi-ai（统一 LLM API），前端为 web/ 预构建的 shadcn/ui 应用（web/dist）
 'use strict';
 // TLS 证书校验关闭（用户决策：内网私有部署自签证书常见，能访问优先）
-// 覆盖所有出站 fetch（ARM REST/MCP、LLM、面板代理）。本工具面向内网/本机使用。
+// 覆盖所有出站 fetch（ARM REST、LLM、面板代理）。本工具面向内网/本机使用。
 process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 const http = require('http');
 const fs = require('fs');
@@ -76,7 +76,7 @@ const PORT = +(process.env.PORT || env.PORT || 5600);
 const HOST = process.env.AIMS_HOST || '0.0.0.0'; // 默认局域网可达（团队共用）；仅本机使用可设 AIMS_HOST=127.0.0.1
 // ── 运行时配置（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: '', access_token: '' };
+const cfg = { arm_api_base: '', arm_token: '', llm_base_url: '', llm_api_key: '', llm_model: '', llm_context_tokens: 0, scene_profile: '', access_token: '' };
 // 守护栏默认策略（可在「系统设置·守护栏」维护，存 platform.json，保存即热生效）：deny=正则源串（命中即永久拒绝，任何级别不豁免）；
 // ro=只读白名单命令名（免确认直行）；sudo_u_l2=true 时 `sudo -u <用户>` 降权形式不再永久拒绝、按写命令走 L2 人工确认（裸 sudo 仍拒绝）
 const GUARD_DEFAULT = {
@@ -92,20 +92,23 @@ function normalizeGuard(g) {
     sudo_u_l2: !!g.sudo_u_l2,
   };
 }
-function loadCfg() { try { Object.assign(cfg, JSON.parse(fs.readFileSync(CFG_FILE, 'utf8'))); } catch { } cfg.guard = normalizeGuard(cfg.guard); }
+function loadCfg() { try { Object.assign(cfg, JSON.parse(fs.readFileSync(CFG_FILE, 'utf8'))); } catch { } delete cfg.arm_mcp_url; /* MCP 通道已退役：剥离旧配置残留 */ cfg.guard = normalizeGuard(cfg.guard); }
 loadCfg();
 const guardNow = () => cfg.guard;
 function saveCfg() { fs.writeFileSync(CFG_FILE, JSON.stringify(cfg, null, 2)); }
-// ARM 站点地址：运行时配置 > ARM_API_BASE(env) > 从 MCP URL 推导 > 公司内网默认（内网可达即开箱可用）；MCP 端点：显式配置 > 跟随站点地址
+// ARM 站点地址：运行时配置 > ARM_API_BASE(env) > 公司内网默认（内网可达即开箱可用）
+//（2026-10-21 全面切换新版 ARM：仅 REST 通道，MCP 通道及旧版兼容回落已退役）
 const ARM_DEFAULT_BASE = 'http://arm.agent-platform.dev.aimstek.cn';
-const armApiBase = () => cfg.arm_api_base || process.env.ARM_API_BASE || env.ARM_API_BASE || (env.ARM_MCP_URL ? String(env.ARM_MCP_URL).replace(/\/api\/mcp$/, '') : ARM_DEFAULT_BASE);
-const armMcpUrl = () => cfg.arm_mcp_url || `${armApiBase()}/api/mcp`;
+const armApiBase = () => cfg.arm_api_base || process.env.ARM_API_BASE || env.ARM_API_BASE || ARM_DEFAULT_BASE;
 const armApiToken = () => cfg.arm_token || env.ARM_API_TOKEN || ARM_PAT;
 // LLM：OpenAI 兼容端点（baseUrl/模型/密钥），缺省公司内网 bifrost 网关（内网可达即可用，无需配置）
 const LLM_DEFAULT_BASE = 'http://bifrost.infra.dev.aimstek.cn/v1';
 const llmBaseUrl = () => cfg.llm_base_url || env.LLM_BASE_URL || LLM_DEFAULT_BASE;
 const llmApiKey = () => cfg.llm_api_key || env.LLM_API_KEY || 'def';
 const llmModelName = () => cfg.llm_model || env.LLM_MODEL || 'def';
+// 上下文窗口（token）：设置页可配（跟随所选模型的真实窗口），驱动会话历史裁剪预算；0/未配 = 默认 128K
+const LLM_DEFAULT_CONTEXT_TOKENS = 128_000;
+const llmContextTokens = () => { const n = +cfg.llm_context_tokens; return Number.isFinite(n) && n > 0 ? n : LLM_DEFAULT_CONTEXT_TOKENS; };
 // 场景画像：平台级、全局一份的用户场景描述（团队环境/系统清单/规范），注入所有助手；空则不注入。
 // 与知识检索互补（常驻事实 vs 按需检索）；凭据不进画像（放"凭据在哪、找谁要"）。
 const sceneProfile = () => String(cfg.scene_profile || '').trim();
@@ -175,6 +178,8 @@ async function llmProbe() { // 设置页「保存并测试」：一次极小补
 }
 async function llmComplete(systemPrompt, userText) { // 无工具的一次性调用（起草/摘要）
   const r = await models.complete(model, { systemPrompt, messages: [{ role: 'user', content: userText, timestamp: Date.now() }], tools: [] });
+  // pi-ai 把认证/请求失败表现为 stopReason=error 而非异常（同 llmProbe 判定）——不抛会变成空串静默流向调用方
+  if (r.stopReason === 'error') throw new Error(`LLM 请求失败: ${r.errorMessage || r.rawStopReason || 'stop=error'}`);
   return (r.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
 }
 
@@ -186,26 +191,7 @@ 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 抛错）
+// 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();
@@ -232,6 +218,11 @@ async function armRest(pathname, init = {}, timeout_ms = 20000) {
     throw e;
   } finally { clearTimeout(timer); }
 }
+// 知识写入（经验回流链）：REST v2，令牌走 armApiToken() 三级回落（设置页 > env > ~/.arm PAT）
+// 返回 data: { id, name, shareUrl, … }——id 为 UUID，供指标留痕与回流记录定位
+async function armCreateKnowledge({ name, description, content, tags }) {
+  return armRest('/api/v1/knowledges', { method: 'POST', body: JSON.stringify({ name, description, content, tags }) }, 25000);
+}
 const vVer = (v) => (String(v || '').startsWith('v') ? String(v) : `v${v || '0.0.0'}`); // REST 无 v 前缀，统一内部表示
 
 const agentCache = new Map();
@@ -240,30 +231,14 @@ async function getArmAgent(agentId) {
   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 };
+  const d = await armRest(`/api/v1/agents/${agentId}`);
+  const knowledges = (d.knowledges || []).map(kb => (kb.knowledge && kb.knowledge.name) || kb.knowledgeId || '').filter(Boolean);
+  const data = { name: d.name || agentId, version: vVer(d.version), prompt: d.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）
+// 助手目录：REST 分页结构化（可全量）
 async function armListAgents(keyword = '') {
   const out = [];
   for (let page = 1; page <= 5; page++) {
@@ -274,26 +249,16 @@ async function armListAgents(keyword = '') {
   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', created_by: a.creatorName || a.createdBy || '' }));
 }
 
-// 知识检索（全局经验库）：REST 混合检索（RAG 语义 ⊕ 关键词）优先，回落 MCP RAG
+// 知识检索（全局经验库）：REST 混合检索（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 };
-  }
+  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 })),
+  };
 }
 
 // ── 本地助手库（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 }; }
@@ -319,13 +284,7 @@ function cmpVersion(a, b) { // 'v1.10.0' vs 'v1.9.3' 语义化比较
 }
 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);
@@ -349,7 +308,8 @@ function uninstallLocalAgent(agentId, purge_workspaces) {
   return true;
 }
 
-async function downloadAgentRest(agentId) {
+// 下载物化：REST 结构化详情 + knowledgeId 直取全文
+async function downloadAgent(agentId) {
   const d = await armRest(`/api/v1/agents/${agentId}`);
   const version = vVer(d.version);
   const verDir = path.join(ARM_AGENTS_DIR, agentId, 'versions', version);
@@ -396,48 +356,9 @@ async function downloadAgentRest(agentId) {
   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 remote = await armListAgents();
   const reg = loadRegistry();
   const remoteIds = new Set(remote.map(r => r.agent_id));
   const events = { new: [], update: [], delisted: [] };
@@ -465,7 +386,7 @@ async function flushExperienceOutbox() {
   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++; }
+    try { const it = JSON.parse(line); await armCreateKnowledge(it.args); ok++; }
     catch { remain.push(line); }
   }
   fs.writeFileSync(OUTBOX_FILE, remain.length ? remain.join('\n') + '\n' : '');
@@ -687,16 +608,15 @@ const TOOLS = {
       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 }); }
+      try { r = await armCreateKnowledge(args); }
       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 });
+      metric({ kind: 'experience', agentId, title, knowledge_id: r.id });
       audit({ actor: 'experience-reflow', target: 'ARM', title });
-      return `经验已沉淀到 ARM 知识库：\n${r}`;
+      return `经验已沉淀到 ARM 知识库：${r.name}（id: ${r.id}${r.shareUrl ? `，${r.shareUrl}` : ''}）`;
     },
   },
 };
@@ -1389,6 +1309,26 @@ const DEV_TOOLS = {
 const devCtx = { agentId: null };
 const devSessions = new Map();
 
+// 会话上下文裁剪（dev/主对话共用）：前端 sessionId 固定（dev-<agentId前缀> / chat-<agentId>-<wsId>），会话跨请求长存——
+// 不裁剪会无限增长，最终超过模型上下文窗口被网关整单拒绝（2026-10-21 海立实例"发消息没反应"根因）。
+// 预算随设置页「上下文窗口（token）」联动：预留 16K token 给系统提示/当前轮/输出，1.6 char/token 对中文最坏比例（~0.67 token/char）仍在预留内。
+const ctxCharBudget = () => Math.max(4_000, Math.floor((llmContextTokens() - 16_000) * 1.6));
+// 超预算从最旧轮次整轮丢弃；下刀点只选 user 消息边界，剩余前缀不会出现孤儿 toolResult（转换层要求其紧跟 assistant 的 toolCall）；当前轮永不裁。
+function trimContext(ctx, budget = ctxCharBudget()) {
+  const msgs = ctx.messages;
+  const size = () => msgs.reduce((n, m) => n + JSON.stringify(m.content ?? '').length, 0);
+  if (size() <= budget) return 0;
+  const lastUser = msgs.length - 1 - [...msgs].reverse().findIndex((m) => m.role === 'user');
+  let dropped = 0;
+  while (size() > budget) {
+    const cut = msgs.slice(1, lastUser - dropped).findIndex((m) => m.role === 'user');
+    if (cut < 0) break; // 当前轮之前再无完整轮次可丢（单轮就超预算只能放行，交由模型侧报错）
+    dropped += cut + 1;
+    msgs.splice(0, cut + 1);
+  }
+  return dropped;
+}
+
 function devSystemPrompt() {
   const live = loadWorkbench(devCtx.agentId);
   const plugins = listPanelPlugins();
@@ -1470,12 +1410,24 @@ async function devChatLoop(session, emit, signal = null) {
     if (interrupted()) { emit('interrupted', { at: `第 ${round + 1} 轮` }); return { reply: '（已被用户中断）', events }; }
     emit('status', { text: `第 ${round + 1} 轮` });
     const stream = models.stream(model, session.context, signal ? { signal } : undefined);
-    for await (const ev of stream) {
-      if (interrupted()) break;
-      if (ev.type === 'text_delta') emit('text_delta', { delta: ev.delta });
-      else if (ev.type === 'toolcall_end') emit('status', { text: `调用工具 ${ev.toolCall?.name || ''}` });
+    let final = null;
+    try {
+      for await (const ev of stream) {
+        if (interrupted()) break;
+        if (ev.type === 'text_delta') emit('text_delta', { delta: ev.delta });
+        else if (ev.type === 'toolcall_end') emit('status', { text: `调用工具 ${ev.toolCall?.name || ''}` });
+        else if (ev.type === 'error') {
+          if (interrupted()) break; // 中断引发的流错误按中断处理，不报错
+          throw new Error(`LLM 流错误: ${ev.error?.errorMessage || JSON.stringify(ev.error).slice(0, 200)}`);
+        }
+      }
+      final = await stream.result();
+      // pi-ai 把认证/请求失败表现为 stopReason=error 而非异常（同 llmProbe 判定）——不检查会被吞成静默空回复
+      if (final?.stopReason === 'error') throw new Error(`LLM 请求失败: ${final.errorMessage || final.rawStopReason || 'stop=error'}`);
+    } catch (e) {
+      if (!interrupted()) throw e; // 真实错误上抛给路由 catch → SSE error → 前端 toast；中断路径用占位消息兜底
     }
-    const final = await stream.result();
+    if (!final) final = { role: 'assistant', content: [], timestamp: Date.now() };
     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('');
@@ -1680,7 +1632,7 @@ const server = http.createServer(async (req, res) => {
       if (pathname === '/api/health') return json(res, 200, { ok: true, auth_required: true }); // 前端据此弹登录门
       return json(res, 401, { error: '需要访问令牌', code: 'AUTH_REQUIRED' });
     }
-    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 });
+    if (req.method === 'GET' && pathname === '/api/health') return json(res, 200, { ok: true, model: model?.id, arm: armApiBase(), pat: !!ARM_PAT, local_agents: loadRegistry().agents.length });
 
     // ── ARM 连接与同步（07：大厅双视图 = 本地助手库 ∪ 远端目录）──
     if (req.method === 'GET' && pathname === '/api/settings') {
@@ -1689,7 +1641,6 @@ const server = http.createServer(async (req, res) => {
       return json(res, 200, {
         arm: {
           api_base: armApiBase(), api_base_runtime: !!cfg.arm_api_base, default_base: ARM_DEFAULT_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')),
         },
@@ -1698,6 +1649,7 @@ const server = http.createServer(async (req, res) => {
           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'),
+          context_tokens: llmContextTokens(), context_tokens_runtime: !!cfg.llm_context_tokens, default_context_tokens: LLM_DEFAULT_CONTEXT_TOKENS,
         },
         scene: { profile: sceneProfile(), length: sceneProfile().length },
         auth: { enabled: !!accessToken(), token_masked: accessToken() ? `${accessToken().slice(0, 4)}…${accessToken().slice(-2)}` : '' },
@@ -1705,7 +1657,7 @@ const server = http.createServer(async (req, res) => {
       });
     }
     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, access_token, guard } = await body(req);
+      const { arm_api_base, arm_token, llm_base_url, llm_api_key, llm_model, llm_context_tokens, scene_profile, access_token, guard } = await body(req);
       // 守护栏维护：deny 正则可编译 / ro 须为单命令名；保存即热生效（classifyExec 每次调用现读配置）；删减危险规则记入审计
       let guardAudit = null;
       if (guard !== undefined) {
@@ -1736,11 +1688,6 @@ const server = http.createServer(async (req, res) => {
         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);
@@ -1752,6 +1699,15 @@ const server = http.createServer(async (req, res) => {
         if (m && !/^[\w.:@\/-]{1,80}$/.test(m)) return json(res, 400, { error: `模型名不合法：${m}` });
         cfg.llm_model = m;
       }
+      if (llm_context_tokens !== undefined) { // 上下文窗口（token）：驱动会话裁剪预算；留空/0 = 默认 128K。不影响 provider，无需热切换
+        const raw = String(llm_context_tokens ?? '').trim();
+        if (raw === '') cfg.llm_context_tokens = 0;
+        else {
+          const n = Math.floor(+raw);
+          if (!Number.isFinite(n) || n < 4_000 || n > 2_000_000) return json(res, 400, { error: `上下文窗口须为 4000-2000000 的 token 数（留空 = 默认 ${LLM_DEFAULT_CONTEXT_TOKENS}）：${raw}` });
+          cfg.llm_context_tokens = n;
+        }
+      }
       if (llm_api_key !== undefined) cfg.llm_api_key = String(llm_api_key || '').trim();
       // LLM 热切换：先应用验证，失败整体回滚（应用只是构建对象，无网络请求）
       let llm_probe = null;
@@ -1766,10 +1722,10 @@ const server = http.createServer(async (req, res) => {
         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, auth_changed: authChanged, guard_changed: guardAudit });
+      audit({ actor: 'settings', action: 'save', arm_api_base: cfg.arm_api_base, llm_model: cfg.llm_model, llm_context_tokens: cfg.llm_context_tokens, 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, auth_changed: authChanged, guard_changed: guardAudit });
       // ARM 保存后即时探测（失败不回滚：允许先配置后启动 ARM）
       let probe = { online: false, error: '' };
-      if ([arm_api_base, arm_mcp_url, arm_token].some((v) => v !== undefined)) {
+      if ([arm_api_base, arm_token].some((v) => v !== undefined)) {
         try {
           const t0 = Date.now();
           await armRest('/api/v1/agents?page=1&pageSize=1', {}, 6000);
@@ -1777,7 +1733,7 @@ const server = http.createServer(async (req, res) => {
         } catch (e) { probe = { online: false, error: String(e.message).slice(0, 120) }; }
       }
       const notes = [];
-      if (probe.error) notes.push('ARM 当前源不可达（目录/检索将回落 MCP 或本地库，源恢复后自动可用）');
+      if (probe.error) notes.push('ARM 当前源不可达（目录/检索将回落本地库，源恢复后自动可用）');
       if (llm_probe && !llm_probe.online) notes.push('LLM 已保存但探针未通过（密钥/端点/模型可用性待确认，对话可能失败，可再试或改回）');
       return json(res, 200, { saved: true, probe, llm_probe, note: notes.join('；') });
     }
@@ -1787,14 +1743,9 @@ const server = http.createServer(async (req, res) => {
       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 { }
-      }
+      } 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() });
+      return json(res, 200, { online, latency_ms, 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()); }
@@ -1806,7 +1757,7 @@ const server = http.createServer(async (req, res) => {
       const kw = (url.searchParams.get('keyword') || '').trim().toLowerCase();
       const reg = loadRegistry();
       let online = true, remoteCards = [], authError = false;
-      try { remoteCards = await armListAgents(url.searchParams.get('keyword') || ''); } // REST 全量优先，旧版回落 MCP
+      try { remoteCards = await armListAgents(url.searchParams.get('keyword') || ''); } // REST 全量
       catch (e) { online = false; authError = /令牌未配置或无权限/.test(String(e.message)); } // 区分"未授权"与"不可达"，前端引导配置令牌
       const byId = new Map();
       for (const e of reg.agents) {
@@ -1859,8 +1810,12 @@ const server = http.createServer(async (req, res) => {
         };
         const stream = models.stream(model, ctx);
         let out = '';
-        for await (const ev of stream) { if (ev.type === 'text_delta') out += ev.delta; }
+        for await (const ev of stream) {
+          if (ev.type === 'text_delta') out += ev.delta;
+          else if (ev.type === 'error') throw new Error(`LLM 流错误: ${ev.error?.errorMessage || JSON.stringify(ev.error).slice(0, 200)}`); // pi-ai 失败不抛异常，须显式拦截，否则 200 返回空 prompt
+        }
         const final = await stream.result();
+        if (final?.stopReason === 'error') throw new Error(`LLM 请求失败: ${final.errorMessage || final.rawStopReason || 'stop=error'}`);
         const text = ((final.content || []).filter(b => b.type === 'text').map(b => b.text).join('') || out).trim();
         let draftName = '', prompt = text;
         const jm = text.match(/\{[\s\S]*\}/); // JSON 容错解析：失败则整段当 prompt，不阻断
@@ -2082,7 +2037,9 @@ const server = http.createServer(async (req, res) => {
       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"}...]}。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);
+      let out;
+      try { out = await llmComplete(sys, user); }
+      catch (e) { return json(res, 502, { error: `AI 草稿生成失败: ${e.message}` }); }
       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) }); }
@@ -2409,6 +2366,8 @@ const server = http.createServer(async (req, res) => {
           s.context.systemPrompt = devSystemPrompt();
         }
         s.context.messages.push({ role: 'user', content: message, timestamp: Date.now() });
+        const dropped = trimContext(s.context);
+        if (dropped > 0) emit('status', { text: `会话历史过长，已自动裁剪最早 ${dropped} 条消息` });
         await devChatLoop(s, emit, ctl.signal);
         emit('meta', { hasDraft: !!loadDraft(agentId) });
       } catch (e) { emit('error', { message: e.message }); }
@@ -2438,6 +2397,8 @@ const server = http.createServer(async (req, res) => {
           return res.end();
         }
         s.context.messages.push({ role: 'user', content: context ? `${message}\n（界面注入上下文：当前选中设备 ${context.device}）` : message, timestamp: Date.now() });
+        const dropped = trimContext(s.context); // 主对话 sessionId 同样固定（chat-<agentId>-<wsId>），不裁剪会同样撑死
+        if (dropped > 0) emit('status', { text: `会话历史过长，已自动裁剪最早 ${dropped} 条消息` });
         s.running = true; s.sinceTs = Date.now(); s.abortCtl = ctl;
         const out = await agentLoop(s, deployment, emit, ctl.signal);
         emit('done', { reply: out.reply, pending: out.pending });
@@ -2481,6 +2442,18 @@ const server = http.createServer(async (req, res) => {
       finally { finished = true; if (s) { s.running = false; s.statusText = ''; s.abortCtl = null; } }
       return res.end();
     }
+    // ── 会话清空：主动丢弃上下文重开（上下文污染/换思路）；运行中拒绝（先中断），pending 确认卡随会话一并作废 ──
+    if (req.method === 'POST' && pathname === '/api/session/reset') {
+      const { scope, sessionId } = await body(req);
+      if (!sessionId || !String(sessionId).trim()) return json(res, 400, { error: '缺少 sessionId' });
+      const store = scope === 'dev' ? devSessions : sessions;
+      const s = store.get(String(sessionId).trim());
+      if (!s) return json(res, 200, { ok: true, note: '会话本就为空' });
+      if (s.running) return json(res, 409, { error: '会话正在处理中，请先中断再清空' });
+      store.delete(String(sessionId).trim());
+      audit({ actor: 'user', action: 'session-reset', scope: scope === 'dev' ? 'dev' : 'chat', sessionId: String(sessionId).slice(0, 48) });
+      return json(res, 200, { ok: true });
+    }
     // ── 会话历史与进度（切换助手后回来：上下文回放 + 后台运行状态；服务端为唯一事实源）──
     if (req.method === 'GET' && pathname === '/api/chat/history') {
       const sid = url.searchParams.get('sessionId');
@@ -2533,18 +2506,19 @@ const server = http.createServer(async (req, res) => {
       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 || '（空会话）');
+      let md;
+      try { md = await llmComplete('你是经验沉淀器。把运维对话提炼为一条结构化经验 markdown，章节固定：## 现象 / ## 根因 / ## 处置步骤 / ## 验证 / ## 预防。事实不确定就写"待确认"。只输出 markdown 正文。', convo || '（空会话）'); }
+      catch (e) { return json(res, 502, { error: `经验起草失败: ${e.message}` }); }
       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 });
+      const r = await armCreateKnowledge({ name, description: description || `工作台人工审阅沉淀`, content: full, tags: ['MVP回流'] });
+      metric({ kind: 'experience', agentId, title: name, knowledge_id: r.id });
       audit({ actor: 'experience-reflow', target: 'ARM', name });
-      return json(res, 200, { result: r });
+      return json(res, 200, { result: `已创建 ${r.name}（id: ${r.id}）${r.shareUrl ? `\n${r.shareUrl}` : ''}`, knowledge_id: r.id, share_url: r.shareUrl || '' });
     }
     // ── 自进化看板 ──
     if (req.method === 'GET' && pathname === '/api/evolution') {
@@ -2623,7 +2597,7 @@ 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}`);
+      console.log(`[aims-workstation] ARM(REST): ${armApiBase()} | PAT: ${ARM_PAT ? '已加载' : '未配置'} | 已上岗助手: ${fs.readdirSync(DEPLOY_DIR).length} | 本地助手库: ${loadRegistry().agents.length}`);
   });
   // 已上岗助手后台物化为本地档案（best-effort；ARM 不可达时静默跳过，待手动同步）
   (async () => {