@iamsamyiok/agents-chat 3.19.2 → 3.21.0

package/app/lib/cards.js

@@ -22,27 +22,79 @@ const TRASH_PATH = path.join(DATA_DIR, 'cards_trash.json');
 const TRASH_TTL = 30 * 24 * 3600 * 1000; // 垃圾桶默认保留 30 天
 
 function ensureDir() { if (!fs.existsSync(DATA_DIR)) fs.mkdirSync(DATA_DIR, { recursive: true }); }
+// 数据损坏保护：解析失败（文件存在但 JSON 损坏）时备份原文件并置损坏标记；
+// 后续写入直接拒绝，防止「读到空列表 → 新增一条 → 覆盖写」把用户全部卡牌冲掉
+const corrupted = new Set(); // 已损坏的文件路径
+function cachedReader(file, cacheBox) {
+  return function read() {
+    if (corrupted.has(file)) return [];
+    try {
+      const st = fs.statSync(file);
+      if (cacheBox.list && st.mtimeMs === cacheBox.mtime) return cacheBox.list;
+      const list = JSON.parse(fs.readFileSync(file, 'utf8'));
+      cacheBox.mtime = st.mtimeMs; cacheBox.list = list;
+      return list;
+    } catch (err) {
+      if (err && err.code === 'ENOENT') { // 文件不存在：正常的初始状态
+        cacheBox.mtime = 0; cacheBox.list = null;
+        return [];
+      }
+      // 文件存在但解析失败：备份损坏现场，进入只读保护
+      try { fs.copyFileSync(file, `${file}.corrupt-${Date.now()}`); } catch { /* ignore */ }
+      corrupted.add(file);
+      cacheBox.mtime = 0; cacheBox.list = null;
+      console.error(`[cards] 数据文件损坏已备份并进入保护：${file}`);
+      return [];
+    }
+  };
+}
+const _cardsCache = { mtime: 0, list: null };
+const _cfgCache = { mtime: 0, list: null };
+const _trashCache = { mtime: 0, list: null };
+const readCardsRaw = cachedReader(CARDS_PATH, _cardsCache);
+const readConfigRaw = cachedReader(CARDS_CFG_PATH, _cfgCache);
+const readTrashRaw = cachedReader(TRASH_PATH, _trashCache);
 function readCards() {
-  try { return JSON.parse(fs.readFileSync(CARDS_PATH, 'utf8')); } catch { return []; }
+  // 返回浅拷贝：调用方（list 的 sort 等）对数组的操作不影响缓存
+  const v = readCardsRaw();
+  return Array.isArray(v) ? v.slice() : [];
+}
+function invalidate(file) {
+  if (file === CARDS_PATH) { _cardsCache.mtime = 0; _cardsCache.list = null; }
+  else if (file === CARDS_CFG_PATH) { _cfgCache.mtime = 0; _cfgCache.list = null; }
+  else if (file === TRASH_PATH) { _trashCache.mtime = 0; _trashCache.list = null; }
+}
+// 损坏保护下的写入守卫：拒绝覆盖写（保留备份供人工恢复）
+function guardWrite(file) {
+  if (corrupted.has(file)) {
+    throw new Error(`数据文件 ${path.basename(file)} 已损坏（原文件已备份为 .corrupt-*），为防数据丢失已停止写入，请人工检查 ${DATA_DIR} 后删除损坏标记文件`);
+  }
 }
 function writeCards(list) {
   ensureDir();
+  guardWrite(CARDS_PATH);
+  invalidate(CARDS_PATH);
   const tmp = CARDS_PATH + '.tmp';
   fs.writeFileSync(tmp, JSON.stringify(list, null, 2), 'utf8');
   fs.renameSync(tmp, CARDS_PATH);
 }
 function readConfig() {
-  try { return JSON.parse(fs.readFileSync(CARDS_CFG_PATH, 'utf8')); } catch { return { workspace: '' }; }
+  const v = readConfigRaw();
+  return (v && typeof v === 'object' && !Array.isArray(v)) ? v : { workspace: '' };
 }
 function writeConfig(cfg) {
   ensureDir();
+  guardWrite(CARDS_CFG_PATH);
+  invalidate(CARDS_CFG_PATH);
   fs.writeFileSync(CARDS_CFG_PATH, JSON.stringify(cfg, null, 2), 'utf8');
 }
 function readTrash() {
-  try { return JSON.parse(fs.readFileSync(TRASH_PATH, 'utf8')); } catch { return []; }
+  const v = readTrashRaw();
+  return Array.isArray(v) ? v.slice() : [];
 }
 function writeTrash(list) {
-  ensureDir();
+  guardWrite(TRASH_PATH);
+  invalidate(TRASH_PATH);
   fs.writeFileSync(TRASH_PATH, JSON.stringify(list, null, 2), 'utf8');
 }
 // 启动时清理超过 30 天的垃圾桶快照，并连带清除其日志，避免占用磁盘
@@ -209,6 +261,24 @@ function isEligible(card, all) {
   return true;
 }
 
