aims-workstation 0.1.18 → 0.1.20

package/package.json

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

package/server.js

@@ -156,9 +156,41 @@ 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
+// 上下文窗口（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; };
+// 常见模型族的真实窗口（按序首条命中生效，大小写不敏感；数值随各模型官方文档更新，2026-10）
+const LLM_MODEL_CONTEXT_RULES = [
+  { re: /glm[-_. ]?5/i, tokens: 1_000_000 },          // GLM-5.x：1M
+  { re: /glm[-_. ]?4[-_.]?6/i, tokens: 200_000 },     // GLM-4.6：200K
+  { re: /glm/i, tokens: 128_000 },                    // GLM-4.5 及更早：128K
+  { re: /minimax[-_. ]?m[3-9]/i, tokens: 1_000_000 }, // MiniMax-M3 及以后：1M
+  { re: /minimax/i, tokens: 204_800 },                // MiniMax-M2/M1：204K
+  { re: /gpt[-_. ]?4[-_.]?1/i, tokens: 1_000_000 },   // GPT-4.1：1M
+  { re: /claude/i, tokens: 200_000 },                 // Claude：200K
+  { re: /deepseek/i, tokens: 128_000 },               // DeepSeek：128K
+  { re: /qwen/i, tokens: 131_072 },                   // Qwen：128K
+  { re: /gemini/i, tokens: 1_000_000 },               // Gemini：1M+
+  { re: /gpt/i, tokens: 128_000 },                    // GPT-4o 等：128K
+];
+const llmContextInfo = () => {
+  const n = +cfg.llm_context_tokens;
+  if (Number.isFinite(n) && n > 0) return { source: 'runtime', tokens: n };
+  const hit = LLM_MODEL_CONTEXT_RULES.find((r) => r.re.test(llmModelName()));
+  return hit ? { source: 'model', tokens: hit.tokens } : { source: 'default', tokens: LLM_DEFAULT_CONTEXT_TOKENS };
+};
+const llmContextTokens = () => llmContextInfo().tokens;
+// 上下文超限的识别与自愈：小白可以不懂数字，但报错必须看得懂、知道去哪调
+let ctxBudgetScale = 1; // 裁剪预算收缩系数：超限自愈时减半（下限 12.5%）；改动模型/窗口配置后复位
+const ctxSourceLabel = (src) => ({ runtime: '手动配置', model: '按模型自动识别', default: '默认' }[src] || src);
+// 各家超限文案不同（OpenAI/Anthropic/GLM/MiniMax/中文网关），宽匹配关键词组；认证/限流/超时类不误伤
+const isContextOverflow = (t) => /context.{0,24}(length|window|limit|size)|maximum context|prompt is too long|tokens?.{0,16}(exceed|too many|too long)|exceed.{0,24}context|上下文.{0,10}(超|过长|上限)/i.test(String(t || ''));
+function contextOverflowMsg(raw) {
+  const info = llmContextInfo();
+  const scaled = ctxBudgetScale < 1 ? `，已自动收缩至 ${Math.round(ctxBudgetScale * 100)}% 仍超` : '';
+  return `上下文超出模型窗口（当前生效 ${info.tokens.toLocaleString()} token，${ctxSourceLabel(info.source)}${scaled}）。` +
+    `请到「系统设置 → LLM 模型服务」调低上下文窗口，或缩短本次输入/更换小附件后重试。模型侧原文：${String(raw || '').slice(0, 160)}`;
+}
 // 场景画像：平台级、全局一份的用户场景描述（团队环境/系统清单/规范），注入所有助手；空则不注入。
 // 与知识检索互补（常驻事实 vs 按需检索）；凭据不进画像（放"凭据在哪、找谁要"）。
 const sceneProfile = () => String(cfg.scene_profile || '').trim();
@@ -232,7 +264,10 @@ 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'}`);
+  if (r.stopReason === 'error') {
+    const raw = String(r.errorMessage || r.rawStopReason || 'stop=error');
+    throw new Error(isContextOverflow(raw) ? contextOverflowMsg(raw) : `LLM 请求失败: ${raw}`);
+  }
   return (r.content || []).filter(b => b.type === 'text').map(b => b.text).join('');
 }
 
