aims-workstation 0.1.2 → 0.1.4

package/README.md

@@ -9,8 +9,9 @@
 - **工作台**：每个助手一个专属操作面；区块自由布局，**对话式开发面板插件**（描述需求 → 二开助手生成 → 草稿审阅 → 发布）
 - **工作区**：助手 1:N 工作区（文件现场隔离），`exec` 锚定工作区目录，数据集按工作区分库
 - **分级自主**：L0 只读 → L2 确认执行（写操作挂起人工确认）→ L3 自主，危险命令永久拒绝；全程审计
-- **并行会话**：多助手并行、后台运行进度跟踪、确认卡跨切换恢复
-- **系统设置**：ARM 源 / LLM（任意 OpenAI 兼容端点）/ 全局场景画像，界面配置即时生效
+- **守护栏可维护**：危险命令清单（正则）与只读白名单在「系统设置·守护栏」增删，保存即热生效；`sudo -u <用户>` 降权形式可配置为 L2 确认执行；删减危险规则需二次确认并写审计
+- **并行会话**：多助手并行、后台运行进度跟踪、确认卡跨切换恢复；对话可随时中断（停止按钮/状态行中断，执行中的命令一并终止，部分回复保留进上下文可续聊）
+- **系统设置**：ARM 源 / LLM（任意 OpenAI 兼容端点）/ 全局场景画像 / 守护栏策略，界面配置即时生效
 
 ## 快速开始
 

package/package.json

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

package/server.js

@@ -2,6 +2,9 @@
 // 链路: ARM员工库 → 下载物化本地 → 平台实例化(pi-ai + 工具注入 + 分级自主) → 工作台(DSL) → 经验回流ARM
 // Agent 层基于 @earendil-works/pi-ai（统一 LLM API），前端为 web/ 预构建的 shadcn/ui 应用（web/dist）
 'use strict';
+// TLS 证书校验关闭（用户决策：内网私有部署自签证书常见，能访问优先）
+// 覆盖所有出站 fetch（ARM REST/MCP、LLM、面板代理）。本工具面向内网/本机使用。
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
@@ -74,8 +77,24 @@ 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: '', access_token: '' };
-function loadCfg() { try { Object.assign(cfg, JSON.parse(fs.readFileSync(CFG_FILE, 'utf8'))); } catch { } }
+// 守护栏默认策略（可在「系统设置·守护栏」维护，存 platform.json，保存即热生效）：deny=正则源串（命中即永久拒绝，任何级别不豁免）；
+// ro=只读白名单命令名（免确认直行）；sudo_u_l2=true 时 `sudo -u <用户>` 降权形式不再永久拒绝、按写命令走 L2 人工确认（裸 sudo 仍拒绝）
+const GUARD_DEFAULT = {
+  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'],
+  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'],
+  sudo_u_l2: false,
+};
+function normalizeGuard(g) {
+  g = g && typeof g === 'object' ? g : {};
+  return {
+    deny: Array.isArray(g.deny) ? [...new Set(g.deny.map((s) => String(s).trim()).filter(Boolean))] : GUARD_DEFAULT.deny.slice(),
+    ro: Array.isArray(g.ro) ? [...new Set(g.ro.map((s) => String(s).trim()).filter(Boolean))] : GUARD_DEFAULT.ro.slice(),
+    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); }
 loadCfg();
+const guardNow = () => cfg.guard;
 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$/, '');