+// 环检测：把 cardId 的依赖改为 newDeps 后，沿依赖边 DFS 是否能回到 cardId 自身
+// 用于 PUT 写入拦截（间接环也拦截，如 A→B→C→A）
+function wouldCycle(cardId, newDeps) {
+  const all = CardStore.list();
+  const byId = new Map(all.filter(c => c.id !== cardId).map(c => [c.id, c]));
+  const seen = new Set();
+  const stack = [...(newDeps || [])];
+  while (stack.length) {
+    const cur = stack.pop();
+    if (cur === cardId) return true;
+    if (seen.has(cur)) continue;
+    seen.add(cur);
+    const c = byId.get(cur);
+    if (c) stack.push(...(c.dependsOn || []));
+  }
+  return false;
+}
+
 function pickEligible(all, activeIds) {
   const eligible = all.filter(c => isEligible(c, all) && !activeIds.has(c.id));
   eligible.sort((a, b) => {
@@ -228,10 +298,16 @@ class CardRunner {
     this.timer = null;
     this.procs = new Map(); // cardId -> { pid, child, lastActive, status }
     this.followups = new Set(); // 追加聊天中的卡牌（并发防护）
+    this.killedCards = new Set(); // 本轮编排中被单卡停止的卡：跳过调度直到本轮结束
     this.baseline = null; // 本轮编排开始时的 done/failed 基线（all_done 报增量）
   }
   isRunning() { return this.running; }
 
+  // 并行度热更新：调大后立即补齐在跑任务（无需等下一个任务完成触发 tick）
+  onConfigChanged() {
+    if (this.running) this.tick();
+  }
+
   // 并行度：cards_config.maxParallel 可热更新（1-8），未配置时用 env 默认
   maxP() {
     try {
@@ -241,7 +317,7 @@ class CardRunner {
     return MAX_PARALLEL;
   }
 
-  // 终止单个任务对应的子进程
+  // 终止单个任务对应的子进程（删除卡等场景：不改变调度语义）
   killCard(cardId) {
     this.active.delete(cardId);
     const p = this.procs.get(cardId);
@@ -249,6 +325,21 @@ class CardRunner {
     this.procs.delete(cardId);
   }
 
+  // 单卡停止：杀进程 + 标记本轮不再自动调度（状态回待执行，与全局停止的复位语义一致）
+  stopOne(cardId) {
+    const card = CardStore.get(cardId);
+    if (!card || card.status !== 'running') return false;
+    if (this.followups.has(cardId)) return false; // 追加聊天进行中：走 chatFollowup 自己的错误路径
+    this.killedCards.add(cardId);
+    this.killCard(cardId);
+    // 主动复位状态：以这里为准（子进程 close 回调到达时 runCard 会再写一次 pending，幂等），
+    // 避免回调异常丢失时卡片永远停留在 running
+    CardStore.update(cardId, { status: 'pending', result: '', error: '', finishedAt: Date.now() });
+    broadcast({ type: 'notice', content: `⏹ 已停止任务「${card.title}」，该任务回到待执行（本轮编排不再自动调度它）` });
+    broadcast({ type: 'task_done', cardId, status: 'stopped', title: card.title });
+    return true;
+  }
+
   // 供前端展示：当前存活进程 + opencode 是否在工作中（近 5s 有活动即视为工作中）
   getProcesses() {
     const out = [];
@@ -262,6 +353,7 @@ class CardRunner {
   stop() {
     this.token++;
     this.running = false;
+    this.killedCards.clear();
     if (this.timer) { try { this.timer.unref(); } catch { /* ignore */ } }
     try { stopScope('solo'); } catch { /* ignore */ }
     this.procs.clear();
@@ -273,6 +365,7 @@ class CardRunner {
     if (this.running) return;
     this.running = true;
     this.token++;
+    this.killedCards.clear();
     // 记录基线：all_done 时报告本轮增量（成功/失败数），避免混入历史任务
     const all0 = CardStore.list();
     this.baseline = { done: all0.filter(c => c.status === 'done').length, failed: all0.filter(c => c.status === 'failed').length };
@@ -284,7 +377,8 @@ class CardRunner {
     if (!this.running) return;
     const myToken = this.token;
     const all = CardStore.list();
-    const eligible = pickEligible(all, this.active);
+    // 单卡停止的任务本轮跳过（用户已明确表示停它，不让调度器立刻拉起）
+    const eligible = pickEligible(all, this.active).filter(c => !this.killedCards.has(c.id));
     if (!eligible.length) {
       if (this.active.size === 0) {
         this.running = false;
@@ -331,6 +425,12 @@ class CardRunner {
     if (card.mode === 'continue' && card.chainId) {
       const prev = CardStore.get(card.chainId);
       ocSessionId = prev && prev.ocSessionId ? prev.ocSessionId : '';
+      // 语义降级显式提示：避免「名义续聊、实际新会话」静默发生
+      if (!ocSessionId) {
+        const warn = '续聊链首无可用会话（可能已被重置，或由不支持会话续聊的内核执行），本任务将以全新会话执行';
+        store.addMessage({ role: 'assistant', agentId: 'solo', agentName: 'Agent', actor: 'assistant', phase: 'system', taskId: card.id, content: `[系统提示] ${warn}` });
+        broadcast({ type: 'notice', content: `⚠ ${card.title}：${warn}` });
+      }
     }
 
     CardStore.update(card.id, { status: 'running', startedAt: Date.now(), error: '', result: '' });
@@ -399,16 +499,18 @@ class CardRunner {
 
     const finalText = order.map(id => texts.get(id)).join('\n\n').trim();
     const stopped = myToken !== this.token;
+    const cardStopped = this.killedCards.has(card.id); // 单卡停止：与全局停止同样复位为待执行
     if (finalText) {
       store.addMessage({ role: 'assistant', agentId: 'solo', agentName: 'Agent', actor: 'assistant', phase: 'work', taskId: card.id, content: finalText.slice(0, 20000) });
     }
-    const status = stopped ? 'pending' : (doneError ? 'failed' : 'done');
+    const stoppedAny = stopped || cardStopped;
+    const status = stoppedAny ? 'pending' : (doneError ? 'failed' : 'done');
     CardStore.update(card.id, {
       status,
       ocSessionId: sesId,
       // 手动停止回到待执行：清掉残留，避免 pending 卡带着脏结果/错误
-      result: stopped ? '' : (doneError ? `执行出错：${doneError}` : finalText).slice(0, 20000),
-      error: stopped ? '' : (doneError || ''),
+      result: stoppedAny ? '' : (doneError ? `执行出错：${doneError}` : finalText).slice(0, 20000),
+      error: stoppedAny ? '' : (doneError || ''),
       finishedAt: Date.now()
     });
     broadcast({ type: 'task_done', cardId: card.id, status, title: card.title });
@@ -471,7 +573,8 @@ class CardRunner {
             model: card.model || '',
             ocSessionId: sesId,
             behavior: 'card',
-            cwd
+            cwd,
+            scope: 'card-fu' // 独立进程域：停止编排不牵连追加聊天
           }, (ev) => {
             const proc = this.procs.get(cardId);
             if (proc) proc.lastActive = Date.now();
@@ -521,12 +624,16 @@ class CardRunner {
   }
 
   isFollowupRunning(cardId) { return !!this.followups && this.followups.has(cardId); }
+  getFollowupIds() { return [...this.followups]; }
 }
 
+// 数据文件损坏状态（供 API 告警展示）
+function getCorruptedFiles() { return [...corrupted]; }
+
 function isValidDir(p) {
   try { return fs.existsSync(p) && fs.statSync(p).isDirectory(); } catch { return false; }
 }
 
 const runner = new CardRunner();
 
-module.exports = { CardStore, CardRunner, runner, sseSubscribe, buildCardPrompt, isEligible, pickEligible, MAX_PARALLEL, CARDS_PATH, CARDS_CFG_PATH };
+module.exports = { CardStore, CardRunner, runner, sseSubscribe, buildCardPrompt, isEligible, pickEligible, wouldCycle, MAX_PARALLEL, CARDS_PATH, CARDS_CFG_PATH, getCorruptedFiles };

package/app/lib/oc.js

@@ -4,6 +4,7 @@
 // - 首个 sessionID 事件回填 store，实现同一网页会话跨轮次续聊
 // - 非 opencode 内核（claude/codex/pi）无 -s 续聊能力：单聊退化为一次性对话，每轮全新上下文
 // - 演示模式（AGENTS_CHAT_MOCK=1）走 mock 子进程，输出模拟为快照事件
+const fs = require('fs');
 const path = require('path');
 const { spawn, execFileSync } = require('child_process');
 const { registerChild, describeTool, resolveCwd } = require('./agent');
@@ -98,7 +99,7 @@ function parseSoloEventLine(line, onEvent, state) {
 
 // ---------- 通用子进程运行器 ----------
 // runnerSpec: { cmd, shell, json, cwd }；json=false 时把输出行累积为快照（演示模式用）
-function spawnSoloRunner(runnerSpec, args, prompt, env, onEvent, finish) {
+function spawnSoloRunner(runnerSpec, args, prompt, env, onEvent, finish, scope) {
   let child;
   try {
     child = spawn(runnerSpec.cmd, args, {
@@ -112,7 +113,7 @@ function spawnSoloRunner(runnerSpec, args, prompt, env, onEvent, finish) {
     finish(`启动失败：${error.message}`);
     return null;
   }
-  registerChild(child, 'solo'); // 停止/退出清理复用 agent.js 的登记表（scope='solo'）
+  registerChild(child, scope || 'solo'); // 停止/退出清理复用 agent.js 的登记表（scope 可区分编排与追加聊天）
 
   child.stdin.on('error', () => { /* stdin 已关闭则忽略 */ });
   if (prompt) child.stdin.write(prompt);
@@ -190,6 +191,8 @@ function chatSolo(runnerKind, runner, opts, onEvent) {
   const prompt = String(opts.prompt || '');
   const model = String(opts.model || '');
   const ocSessionId = String(opts.ocSessionId || '');
+  // 进程归属 scope：停止编排（stopScope('solo')）只杀编排任务，追加聊天用独立 scope 免受牵连
+  const scope = String(opts.scope || 'solo');
   // 工作区：指定后 Agent 在该目录读写文件（卡牌可选 workspace）
   const cwd = opts.cwd && fs.existsSync(opts.cwd) && fs.statSync(opts.cwd).isDirectory() ? opts.cwd : '';
   const cwdEnv = cwd ? { ...process.env, AGENTS_CHAT_CWD: cwd } : process.env;
@@ -206,7 +209,8 @@ function chatSolo(runnerKind, runner, opts, onEvent) {
         // 演示模式的会话 ID：续聊时复用传入 ID（打通链路），新任务本地生成（无真实续聊）
         onEvent({ type: 'session', ocSessionId: ocSessionId || 'ses_demo-' + Date.now().toString(36) });
         onEvent({ type: 'done', error });
-      }
+      },
+      scope
     );
   }
 
@@ -222,7 +226,8 @@ function chatSolo(runnerKind, runner, opts, onEvent) {
       { cmd: runner.cmd, shell: runner.shell, json: true, cwd: cwd || resolveCwd() },
       args, prompt, cwdEnv,
       onEvent,
-      (error) => onEvent({ type: 'done', error })
+      (error) => onEvent({ type: 'done', error }),
+      scope
     );
   }
 

package/app/public/cards.html

@@ -148,6 +148,25 @@
   .trash-item .ti-info{flex:1;min-width:0}
   .trash-item .ti-title{font-weight:600;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
   .trash-item .ti-sub{font-size:11px;color:var(--dim)}
+  /* 内核状态横幅（缺失/演示模式/数据保护时显示） */
+  .kernel-banner{display:none;gap:8px;align-items:center;padding:8px 18px;font-size:12.5px;line-height:1.6;border-bottom:1px solid var(--line)}
+  .kernel-banner.show{display:flex}
+  .kernel-banner.kb-missing{background:#fdeceb;color:#b03a31}
+  .kernel-banner.kb-demo{background:#fdf6ec;color:#8a5a00}
+  .kernel-banner.kb-corrupt{background:#fdeceb;color:#b03a31}
+  /* 内核徽标（正常时显示在状态胶囊旁） */
+  .kernel-chip{display:inline-flex;align-items:center;gap:4px;font-size:11px;color:var(--dim);background:#eef0f3;border:1px solid var(--line);border-radius:6px;padding:2px 7px}
+  /* 执行中卡的运行时长徽标 */
+  .badge.run-elapsed{background:#eef7ff;color:var(--acc2);border-color:#c4e2ff;font-variant-numeric:tabular-nums}
+  /* 追加聊天进行中徽标 */
+  .badge.fu-live{background:#f1e9ff;color:#8a6fe8;border-color:#ddd0ff}
+  /* 单卡停止按钮 */
+  .icon-btn.danger:hover{color:var(--err);border-color:var(--err)}
+  /* 详情弹窗：任务内容块 */
+  .detail-content{background:#fafbfc;border:1px solid var(--line);border-radius:10px;padding:12px;margin:2px 0 10px;white-space:pre-wrap;word-break:break-word;max-height:18vh;overflow:auto;line-height:1.6;font-size:13px}
+  /* 空看板引导 */
+  .board-guide{grid-column:1/-1;text-align:center;padding:40px 10px;color:var(--dim)}
+  .board-guide .bg-actions{display:flex;gap:10px;justify-content:center;margin-top:14px}
 </style>
 </head>
 <body>
@@ -155,6 +174,7 @@
   <a class="backlink" href="/" title="返回 Agents Chat 群聊">← 群聊</a>
   <h1>🗂️ 多任务编排</h1>
   <span class="status-pill" id="statusPill">空闲</span>
+  <span class="kernel-chip" id="kernelChip" style="display:none"></span>
   <span class="sp"></span>
   <div class="ws-box" title="工作区：选定后 Agent 在该目录读写相关文件（可选）">
     📁 <input id="wsInput" placeholder="工作文件夹（点右侧选择）" />
@@ -167,11 +187,13 @@
     </select>
   </div>
   <button class="btn" id="btnNew">＋ 新建任务</button>
-  <button class="btn primary" id="btnRun">▶ 开始编排</button>
-  <button class="btn danger" id="btnStop" disabled>⏹ 停止</button>
+  <button class="btn primary" id="btnRun" title="按依赖与优先级调度全部待执行任务">▶ 开始编排</button>
+  <button class="btn danger" id="btnStop" disabled title="停止编排：进行中的任务复位为待执行（不影响追加聊天），未开始的任务保留">⏹ 停止</button>
   <button class="btn" id="btnClear">清空</button>
 </header>
 
+<div class="kernel-banner" id="kernelBanner"></div>
+
 <div class="procbar" id="procBar"><span class="ptitle">进程：</span><span class="proc-empty">无运行中的 opencode 进程</span></div>
 
 <main>
@@ -209,7 +231,7 @@
     <label>任务内容（描述，支持 Markdown）</label>
     <textarea id="fContent" placeholder="把要做的事详细写在这里，Agent 会据此执行"></textarea>
     <div class="row">
-      <div><label>优先级（数字越小越优先）</label><input id="fPriority" type="number" value="999" /></div>
+      <div><label>优先级（数字越小越优先；拖拽看板卡会按新顺序重写优先级）</label><input id="fPriority" type="number" value="999" /></div>
       <div><label>执行模式</label>
         <select id="fMode">
           <option value="new">新进程（new）</option>
@@ -237,6 +259,8 @@
     <h3 id="dTitle">任务详情</h3>
     <div id="dMeta" class="meta" style="margin-bottom:10px"></div>
     <div class="dep-tag" id="dDeps"></div>
+    <label>任务内容</label>
+    <div class="detail-content" id="dContent"><span class="empty">（无任务内容）</span></div>
     <div class="detail-err" id="dError" style="display:none"></div>
     <label>执行过程（实时）</label>
     <div class="detail-log" id="dLog"><span class="empty">暂无过程记录</span></div>
@@ -280,24 +304,64 @@ const $ = s => document.querySelector(s);
 const api = async (url, opt) => { const r = await fetch(url, opt); return r.json(); };
 const post = (url, body) => api(url, {method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(body||{})});
 function toast(msg){ const t=$('#toast'); t.textContent=msg; t.classList.add('show'); setTimeout(()=>t.classList.remove('show'),1800); }
-function esc(s){const d=document.createElement('div');d.textContent=s==null?'':String(s);return d.innerHTML;}
+function esc(s){const d=document.createElement('div');d.textContent=s==null?'':String(s);return d.innerHTML.replace(/"/g,'&quot;').replace(/'/g,'&#39;');}
 
 let CARDS = [];
 let OPEN_ID = null;
+let FOLLOWUP_IDS = [];   // 追加聊天进行中的卡 id
+let RUNNER_INFO = null;  // { kind, label }
+let CORRUPTED = [];      // 已进入损坏保护的数据文件
+let LOAD_SEQ = 0;        // loadCards 响应乱序守卫：快速触发多次时只认最新请求
 
 async function loadCards(){
+  const seq = ++LOAD_SEQ;
   const data = await api('/api/cards');
+  if (seq !== LOAD_SEQ) return; // 已有更新的请求发出：丢弃本次过期响应
   CARDS = data.cards || [];
+  FOLLOWUP_IDS = data.followupIds || [];
+  RUNNER_INFO = data.runner || null;
+  CORRUPTED = data.corrupted || [];
   $('#statusPill').textContent = data.running ? '编排中…' : '空闲';
   $('#btnRun').disabled = data.running;
   $('#btnStop').disabled = !data.running;
   if(data.config) $('#wsInput').value = data.config.workspace || '';
   if(data.maxParallel) $('#parallelSel').value = String(data.maxParallel);
+  renderKernelBanner();
   render();
   renderGraph();
   loadTrashCount();
 }
 
+// 内核状态展示：正常=头部小徽标；缺失/演示模式/数据保护=醒目横幅
+function renderKernelBanner(){
+  const chip=$('#kernelChip'), banner=$('#kernelBanner');
+  const k = RUNNER_INFO && RUNNER_INFO.kind;
+  if (CORRUPTED.length){
+    chip.style.display='none';
+    banner.className='kernel-banner show kb-corrupt';
+    banner.innerHTML='⚠ <b>数据保护已触发</b>：'+CORRUPTED.map(f=>'<code>'+esc(f.split(/[\\/]/).pop())+'</code>').join('、')+' 解析失败（原文件已备份为 .corrupt-*），为防数据丢失写入已暂停。请检查数据目录后恢复备份文件。';
+    return;
+  }
+  if (k === 'missing'){
+    chip.style.display='none';
+    banner.className='kernel-banner show kb-missing';
+    banner.innerHTML='❌ <b>未检测到执行内核</b>：任务无法真实执行。请安装 opencode（推荐）：终端运行 <code>npm install -g opencode-ai</code>，安装并登录后刷新本页。';
+    return;
+  }
+  if (k === 'demo'){
+    chip.style.display='none';
+    banner.className='kernel-banner show kb-demo';
+    banner.innerHTML='⚠ <b>演示模式</b>（AGENTS_CHAT_MOCK=1）：输出均为模拟结果，任务执行不可用。删除 .env 中该配置并安装内核后即为真实执行。';
+    return;
+  }
+  banner.className='kernel-banner';
+  if (RUNNER_INFO && RUNNER_INFO.label){
+    chip.style.display='inline-flex';
+    chip.textContent='⚡ '+RUNNER_INFO.label;
+    chip.title='当前执行内核：'+RUNNER_INFO.label;
+  }
+}
+
 function badge(card){
   let p = card.priority;
   let pc = p<=100?'prio-high':(p<=500?'prio-mid':'');
@@ -310,10 +374,20 @@ function errSummary(err){
   if(!err) return '';
   return String(err).split('\n').map(s=>s.trim()).filter(Boolean)[0] || '';
 }
-// 依赖阻塞判定：pending 卡的依赖存在未完成（等待）或已失败（阻塞）
+// 依赖阻塞判定：pending 卡的依赖存在未完成（等待）或已失败（阻塞）；依赖链成环时明确提示
 function blockedInfo(card){
   if(card.status!=='pending' || !(card.dependsOn&&card.dependsOn.length)) return null;
   const byId=Object.fromEntries(CARDS.map(c=>[c.id,c]));
+  // 环检测：沿依赖边 DFS，回到自身即成环（历史数据兜底，正常写入已被服务端拦截）
+  const seen=new Set(), stack=[...card.dependsOn];
+  while(stack.length){
+    const cur=stack.pop();
+    if(cur===card.id) return {kind:'fail',text:'循环依赖：依赖链最终依赖本任务，全量执行时将被跳过'};
+    if(seen.has(cur)) continue;
+    seen.add(cur);
+    const c=byId[cur];
+    if(c) stack.push(...(c.dependsOn||[]));
+  }
   const failedDeps=[], waitDeps=[];
   for(const d of card.dependsOn){
     const dc=byId[d];
@@ -336,11 +410,16 @@ function cardEl(card){
   const blkHtml = blk ? `<div class="card-blocked${blk.kind==='wait'?' wait':''}">${blk.kind==='fail'?'⛔':'⏳'} ${esc(blk.text)}</div>` : '';
   const resetHtml = (card.status==='pending' && /服务重启/.test(card.error||''))
     ? `<div class="card-reset">↻ ${esc(errSummary(card.error))}</div>` : '';
+  // 执行中：实时运行时长徽标（每秒刷新）；追加聊天中：紫色徽标
+  const elapsedHtml = (card.status==='running' && card.startedAt)
+    ? `<span class="badge run-elapsed" data-start="${card.startedAt}">⏱ ${fmtElapsed(Date.now()-card.startedAt)}</span>` : '';
+  const fuHtml = FOLLOWUP_IDS.includes(card.id) ? '<span class="badge fu-live">💬 回复中</span>' : '';
   el.innerHTML = `<div class="title">${esc(card.title)}</div>
-    <div class="meta">${badge(card)} ${card.status!=='pending'&&card.status!=='running'?`<span class="badge">${card.status}</span>`:''}</div>
+    <div class="meta">${badge(card)} ${elapsedHtml} ${fuHtml} ${card.status!=='pending'&&card.status!=='running'?`<span class="badge">${card.status}</span>`:''}</div>
     ${errHtml}${blkHtml}${resetHtml}
     <div class="op">
-      <button class="icon-btn" data-act="run" title="执行">▶</button>
+      ${card.status==='running'?'<button class="icon-btn danger" data-act="stop" title="停止该任务（复位为待执行，本轮编排不再自动调度）">⏹</button>':''}
+      <button class="icon-btn" data-act="run" title="执行${card.status==='pending'?'（若依赖未完成将先确认）':'（旧结果先归档）'}">▶</button>
       <button class="icon-btn" data-act="reset" title="重置（清除结果回到待执行）">⟲</button>
       <button class="icon-btn" data-act="copy" title="复制为新任务">⧉</button>
       <button class="icon-btn" data-act="edit" title="编辑">✎</button>
@@ -350,6 +429,7 @@ function cardEl(card){
     if(a==='del') delCard(card.id);
     else if(a==='edit') openEdit(card);
     else if(a==='run') runOne(card.id);
+    else if(a==='stop') stopOne(card.id);
     else if(a==='reset') resetCard(card.id);
     else if(a==='copy') copyCard(card);
     return; }
@@ -361,6 +441,20 @@ function cardEl(card){
   el.addEventListener('drop', e=>{ e.preventDefault(); el.classList.remove('drag-over'); onDrop(card.id, el); });
   return el;
 }
+// 运行时长格式化：ms -> "1:05" / "12:03:44"
+function fmtElapsed(ms){
+  const s = Math.max(0, Math.floor(ms/1000));
+  const h = Math.floor(s/3600), m = Math.floor((s%3600)/60), sec = s%60;
+  const p2 = n => String(n).padStart(2,'0');
+  return h ? `${h}:${p2(m)}:${p2(sec)}` : `${m}:${p2(sec)}`;
+}
+// 每秒刷新执行中卡片的运行时长（不重建 DOM，只更新徽标文本）
+setInterval(()=>{
+  document.querySelectorAll('.badge.run-elapsed').forEach(b=>{
+    const st = Number(b.dataset.start);
+    if (st) b.textContent = '⏱ ' + fmtElapsed(Date.now()-st);
+  });
+}, 1000);
 let dragId=null;
 function onDrop(targetId, targetEl){
   if(!dragId || dragId===targetId) return;
@@ -384,9 +478,41 @@ function render(){
   for(const c of CARDS){ counts[c.status]=(counts[c.status]||0)+1; (cols[c.status]||cols.pending).appendChild(cardEl(c)); }
   $('#cntPending').textContent=counts.pending||''; $('#cntRunning').textContent=counts.running||'';
   $('#cntDone').textContent=counts.done||''; $('#cntFailed').textContent=counts.failed||'';
+  // 空看板引导：一个任务都没有时给出上手入口（含示例）
+  if(!CARDS.length){
+    cols.pending.innerHTML=`<div class="board-guide">
+      还没有任何任务<br/>把要做的事写成一张张卡牌，Agent 会按依赖与优先级自动调度执行
+      <div class="bg-actions">
+        <button class="btn primary" onclick="openEdit(null)">＋ 新建第一个任务</button>
+        <button class="btn" id="btnExamples">📦 载入示例任务</button>
+      </div></div>`;
+    const be=$('#btnExamples'); if(be) be.onclick=loadExamples;
+    for(const k of ['running','done','failed']) cols[k].innerHTML='<div class="empty">—</div>';
+    return;
+  }
   for(const k in cols){ if(!cols[k].children.length) cols[k].innerHTML='<div class="empty">—</div>'; }
 }
 
+// 载入示例：三张卡展示三种执行模式与依赖关系（可编辑/删除，当作模板随意改造）
+async function loadExamples(){
+  const mk = (title, content, extra) => post('/api/cards', Object.assign({ title, content }, extra||{})).then(r=>r.card);
+  const a = await mk('示例A · 独立任务', '列出当前工作目录下的全部文件，并统计各类型文件的数量。', { priority: 1 });
+  await mk('示例B · 续聊任务', '接续上一个任务的结论：把统计结果整理成一份 markdown 表格。', { priority: 2, mode: 'continue', chainId: a.id, dependsOn: [a.id] });
+  await mk('示例C · 并行任务', '查询今日天气概况并给出一句话总结（与示例A/B 互不依赖，可同时执行）。', { priority: 3, mode: 'parallel' });
+  await loadCards();
+  toast('已载入 3 个示例任务，点击「开始编排」体验');
+}
+
+// 单卡停止：执行中的任务杀进程并复位为待执行（本轮编排不再自动调度）
+async function stopOne(id){
+  const c=CARDS.find(x=>x.id===id);
+  if(!c || c.status!=='running') return;
+  if(!confirm(`停止任务「${c.title}」？该任务将复位为待执行，本轮编排不再自动调度它。`)) return;
+  const r=await post('/api/cards/'+id+'/stop');
+  if(!r.success) toast(r.error||'停止失败');
+  await loadCards();
+}
+
 // ---- 编辑/新建 ----
 // 候选列表排除自身：禁止把自己选为依赖/链首（防自环）
 function fillSelectors(){
@@ -448,7 +574,11 @@ $('#btnEditSave').onclick=async()=>{
     dependsOn:deps };
   if(EDIT_ID) await api('/api/cards/'+EDIT_ID,{method:'PUT',headers:{'Content-Type':'application/json'},body:JSON.stringify(body)});
   else await post('/api/cards',body);
-  $('#maskEdit').classList.remove('show'); await loadCards(); toast('已保存');
+  $('#maskEdit').classList.remove('show');
+  await loadCards();
+  // 编排状态联动提示：编排进行中=新卡自动加入调度；空闲=明确告知需手动开始
+  if(!EDIT_ID) toast($('#btnRun').disabled ? '已保存，新任务将自动加入本轮调度' : '已保存。当前编排空闲，点「▶ 开始编排」执行');
+  else toast('已保存');
 };
 async function delCard(id){ if(!confirm('确认删除该任务？将移入垃圾桶（30 天内可还原）。'))return; await api('/api/cards/'+id,{method:'DELETE'}); await loadCards(); toast('已移入垃圾桶'); }
 $('#btnClear').onclick=async()=>{ if(!confirm('清空全部任务？将移入垃圾桶（30 天内可还原）。'))return; await post('/api/cards/clear'); await loadCards(); };
@@ -471,6 +601,13 @@ $('#parallelSel').onchange=async()=>{
 $('#dExport').onclick=()=>{ if(!OPEN_ID)return; window.open('/api/cards/'+encodeURIComponent(OPEN_ID)+'/export.md','_blank'); };
 async function runOne(id){
   const c=CARDS.find(x=>x.id===id);
+  // 依赖未完成时显式确认：让「立即执行会绕过依赖」这件事说清楚
+  if(c && c.status==='pending' && c.dependsOn && c.dependsOn.length){
+    const undone = c.dependsOn.filter(d=>{ const dc=CARDS.find(x=>x.id===d); return !dc || dc.status!=='done'; });
+    if(undone.length){
+      if(!confirm(`该任务还有 ${undone.length} 个依赖未完成（调度器会等它们完成后才自动执行）。\n立即执行将忽略依赖直接运行，确认？`)) return;
+    }
+  }
   // 重跑保护：已有结果时先确认（旧结果会归档进过程日志）
   if(c && (c.status==='done'||c.status==='failed') && c.result){
     if(!confirm('重新执行将把上次结果归档到过程日志，然后开始新一轮执行。确认？')) return;
@@ -538,6 +675,10 @@ async function openDetail(id){
   $('#dMeta').innerHTML=badge(card)+`<span class="badge">${card.status}</span>`;
   const depTitles = (card.dependsOn||[]).map(d=>{const c=CARDS.find(x=>x.id===d);return c?c.title:d;});
   $('#dDeps').textContent = depTitles.length ? ('依赖：'+depTitles.join('、')) : '';
+  // 任务内容：详情首先呈现「这个任务要求做什么」，不必再点编辑查看
+  const cbox=$('#dContent');
+  if(card.content) cbox.textContent=card.content;
+  else cbox.innerHTML='<span class="empty">（无任务内容）</span>';
   // 失败原因块：任务执行错误优先，其次追加聊天的错误
   const errBox=$('#dError');
   const errText = card.error || card.followupError || '';
@@ -728,7 +869,8 @@ async function refreshProcs(){
     const d = await api('/api/cards/processes');
     const procs = d.processes||[];
     const bar=$('#procBar');
-    if(!procs.length){ bar.innerHTML='<span class="ptitle">进程：</span><span class="proc-empty">无运行中的 opencode 进程</span>'; return; }
+    const kname = (RUNNER_INFO && RUNNER_INFO.label) || 'opencode';
+    if(!procs.length){ bar.innerHTML='<span class="ptitle">进程：</span><span class="proc-empty">无运行中的 '+esc(kname)+' 进程</span>'; return; }
     bar.innerHTML='<span class="ptitle">进程：</span>'+procs.map(p=>{
       const working=p.working;
       return `<span class="proc-chip ${working?'':'idle'}"><span class="dot"></span><span class="pid">PID ${p.pid}</span><span class="st">${working?'工作中':'空闲'}</span></span>`;
@@ -763,8 +905,17 @@ function notifyDone(done,failed){
   }catch{ /* ignore */ }
 }
 const es = new EventSource('/api/cards/stream');
+// 断线重连后补拉：错过的状态迁移事件靠全量刷新弥补（init 只恢复按钮态）
+es.onopen = ()=>{ loadCards(); refreshProcs(); };
 es.onmessage = (e)=>{
   let ev; try{ ev=JSON.parse(e.data); }catch{ return; }
+  if(ev.type==='init'){ // 连接建立时的初始状态（含断线重连场景）
+    $('#statusPill').textContent = ev.running ? '编排中…' : '空闲';
+    $('#btnRun').disabled = !!ev.running; $('#btnStop').disabled = !ev.running;
+    if(ev.maxParallel) $('#parallelSel').value = String(ev.maxParallel);
+    return;
+  }
+  if(ev.type==='notice'){ toast(ev.content); }
   if(ev.type==='runner_started'){ $('#statusPill').textContent='编排中…'; $('#btnRun').disabled=true; $('#btnStop').disabled=false; }
   if(ev.type==='runner_stopped'){ $('#statusPill').textContent='空闲'; $('#btnRun').disabled=false; $('#btnStop').disabled=true; }
   if(ev.type==='all_done'){
@@ -773,17 +924,25 @@ es.onmessage = (e)=>{
   }
   if(ev.type==='ws_warning'){ toast('⚠ 工作区路径无效：'+ev.path+'，任务将在默认目录执行'); }
   if(ev.type==='followup_start'||ev.type==='followup_done'){ loadCards(); }
-  // text 为正文快照（不改变卡片状态）：仅实时渲染，不触发全量刷新，避免流式期间频繁重建 DOM
-  if(['task_start','tool','task_done','proc'].includes(ev.type)){
+  // 状态迁移事件：才触发全量刷新（text/tool 快照不改变卡片状态）
+  if(['task_start','task_done'].includes(ev.type)){
     loadCards();
     refreshProcs();
+    // 失败即时提醒（完成静默：看板移动可见 + all_done 汇总通知）
+    if(ev.type==='task_done' && ev.status==='failed') toast('✗「'+(ev.title||'任务')+'」执行失败，点击卡片查看原因');
     if(OPEN_ID && ev.cardId===OPEN_ID){
       const log=$('#dLog'); if(log.querySelector('.empty')) log.innerHTML='';
       if(ev.type==='task_start') TEXT_PARTS.clear();
-      else if(ev.type==='tool'){ appendLog(log,'🔧 ['+ev.name+'] '+(ev.summary||''),'msg-tool'); log.scrollTop=log.scrollHeight; }
       else if(ev.type==='task_done'){ loadCards().then(()=>{ if(OPEN_ID===ev.cardId) openDetail(ev.cardId); }); }
     }
   }
+  // proc 仅刷新进程条（另有 2s 轮询兜底），不重建看板 DOM
+  if(ev.type==='proc'){ refreshProcs(); }
+  // tool 事件仅在打开对应详情时追加过程日志，避免工具密集时高频全量刷新
+  if(ev.type==='tool' && OPEN_ID===ev.cardId){
+    const log=$('#dLog'); if(log.querySelector('.empty')) log.innerHTML='';
+    appendLog(log,'🔧 ['+ev.name+'] '+(ev.summary||''),'msg-tool'); log.scrollTop=log.scrollHeight;
+  }
   // 正文快照独立渲染（不依赖上面的状态事件）
   if(ev.type==='text' && OPEN_ID===ev.cardId) renderSnapText(ev);
   if(ev.type==='followup_start' && OPEN_ID===ev.cardId) TEXT_PARTS.clear();

package/app/public/index.html

@@ -634,7 +634,7 @@
 </div>
 
 <script>
-const PAGE_VERSION = '3.19.2'; // 与服务端 /api/health.version 互检，不一致说明页面缓存过期
+const PAGE_VERSION = '3.20.0'; // 与服务端 /api/health.version 互检，不一致说明页面缓存过期
 const AV_COLORS = ['#5b8def','#07c160','#fa9d3b','#10aeff','#8a6fe8','#fa5151','#e8a33d','#3aa7a3'];
 const PHASE_LABEL = { plan: '调度规划', work: '执行', review: '验收', report: '汇总', talk: '圆桌发言', task: '任务执行' };
 // 职业图标库（智能体配置可选）
@@ -2319,7 +2319,6 @@ async function doImport() {
     (data.warnings || []).forEach(w => chatMode === 'solo' ? addSoloSys('⚠ ' + w) : addSys('⚠ ' + w));
     closeImport();
     importText.value = '';
-    if (importMode === 'scheduled' && schedOpen) renderSchedList();
   } else toast(data.error || '导入失败');
 }
 

package/app/server.js

@@ -1,6 +1,6 @@
 // Agents Chat Portable - 零依赖 HTTP 服务
 // 启动：node app/server.js [--port 3456]
-const APP_VERSION = '3.19.2'; // 页面与服务端版本互检，不一致提示强刷
+const APP_VERSION = '3.20.0'; // 页面与服务端版本互检，不一致提示强刷
 const http = require('http');
 const fs = require('fs');
 const path = require('path');
@@ -38,7 +38,7 @@ const { runAgent, stopScope, stopAllChildren } = require('./lib/agent');
 const { runButler, runMentioned, runRoundtable, runTasks, prepareRerun } = require('./lib/orchestrator');
 const oc = require('./lib/oc');
 const memoryMod = require('./lib/memory');
-const { CardStore, runner: cardRunner, sseSubscribe, MAX_PARALLEL } = require('./lib/cards');
+const { CardStore, runner: cardRunner, sseSubscribe, MAX_PARALLEL, wouldCycle } = require('./lib/cards');
 
 // ---------- 人工审批关卡：orchestrator 暂停等待用户放行（方案/交付），SSE 断线后可经 /api/approvals 恢复 ----------
 const pendingApprovals = new Map(); // approvalId -> {kind,label,taskId,resolve,timer}
@@ -948,7 +948,18 @@ const server = http.createServer(async (req, res) => {
     try {
       for (const m of store.getMessages()) if (m.taskId) counts[m.taskId] = (counts[m.taskId] || 0) + 1;
     } catch { /* ignore */ }
-    json(res, 200, { success: true, cards, running: cardRunner.isRunning(), maxParallel: cardRunner.maxP(), msgCounts: counts, config: CardStore.getConfig() });
+    // 执行内核状态（前端据此显示内核徽标/缺失警告）与追加聊天进行中的卡
+    let runnerInfo = { kind: 'unknown', label: '' };
+    try {
+      const { resolveRunner } = require('./lib/agent');
+      const r = resolveRunner();
+      runnerInfo = { kind: r.kind, label: r.kernel ? r.kernel.label : '' };
+    } catch { /* ignore */ }
+    const { getCorruptedFiles } = require('./lib/cards');
+    json(res, 200, {
+      success: true, cards, running: cardRunner.isRunning(), maxParallel: cardRunner.maxP(), msgCounts: counts, config: CardStore.getConfig(),
+      followupIds: cardRunner.getFollowupIds(), runner: runnerInfo, corrupted: getCorruptedFiles()
+    });
     return;
   }
 
@@ -979,6 +990,7 @@ const server = http.createServer(async (req, res) => {
     }
     if (parallelBad) { json(res, 400, { success: false, error: 'maxParallel 需在 1-8 之间' }); return; }
     const cfg = Object.keys(patch).length ? CardStore.setConfig(patch) : CardStore.getConfig();
+    if (patch.maxParallel !== undefined) cardRunner.onConfigChanged(); // 并行度调大时立即补齐
     // 工作区校验：保存允许（可能是尚未创建的目录），但路径不存在时显式警告
     let warning = '';
     const ws = (cfg.workspace || '').trim();
@@ -1071,16 +1083,22 @@ const server = http.createServer(async (req, res) => {
     const card = CardStore.get(id);
     if (!card) { json(res, 404, { success: false, error: '卡牌不存在' }); return; }
     const msgs = store.getMessages(id);
+    // 中文友好的日期时间（YYYY-MM-DD HH:mm，避免随系统 locale 变成英文格式）
+    const fmtDateTime = (t) => {
+      const d = new Date(t || Date.now());
+      const p2 = (n) => String(n).padStart(2, '0');
+      return `${d.getFullYear()}-${p2(d.getMonth() + 1)}-${p2(d.getDate())} ${p2(d.getHours())}:${p2(d.getMinutes())}`;
+    };
     const roleOf = (m) => (m.role === 'user' ? '用户' : (m.phase === 'archive' ? '归档' : (m.phase === 'system' ? '系统' : 'Agent')));
     const lines = [
       `# ${card.title}`, '',
       `- 状态：${card.status}｜模式：${card.mode}｜优先级：P${card.priority}`,
-      `- 创建：${new Date(card.createdAt).toLocaleString()}${card.finishedAt ? `｜完成：${new Date(card.finishedAt).toLocaleString()}` : ''}`,
+      `- 创建：${fmtDateTime(card.createdAt)}${card.finishedAt ? `｜完成：${fmtDateTime(card.finishedAt)}` : ''}`,
       card.error ? `- 失败原因：${card.error.replace(/\n/g, ' ')}` : '',
       '', '## 任务内容', '', String(card.content || '').trim(), '', '## 执行过程', ''
     ];
     for (const m of msgs) {
-      lines.push(`### ${new Date(m.timestamp || Date.now()).toLocaleString()} · ${roleOf(m)}`, '');
+      lines.push(`### ${fmtDateTime(m.timestamp || Date.now())} · ${roleOf(m)}`, '');
       lines.push(String(m.content || '').trim() || '（无内容）');
       lines.push('');
     }
@@ -1107,13 +1125,24 @@ const server = http.createServer(async (req, res) => {
   if (p.startsWith('/api/cards/') && req.method === 'PUT') {
     const id = p.slice('/api/cards/'.length);
     const body = await readBody(req);
+    // 运行中/追加聊天中的卡禁止编辑与重置：子进程结束时会回写状态，中途改写会产生竞争
+    const target = CardStore.get(id);
+    if (target && (target.status === 'running' || cardRunner.isFollowupRunning(id))) {
+      json(res, 409, { success: false, error: target.status === 'running' ? '任务正在执行中，无法编辑或重置，请等待完成或先停止编排' : '该任务追加聊天进行中，稍后再修改' });
+      return;
+    }
     const patch = {};
     if (body.title !== undefined) patch.title = String(body.title).slice(0, 500);
     if (body.content !== undefined) patch.content = String(body.content).slice(0, 20000);
     if (body.priority !== undefined) patch.priority = Number(body.priority) || 999;
     if (body.mode !== undefined) patch.mode = ['new', 'continue', 'parallel'].includes(body.mode) ? body.mode : 'new';
     if (body.chainId !== undefined) patch.chainId = String(body.chainId).slice(0, 100);
-    if (Array.isArray(body.dependsOn)) patch.dependsOn = body.dependsOn.map(String).slice(0, 50);
+    if (Array.isArray(body.dependsOn)) {
+      const deps = body.dependsOn.map(String).slice(0, 50);
+      // 环检测：修改依赖后若形成（直接或间接）循环依赖则拒绝写入
+      if (wouldCycle(id, deps)) { json(res, 409, { success: false, error: '循环依赖：该任务的依赖链最终会依赖它自己，请调整依赖关系' }); return; }
+      patch.dependsOn = deps;
+    }
     if (body.model !== undefined) patch.model = String(body.model).slice(0, 80);
     // 状态手动复位：failed/pending -> pending 可重跑
     if (body.status === 'pending') { patch.status = 'pending'; patch.result = ''; patch.error = ''; patch.ocSessionId = ''; }
@@ -1125,6 +1154,7 @@ const server = http.createServer(async (req, res) => {
 
   if (p.startsWith('/api/cards/') && req.method === 'DELETE') {
     const id = p.slice('/api/cards/'.length);
+    if (!CardStore.get(id)) { json(res, 404, { success: false, error: '卡牌不存在' }); return; }
     cardRunner.killCard(id);
     CardStore.remove(id);
     json(res, 200, { success: true });
@@ -1138,6 +1168,14 @@ const server = http.createServer(async (req, res) => {
     return;
   }
 
+  // 单卡停止：杀掉该卡子进程，状态复位为待执行（本轮编排不再自动调度它）
+  if (p.startsWith('/api/cards/') && req.method === 'POST' && p.endsWith('/stop')) {
+    const id = p.slice('/api/cards/'.length, -'/stop'.length);
+    const ok = cardRunner.stopOne(id);
+    json(res, ok ? 200 : 409, { success: ok, error: ok ? '' : '任务不在执行中，无法停止' });
+    return;
+  }
+
   // 追加聊天：任务完成后复用其 opencode 会话续聊（同一进程的第二轮输入）
   if (p.startsWith('/api/cards/') && req.method === 'POST' && p.endsWith('/chat')) {
     const id = p.slice('/api/cards/'.length, -'/chat'.length);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iamsamyiok/agents-chat",
-  "version": "3.19.2",
+  "version": "3.21.0",
   "description": "多智能体群聊工具 - 支持 OpenCode/Claude Code/Codex/pi 内核，微信风格聊天界面",
   "main": "lib/start.js",
   "bin": {