nx-kv 0.8.0 → 0.8.2

package/src/modules/localtask/service.js

@@ -37,6 +37,25 @@ export const MAX_TIMEOUT_SEC = 600; // 阻塞时长上限（10 分钟）
 export const MAX_SUMMARY = 2000; // 现状（状态）长度上限（原 200，已放宽）
 export const MAX_TEXT = 20_000; // 单条任务内容长度上限
 
+// wait 取任务返回时，在 task.text 末尾追加的「收尾指令」（可在面板/CLI 修改；置空关闭）。
+// 作用：从每一条任务层面反复强调「计划最后再 wait 一次」，避免 agent 在长对话里漂移、漏调。
+// 注意：命令名是 localtask 不是 sessiontask（v0.8.0 重命名后），但默认文案直接复用同一段文字。
+export const DEFAULT_TASK_SUFFIX =
+  '规划计划，然后完成这个任务；计划的最后一个动作，是再次调用 ' +
+  'nx-kv localtask wait（带上 --cwd 当前工作目录、--summary 当前现状、--json）收尾本轮，' +
+  '在拿到下一条任务或超时之前不要提前结束。';
+const MAX_SUFFIX_LEN = 500; // 收尾追加语长度上限
+
+// 归一化收尾追加语：缺省（旧 store 无此字段）→ 默认；显式传 ''（清空）→ '' 表示关闭。
+// 注意：与 timeoutSec 不同——timeoutSec 缺省→推荐值（仍开启），taskSuffix 缺省→默认文本。
+// 因此从老 store 读 settings.taskSuffix 时，clampTaskSuffix 会自动补默认；想"关闭"必须显式 ''。
+export function clampTaskSuffix(v) {
+  if (v === undefined || v === null) return DEFAULT_TASK_SUFFIX;
+  let s = String(v).trim();
+  if (s.length > MAX_SUFFIX_LEN) s = s.slice(0, MAX_SUFFIX_LEN);
+  return s;
+}
+
 // ─── 存储位置：可环境变量覆盖（测试隔离）；旧名/旧文件自动兼容 ──────────
 
 export function storePath() {
@@ -119,7 +138,11 @@ export function stampNow(d = new Date()) {
 // ─── 存储读写（原子写 + 损坏容忍 + v1/v2 迁移） ───────────────────
 
 function emptyStore() {
-  return { version: 4, settings: { timeoutSec: DEFAULT_TIMEOUT_SEC }, topics: {} };
+  return {
+    version: 4,
+    settings: { timeoutSec: DEFAULT_TIMEOUT_SEC, taskSuffix: DEFAULT_TASK_SUFFIX },
+    topics: {},
+  };
 }
 
 // 归一化超时秒数：非法/缺省 → 推荐值；超上限截断为 10 分钟
@@ -182,7 +205,14 @@ async function loadStore() {
   if (!topics) return emptyStore();
   return {
     version: 4,
-    settings: { timeoutSec: clampTimeoutSec(settings && settings.timeoutSec) },
+    settings: {
+      timeoutSec: clampTimeoutSec(settings && settings.timeoutSec),
+      // 旧 store 可能没存过 taskSuffix（v0.8.0 之前）；clampTaskSuffix 缺省→默认文本。
+      // 显式 ''（关闭）会保留——判断条件是「字段存在且非 undefined」，不能只看 falsy。
+      taskSuffix: settings && Object.prototype.hasOwnProperty.call(settings, 'taskSuffix')
+        ? clampTaskSuffix(settings.taskSuffix)
+        : DEFAULT_TASK_SUFFIX,
+    },
     topics,
   };
 }
@@ -248,6 +278,8 @@ function topicView(t) {
     summary: t.summary || '',
     waiting: !!t.waiting,
     waitingUntil: t.waitingUntil || '',
+    waitingSince: t.waitingSince || '',
+    cancelRequested: !!t.cancelRequested,
     createdAt: t.createdAt,
     updatedAt: t.updatedAt,
     pending: tasks.filter((x) => x.status !== 'consumed').length,
@@ -282,12 +314,17 @@ export async function consumeFirstPending(key, roundSummary) {
   return normalizeTask(task);
 }
 
-// 在 store 里把某主题置为等待/结束，并刷新现状
+// 在 store 里把某主题置为等待/结束，并刷新现状。
+// waitingSince 是「等待起点」，面板据此显示「已等多久」——waitingUntil（截止时刻）
+// 只能反推剩余，反推不出起点（超时值可被改写），所以两者都存。
 async function setWaiting(key, cwd, summary, waiting, deadline) {
   const store = await loadStore();
   const t = topicOf(store, key, cwd);
-  t.waiting = waiting;
+  t.waiting = !!waiting;
   t.waitingUntil = waiting && deadline ? stampNow(deadline) : '';
+  t.waitingSince = waiting ? stampNow() : '';
+  // 新一轮等待不继承上一轮残留的「关闭」请求，否则刚进来就被立刻收尾
+  t.cancelRequested = false;
   if (summary) t.summary = summary;
   t.updatedAt = stampNow();
   await saveStore(store);
@@ -301,8 +338,47 @@ async function clearWaiting(key) {
   if (!t) return;
   t.waiting = false;
   t.waitingUntil = '';
+  t.waitingSince = '';
+  t.cancelRequested = false;
+  t.updatedAt = stampNow();
+  await saveStore(store);
+}
+
+/**
+ * 用户在面板点「关闭」：关掉某主题的等待，让**阻塞中的 wait 立即收尾**。
+ *
+ * 只翻 store 里的 cancelRequested 标记——wait 端每 0.5s 轮询到就结束本轮（返回
+ * status:"timeout" + cancelled:true，与超时同一条出口，agent 照常收尾）。
+ * **不删主题、不删任务、不动队列**：等待可以取消，历史照留。
+ *
+ * @returns {{cancelled:boolean,key:string,name:string,cwd:string,reason?:string}}
+ */
+export async function cancelWait({ cwd: rawCwd, key: rawKey } = {}) {
+  if (!rawKey && !rawCwd) {
+    const { badInput } = await import('../../core/errors.js');
+    throw badInput('需要 --cwd "<工作目录>" 或 --key "<主题key>"');
+  }
+  const key = resolveTopicKey({ key: rawKey, cwd: rawCwd });
+  const store = await loadStore();
+  const t = store.topics[key];
+  if (!t || !t.waiting) {
+    return { cancelled: false, key, name: (t && t.name) || '', cwd: (t && t.cwd) || '', reason: 'not_waiting' };
+  }
+  t.cancelRequested = true;
+  t.updatedAt = stampNow();
+  await saveStore(store);
+  return { cancelled: true, key, name: t.name, cwd: t.cwd };
+}
+
+// wait 端轮询：该主题是否被请求关闭；取到即清标记（只生效一次）。
+async function consumeCancelRequest(key) {
+  const store = await loadStore();
+  const t = store.topics[key];
+  if (!t || !t.cancelRequested) return false;
+  t.cancelRequested = false;
   t.updatedAt = stampNow();
   await saveStore(store);
+  return true;
 }
 
 // ─── CRUD ───────────────────────────────────────────────────────────
@@ -312,6 +388,10 @@ function settingsView(s) {
     timeoutSec: clampTimeoutSec(s && s.timeoutSec),
     recommendedSec: DEFAULT_TIMEOUT_SEC,
     maxSec: MAX_TIMEOUT_SEC,
+    // wait 交付任务时追加到 task.text 末尾的收尾提醒；''=关闭；defaultTaskSuffix 供 UI 恢复默认
+    taskSuffix: clampTaskSuffix(s && s.taskSuffix),
+    defaultTaskSuffix: DEFAULT_TASK_SUFFIX,
+    suffixEnabled: !!clampTaskSuffix(s && s.taskSuffix),
   };
 }
 
@@ -356,14 +436,27 @@ export async function pruneTopics({ allFinished = false, dryRun = false } = {})
   return { status: 'ok', dryRun: !!dryRun, count: removed.length, removed };
 }
 
-// 配置等待超时（页面可调；推荐 180=3 分钟，最大 600=10 分钟，超上限自动截断）
-export async function updateSettings({ timeoutSec } = {}) {
-  const n = Number(timeoutSec);
-  if (!Number.isFinite(n) || n <= 0) {
-    throw badInput(`超时时间需为 1-${MAX_TIMEOUT_SEC} 秒（推荐 ${DEFAULT_TIMEOUT_SEC}）`);
+// 配置等待超时 / 任务收尾追加语（页面可调）。超时推荐 180=3 分钟、最大 600=10 分钟；
+// taskSuffix 为 wait 返回任务时追加到 task.text 末尾的固定指令，传 '' 关闭、不传保持不变。
+export async function updateSettings({ timeoutSec, taskSuffix } = {}) {
+  const hasTimeout = timeoutSec !== undefined && timeoutSec !== null;
+  const hasSuffix = taskSuffix !== undefined;
+  if (!hasTimeout && !hasSuffix) {
+    throw badInput(
+      '请至少指定一项：--timeout <秒>，或 --suffix "<收尾追加语>"（--no-suffix 关闭追加、--reset-suffix 恢复默认）'
+    );
   }
   const store = await loadStore();
-  store.settings = { timeoutSec: clampTimeoutSec(n) };
+  const next = { ...store.settings };
+  if (hasTimeout) {
+    const n = Number(timeoutSec);
+    if (!Number.isFinite(n) || n <= 0) {
+      throw badInput(`超时时间需为 1-${MAX_TIMEOUT_SEC} 秒（推荐 ${DEFAULT_TIMEOUT_SEC}）`);
+    }
+    next.timeoutSec = clampTimeoutSec(n);
+  }
+  if (hasSuffix) next.taskSuffix = clampTaskSuffix(taskSuffix);
+  store.settings = next;
   await saveStore(store);
   return settingsView(store.settings);
 }
@@ -582,6 +675,16 @@ export async function reorderTasks({ cwd: rawCwd, id, beforeId, afterId } = {})
 
 // ─── 阻塞等待：核心入口 ─────────────────────────────────────────────
 
+// 把收尾追加语拼到返回给 agent 的 task.text 末尾（只改返回载荷，绝不回写库存原文）。
+// suffix 为空 → 原样返回；已包含同样追加语（幂等）→ 不重复追加。
+function withTaskSuffix(task, suffix) {
+  const s = clampTaskSuffix(suffix);
+  if (!task || !s) return task;
+  const base = String(task.text || '');
+  if (base.includes(s)) return task;
+  return { ...task, text: `${base.replace(/\s+$/, '')}\n\n${s}` };
+}
+
 /**
  * 针对某主题（工作目录）等待用户回填下一条任务。
  * @param {string}  [cwd]     工作目录（主题按目录名识别）；缺省 → 进程当前 cwd
@@ -603,15 +706,19 @@ export async function waitForTask({
   const summary = normalizeSummary(rawSummary); // 现状必填
 
   // 超时：显式 --timeout（秒/毫秒）优先；否则用页面配置；统一夹到 1-600
+  const startStore = await loadStore();
   let sec;
   if (timeoutSec !== undefined && timeoutSec !== null) sec = timeoutSec;
   else if (timeoutMs !== undefined && timeoutMs !== null) sec = Number(timeoutMs) / 1000;
-  else sec = (await loadStore()).settings.timeoutSec;
+  else sec = startStore.settings.timeoutSec;
   const tmo = clampTimeoutSec(sec) * 1000;
+  const suffix = startStore.settings.taskSuffix; // 返回任务时追加的收尾指令（本轮固定）
 
   // 1. 主题队列已有 pending → 立即取走，不开窗、不阻塞；记录本轮完成总结
   const queued = await consumeFirstPending(key, summary);
-  if (queued) return { status: 'ok', key, cwd, name, summary, task: queued, queued: true };
+  if (queued) {
+    return { status: 'ok', key, cwd, name, summary, task: withTaskSuffix(queued, suffix), queued: true };
+  }
 
   // 2. 没有 pending → 起内嵌弹窗服务器
   const server = await startPopupServer(key, cwd, summary, tmo);
@@ -638,9 +745,25 @@ export async function waitForTask({
 
   const timer = setTimeout(() => resolveOutcome({ kind: 'timeout' }), tmo);
 
+  // 关闭轮询：用户在面板点了「关闭」→ 立即收尾本轮（走与超时同一条出口，只多带 cancelled 标记，
+  // agent 不必认识新状态，照常结束本轮）。
+  const cancelPoll = setInterval(() => {
+    consumeCancelRequest(key)
+      .then((yes) => {
+        if (yes) resolveOutcome({ kind: 'cancelled' });
+      })
+      .catch(() => {});
+  }, POLL_MS);
+
   // 登记「等待中」（含截止时刻与现状），面板/弹窗据此显示倒计时
   await setWaiting(key, cwd, summary, true, new Date(Date.now() + tmo));
 
+  // 登记之后再查一次关闭标记：setWaiting 刚清掉上一轮残留的标记，因此这里若有值
+  // 一定是新一次关闭请求——立刻收尾，不让用户白等。
+  if (await consumeCancelRequest(key).catch(() => false)) {
+    resolveOutcome({ kind: 'cancelled' });
+  }
+
   // waiter/轮询就位后再回调，保证 onReady 里立刻回填也能被接住
   if (typeof onReady === 'function') {
     try {
@@ -658,9 +781,12 @@ export async function waitForTask({
     result =
       r.kind === 'timeout'
         ? { status: 'timeout', key, cwd, summary, timeoutMs: tmo }
-        : { status: 'ok', key, cwd, name, summary, task: r.task, delivered: r.delivered, queued: false };
+        : r.kind === 'cancelled'
+        ? { status: 'timeout', key, cwd, summary, timeoutMs: tmo, cancelled: true }
+        : { status: 'ok', key, cwd, name, summary, task: withTaskSuffix(r.task, suffix), delivered: r.delivered, queued: false };
   } finally {
     clearInterval(poll);
+    clearInterval(cancelPoll);
     clearTimeout(timer);
     waiters.delete(key);
     await clearWaiting(key);
@@ -777,3 +903,74 @@ function stopServer(server) {
     });
   });
 }
+
+// ─── 面板空闲自释放所需的观测接口（panel-guard.js 调用）────────────
+
+// 当前有多少主题「真的在等待」——常驻面板的空闲自释放据此否决退出：
+// 有 agent 正阻塞等人时，面板是唯一提醒来源，绝不能在此时释放。
+//
+// waiting 标志由 wait 进程写入、结束复位，跨进程可见；但 wait 被强杀（SIGKILL）时
+// 标志会残留。所以再过一道「截止时刻」：waitingUntil 已过期视为不在等待——那一刻
+// wait 本来也要收尾了，不会误伤正常等待。
+export async function countWaitingTopics() {
+  const store = await loadStore();
+  const now = Date.now();
+  let n = 0;
+  for (const t of Object.values(store.topics)) {
+    if (!t || !t.waiting) continue;
+    const until = parseStampMs(t.waitingUntil);
+    if (Number.isFinite(until) && until <= now) continue; // 残留标志：截止时刻已过
+    n += 1;
+  }
+  return n;
+}
+
+// "YYYY-MM-DD HH:mm:ss"（本地）→ epoch ms；无法解析返回 NaN
+function parseStampMs(s) {
+  const m = /^(\d{4})-(\d{2})-(\d{2})[ T](\d{2}):(\d{2}):(\d{2})$/.exec(String(s || ''));
+  if (!m) return NaN;
+  return new Date(+m[1], +m[2] - 1, +m[3], +m[4], +m[5], +m[6]).getTime();
+}
+
+// 活动 SSE 面板连接（只在常驻 serve 进程内有意义）。每条记录最近一次成功写入的时间，
+// wait 据此判断是否真有「活着的」面板标签：心跳写失败（标签已关、TCP 残留）会立刻剔除，
+// 超过新鲜窗口没成功写过的连接不计入——避免页面关了却误判在线、整轮零提醒也不开页。
+//
+// 本期只交付「存在性」接口：panel-guard 只要 clients 数字。SSE 事件流是更上层能力，
+// 留到下个 release 再叠加；这里只保留最小数据结构，streamEventsSSE 接入时直接复用。
+const SSE_HEARTBEAT_MS = 15000;
+const SSE_LIVE_WINDOW_MS = 30000;
+const sseConns = new Set();
+export function panelPresence() {
+  const now = Date.now();
+  let clients = 0;
+  for (const conn of sseConns) {
+    if (now - conn.lastOkWrite <= SSE_LIVE_WINDOW_MS) clients += 1;
+  }
+  return { clients, total: sseConns.size };
+}
+
+// 给 runtime/api.js 用的最小 SSE 注册表：每次「/api/localtasks/events」连接时
+// 调一下 addEventStreamConn(req, res)，把连接纳入 panelPresence 统计。
+export function addEventStreamConn(req, res) {
+  const conn = { lastOkWrite: Date.now() };
+  sseConns.add(conn);
+  const beat = setInterval(() => {
+    try {
+      res.write(`: ping ${Date.now()}\n\n`);
+      conn.lastOkWrite = Date.now();
+    } catch {
+      clearInterval(beat);
+      sseConns.delete(conn);
+    }
+  }, SSE_HEARTBEAT_MS);
+  beat.unref?.();
+  const cleanup = () => {
+    clearInterval(beat);
+    sseConns.delete(conn);
+  };
+  req.on('close', cleanup);
+  req.on('error', cleanup);
+  res.on('close', cleanup);
+  return conn;
+}

package/src/modules/localtask/view.jsx

@@ -21,6 +21,21 @@ function countdown(s) {
   return `等待中 ${mm}:${String(ss).padStart(2, '0')}`;
 }
 
+// 「已等 m:ss · 剩 m:ss」：waitingSince（起点）反推已等，waitingUntil（截止）反推剩余。
+// waitingSince 缺字段时（老数据）退化为只显示剩余。
+function waitingBadge(t) {
+  if (!t || !t.waiting) return null;
+  const remain = countdown(t.waitingUntil);
+  if (!t.waitingSince) return remain; // 老数据兜底
+  const since = parseStamp(t.waitingSince);
+  if (!since) return remain;
+  const elapsedMs = Date.now() - since.getTime();
+  if (elapsedMs < 0) return remain;
+  const mm = Math.floor(elapsedMs / 60000);
+  const ss = Math.floor((elapsedMs % 60000) / 1000);
+  return `等待中 已等 ${mm}:${String(ss).padStart(2, '0')} · 剩 ${remain.replace(/^等待中\s*/, '')}`;
+}
+
 export default function SessionTaskView() {
   const toast = useToast();
   const guard = useGuard();
@@ -32,6 +47,13 @@ export default function SessionTaskView() {
   const [timeoutSec, setTimeoutSec] = useState(180);
   const [cfgSaving, setCfgSaving] = useState(false);
   const [pruning, setPruning] = useState(false);
+  // 收尾追加语：task.text 末尾自动追加的固定指令（强制 agent 计划最后再 wait 一次）
+  const [taskSuffix, setTaskSuffix] = useState('');
+  const [defaultTaskSuffix, setDefaultTaskSuffix] = useState('');
+  const [suffixEnabled, setSuffixEnabled] = useState(false);
+  const [suffixEditing, setSuffixEditing] = useState(false);
+  const [suffixDraft, setSuffixDraft] = useState('');
+  const [suffixSaving, setSuffixSaving] = useState(false);
   const [editingId, setEditingId] = useState(null);
   const [editText, setEditText] = useState('');
   const [editSaving, setEditSaving] = useState(false);
@@ -67,7 +89,12 @@ export default function SessionTaskView() {
 
   // 同步页面上的超时配置（来源：后端 settings）
   useEffect(() => {
-    if (overview && overview.settings) setTimeoutSec(overview.settings.timeoutSec);
+    if (overview && overview.settings) {
+      setTimeoutSec(overview.settings.timeoutSec);
+      setTaskSuffix(overview.settings.taskSuffix || '');
+      setDefaultTaskSuffix(overview.settings.defaultTaskSuffix || '');
+      setSuffixEnabled(!!overview.settings.suffixEnabled);
+    }
   }, [overview]);
 
   const saveTimeout = (sec) =>
@@ -86,6 +113,30 @@ export default function SessionTaskView() {
       }
     });
 
+  // 收尾追加语：保存（draft 是 '' 等价于关闭；非空则启用）
+  const saveSuffix = (text) =>
+    guard(async () => {
+      setSuffixSaving(true);
+      try {
+        const s = await api('/api/localtasks/setting', {
+          method: 'PATCH',
+          body: { suffix: text },
+        });
+        setTaskSuffix(s.taskSuffix);
+        setSuffixEnabled(!!s.suffixEnabled);
+        setSuffixEditing(false);
+        setSuffixDraft('');
+        toast(s.suffixEnabled ? '收尾追加语已更新' : '收尾追加语已关闭');
+        await load();
+      } finally {
+        setSuffixSaving(false);
+      }
+    });
+
+  // 显式关闭（不进入编辑，直接 PATCH suffix=''）
+  const disableSuffix = () =>
+    saveSuffix('');
+
   // 清理旧脏数据（旧模型无目录主题、空主题；等待中保留）
   const prune = () =>
     guard(async () => {
@@ -191,6 +242,22 @@ export default function SessionTaskView() {
       }
     });
 
+  // 关闭某主题的等待：只翻 store 里的 cancelRequested 标记，阻塞中的 wait 立即收尾。
+  // 不删主题、不删任务、不动队列——历史照留，只是当前这一轮不等了。
+  const cancelTopic = (t) =>
+    guard(async () => {
+      if (!t || !t.waiting) return;
+      const msg = `关闭主题「${t.name}」的等待？\n\n阻塞中的 wait 立即收尾（走与超时同一条出口，agent 照常结束本轮），主题与任务都保留。`;
+      if (!window.confirm(msg)) return;
+      const r = await api('/api/localtasks/cancel', {
+        method: 'POST',
+        body: { key: t.key },
+      });
+      if (r && r.cancelled) toast('已关闭等待');
+      else toast('该主题不在等待中');
+      await load();
+    });
+
   // 批量删除勾选主题；含等待中时 force 并提示
   const batchDelete = () =>
     guard(async () => {
@@ -328,6 +395,96 @@ export default function SessionTaskView() {
         </span>
       </div>
 
+      <div className="card" style={{ padding: '10px 14px' }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'wrap', marginBottom: suffixEditing ? 10 : 0 }}>
+          <span style={{ fontWeight: 700 }}>收尾追加语</span>
+          <span className="muted" style={{ fontSize: 12 }}>
+            每次 wait 返回任务时，自动拼到 task.text 末尾。强制 agent 计划最后再 wait 一次，避免长对话漂移漏调。
+          </span>
+          <span style={{ marginLeft: 'auto', display: 'flex', gap: 8, alignItems: 'center' }}>
+            <span className={'tag' + (suffixEnabled ? '' : ' muted')} style={{ fontSize: 11 }}>
+              {suffixEnabled ? '已开启' : '已关闭'}
+            </span>
+            {!suffixEditing && (
+              <>
+                {suffixEnabled && (
+                  <button className="btn small ghost" onClick={() => { setSuffixDraft(taskSuffix); setSuffixEditing(true); }}>
+                    编辑
+                  </button>
+                )}
+                {suffixEnabled ? (
+                  <button
+                    className="btn small ghost"
+                    onClick={() => disableSuffix()}
+                    disabled={suffixSaving}
+                    title="关闭后，wait 返回的任务不再追加提示词"
+                  >
+                    关闭
+                  </button>
+                ) : (
+                  <button
+                    className="btn small"
+                    onClick={() => { setSuffixDraft(defaultTaskSuffix); setSuffixEditing(true); }}
+                    title="恢复默认收尾追加语并开启"
+                  >
+                    开启
+                  </button>
+                )}
+              </>
+            )}
+          </span>
+        </div>
+        {!suffixEditing && taskSuffix && (
+          <div
+            className="muted"
+            style={{ fontSize: 12, whiteSpace: 'pre-wrap', borderLeft: '2px solid #eee', padding: '4px 0 4px 10px' }}
+          >
+            {taskSuffix}
+          </div>
+        )}
+        {suffixEditing && (
+          <div>
+            <textarea
+              value={suffixDraft}
+              onChange={(e) => setSuffixDraft(e.target.value)}
+              rows={5}
+              style={{ width: '100%', font: 'inherit', padding: 8, boxSizing: 'border-box' }}
+              placeholder="（留空 = 关闭；非空 = 启用并以这段文本作为追加语）"
+            />
+            <div style={{ display: 'flex', gap: 8, marginTop: 8, alignItems: 'center', flexWrap: 'wrap' }}>
+              <button
+                className="btn small"
+                onClick={() => saveSuffix(suffixDraft)}
+                disabled={suffixSaving}
+              >
+                保存
+              </button>
+              <button
+                className="btn small ghost"
+                onClick={() => {
+                  setSuffixEditing(false);
+                  setSuffixDraft('');
+                }}
+                disabled={suffixSaving}
+              >
+                取消
+              </button>
+              <button
+                className="btn small ghost"
+                onClick={() => saveSuffix(defaultTaskSuffix)}
+                disabled={suffixSaving}
+                title="覆盖为默认文案并开启"
+              >
+                恢复默认
+              </button>
+              <span className="muted" style={{ fontSize: 11, marginLeft: 'auto' }}>
+                留空保存 = 关闭
+              </span>
+            </div>
+          </div>
+        )}
+      </div>
+
       <div className="colhead">
         <input
           type="checkbox"
@@ -404,9 +561,9 @@ export default function SessionTaskView() {
                     现状：{t.summary}
                   </div>
                 )}
-                <div style={{ display: 'flex', gap: 6, alignItems: 'center' }}>
+                <div style={{ display: 'flex', gap: 6, alignItems: 'center', flexWrap: 'wrap' }}>
                   {t.waiting ? (
-                    <span className="tag strong">{countdown(t.waitingUntil)}</span>
+                    <span className="tag strong">{waitingBadge(t) || countdown(t.waitingUntil)}</span>
                   ) : (
                     <span className="tag">已结束</span>
                   )}
@@ -415,9 +572,18 @@ export default function SessionTaskView() {
                   </span>
                 </div>
                 <div
-                  style={{ display: 'flex', justifyContent: 'flex-end', marginTop: 8 }}
+                  style={{ display: 'flex', justifyContent: 'flex-end', gap: 6, marginTop: 8 }}
                   onClick={(e) => e.stopPropagation()}
                 >
+                  {t.waiting && (
+                    <button
+                      className="btn small ghost"
+                      onClick={() => cancelTopic(t)}
+                      title="关闭本次等待（阻塞中的 wait 立即收尾，主题与任务保留）"
+                    >
+                      关闭
+                    </button>
+                  )}
                   <button
                     className="btn small ghost"
                     onClick={() => deleteTopic(t)}

package/src/runtime/cli.js

@@ -21,7 +21,16 @@ const BUILTINS = [
     id: 'serve',
     cli: ['serve'],
     summary: '启动 Web 面板',
-    flags: { port: { type: 'number', default: DEFAULT_PORT }, 'no-open': { type: 'boolean' } },
+    flags: {
+      port: { type: 'number', default: DEFAULT_PORT },
+      'no-open': { type: 'boolean' },
+      // --auto-exit：面板（web）全关且无等待中的主题时，serve 自动退出。
+      // 用户手动 `nx-kv serve` 默认不带该标志，面板不会自己跑掉；
+      // wait 临时拉起 serve 时会加 --no-open --auto-exit，用完即让位。
+      'auto-exit': { type: 'boolean', hint: '面板关闭后空闲自释放（wait 临时拉起实例专用）' },
+      // 宽限期：连续多久无面板活动后才允许释放（与 --auto-exit 配合使用）
+      idle: { type: 'number', hint: '空闲宽限期（秒；与 --auto-exit 配合，默认 120）' },
+    },
     run: (ctx) => cmdServe(ctx),
   },
   {
@@ -245,15 +254,22 @@ function printCommandHelp(cmd) {
 
 async function cmdServe(ctx) {
   const { startServer } = await import('./server.js');
+  const { startPanelIdleGuard } = await import('../modules/localtask/panel-guard.js');
   const { openBrowser } = await import('../core/open.js');
   const port = ctx.port || DEFAULT_PORT;
-  const server = await startServer({ port, host: '127.0.0.1' });
+  const autoExit = !!ctx['auto-exit'];
+
+  // 活动观测钩子：每个进来的请求（静态或 /api）都回调一次，供空闲自释放判活。
+  // 不参与响应，异常必须吞掉。
+  const onRequest = () => {};
+  const server = await startServer({ port, host: '127.0.0.1', onRequest });
   const addr = `http://127.0.0.1:${server.address().port}`;
 
   console.log('nx-kv · nx-kv v' + VERSION);
   console.log(`面板:   ${addr}`);
   console.log(`配置:   ${configPathFromEnv()}`);
   console.log('CLI:    nx-kv help（每个按钮都有对应命令，agent 可加 --json）');
+  if (autoExit) console.log('模式:   空闲自释放（面板关闭且无等待中的主题后自动退出）');
   console.log('按 Ctrl+C 停止');
 
   if (!ctx['no-open']) openBrowser(addr);
@@ -264,6 +280,11 @@ async function cmdServe(ctx) {
   };
   process.on('SIGINT', shutdown);
   process.on('SIGTERM', shutdown);
+
+  // 启动空闲看门狗（仅 --auto-exit 模式）；空回调避免依赖具体参数
+  if (autoExit) {
+    startPanelIdleGuard({ server, idleSec: ctx.idle });
+  }
 }
 
 // ---- 主入口 ----

package/src/runtime/server.js

@@ -50,10 +50,26 @@ async function serveStatic(pathname, res) {
   }
 }
 
