aims-workstation 0.1.3 → 0.1.5

package/.env.example

@@ -2,15 +2,19 @@
 PORT=5600
 
 # 平台 LLM（OpenAI 兼容端点；也可在「系统设置」页运行时切换）
-LLM_BASE_URL=https://open.bigmodel.cn/api/coding/paas/v4
-LLM_API_KEY=<your-llm-api-key>
-LLM_MODEL=glm-5.3
+# 缺省公司内网 bifrost 网关（内网可达即开箱可用）；以下三行留空/删除即用默认
+LLM_BASE_URL=http://bifrost.infra.dev.aimstek.cn/v1
+LLM_API_KEY=def
+LLM_MODEL=def
 
-# ARM 系统（人事系统：助手档案 + 经验库）
-ARM_MCP_URL=https://your-arm-host/api/mcp
-# PAT 留空则自动读取 ~/.arm/config.json 的 token（仅经验写入需要）
+# 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=
-
-# ARM REST API 默认值（v2：助手检索/下载 + 知识混合检索；运行时可在「系统设置」页切换源）
-ARM_API_BASE=http://localhost:3001
 ARM_API_TOKEN=<arm_pat_xxx-or-leave-empty>
+
+# npm 发版令牌（npmjs.com → Access Tokens 生成；供 scripts/publish-npm.sh 使用，发布免浏览器授权）
+# 选 Granular（限定本包、Read and write）或 Classic → Automation
+# NPM_TOKEN=npm_xxxxxxxxxxxxxxxxxxxx

package/README.md

@@ -10,7 +10,7 @@
 - **工作区**：助手 1:N 工作区（文件现场隔离），`exec` 锚定工作区目录，数据集按工作区分库
 - **分级自主**：L0 只读 → L2 确认执行（写操作挂起人工确认）→ L3 自主，危险命令永久拒绝；全程审计
 - **守护栏可维护**：危险命令清单（正则）与只读白名单在「系统设置·守护栏」增删，保存即热生效；`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.3",
+  "version": "0.1.5",
   "description": "AIMS 工作站：本地智能体工作站——ARM 助手本地化（下载/离线/升级）、工作台对话式定制、多工作区隔离、分级自主与审计",
   "bin": {
     "aims-workstation": "bin/aims-workstation.js"

package/scripts/publish-npm.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/env bash
+# 发布到 npm 公共仓（令牌免浏览器 2FA 授权）
+#
+# 令牌配置（一次性）：在包根目录 .env 里加一行
+#     NPM_TOKEN=npm_xxxxxxxxxxxx
+#   令牌到 npmjs.com → 头像 → Access Tokens 生成：
+#   推荐 Granular（限定 aims-workstation 包、Read and write、可设过期时间）；
+#   选 Classic 时必须用 Automation 类型——Publish 类型在 2FA 开启下仍会要求验证码。
+#   CI/临时覆盖可用环境变量：NPM_TOKEN=npm_xxx ./scripts/publish-npm.sh
+#   ⚠ 令牌不要写进本文件：scripts/ 在 package.json 的 files 清单里，会随 npm 包发布出去
+#
+# 用法（在 aims-workstation/ 目录下）：
+#   ./scripts/publish-npm.sh            发布当前版本
+#   ./scripts/publish-npm.sh patch      先升版本（patch/minor/major/1.2.3）再发布
+set -euo pipefail
+cd "$(dirname "$0")/.."
+
+REGISTRY="${NPM_REGISTRY:-https://registry.npmjs.org/}"
+
+# 令牌：环境变量 > .env 的 NPM_TOKEN（不 source 整个 .env，只取这一行）
+TOKEN="${NPM_TOKEN:-}"
+if [[ -z "$TOKEN" && -f .env ]]; then
+  TOKEN="$(sed -n 's/^NPM_TOKEN=//p' .env | tail -n1 | tr -d "[:space:]\"'")"
+fi
+if [[ -z "$TOKEN" ]]; then
+  echo "✗ 未找到 NPM_TOKEN（环境变量或 .env）。到 npmjs.com → Access Tokens 生成后执行："
+  echo "    echo 'NPM_TOKEN=npm_你的令牌' >> .env"
+  exit 1
+fi
+case "$TOKEN" in
+  npm_*) ;;
+  *) echo "⚠ 令牌不以 npm_ 开头（npmjs.org 令牌通常以 npm_ 开头），请确认来源" ;;
+esac
+
+if [[ $# -ge 1 ]]; then
+  npm version "$1" --no-git-tag-version
+fi
+NAME="$(node -p "require('./package.json').name")"
+VERSION="$(node -p "require('./package.json').version")"
+echo "→ 发布 $NAME@$VERSION → $REGISTRY"
+
+# 令牌经临时 userconfig 传入，不写 ~/.npmrc、不落盘
+CFG="$(mktemp)"
+trap 'rm -f "$CFG"' EXIT
+HOST_KEY="$(echo "$REGISTRY" | sed -E 's|^https?://||; s|/+$||')"
+printf '//%s/:_authToken=%s\n' "$HOST_KEY" "$TOKEN" > "$CFG"
+
+echo "→ 身份: $(NPM_CONFIG_USERCONFIG="$CFG" npm whoami --registry="$REGISTRY" 2>/dev/null || echo '未知（Granular 令牌不支持 whoami，属正常，直接尝试发布）')"
+NPM_CONFIG_USERCONFIG="$CFG" npm publish --registry="$REGISTRY"
+echo "✅ 已发布 $NAME@$VERSION"
+echo "   安装: npx $NAME@$VERSION"
+if [[ $# -ge 1 ]]; then
+  echo "ℹ 版本号已变更，记得提交 package.json / package-lock.json"
+fi

package/server.js

@@ -67,13 +67,13 @@ 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];
+      // 跳过模板占位符（<xxx-or-leave-empty> 之类）：直接复制 .env.example 为 .env 时不应产生毒害值
+      if (m && env[m[1]] === undefined && !/^<[^>]*>$/.test(m[2])) env[m[1]] = m[2];
     }
   } catch { /* .env 可选 */ }
 }
 const PORT = +(process.env.PORT || env.PORT || 5600);
 const HOST = process.env.AIMS_HOST || '0.0.0.0'; // 默认局域网可达（团队共用）；仅本机使用可设 AIMS_HOST=127.0.0.1
-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: '' };
@@ -96,15 +96,16 @@ function loadCfg() { try { Object.assign(cfg, JSON.parse(fs.readFileSync(CFG_FIL
 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$/, '');
-const armMcpUrl = () => cfg.arm_mcp_url || (cfg.arm_api_base ? `${cfg.arm_api_base}/api/mcp` : ARM_MCP_URL);
+// ARM 站点地址：运行时配置 > ARM_API_BASE(env) > 从 MCP URL 推导 > 公司内网默认（内网可达即开箱可用）；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 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';
+// 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 || '';
-const llmModelName = () => cfg.llm_model || env.LLM_MODEL || 'glm-5.3';
+const llmApiKey = () => cfg.llm_api_key || env.LLM_API_KEY || 'def';
+const llmModelName = () => cfg.llm_model || env.LLM_MODEL || 'def';
 // 场景画像：平台级、全局一份的用户场景描述（团队环境/系统清单/规范），注入所有助手；空则不注入。
 // 与知识检索互补（常驻事实 vs 按需检索）；凭据不进画像（放"凭据在哪、找谁要"）。
 const sceneProfile = () => String(cfg.scene_profile || '').trim();
@@ -214,7 +215,10 @@ async function armRest(pathname, init = {}, timeout_ms = 20000) {
   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}`);