@@ -706,6 +741,112 @@ function pruneOldImages(ctx, keep = 3) {
   }
 }
 
+// ── 平台级定时任务：到点向在岗助手的会话注入消息并跑一轮（与真人发消息同构——同一守护栏/审计/历史回放）──
+// cron 子集：5 段（分 时 日 月 周），支持 * / */n / n / a-b / a-b/n 与逗号组合；周 0/7 均为周日；本地时区
+function parseCronField(f, min, max) {
+  const out = new Set();
+  for (const part of String(f).split(',')) {
+    const m = part.match(/^(\*|\d+-\d+|\d+)(?:\/(\d+))?$/);
+    if (!m) throw new Error(`cron 字段无法解析「${part}」`);
+    const step = m[2] ? +m[2] : 1;
+    if (!Number.isInteger(step) || step < 1) throw new Error(`cron 步长不合法「${part}」`);
+    let from, to;
+    if (m[1] === '*') { from = min; to = max; }
+    else if (m[1].includes('-')) { const [a, b] = m[1].split('-'); from = +a; to = +b; }
+    else { from = to = +m[1]; }
+    if (from < min || to > max || from > to) throw new Error(`cron 字段越界「${part}」（${min}-${max}）`);
+    for (let v = from; v <= to; v += step) out.add(v);
+  }
+  return out;
+}
+function parseCron(expr) {
+  const f = String(expr || '').trim().split(/\s+/);
+  if (f.length !== 5) throw new Error('cron 须为 5 段：分 时 日 月 周（如 "0 12 * * *" 表示每天 12:00）');
+  return { minute: parseCronField(f[0], 0, 59), hour: parseCronField(f[1], 0, 23), dom: parseCronField(f[2], 1, 31), month: parseCronField(f[3], 1, 12), dow: parseCronField(f[4], 0, 7), domStar: f[2] === '*', dowStar: f[4] === '*' };
+}
+function cronMatches(p, d) {
+  if (!p.month.has(d.getMonth() + 1)) return false;
+  const domR = p.dom.has(d.getDate());
+  const dowR = p.dow.has(d.getDay()) || (d.getDay() === 0 && p.dow.has(7)); // 0/7 都是周日
+  if (!p.domStar && !p.dowStar) { if (!(domR || dowR)) return false; } // 标准语义：日与周同时受限时任一命中即可
+  else if (p.domStar) { if (!dowR) return false; }
+  else if (!domR) return false;
+  return p.hour.has(d.getHours()) && p.minute.has(d.getMinutes());
+}
+function nextCronRun(expr, from = new Date()) {
+  const p = parseCron(expr);
+  const d = new Date(from); d.setSeconds(0, 0); d.setMinutes(d.getMinutes() + 1); // 从下一整分开始找
+  for (let i = 0; i < 366 * 24 * 60; i++) { if (cronMatches(p, d)) return new Date(d); d.setMinutes(d.getMinutes() + 1); }
+  return null; // 一年内无命中（如 2 月 30 日）
+}
+const SCHEDULES_FILE = path.join(AIMS_HOME, 'config', 'schedules.json');
+function loadSchedules() { try { return JSON.parse(fs.readFileSync(SCHEDULES_FILE, 'utf8')); } catch { return { schedules: [] }; } }
+function saveSchedules(db) { fs.mkdirSync(path.dirname(SCHEDULES_FILE), { recursive: true }); fs.writeFileSync(SCHEDULES_FILE, JSON.stringify(db, null, 2)); }
+function normalizeSchedule(sc) {
+  parseCron(sc.cron); // 校验
+  return {
+    id: sc.id, name: String(sc.name || '').trim().slice(0, 60) || '未命名任务', agent_id: sc.agent_id, ws_id: sc.ws_id || 'default',
+    cron: String(sc.cron).trim(), message: String(sc.message || '').trim(), autonomy_level: Number.isInteger(sc.autonomy_level) && sc.autonomy_level >= 0 && sc.autonomy_level <= 3 ? sc.autonomy_level : null,
+    enabled: sc.enabled !== false, created_at: sc.created_at || new Date().toISOString(),
+    next_run: sc.next_run || null, last: sc.last || null, history: Array.isArray(sc.history) ? sc.history.slice(0, 10) : [],
+  };
+}
+// 执行一次（定时触发与「立即执行」同一入口）：注入消息 → agentLoop（emit 置空）；会话忙/待确认跳过；结果入 last/history + 审计
+async function runSchedule(sc, trigger = 'cron') {
+  const sessionId = `chat-${sc.agent_id}-${sc.ws_id || 'default'}`;
+  const rec = { at: new Date().toISOString(), trigger, status: 'ok', summary: '' };
+  try {
+    const deployment = loadDeployment(sc.agent_id);
+    if (!deployment) throw new Error('助手已不在岗（deployment 缺失）');
+    const { s } = await ensureSession(sessionId, sc.agent_id, sc.autonomy_level ?? undefined, sc.ws_id || 'default');
+    if (s.running) { rec.status = 'skipped_busy'; rec.summary = `会话正在处理（${s.statusText || '进行中'}），本次跳过`; }
+    else if (s.pending) { rec.status = 'skipped_pending'; rec.summary = '会话有写操作等待人工确认，本次跳过'; }
+    else {
+      s.context.messages.push({ role: 'user', content: `【定时任务 · ${sc.name}】\n${sc.message}`, timestamp: Date.now() });
+      trimContext(s.context);
+      s.running = true; s.sinceTs = Date.now(); s.statusText = `定时任务：${sc.name}`;
+      try {
+        const out = await agentLoop(s, deployment, () => { }, null);
+        rec.summary = String(out.reply || '').slice(0, 300) || '（无回复）';
+        if (out.pending) rec.summary += `（含待确认操作：${out.pending.tool}）`;
+      } finally { s.running = false; s.statusText = ''; s.abortCtl = null; }
+    }
+  } catch (e) { rec.status = 'error'; rec.summary = String(e.message).slice(0, 300); }
+  const db = loadSchedules(); const cur = db.schedules.find((x) => x.id === sc.id);
+  if (cur) { cur.last = rec; cur.history = [rec, ...(cur.history || [])].slice(0, 10); saveSchedules(db); }
+  audit({ actor: 'scheduler', action: 'run', schedule: sc.id, name: sc.name, agentId: sc.agent_id, trigger, status: rec.status, summary: rec.summary.slice(0, 120) });
+  return rec;
+}
+// 调度器：30s tick + 防重入；到期先从当前时刻重算下一次（错过不补跑），再执行；启动时统一重算 next_run
+let schedulerTimer = null, tickBusy = false;
+function startScheduler() {
+  if (schedulerTimer) return;
+  { // 启动归一：不补跑停机期间错过的触发
+    const db = loadSchedules(); let dirty = false;
+    for (const sc of db.schedules) { const n = sc.enabled ? nextCronRun(sc.cron) : null; if (sc.next_run !== (n ? n.toISOString() : null)) { sc.next_run = n ? n.toISOString() : null; dirty = true; } }
+    if (dirty) saveSchedules(db);
+  }
+  schedulerTimer = setInterval(async () => {
+    if (tickBusy) return; tickBusy = true;
+    try {
+      const db = loadSchedules(); const now = Date.now(); const due = []; let dirty = false;
+      for (const sc of db.schedules) {
+        if (!sc.enabled) { if (sc.next_run) { sc.next_run = null; dirty = true; } continue; }
+        if (!sc.next_run) { const n = nextCronRun(sc.cron); if (n) { sc.next_run = n.toISOString(); dirty = true; } continue; }
+        if (now >= Date.parse(sc.next_run)) {
+          const n = nextCronRun(sc.cron, new Date(now)); sc.next_run = n ? n.toISOString() : null; dirty = true; due.push(sc);
+        }
+      }
+      if (dirty) saveSchedules(db); // 先落盘再执行，避免 runSchedule 的历史写被旧快照覆盖
+      for (const sc of due) await runSchedule(sc, 'cron');
+    } catch (e) { audit({ actor: 'scheduler', action: 'tick-error', error: String(e.message).slice(0, 120) }); }
+    finally { tickBusy = false; }
+  }, 30_000);
+  schedulerTimer.unref?.();
+  console.log(`[aims-workstation] 定时任务调度器已启动（${loadSchedules().schedules.filter((s) => s.enabled).length} 个启用）`);
+}
+const scheduleView = (sc) => ({ ...sc, agent_name: loadDeployment(sc.agent_id)?.name || localAgent(sc.agent_id)?.name || sc.agent_id.slice(0, 8), deployed: !!loadDeployment(sc.agent_id) });
+
 // ── 通用计算原语与平台数据服务（pi-core 哲学：少量原语 + 组合，而非功能堆叠）──
 const { exec: cpExec } = require('node:child_process');
 // ── exec 用 shell 跨平台解析：/bin/zsh 在 Windows 与无 zsh 的 Linux 上不存在，硬编码会让所有命令 spawn ENOENT ──