-export function startServer({ port = DEFAULT_PORT, host = '127.0.0.1' } = {}) {
+// /api/ping：纯本机快返回，供面板心跳与「面板还开着吗」观测。
+// 不触网、不读盘、不查登录态——只为测「端口上还活着」。这与 /api/health 不同：
+// /api/health 走的是更重的鉴权/状态检查，不适合每 15s 一次的高频探活。
+async function handlePing(_req, res) {
+  sendJson(res, 200, { ok: true, data: { pong: true, ts: Date.now() } });
+}
+
+export function startServer({ port = DEFAULT_PORT, host = '127.0.0.1', onRequest } = {}) {
   const server = http.createServer(async (req, res) => {
+    // 活动观测：每个请求（包括 /api/ping 与静态文件）都回调一次；
+    // 回调只上报，不参与响应；异常必须吞掉以免影响主流程。
+    if (typeof onRequest === 'function') {
+      try { onRequest(req); } catch { /* ignore */ }
+    }
     try {
       const url = new URL(req.url, `http://${req.headers.host || 'localhost'}`);
+      if (url.pathname === '/api/ping') {
+        await handlePing(req, res);
+        return;
+      }
       if (url.pathname.startsWith('/api/')) {
         await handleApi(req, res, url);
         return;

package/src/web/frontend/App.jsx

@@ -4,6 +4,7 @@ import { Suspense, useEffect } from 'react';
 import { useStore } from './store.jsx';
 import { ErrorBoundary } from './components/ui.jsx';
 import { VIEWS } from './registry.js';
+import { api } from './api/client.js';
 
 function viewFromHash() {
   const h = (location.hash || '').replace(/^#\/?/, '');
@@ -31,6 +32,24 @@ export default function App() {
     return () => window.removeEventListener('hashchange', onHash);
   }, [patchUi]);
 
+  // 心跳：每 15s 打一次 /api/ping。
+  // 目的不是健康检查，而是给 serve --auto-exit 上报「面板还开着」。
+  // 单视图挂载（current.component）切到任意页面都算「开着」，
+  // 不用 SSE 数连接来判——切页会断 SSE，但页面明明还开着。
+  useEffect(() => {
+    let stopped = false;
+    const beat = () => {
+      if (stopped) return;
+      api('/api/ping').catch(() => {});
+    };
+    beat();
+    const t = setInterval(beat, 15_000);
+    return () => {
+      stopped = true;
+      clearInterval(t);
+    };
+  }, []);
+
   const current = VIEWS.find((v) => v.id === ui.view) || VIEWS[0];
 
   const switchTo = (id) => {