@@ -197,6 +216,16 @@ async function armRest(pathname, init = {}, timeout_ms = 20000) {
     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;
+  } catch (e) {
+    if (e.message === 'fetch failed') { // undici 把网络层错误笼统包装，展开真实原因（DNS/连接/TLS）
+      const c = e.cause || {};
+      const reason = c.code || c.message || '未知网络错误';
+      const hint = /LEAF|CERT|SSL|TLS/i.test(String(reason)) ? '——HTTPS 证书校验失败（自签证书？内网解析应直连 HTTP）'
+        : /ENOTFOUND|EAI_AGAIN/.test(String(reason)) ? '——域名解析失败（当前 DNS 无此内网记录）'
+        : /ECONNREFUSED|ETIMEDOUT|EHOSTUNREACH/.test(String(reason)) ? '——目标不可达（连接被拒/超时）' : '';
+      throw new Error(`ARM 请求失败: ${reason}${hint}`);
+    }
+    throw e;
   } finally { clearTimeout(timer); }
 }
 const vVer = (v) => (String(v || '').startsWith('v') ? String(v) : `v${v || '0.0.0'}`); // REST 无 v 前缀，统一内部表示
@@ -238,7 +267,7 @@ async function armListAgents(keyword = '') {
     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' }));
+  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
@@ -302,6 +331,19 @@ function commitDownload(manifest) {
   e.versions.sort(cmpVersion);
   saveRegistry(reg);
 }
+// 本地卸载（本地 DELETE 与「从 ARM 删除并卸载」共用）：上岗配置/工作台/版本目录/注册表，可选清工作区数据
+function uninstallLocalAgent(agentId, purge_workspaces) {
+  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 { } }
+  }
+  return true;
+}
 
 async function downloadAgentRest(agentId) {
   const d = await armRest(`/api/v1/agents/${agentId}`);
@@ -503,11 +545,15 @@ function deleteWorkspace(agentId, wsId, purge) {
 
 // ── 通用计算原语与平台数据服务（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 g = guardNow();
+  // sudo 降权特例（可配置）：开启后剥掉 `sudo -u <用户>` 片段再匹配危险清单（嵌套的裸 sudo/毁灭性命令仍会命中），剩余部分按普通命令分级
+  const denyCmd = g.sudo_u_l2 ? cmd.replace(/\bsudo\s+(?:-\w+\s+)*-u\s+\S+/g, '') : cmd;
+  const denyRes = [];
+  for (const src of g.deny) { try { denyRes.push(new RegExp(src)); } catch { /* 坏正则跳过（PUT 时已校验，历史数据兜底） */ } }
+  if (denyRes.some((re) => re.test(denyCmd))) return { status: 'blocked', reason: '【守护栏】命令命中危险清单（清单可在 系统设置·守护栏 维护）' };
+  const EXEC_RO = g.ro;
   const noRedirect = cmd.replace(/2>&1/g, ''); // 重定向/tee 使白名单命令具备写能力，不再视为只读
   const SQL_WRITE = /\b(INSERT|UPDATE|DELETE|DROP|CREATE|ALTER|REPLACE)\b/i;
   // 复合命令逐段判定：每个由 ; && || | 换行 分隔的段都须只读（控制关键字与 for 头部放行）
@@ -522,7 +568,7 @@ function classifyExec(command, autonomy) {
   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 并人工确认` };
+  return { status: 'blocked', reason: `【守护栏】L${autonomy} 仅放行只读命令（${EXEC_RO.slice(0, 8).join('/')}等，完整清单见 系统设置·守护栏）。写操作需 L2 并人工确认` };
 }
 const PRIMITIVE_TOOLS = {
   exec: {
@@ -530,17 +576,18 @@ const PRIMITIVE_TOOLS = {
     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) => {
+    run: async ({ command, timeout_ms = 15000 }, agentId, _wsId, signal) => {
       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 child = 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 : ''}`);
+          resolve(`$ ${command}\n${out}${errOut ? '\n[stderr] ' + errOut : ''}${err && !out && !errOut ? '\n[错误] ' + err.message : ''}${signal?.aborted ? '\n[中断] 命令已被用户终止' : ''}`);
         });
+        if (signal) signal.addEventListener('abort', () => { try { child.kill('SIGTERM') } catch { /* 已退出 */ } }, { once: true }); // 用户中断 → 终止执行中的命令
       });
     },
   },
@@ -1176,13 +1223,16 @@ function devSystemPrompt() {
   ].join('\n');
 }
 