+    if (!res.ok || data.ok === false) {
+      const noAuth = res.status === 401 || res.status === 403 || /401|403|unauthorized|forbidden/i.test(String(data.msg || ''));
+      throw new Error(`ARM REST ${pathname.split('?')[0]}: ${data.msg || res.status}${noAuth ? '——令牌未配置或无权限：到 ARM（' + armApiBase() + '）生成访问令牌（arm_pat_…）后，粘贴到「系统设置 · ARM 源 · 访问令牌」' : ''}`);
+    }
     return data.data;
   } catch (e) {
     if (e.message === 'fetch failed') { // undici 把网络层错误笼统包装，展开真实原因（DNS/连接/TLS）
@@ -267,7 +271,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
@@ -331,6 +335,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}`);
@@ -563,17 +580,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 }); // 用户中断 → 终止执行中的命令
       });
     },
   },
@@ -1209,13 +1227,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 || ''}` });
     }
@@ -1225,6 +1246,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;
@@ -1234,9 +1259,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 事件流）────
@@ -1293,7 +1317,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);
@@ -1307,24 +1331,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}`;
@@ -1344,14 +1396,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 ────────────────────────────────────────────────
@@ -1359,7 +1415,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) => {
@@ -1397,7 +1453,7 @@ const server = http.createServer(async (req, res) => {
       const k = llmApiKey();
       return json(res, 200, {
         arm: {
-          api_base: armApiBase(), api_base_runtime: !!cfg.arm_api_base,
+          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')),
@@ -1512,15 +1568,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
-      catch { online = false; }
+      let online = true, remoteCards = [], authError = false;
+      try { remoteCards = await armListAgents(url.searchParams.get('keyword') || ''); } // REST 全量优先，旧版回落 MCP
+      catch (e) { online = false; authError = /令牌未配置或无权限/.test(String(e.message)); } // 区分"未授权"与"不可达"，前端引导配置令牌
       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 || '',
@@ -1530,7 +1589,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 };
@@ -1541,14 +1601,100 @@ 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()] });
+      return json(res, 200, { online, auth_error: authError, 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: '你是助手档案起草器。根据用户的职责描述输出严格 JSON（不要 markdown 代码围栏）：{"name":"助手名称","prompt":"System Prompt"}。name：12 字以内的中文名称，体现职责；prompt：第一句角色定位，随后 3-6 条职责要点（每条一个短句），最后 1-2 条工作方式或能力边界约束，200 字以内。只输出 JSON。',
+          messages: [{ role: 'user', content: `助手名称（用户意向，可参考）：${String(name || '').trim() || '（待定）'}\n职责描述：${String(description).trim()}\n\n请输出 JSON：`, 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();
+        let draftName = '', prompt = text;
+        const jm = text.match(/\{[\s\S]*\}/); // JSON 容错解析：失败则整段当 prompt，不阻断
+        if (jm) { try { const j = JSON.parse(jm[0]); if (j.prompt) { prompt = String(j.prompt).trim(); if (j.name) draftName = String(j.name).trim().slice(0, 24); } } catch { } }
+        return json(res, 200, { prompt, name: draftName });
+      } 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)$/);
@@ -1588,15 +1734,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 });
     }
@@ -1923,6 +2061,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();
@@ -1934,9 +2075,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();
     }
 
@@ -1948,10 +2090,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) {
@@ -1959,19 +2104,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;
@@ -1981,17 +2135,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();
     }
     // ── 会话历史与进度（切换助手后回来：上下文回放 + 后台运行状态；服务端为唯一事实源）──