@@ -954,7 +1095,6 @@ function openDb(file) {
 function bumpVer(db, coll) {
   db.prepare("INSERT INTO _meta (k, v) VALUES (?, '1') ON CONFLICT(k) DO UPDATE SET v = CAST(v AS INTEGER) + 1").run(`ver:${coll}`);
 }
-const DB = openDb('store.db'); // 兼容旧引用（迁移后即空）
 // 作用域语义：agent=助手私有（默认，存归属助手×工作区的独立库）；shared=跨助手共享（存共享库）
 const scopeOf = (m) => (m.scope === 'shared' || m.scope === 'global') ? 'shared' : 'agent'; // legacy global→shared, workbench→agent
 const dbFor = (m, wsId = 'default') => openDb(scopeOf(m) === 'shared' ? 'store-shared.db' : `ws-${m.owner_agent || 'orphan'}-${wsId}.db`);
@@ -1039,6 +1179,7 @@ function deleteDoc(m, id, wsId = 'default') {
       dbFor(m, 'default').prepare('INSERT OR REPLACE INTO docs (collection, id, data, created, updated) VALUES (?,?,?,?,?)')
         .run(r.collection, r.id, r.data, r.created, r.updated);
     }
+    old.close(); // Windows：句柄不关，renameSync 必报 EBUSY（macOS/Linux 可重命名打开中的文件，故此前未现）
     fs.renameSync(legacy, legacy + '.migrated');
     audit({ actor: 'migration', action: 'per-agent-split', moved: rows.length });
     console.log(`[mvp] 数据已按助手分库迁移（${rows.length} 条）`);
@@ -1577,7 +1718,7 @@ 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));
+const ctxCharBudget = () => Math.max(4_000, Math.floor((llmContextTokens() * ctxBudgetScale - 16_000) * 1.6));
 // 超预算从最旧轮次整轮丢弃；下刀点只选 user 消息边界，剩余前缀不会出现孤儿 toolResult（转换层要求其紧跟 assistant 的 toolCall）；当前轮永不裁。
 function trimContext(ctx, budget = ctxCharBudget()) {
   const msgs = ctx.messages;
@@ -1796,6 +1937,7 @@ async function ensureSession(sessionId, agentId, autonomyLevel, wsId) {
 // 中断时保留已流出的部分文本为助手消息并补记"（已被用户中断）"，未应答的 toolCall 补占位 toolResult 保证下轮上下文合法
 async function agentLoop(s, deployment, emit, signal = null) {
   const interrupted = () => !!signal?.aborted;
+  let ctxRetried = false; // 上下文超限自愈一轮 agentLoop 只重试一次：连续收缩无意义，再失败走友好报错
   for (let round = 0; ; round++) {
     if (interrupted()) return { reply: '（已被用户中断）', interrupted: true, pending: s.pending };
     s.statusText = `第 ${round + 1} 轮 · 推理中`;
@@ -1815,7 +1957,18 @@ async function agentLoop(s, deployment, emit, signal = null) {
       }
       final = await stream.result(); // 中止时 pi-ai 以 done(aborted) 收尾，result() 返回已积累的部分消息
     } catch (e) {
-      if (!interrupted()) throw e; // 真实错误上抛；中断路径用占位消息兜底
+      if (interrupted()) throw e; // 中断路径由下方 aborted 分支兜底
+      const raw = String(e.message || '');
+      if (!ctxRetried && isContextOverflow(raw)) { // 超限自愈：收缩预算 → 重裁历史 → 本轮重试一次
+        ctxRetried = true;
+        ctxBudgetScale = Math.max(0.125, ctxBudgetScale / 2);
+        const dropped = trimContext(s.context);
+        audit({ actor: 'llm', agent: deployment.agent_id, action: 'context-shrink-retry', scale: ctxBudgetScale, dropped, raw: raw.slice(0, 120) });
+        emit('status', { text: dropped > 0 ? `上下文超限，已自动收缩历史（丢弃最早 ${dropped} 条）重试` : '上下文超限，已自动收缩历史重试' });
+        round--; continue;
+      }
+      if (isContextOverflow(raw)) throw new Error(contextOverflowMsg(raw)); // 重试仍超限：指路式报错
+      throw e;
     }
     const aborted = interrupted();
     if (!final) final = { role: 'assistant', content: [], timestamp: Date.now() };
@@ -1914,6 +2067,7 @@ const server = http.createServer(async (req, res) => {
       const t = armApiToken();
       const k = llmApiKey();
       const cur = armCurrent();
+      const ctxInfo = llmContextInfo();
       return json(res, 200, {
         arm: { // 兼容字段描述的是当前源；多源列表与管理走 /api/arm/sources
           api_base: armApiBase(), api_base_runtime: !!cur.base, default_base: ARM_DEFAULT_BASE,
@@ -1926,7 +2080,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,
+          context_tokens: ctxInfo.tokens, context_tokens_source: ctxInfo.source, context_tokens_runtime: !!cfg.llm_context_tokens, default_context_tokens: LLM_DEFAULT_CONTEXT_TOKENS,
           vision: llmVision(), vision_mode: cfg.llm_vision || 'auto', vision_auto: !!(model && Array.isArray(model.input) && model.input.includes('image')),
         },
         scene: { profile: sceneProfile(), length: sceneProfile().length },
@@ -1977,15 +2131,17 @@ const server = http.createServer(async (req, res) => {
         const m = String(llm_model || '').trim();
         if (m && !/^[\w.:@\/-]{1,80}$/.test(m)) return json(res, 400, { error: `模型名不合法：${m}` });
         cfg.llm_model = m;
+        ctxBudgetScale = 1; // 换模型：上下文超限自愈的收缩系数复位
       }
-      if (llm_context_tokens !== undefined) { // 上下文窗口（token）：驱动会话裁剪预算；留空/0 = 默认 128K。不影响 provider，无需热切换
+      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}` });
+          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;
         }
+        ctxBudgetScale = 1; // 手动改窗口：收缩系数复位
       }
       if (llm_api_key !== undefined) cfg.llm_api_key = String(llm_api_key || '').trim();
       if (llm_vision !== undefined) { // 视觉能力：auto=按模型条目 input 判定；on/off 强制（自定义模型名能力未知时按实际选）。不影响 provider，无需热切换
@@ -2898,6 +3054,51 @@ const server = http.createServer(async (req, res) => {
       return res.end();
     }
 
+    // ── 平台级定时任务：列表 / 增删改 / 立即执行 ──
+    if (pathname === '/api/schedules' && req.method === 'GET') {
+      return json(res, 200, { schedules: loadSchedules().schedules.map(scheduleView) });
+    }
+    if (pathname === '/api/schedules' && req.method === 'POST') {
+      const { name, agent_id, ws_id, cron, message, autonomy_level } = await body(req);
+      if (!/^[\w-]{1,80}$/.test(String(agent_id || ''))) return json(res, 400, { error: 'agent_id 必填' });
+      if (!loadDeployment(agent_id)) return json(res, 400, { error: '该助手未上岗——定时任务只面向在岗助手（先在大厅完成上岗配置）' });
+      if (!String(message || '').trim()) return json(res, 400, { error: '消息内容必填（到点后会作为这条消息发给助手）' });
+      let sc;
+      try { sc = normalizeSchedule({ id: `sch_${crypto.randomUUID().slice(0, 6)}`, name, agent_id, ws_id, cron, message, autonomy_level, enabled: true }); }
+      catch (e) { return json(res, 400, { error: `任务定义不合法：${e.message}` }); }
+      const n = nextCronRun(sc.cron); if (n) sc.next_run = n.toISOString();
+      const db = loadSchedules(); db.schedules.push(sc); saveSchedules(db);
+      audit({ actor: 'user', action: 'schedule-create', schedule: sc.id, name: sc.name, agentId: sc.agent_id, cron: sc.cron });
+      return json(res, 200, { schedule: scheduleView(sc) });
+    }
+    const mSch = pathname.match(/^\/api\/schedules\/([\w-]+)(?:\/(run))?$/);
+    if (mSch) {
+      const db = loadSchedules();
+      const sc = db.schedules.find((x) => x.id === mSch[1]);
+      if (!sc) return json(res, 404, { error: `任务不存在：${mSch[1]}` });
+      if (req.method === 'PUT' && !mSch[2]) {
+        const { name, ws_id, cron, message, autonomy_level, enabled } = await body(req);
+        try {
+          const next = normalizeSchedule({ ...sc, ...(name !== undefined ? { name } : {}), ...(ws_id !== undefined ? { ws_id } : {}), ...(cron !== undefined ? { cron } : {}), ...(message !== undefined ? { message } : {}), ...(autonomy_level !== undefined ? { autonomy_level } : {}), ...(enabled !== undefined ? { enabled } : {}) });
+          const n = next.enabled ? nextCronRun(next.cron) : null; next.next_run = n ? n.toISOString() : null;
+          db.schedules = db.schedules.map((x) => (x.id === next.id ? next : x)); saveSchedules(db);
+          audit({ actor: 'user', action: 'schedule-update', schedule: sc.id, fields: Object.keys({ ...(name !== undefined && { name }), ...(cron !== undefined && { cron }), ...(message !== undefined && { message }), ...(enabled !== undefined && { enabled }) }) });
+          return json(res, 200, { schedule: scheduleView(next) });
+        } catch (e) { return json(res, 400, { error: `任务定义不合法：${e.message}` }); }
+      }
+      if (req.method === 'DELETE' && !mSch[2]) {
+        db.schedules = db.schedules.filter((x) => x.id !== sc.id); saveSchedules(db);
+        audit({ actor: 'user', action: 'schedule-delete', schedule: sc.id, name: sc.name });
+        return json(res, 200, { ok: true });
+      }
+      if (req.method === 'POST' && mSch[2] === 'run') {
+        const rec = await runSchedule(sc, 'manual'); // 立即执行一次（不影响 next_run）
+        const cur = loadSchedules().schedules.find((x) => x.id === sc.id);
+        return json(res, 200, { run: rec, schedule: cur ? scheduleView(cur) : null });
+      }
+      return json(res, 405, { error: 'method not allowed' });
+    }
+
     // ── 现场状态 ──
     if (req.method === 'GET' && pathname === '/api/state') {
       return json(res, 200, { devices: world.devices, alarms: world.alarms, kpi: world.kpi, work_orders: world.work_orders, inspections: world.inspections });
@@ -3267,11 +3468,87 @@ if (process.argv.includes('--test-arm-sources')) {
   process.exit(pass ? 0 : 1);
 }
 
+// ── 单测: node server.js --test-llm-ctx（上下文窗口解析：显式配置优先 / 按模型识别 / 回落与预算联动；不碰网络与 LLM）──
+if (process.argv.includes('--test-llm-ctx')) {
+  let pass = true;
+  const ok = (name, cond, detail = '') => { if (!cond) pass = false; console.log(`${cond ? '✅' : '❌'} ${name}${cond ? '' : '  ← ' + detail}`); };
+  const saved = { m: cfg.llm_model, c: cfg.llm_context_tokens, e: process.env.LLM_MODEL };
+  const setModel = (m, ctx = 0) => { cfg.llm_model = m; cfg.llm_context_tokens = ctx; process.env.LLM_MODEL = ''; };
+  try {
+    setModel('');
+    ok('未识别模型（def）回落默认 128K', llmContextInfo().source === 'default' && llmContextTokens() === 128_000, JSON.stringify(llmContextInfo()));
+    setModel('glm-5.3');
+    ok('GLM-5.3 → 自动识别 1M', llmContextInfo().source === 'model' && llmContextTokens() === 1_000_000, JSON.stringify(llmContextInfo()));
+    setModel('GLM-4.6-Flag');
+    ok('GLM-4.6 → 200K（大小写不敏感）', llmContextTokens() === 200_000, String(llmContextTokens()));
+    setModel('glm-4.5-air');
+    ok('GLM-4.5 → 128K（泛 GLM 回落）', llmContextTokens() === 128_000, String(llmContextTokens()));
+    setModel('MiniMax-M3');
+    ok('MiniMax-M3 → 1M', llmContextTokens() === 1_000_000, String(llmContextTokens()));
+    setModel('minimax-m2');
+    ok('MiniMax-M2 → 204K（保守回落）', llmContextTokens() === 204_800, String(llmContextTokens()));
+    setModel('claude-sonnet-4.5');
+    ok('Claude → 200K', llmContextTokens() === 200_000, String(llmContextTokens()));
+    setModel('deepseek-chat');
+    ok('DeepSeek → 128K', llmContextTokens() === 128_000, String(llmContextTokens()));
+    setModel('glm-5.3', 64_000);
+    ok('显式配置优先于模型识别', llmContextInfo().source === 'runtime' && llmContextTokens() === 64_000, JSON.stringify(llmContextInfo()));
+    setModel('glm-5.3', 0);
+    ok('清空配置回落模型识别', llmContextTokens() === 1_000_000, String(llmContextTokens()));
+    ok('预算联动：1M 窗口 → 字符预算 (1M-16K)*1.6', ctxCharBudget() === Math.floor((1_000_000 - 16_000) * 1.6), String(ctxCharBudget()));
+    ok('超限识别：OpenAI 文案', isContextOverflow("This model's maximum context length is 128000 tokens. However, you requested 130000 tokens"));
+    ok('超限识别：Anthropic 文案', isContextOverflow('prompt is too long: 210000 tokens > 200000 maximum'));
+    ok('超限识别：GLM/MiniMax 风格', isContextOverflow('input length and max_tokens exceed context limit') && isContextOverflow('Tokens exceed the limit of this model'));
+    ok('超限识别：中文文案', isContextOverflow('请求失败：上下文长度超限'));
+    ok('不误伤：认证/限流/超时/模型不存在', !isContextOverflow('invalid api key') && !isContextOverflow('rate limit exceeded') && !isContextOverflow('request timeout after 30s') && !isContextOverflow('model not found'));
+    const msg = contextOverflowMsg('input length and max_tokens exceed context limit');
+    ok('友好报错：含来源/指路/原文', msg.includes('按模型自动识别') && msg.includes('调低上下文窗口') && msg.includes('系统设置') && msg.includes('token') && msg.includes('max_tokens'), msg);
+    const full = ctxCharBudget();
+    ctxBudgetScale = 0.5;
+    ok('自愈收缩：预算随系数减半', ctxCharBudget() < full / 1.9 && ctxCharBudget() === Math.max(4_000, Math.floor((1_000_000 * 0.5 - 16_000) * 1.6)), `${ctxCharBudget()} / ${full}`);
+    ok('友好报错：收缩后提示已自动收缩', contextOverflowMsg('x').includes('已自动收缩至 50%'), contextOverflowMsg('x'));
+    ctxBudgetScale = 0.125;
+    ok('自愈收缩：下限 12.5%', ctxCharBudget() === Math.max(4_000, Math.floor((1_000_000 * 0.125 - 16_000) * 1.6)), String(ctxCharBudget()));
+    ctxBudgetScale = 1;
+  } finally {
+    cfg.llm_model = saved.m; cfg.llm_context_tokens = saved.c; process.env.LLM_MODEL = saved.e;
+  }
+  console.log(pass ? '上下文窗口单测全部通过' : '上下文窗口单测存在失败');
+  process.exit(pass ? 0 : 1);
+}
+
+// ── 单测: node server.js --test-schedules（cron 子集解析/匹配/next-run/任务归一；不碰网络与 LLM）──
+if (process.argv.includes('--test-schedules')) {
+  let pass = true;
+  const ok = (name, cond, detail = '') => { if (!cond) pass = false; console.log(`${cond ? '✅' : '❌'} ${name}${cond ? '' : '  ← ' + detail}`); };
+  const at = (y, mo, d, h, mi) => new Date(y, mo - 1, d, h, mi, 0, 0);
+  const fmt = (d) => `${d.getMonth() + 1}-${d.getDate()} ${String(d.getHours()).padStart(2, '0')}:${String(d.getMinutes()).padStart(2, '0')}`;
+  ok('每天 12:30：午前 → 当天', fmt(nextCronRun('30 12 * * *', at(2026, 10, 28, 11, 0))) === '10-28 12:30');
+  ok('每天 12:30：午后 → 次日', fmt(nextCronRun('30 12 * * *', at(2026, 10, 28, 13, 0))) === '10-29 12:30');
+  ok('*/15 步进：12:07 → 12:15', fmt(nextCronRun('*/15 * * * *', at(2026, 10, 28, 12, 7))) === '10-28 12:15');
+  ok('每周一 09:00：周日 → 次日周', fmt(nextCronRun('0 9 * * 1', at(2026, 11, 1, 10, 0))) === '11-2 09:00', fmt(nextCronRun('0 9 * * 1', at(2026, 11, 1, 10, 0))));
+  ok('周日双写法：0 与 7 等价', fmt(nextCronRun('0 9 * * 0', at(2026, 10, 30, 10, 0))) === '11-1 09:00' && fmt(nextCronRun('0 9 * * 7', at(2026, 10, 30, 10, 0))) === '11-1 09:00');
+  ok('列表与区间组合：0,30 8-18', fmt(nextCronRun('0,30 8-18 * * *', at(2026, 10, 28, 19, 10))) === '10-29 08:00');
+  ok('日/周同时受限按 OR：13 号或每周五', !!nextCronRun('0 9 13 * 5', at(2026, 10, 28, 10, 0)) && fmt(nextCronRun('0 9 13 * 5', at(2026, 10, 28, 10, 0))) === '10-30 09:00', fmt(nextCronRun('0 9 13 * 5', at(2026, 10, 28, 10, 0)))); // 10-28 是周三：13 号是周四、最近的周五是 10-30
+  ok('不存在的日期（2 月 31 日）→ 无下一次', nextCronRun('0 9 31 2 *', at(2026, 1, 31, 10, 0)) === null);
+  for (const [bad, why] of [['* * * *', '4 段'], ['60 * * * *', '分越界'], ['*/0 * * * *', '步长 0'], ['a * * * *', '坏 token'], ['1-5/2/x * * * *', '坏组合']]) {
+    let threw = false; try { parseCron(bad); } catch { threw = true; }
+    ok(`非法拒绝：${why}（${bad}）`, threw);
+  }
+  const n = (() => { try { return normalizeSchedule({ id: 'sch_x', name: ' 每日巡检 ', agent_id: 'a', cron: '0 12 * * *', message: ' x ', autonomy_level: 9 }); } catch (e) { return null; } })();
+  ok('任务归一：去空白 / autonomy 越界回落 null / 默认启用', n && n.name === '每日巡检' && n.message === 'x' && n.autonomy_level === null && n.enabled === true && n.ws_id === 'default');
+  let threw = false; try { normalizeSchedule({ id: 'x', agent_id: 'a', cron: 'bad', message: 'm' }); } catch { threw = true; }
+  ok('任务归一：坏 cron 抛错', threw);
+  console.log(pass ? '定时任务单元测试全部通过' : '定时任务单元测试存在失败');
+  process.exit(pass ? 0 : 1);
+}
+
 applyLLMConfig().then(() => {
   server.listen(PORT, HOST, () => {
     console.log(`[aims-workstation] http://localhost:${PORT}（绑定 ${HOST}） | 模型: ${model.id} @ ${model.baseUrl}`);
     console.log(`[aims-workstation] 数据目录 AIMS_HOME: ${AIMS_HOME}`);
     console.log(`[aims-workstation] exec shell: ${SHELL}（${SHELL_HINT}）`);
+    startScheduler();
       console.log(`[aims-workstation] ARM(REST): ${armApiBase()} | PAT: ${ARM_PAT ? '已加载' : '未配置'} | 已上岗助手: ${fs.readdirSync(DEPLOY_DIR).length} | 本地助手库: ${loadRegistry().agents.length}`);
   });
   // 已上岗助手后台物化为本地档案（best-effort；ARM 不可达时静默跳过，待手动同步）