-async function devChatLoop(session, emit) {
+async function devChatLoop(session, emit, signal = null) {
   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 < 32; round++) {
-    emit('status', { text: `第 ${round + 1}/32 轮` });
-    const stream = models.stream(model, session.context);
+  const interrupted = () => !!signal?.aborted;
+  for (let round = 0; ; round++) { // 不设轮次上限：自然结束或用户中断（断开连接/停止按钮）
+    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 || ''}` });
     }
@@ -1192,6 +1242,10 @@ async function devChatLoop(session, emit) {
     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) {
+      if (interrupted()) { // 余下工具不再执行，补占位结果保证工具调用链完整
+        session.context.messages.push({ role: 'toolResult', toolCallId: tc.id, toolName: tc.name, content: [{ type: 'text', text: '（用户中断，未执行）' }], isError: false, timestamp: Date.now() });
+        continue;
+      }
       const args = tc.arguments || {};
       emit('tool_start', { tool: tc.name, args });
       let result, isErr = false;
@@ -1201,9 +1255,8 @@ async function devChatLoop(session, emit) {
       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() });
     }
+    if (interrupted()) { emit('interrupted', { at: `第 ${round + 1} 轮` }); return { reply: text, events }; }
   }
-  emit('done', { reply: '（达到轮次上限——请把结论性需求拆小，或继续对话续跑）', events });
-  return { reply: '（达到轮次上限）', events };
 }
 
 // ── 助手运行时（pi-ai Context + 守护栏 + SSE 事件流）────
@@ -1232,7 +1285,7 @@ function systemPrompt(armAgent, deployment, autonomy, ws) {
     '- 连通性实测：exec `nc -vz -w 3 <host> <port>`（"能否连接"必须实测）',
     '- 平台数据：先 data_describe 看字典，再 data_query 查询（服务端按助手隔离）',
     '- 现场若有已接入的数据面板，以工作台展示为准；没有就说没有，不猜测',
-    'exec 只读命令直接执行；写命令需 L2+人工确认；危险命令永久拒绝。',
+    `exec 只读命令直接执行；写命令需 L2+人工确认；危险命令永久拒绝${guardNow().sudo_u_l2 ? '（例外：sudo 降权形式 sudo -u <用户> 按写命令处理，L2 确认后可执行；裸 sudo 仍拒绝）' : ''}。`,
     '',
     '【事实与推断分离（硬规则）】',
     '- 连通性结论只能来自实测（nc/curl）；记录存在≠可达，设备状态在线≠可达',
@@ -1260,7 +1313,7 @@ async function ensureSession(sessionId, agentId, autonomyLevel, wsId) {
   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 };
+    s = { agentId, wsId: wsId || 'default', autonomy: { L0: 0, L1: 1, L2: 2, L3: 3 }[deployment.default_autonomy] ?? 1, context: null, pending: null };
     sessions.set(sessionId, s);
   }
   const ws = getWs(agentId, s.wsId) || currentWs(agentId);
@@ -1274,24 +1327,52 @@ async function ensureSession(sessionId, agentId, autonomyLevel, wsId) {
 }
 
 // 运行一轮 Agent 循环，事件通过 emit(type, data) 推给 SSE；s.running/s.statusText 供跨页面进度跟踪
-async function agentLoop(s, deployment, emit, maxRounds = 32) {
-  for (let round = 0; round < maxRounds; round++) {
-    s.statusText = `第 ${round + 1}/${maxRounds} 轮 · 推理中`;
-    const stream = models.stream(model, s.context);
+// 不设轮次上限：跑到无更多工具调用自然结束，失控靠用户中断（signal）
+// signal：用户中断（停止按钮/断开连接/POST /api/chat/interrupt）——轮次间、流中、每个工具执行前检查；
+// 中断时保留已流出的部分文本为助手消息并补记"（已被用户中断）"，未应答的 toolCall 补占位 toolResult 保证下轮上下文合法
+async function agentLoop(s, deployment, emit, signal = null) {
+  const interrupted = () => !!signal?.aborted;
+  for (let round = 0; ; round++) {
+    if (interrupted()) return { reply: '（已被用户中断）', interrupted: true, pending: s.pending };
+    s.statusText = `第 ${round + 1} 轮 · 推理中`;
+    const stream = models.stream(model, s.context, signal ? { signal } : undefined);
     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)}`);
+    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 === 'thinking_start') emit('status', { text: '思考中…' });
+        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 以 done(aborted) 收尾，result() 返回已积累的部分消息
+    } catch (e) {
+      if (!interrupted()) throw e; // 真实错误上抛；中断路径用占位消息兜底
     }
-    const final = await stream.result();
+    const aborted = interrupted();
+    if (!final) final = { role: 'assistant', content: [], timestamp: Date.now() };
+    if (aborted) (final.content = final.content || []).push({ type: 'text', text: (final.content.some((b) => b.type === 'text' && b.text) ? '\n\n' : '') + '（已被用户中断）' });
     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 };
+    if (!calls.length || aborted) {
+      if (aborted) {
+        emit('interrupted', { at: `第 ${round + 1} 轮` });
+        audit({ actor: 'user', agent: deployment.agent_id, action: 'interrupt-chat', round: round + 1 });
+        return { reply: textNow, interrupted: true, pending: s.pending };
+      }
+      return { reply: textNow, pending: null };
+    }
 
     for (const tc of calls) {
+      if (interrupted()) { // 后续工具不再执行，补占位结果保证工具调用链完整
+        s.context.messages.push({ role: 'toolResult', toolCallId: tc.id, toolName: tc.name, content: [{ type: 'text', text: '（用户中断，未执行）' }], isError: false, timestamp: Date.now() });
+        continue;
+      }
       const args = tc.arguments || {};
       emit('tool_start', { tool: tc.name, args });
       s.statusText = `调用工具 ${tc.name}`;
@@ -1311,14 +1392,18 @@ async function agentLoop(s, deployment, emit, maxRounds = 32) {
       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'); }
+      try { result = await getTool(tc.name).run(args, s.agentId, s.wsId || 'default', signal); }
       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 });
     }
+    if (interrupted()) {
+      emit('interrupted', { at: `第 ${round + 1} 轮` });
+      audit({ actor: 'user', agent: deployment.agent_id, action: 'interrupt-chat', round: round + 1 });
+      return { reply: textNow, interrupted: true, pending: s.pending };
+    }
   }
-  return { reply: '（达到工具调用轮次上限——回复「继续」可在完整上下文上续跑；也可在工作台 DSL 提高 max_rounds，上限 128）', pending: null };
 }
 
 // ── HTTP ────────────────────────────────────────────────
@@ -1326,7 +1411,7 @@ function json(res, code, data) { res.writeHead(code, { 'Content-Type': 'applicat
 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`);
+  return (type, data) => { if (res.writableEnded || res.destroyed) return; res.write(`data: ${JSON.stringify({ type, ...data })}\n\n`); }; // 客户端断开后不再写
 }
 
 const server = http.createServer(async (req, res) => {
@@ -1377,10 +1462,27 @@ const server = http.createServer(async (req, res) => {
         },
         scene: { profile: sceneProfile(), length: sceneProfile().length },
         auth: { enabled: !!accessToken(), token_masked: accessToken() ? `${accessToken().slice(0, 4)}…${accessToken().slice(-2)}` : '' },
+        guard: { ...guardNow(), default_deny: GUARD_DEFAULT.deny, default_ro: GUARD_DEFAULT.ro },
       });
     }
     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 } = await body(req);
+      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);
+      // 守护栏维护：deny 正则可编译 / ro 须为单命令名；保存即热生效（classifyExec 每次调用现读配置）；删减危险规则记入审计
+      let guardAudit = null;
+      if (guard !== undefined) {
+        if (!guard || typeof guard !== 'object') return json(res, 400, { error: 'guard 须为对象 { deny, ro, sudo_u_l2 }' });
+        const next = normalizeGuard(guard);
+        for (const src of next.deny) { try { new RegExp(src); } catch (e) { return json(res, 400, { error: `危险清单正则不合法：${src}（${e.message}）` }); } }
+        for (const c of next.ro) { if (!/^[A-Za-z0-9_.-]{1,32}$/.test(c)) return json(res, 400, { error: `只读白名单项须为单个命令名（字母数字._-）：${c}` }); }
+        const cur = guardNow();
+        guardAudit = {
+          removed_deny: cur.deny.filter((d) => !next.deny.includes(d)),
+          added_deny: next.deny.filter((d) => !cur.deny.includes(d)),
+          removed_ro: cur.ro.filter((c) => !next.ro.includes(c)),
+          sudo_u_l2: next.sudo_u_l2,
+        };
+        cfg.guard = next;
+      }
       let authChanged = false;
       if (access_token !== undefined) { const t = String(access_token || '').trim(); authChanged = t !== accessToken(); cfg.access_token = t; } // 置空=关闭认证
       const normUrl = (u) => { const s = String(u || '').trim().replace(/\/+$/, ''); return s; };
@@ -1425,7 +1527,7 @@ 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 });
+      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 });
       // ARM 保存后即时探测（失败不回滚：允许先配置后启动 ARM）
       let probe = { online: false, error: '' };
       if ([arm_api_base, arm_mcp_url, arm_token].some((v) => v !== undefined)) {
@@ -1462,15 +1564,18 @@ const server = http.createServer(async (req, res) => {
 
     // ── 助手目录（本地库 ∪ 远端目录；离线时仅本地）──
     if (req.method === 'GET' && pathname === '/api/agents') {
-      const keyword = url.searchParams.get('keyword') || '';
+      const kw = (url.searchParams.get('keyword') || '').trim().toLowerCase();
       const reg = loadRegistry();
       let online = true, remoteCards = [];
-      try { remoteCards = await armListAgents(keyword); } // REST 全量优先，旧版回落 MCP
+      try { remoteCards = await armListAgents(url.searchParams.get('keyword') || ''); } // REST 全量优先，旧版回落 MCP
       catch { online = false; }
       const byId = new Map();
       for (const e of reg.agents) {
         const lm = localManifest(e.agent_id) || {};
+        // 搜索时本地库同样按关键词过滤（名称/描述），与远端搜索结果口径一致
+        if (kw && !(String(e.name || '').toLowerCase().includes(kw) || String(e.description || lm.description || '').toLowerCase().includes(kw))) continue;
         byId.set(e.agent_id, {
+          created_via_workstation: !!e.created_via_workstation, // 工作站新建的助手：大厅提供编辑档案/从 ARM 删除
           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 || '',
@@ -1480,7 +1585,8 @@ const server = http.createServer(async (req, res) => {
           delisted: !!e.delisted, downloaded_at: e.downloaded_at || null,
         });
       }
-      if (online) { // 静默刷新远端版本与下架标记（显式事件统计走 /api/arm/sync）
+      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 };
@@ -1491,15 +1597,98 @@ const server = http.createServer(async (req, res) => {
             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;
+        if (!kw) {
+          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);
         }
-        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()] });
     }
+    // ── 新建助手：本地起草（AI 生成 prompt）→ ARM JSON 创建（创建即发布）→ 可选知识绑定（幂等）→ 下载物化 ──
+    if (req.method === 'POST' && pathname === '/api/agents/draft-prompt') {
+      const { description, name } = await body(req);
+      if (!String(description || '').trim()) return json(res, 400, { error: '请先填写助手职责描述' });
+      try {
+        const ctx = {
+          systemPrompt: '你是助手档案起草器。根据用户对助手职责的描述写出可直接使用的中文 System Prompt：第一句角色定位；随后 3-6 条职责要点（每条一个短句）；最后 1-2 条工作方式或能力边界约束。只输出 Prompt 正文，不要标题、不要解释，200 字以内。',
+          messages: [{ role: 'user', content: `助手名称：${String(name || '').trim() || '（待定）'}\n职责描述：${String(description).trim()}\n\n请生成 System Prompt：`, timestamp: Date.now() }],
+          tools: [],
+        };
+        const stream = models.stream(model, ctx);
+        let out = '';
+        for await (const ev of stream) { if (ev.type === 'text_delta') out += ev.delta; }
+        const final = await stream.result();
+        const text = ((final.content || []).filter(b => b.type === 'text').map(b => b.text).join('') || out).trim();
+        return json(res, 200, { prompt: text });
+      } catch (e) { return json(res, 502, { error: `起草失败: ${e.message}` }); }
+    }
+    if (req.method === 'GET' && pathname === '/api/agents/knowledges') { // 新建向导的知识选择器：ARM 关键词检索
+      const kwd = url.searchParams.get('keyword') || '';
+      try {
+        const d = await armRest(`/api/v1/knowledges?search=${encodeURIComponent(kwd)}&page=1&pageSize=20`);
+        const items = (Array.isArray(d) ? d : (d.items || d.knowledges || [])).map((k) => ({ id: k.id, name: k.name, description: String(k.description || '').slice(0, 80) }));
+        return json(res, 200, { items });
+      } catch (e) { return json(res, 200, { items: [], error: String(e.message).slice(0, 100) }); }
+    }
+    if (req.method === 'POST' && pathname === '/api/agents/create') {
+      const { name, description, prompt, knowledge_ids } = await body(req);
+      const nm = String(name || '').trim(), pr = String(prompt || '').trim();
+      if (!nm || !pr) return json(res, 400, { error: '名称与 System Prompt 必填' });
+      try {
+        const created = await armRest('/api/v1/agents', { method: 'POST', body: JSON.stringify({ name: nm, description: String(description || '').trim().slice(0, 512), prompt: pr, status: 'active' }) });
+        const newId = created?.id || created?.agent?.id;
+        if (!newId) throw new Error('ARM 未返回新助手 id');
+        let bound = 0;
+        for (const kid of (Array.isArray(knowledge_ids) ? knowledge_ids : [])) { // 绑定幂等（重复绑定返回已有版本）
+          try { await armRest(`/api/v1/agents/${newId}/knowledges`, { method: 'POST', body: JSON.stringify({ knowledgeId: kid, kind: 'experience' }) }); bound++; }
+          catch { /* 单条绑定失败不阻断创建 */ }
+        }
+        const manifest = await downloadAgent(newId); // 创建即物化本地（沿用下载链路）
+        const reg = loadRegistry(); const entry = reg.agents.find((x) => x.agent_id === newId); if (entry) entry.created_via_workstation = true; saveRegistry(reg); // 大厅据此显示编辑/删除入口
+        audit({ actor: 'user', action: 'create-agent', agentId: newId, name: nm, knowledges: bound });
+        return json(res, 200, { agent_id: newId, manifest, knowledges_bound: bound });
+      } catch (e) { return json(res, 502, { error: `创建失败: ${e.message}` }); }
+    }
+    // 编辑档案（工作站创建的助手）：ARM PUT 后重新物化，本地 prompt 同步更新
+    if (req.method === 'GET' && pathname.match(/^\/api\/agents\/[0-9a-f-]{36}\/profile$/)) {
+      const id = pathname.split('/')[3];
+      try {
+        const d = await armRest(`/api/v1/agents/${id}`);
+        return json(res, 200, { name: d.name, description: String(d.description || ''), prompt: d.prompt || '' });
+      } catch (e) { return json(res, 502, { error: `档案读取失败: ${e.message}` }); }
+    }
+    if (req.method === 'PUT' && pathname.match(/^\/api\/agents\/[0-9a-f-]{36}$/)) {
+      const id = pathname.split('/')[3];
+      const { name, description, prompt } = await body(req);
+      const patch = {};
+      if (String(name || '').trim()) patch.name = String(name).trim();
+      if (description !== undefined) patch.description = String(description || '').trim().slice(0, 512);
+      if (String(prompt || '').trim()) patch.prompt = String(prompt).trim();
+      if (!Object.keys(patch).length) return json(res, 400, { error: '没有可更新字段' });
+      try {
+        await armRest(`/api/v1/agents/${id}`, { method: 'PUT', body: JSON.stringify(patch) });
+        let manifest = null;
+        try { manifest = await downloadAgent(id); } catch { /* 本地未安装时无需物化 */ }
+        audit({ actor: 'user', action: 'update-agent', agentId: id, fields: Object.keys(patch) });
+        return json(res, 200, { ok: true, manifest });
+      } catch (e) { return json(res, 502, { error: `更新失败: ${e.message}` }); }
+    }
+    // 从 ARM 删除（危险操作，前端二次确认）：可选同时卸载本地档案
+    if (req.method === 'POST' && pathname.match(/^\/api\/agents\/[0-9a-f-]{36}\/arm-delete$/)) {
+      const id = pathname.split('/')[3];
+      const { also_uninstall, purge_workspaces } = await body(req);
+      try {
+        await armRest(`/api/v1/agents/${id}`, { method: 'DELETE' });
+        let uninstalled = false;
+        if (also_uninstall && loadRegistry().agents.some((a) => a.agent_id === id)) uninstalled = uninstallLocalAgent(id, !!purge_workspaces);
+        audit({ actor: 'user', action: 'arm-delete-agent', agentId: id, also_uninstalled: uninstalled });
+        return json(res, 200, { ok: true, uninstalled });
+      } catch (e) { return json(res, 502, { error: `ARM 删除失败: ${e.message}` }); }
+    }
     // ── 本地助手库：下载 / 升级 / 版本历史 / 回滚 / 卸载 ──
     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')) {
@@ -1538,15 +1727,7 @@ const server = http.createServer(async (req, res) => {
       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 { } }
-      }
+      uninstallLocalAgent(agentId, !!purge_workspaces);
       audit({ actor: 'arm-library', agentId, action: 'uninstall', purged_workspaces: !!purge_workspaces });
       return json(res, 200, { ok: true });
     }
@@ -1873,6 +2054,9 @@ const server = http.createServer(async (req, res) => {
     if (req.method === 'POST' && pathname === '/api/dev/chat') {
       const { sessionId, agentId, message } = await body(req);
       const emit = sseInit(req, res);
+      const ctl = new AbortController();
+      let finished = false;
+      req.on('close', () => { if (!finished) ctl.abort(); }); // 断开即中断定制循环（无轮次上限后的失控出口）
       try {
         devCtx.agentId = agentId;
         if (!loadWorkbench(agentId)) return emit('error', { message: '该助手尚无工作台' }), res.end();
@@ -1884,9 +2068,10 @@ const server = http.createServer(async (req, res) => {
           s.context.systemPrompt = devSystemPrompt();
         }
         s.context.messages.push({ role: 'user', content: message, timestamp: Date.now() });
-        await devChatLoop(s, emit);
+        await devChatLoop(s, emit, ctl.signal);
         emit('meta', { hasDraft: !!loadDraft(agentId) });
       } catch (e) { emit('error', { message: e.message }); }
+      finally { finished = true; }
       return res.end();
     }
 
@@ -1898,10 +2083,13 @@ const server = http.createServer(async (req, res) => {
     if (req.method === 'POST' && pathname === '/api/chat') {
       const { sessionId, agentId, message, autonomyLevel, context, ws_id } = await body(req);
       const emit = sseInit(req, res);
+      const ctl = new AbortController();
+      let finished = false;
+      req.on('close', () => { if (!finished) ctl.abort(); }); // 客户端断开（停止按钮/关页面）→ 中断后台循环
       try {
         const { s, deployment, armAgent } = await ensureSession(sessionId, agentId, autonomyLevel, ws_id);
         if (s.running) { // 会话在后台仍在处理上一条消息（跨页面进度跟踪）
-          emit('error', { message: `该会话正在后台处理（${s.statusText || '进行中'}）——可先切换其他助手，稍后回来进度会自动恢复` });
+          emit('error', { message: `该会话正在后台处理（${s.statusText || '进行中'}）——可先切换其他助手，稍后回来进度会自动恢复；也可在状态行点「中断」` });
           return res.end();
         }
         if (s.pending) {
@@ -1909,19 +2097,28 @@ 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 wb = loadDraft(agentId) || loadWorkbench(agentId) || {};
-        s.running = true; s.sinceTs = Date.now();
-        const out = await agentLoop(s, deployment, emit, Math.min(128, Math.max(1, +(wb.max_rounds) || 32)));
+        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 });
       } catch (e) { emit('error', { message: e.message }); }
-      finally { const s = sessions.get(sessionId); if (s) { s.running = false; s.statusText = ''; } }
+      finally { finished = true; const s = sessions.get(sessionId); if (s) { s.running = false; s.statusText = ''; s.abortCtl = null; } }
       return res.end();
     }
+    if (req.method === 'POST' && pathname === '/api/chat/interrupt') {
+      const { sessionId } = await body(req);
+      const s = sessions.get(sessionId);
+      if (s?.running && s.abortCtl) { s.abortCtl.abort(); return json(res, 200, { ok: true, interrupted: true }); } // 幂等：循环在下一个检查点退出
+      return json(res, 200, { ok: true, interrupted: false, note: '当前没有进行中的对话' });
+    }
     if (req.method === 'POST' && pathname === '/api/chat/confirm') {
       const { sessionId, approved } = await body(req);
       const emit = sseInit(req, res);
+      const ctl = new AbortController();
+      let finished = false;
+      let s = null;
+      req.on('close', () => { if (!finished) ctl.abort(); });
       try {
-        const s = sessions.get(sessionId);
+        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;
@@ -1931,17 +2128,16 @@ const server = http.createServer(async (req, res) => {
         } 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; }
+          try { result = await getTool(tool).run(args, s.agentId, s.wsId || 'default', ctl.signal); } 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.min(128, Math.max(1, +(wb.max_rounds) || 32)));
+        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 });
       } catch (e) { emit('error', { message: e.message }); }
-      finally { if (s) { s.running = false; s.statusText = ''; } }
+      finally { finished = true; if (s) { s.running = false; s.statusText = ''; s.abortCtl = null; } }
       return res.end();
     }
     // ── 会话历史与进度（切换助手后回来：上下文回放 + 后台运行状态；服务端为唯一事实源）──
@@ -2065,6 +2261,14 @@ if (process.argv.includes('--test-guard')) {
     ['exec', 3, { command: 'echo hi > /tmp/a.txt' }, 'ok'],
     ['exec', 3, { command: 'sudo reboot' }, 'blocked'],
   ];
+  // 守护栏可配置（系统设置·守护栏）：sudo_u_l2 开启后，`sudo -u <用户>` 降权按写命令走 L2 确认；裸 sudo 与嵌套危险命令仍拒绝
+  cfg.guard = normalizeGuard({ ...guardNow(), sudo_u_l2: true });
+  cases.push(
+    ['exec', 2, { command: "sshpass -p x ssh -o StrictHostKeyChecking=no root@192.0.2.1 'sudo -u aims bash -c \"npm install -g aims-workstation\"' 2>&1 | tail -40" }, 'pending'],
+    ['exec', 0, { command: 'sudo -u aims npm install -g x' }, 'blocked'],
+    ['exec', 2, { command: "sudo -u aims bash -c 'sudo reboot'" }, 'blocked'],
+    ['exec', 2, { command: 'sudo apt install -y x' }, '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;