@weiping/wingline-core 0.1.0 → 0.1.1

package/dist/commands/deps.d.ts

@@ -17,6 +17,8 @@ export interface CommandDeps {
     monotonic: () => number;
 }
 export type Step = 'create' | 'wait' | 'brief' | 'send' | 'close';
+/** terminalSend 的提交等待秒数：launch / restore / send / notify 共用一份，别再各写一个 10。 */
+export declare const WAIT_SUBMIT_SEC = 10;
 export declare const postAddress: (post: string, team: string) => string;
 /**
  * 本地请求账本的键 `<team>:<post>:<step>:<hash8>`（`terminal` 命令族的 --retry-request 只认 Orca 分配的 UUID；编排命令族见 commands/task/ledger.ts）。

package/dist/commands/deps.js

@@ -1,5 +1,7 @@
 import { WinglineError } from '../errors.js';
 import { inRange } from './version-range.js';
+/** terminalSend 的提交等待秒数：launch / restore / send / notify 共用一份，别再各写一个 10。 */
+export const WAIT_SUBMIT_SEC = 10;
 export const postAddress = (post, team) => `${post}@${team}`;
 /**
  * 本地请求账本的键 `<team>:<post>:<step>:<hash8>`（`terminal` 命令族的 --retry-request 只认 Orca 分配的 UUID；编排命令族见 commands/task/ledger.ts）。

package/dist/commands/dispatcher/attention.d.ts

@@ -24,6 +24,8 @@ export interface AttentionReport {
     /** 需要人知道但不属于某个条目的提示：未应用的规格草稿、Orca 同步不可用等。 */
     warnings: string[];
 }
+/** 待办数的唯一口径：CLI `wl dispatcher status`、控制台顶栏与 TUI 都用它，别再各写一遍。 */
+export declare const pendingCount: (r: Pick<AttentionReport, "frozen" | "signals" | "questions" | "stale" | "warnings">) => number;
 /** spec 第 6.5 节：由规格文件、注册表与常量推导，条件成立期间一直显示。 */
 export declare function warningsOf(deps: CommandDeps, team: string, spec: TeamSpec | null): string[];
 /** spec 第 6.5 节：只读汇总；调度员没在跑也能用，取不到的来源显式列在 unavailable。 */

package/dist/commands/dispatcher/attention.js

@@ -8,6 +8,8 @@ import { gatherStaleInput, staleReasons } from '../task/query.js';
 import { dispatcherHealth } from './lifecycle.js';
 import { signalSummary } from './signal-summary.js';
 import { unreadGaveUp } from './unread.js';
+/** 待办数的唯一口径：CLI `wl dispatcher status`、控制台顶栏与 TUI 都用它，别再各写一遍。 */
+export const pendingCount = (r) => r.frozen.length + r.signals.length + r.questions.length + r.stale.length + r.warnings.length;
 const DAY_MS = 24 * 3_600_000;
 /** spec 第 6.5 节：由规格文件、注册表与常量推导，条件成立期间一直显示。 */
 export function warningsOf(deps, team, spec) {
@@ -44,8 +46,7 @@ function specOf(deps, team) {
     }
 }
 function lastCommand(deps, team, s) {
-    const events = deps.registry.listPatrolEvents(team, { limit: 500 });
-    const hit = events.findLast((e) => e.action === 'notify' && e.post === s.post && e.signal === s.signal && (e.taskId ?? '') === s.taskId);
+    const hit = deps.registry.lastNotifyEventOf(team, s.post, s.signal, s.taskId);
     const command = hit?.detail?.command;
     return command ?? null;
 }
@@ -94,9 +95,9 @@ function groupWarnings(events) {
 export async function dispatcherStatus(deps, team) {
     const { registry } = deps;
     const now = deps.now();
-    const events = registry.listPatrolEvents(team, { limit: 500 });
-    const last = (match) => {
-        const e = events.findLast((x) => match(x.action));
+    // 定点查询而非读最新 500 条：巡查事件保留 30 天、每 5 分钟写若干条，500 条窗口会把更早的 check/scan 挤出去
+    const lastOf = (actions) => {
+        const e = registry.lastPatrolEventOf(team, actions);
         return e ? { at: e.at, outcome: e.outcome ?? 'ok' } : null;
     };
     const report = await attention(deps, team);
@@ -104,11 +105,11 @@ export async function dispatcherStatus(deps, team) {
     return {
         team,
         health: report.dispatcher,
-        lastCheck: last((a) => a.startsWith('check_')),
-        lastScan: last((a) => a === 'scan' || a === 'scan_skipped'),
+        lastCheck: lastOf(['check_ok', 'check_failed']),
+        lastScan: lastOf(['scan', 'scan_skipped']),
         frozen: report.frozen.length,
         hushed: registry.listHushes(team).filter((h) => Date.parse(h.until) > now.getTime()).length,
-        attentionItems: report.frozen.length + report.signals.length + report.questions.length + report.stale.length,
-        warnings: groupWarnings(events.filter((e) => e.at >= since && WARNING_ACTIONS.has(e.action))),
+        attentionItems: pendingCount(report),
+        warnings: groupWarnings(registry.listPatrolEvents(team, { since, limit: 10_000 }).filter((e) => WARNING_ACTIONS.has(e.action))),
     };
 }

package/dist/commands/dispatcher/controls.d.ts

@@ -5,7 +5,7 @@ export declare function freezePostCmd(deps: CommandDeps, a: {
     address: string;
     reason: string;
 }): Promise<void>;
-/** 解冻：先重置巡查行与游标，最后删冻结行（中途崩溃仍是冻结状态，可重跑）。 */
+/** 解冻：先重置巡查行与游标，最后删冻结行（中途崩溃仍是冻结状态，可重跑）。团队以冻结行为准——巡查可能冻结的是没登记的终端（任务派去了陌生终端），knownPost 会把它判成 post_unknown，永远解不开。 */
 export declare function unfreezePostCmd(deps: CommandDeps, a: {
     address: string;
 }): Promise<{

package/dist/commands/dispatcher/controls.js

@@ -34,12 +34,14 @@ async function stillReady(deps, team, ids) {
         return new Set(ids);
     }
 }
-/** 解冻：先重置巡查行与游标，最后删冻结行（中途崩溃仍是冻结状态，可重跑）。 */
+/** 解冻：先重置巡查行与游标，最后删冻结行（中途崩溃仍是冻结状态，可重跑）。团队以冻结行为准——巡查可能冻结的是没登记的终端（任务派去了陌生终端），knownPost 会把它判成 post_unknown，永远解不开。 */
 export async function unfreezePostCmd(deps, a) {
-    const team = knownPost(deps, a.address);
     const frozen = deps.registry.getFrozen(a.address);
-    if (!frozen)
+    if (!frozen) {
+        knownPost(deps, a.address); // 没冻结：按原口径报 team_unknown / post_unknown
         throw new WinglineError('input', 'post_not_frozen', `岗位 ${a.address} 没有被冻结`);
+    }
+    const team = frozen.team;
     const at = deps.now().toISOString();
     deps.registry.resetPatrolForPost(a.address, at);
     deps.registry.setCursor(team, a.address, at);

package/dist/commands/dispatcher/loop.js

@@ -150,6 +150,8 @@ function maintain(deps, st) {
         deps.registry.prunePatrolEvents(new Date(now.getTime() - EVENT_KEEP_MS).toISOString());
         // 审计事件同保留 30 天（3A spec §6.4）；调度员循环 + wl log 各清理一次。
         pruneAuditBestEffort(deps, st.team.name, new Date(now.getTime() - EVENT_KEEP_MS).toISOString());
+        // 已结束状态同样只留 30 天：已清除的巡查行、已回答的提问、已定案的账本行，不清会一直涨
+        deps.registry.pruneFinishedState(new Date(now.getTime() - EVENT_KEEP_MS).toISOString());
         st.logDay = dayOf(now);
     }
     const target = mustTeamReady(deps, st.team.name);

package/dist/commands/launch.d.ts

@@ -7,7 +7,6 @@ export interface Launch {
     hash: string;
 }
 export declare const WAIT_TIMEOUT_MS = 60000;
-export declare const WAIT_SUBMIT_SEC = 10;
 /** 先记 pending，再调用，最后按结果记 done / uncertain / failed。ok 为 false 表示 Orca 回执未确认成功。 */
 export declare function recorded<T>(reg: Registry, id: string, fn: () => Promise<T>, ok?: (v: T) => boolean): Promise<{
     confirmed: boolean;

package/dist/commands/launch.js

@@ -1,9 +1,8 @@
 import crypto from 'node:crypto';
 import { WinglineError } from '../errors.js';
-import { postAddress, requestId } from './deps.js';
+import { postAddress, requestId, WAIT_SUBMIT_SEC } from './deps.js';
 import { screenGuard } from './task/notify.js';
 export const WAIT_TIMEOUT_MS = 60_000;
-export const WAIT_SUBMIT_SEC = 10;
 /** 先记 pending，再调用，最后按结果记 done / uncertain / failed。ok 为 false 表示 Orca 回执未确认成功。 */
 export async function recorded(reg, id, fn, ok = () => true) {
     reg.beginRequest(id);

package/dist/commands/restore/index.js

@@ -33,10 +33,16 @@ export async function restore(deps, a) {
         if (hash !== row.specHash) {
             throw new WinglineError('input', 'team_spec_changed', `团队 ${a.team} 的规格已变化`, { hint: `不支持在线修改编队，请先执行 wl down ${a.team}` });
         }
+        const seenSession = new Set();
         for (const [post, id] of Object.entries(a.sessions ?? {})) {
             if (!spec.posts.some((p) => p.id === post) || !SESSION_ID.test(id)) {
                 throw new WinglineError('input', 'session_override_invalid', `--session ${post}=${id} 无效：岗位不在团队里，或会话 ID 格式不符`);
             }
+            // 同一会话指定给两个岗位：后者会在运行期撞上 reserved，这里提前拒绝
+            if (seenSession.has(id)) {
+                throw new WinglineError('input', 'session_override_invalid', `--session ${post}=${id} 无效：会话 ${id} 已指定给另一个岗位`);
+            }
+            seenSession.add(id);
         }
         // 第 2、3 步：按 team.yaml 顺序，牵头岗最先（lead 先就绪，Run 才有认领人）
         const l = { deps, spec, hash };

package/dist/commands/restore/posts.d.ts

@@ -21,7 +21,7 @@ export interface RestorePost {
 /** restore 的请求键独立命名空间（复审 I-1）：与 wl up 的键不冲突，代数各自计数。 */
 export declare const restoreKey: (team: string, post: string, gen: number, step: "create" | "wait" | "notice") => string;
 /** 已完成的 restore create 中最大代数加 1；本代 create 尚未完成（中断重跑沿用原代）时不前进。终端仍活着（located）时调用方走 kept 或补完上一代（pendingResume），不会拉起新代。 */
-export declare function restoreGen(reg: Registry, team: string, post: string, _located: boolean): number;
+export declare function restoreGen(reg: Registry, team: string, post: string): number;
 /**
  * 远端岗位的接回提示带一个每次接回唯一的标识（`WLR-` 加 8 位十六进制，由该次接回的请求键哈希得到，重试时不变）。
  * 提示原文每次相同，原会话里可能早有旧的同样的提示；不带标识，丢了 `--resume` 的这一次会被旧提示误判为通过。

package/dist/commands/restore/posts.js

@@ -1,9 +1,9 @@
 import { createHash } from 'node:crypto';
 import { checkBriefingLimit } from '../../brief/render.js';
 import { WinglineError } from '../../errors.js';
-import { postAddress, requestId } from '../deps.js';
+import { postAddress, requestId, WAIT_SUBMIT_SEC } from '../deps.js';
 import { briefText } from '../up.js';
-import { ensureMarker, lifetimeGen, recorded, startPost, stepDone, WAIT_SUBMIT_SEC, WAIT_TIMEOUT_MS, withMarker, } from '../launch.js';
+import { ensureMarker, lifetimeGen, recorded, startPost, stepDone, WAIT_TIMEOUT_MS, withMarker, } from '../launch.js';
 import { locatePost } from '../locate.js';
 import { screenGuard } from '../task/notify.js';
 import { findSession, markerHighlighted } from './find-session.js';
@@ -11,7 +11,7 @@ import { resumeCommand, SESSION_ID } from './resume-command.js';
 /** restore 的请求键独立命名空间（复审 I-1）：与 wl up 的键不冲突，代数各自计数。 */
 export const restoreKey = (team, post, gen, step) => `restore:${team}:${post}:${gen}:${step}`;
 /** 已完成的 restore create 中最大代数加 1；本代 create 尚未完成（中断重跑沿用原代）时不前进。终端仍活着（located）时调用方走 kept 或补完上一代（pendingResume），不会拉起新代。 */
-export function restoreGen(reg, team, post, _located) {
+export function restoreGen(reg, team, post) {
     let g = 0;
     while (reg.getRequest(restoreKey(team, post, g, 'create'))?.state === 'done')
         g++;
@@ -81,7 +81,7 @@ async function landingResult(deps, address, sessionId, token, remote, retry) {
  * 返回要补完的会话 ID 与请求键；否则 null。会话 ID 没缓存、岗位已 live、句柄对不上都不算。
  */
 function pendingResume(reg, team, post, handle) {
-    const gen = restoreGen(reg, team, post, true) - 1;
+    const gen = restoreGen(reg, team, post) - 1;
     if (gen < 0)
         return null;
     const rid = (step) => restoreKey(team, post, gen, step);
@@ -131,18 +131,20 @@ export async function restorePost(l, post, o) {
     const retry = `wl restore ${l.spec.name}`;
     try {
         const located = await locatePost(orca, address);
-        if (located && located.connected) {
-            // 上次接回没走完（终端是 restore 拉起的、空闲等待或接回提示未定案）：补完它，而不是报 kept
+        if (located) {
+            // 上次接回没走完（终端是 restore 拉起或复用的、空闲等待或接回提示未定案）：补完它，而不是报 kept 或再开新代
             const pending = pendingResume(registry, l.spec.name, post.id, located.handle);
             if (pending && o.dryRun)
                 return { address, outcome: 'resumed', sessionId: pending.sessionId };
             if (pending)
                 return await settleResume(l, address, located.handle, pending.sessionId, pending.rid, retry, remote);
-            if (!o.dryRun) {
-                registry.setPostHandle(address, located.handle);
-                registry.setPostStatus(address, 'live');
+            if (located.connected) {
+                if (!o.dryRun) {
+                    registry.setPostHandle(address, located.handle);
+                    registry.setPostStatus(address, 'live');
+                }
+                return { address, outcome: 'kept' };
             }
-            return { address, outcome: 'kept' };
         }
         const row = registry.getPost(address);
         // path: 固定值直接用；选择器（阶段 3 之前的行）现解析一次
@@ -175,14 +177,12 @@ export async function restorePost(l, post, o) {
         if (sessionId !== null && command !== null) {
             if (o.dryRun)
                 return { address, outcome: 'resumed', sessionId };
-            const gen = restoreGen(registry, l.spec.name, post.id, located !== null);
+            const gen = restoreGen(registry, l.spec.name, post.id);
             const rid = (step) => restoreKey(l.spec.name, post.id, gen, step);
-            let handle = stepDone(registry, rid('create')) ? row.handle : null;
-            if (!handle) {
-                const created = await recorded(registry, rid('create'), () => orca.terminalCreate({ worktree: post.worktree, title: address, command }));
-                handle = created.value.handle;
-                registry.setPostHandle(address, handle);
-            }
+            // 终端还在（哪怕暂时断连）就复用它并同样记入 create 账本，避免把同一会话接进两个终端或下一代重用旧代数
+            const created = await recorded(registry, rid('create'), async () => located ? { handle: located.handle } : orca.terminalCreate({ worktree: post.worktree, title: address, command }));
+            const handle = created.value.handle;
+            registry.setPostHandle(address, handle);
             registry.setSessionId(address, sessionId);
             return await settleResume(l, address, handle, sessionId, rid, retry, remote);
         }

package/dist/commands/restore/resume-command.d.ts

@@ -1,5 +1,4 @@
 /** 会话 ID 形如 Orca 分配的 UUID / 内部 ID：字母、数字、连字符之外的字符一律拒绝。 */
 export declare const SESSION_ID: RegExp;
-export declare function supportsResume(agent: string): boolean;
 /** 拼出该 agent 的接回命令；不支持接回的 agent 返回 null（调用方走 fresh）。 */
 export declare function resumeCommand(agent: string, launch: string, sessionId: string): string | null;

package/dist/commands/restore/resume-command.js

@@ -5,9 +5,6 @@ export const SESSION_ID = /^[A-Za-z0-9-]+$/;
 const RESUME_TEMPLATES = {
     claude: (launch, sessionId) => `${launch} --resume ${sessionId}`,
 };
-export function supportsResume(agent) {
-    return agent in RESUME_TEMPLATES;
-}
 /** 拼出该 agent 的接回命令；不支持接回的 agent 返回 null（调用方走 fresh）。 */
 export function resumeCommand(agent, launch, sessionId) {
     if (!SESSION_ID.test(sessionId)) {

package/dist/commands/send.js

@@ -1,9 +1,8 @@
 import { createHash } from 'node:crypto';
 import { WinglineError } from '../errors.js';
-import { nextRequestId, preflight } from './deps.js';
+import { nextRequestId, preflight, WAIT_SUBMIT_SEC } from './deps.js';
 import { locatePost } from './locate.js';
 const MAX_MESSAGE = 4000;
-const WAIT_SUBMIT_SEC = 10;
 function checkMessage(deps, message) {
     if (message.length > MAX_MESSAGE) {
         throw new WinglineError('input', 'message_too_long', `消息 ${message.length} 字符，超过上限 ${MAX_MESSAGE}`);

package/dist/commands/task/gate-exec.d.ts

@@ -1,12 +1,16 @@
 import type { CommandDeps } from '../deps.js';
 export interface GateExecResult {
     passed: boolean;
-    /** 完整输出（不截断）。 */
+    /** 输出正文；超过 GATE_OUTPUT_LIMIT_BYTES 时只留尾部，并在末尾标明被截断。 */
     output: string;
     timedOut: boolean;
     /** 被 Ctrl-C / SIGTERM 中断（不计为 gate 失败）。 */
     interrupted?: boolean;
+    /** 输出超过上限，gate 被终止并计为失败。 */
+    overflowed?: boolean;
 }
+/** 输出只保留尾部这么多字节：`yes`、`tail -f` 这类跑飞的 gate 不能把内存吃光。 */
+export declare const GATE_OUTPUT_LIMIT_BYTES: number;
 export declare function runGate(command: string | null, opts: {
     cwd: string;
     timeoutMs: number;

package/dist/commands/task/gate-exec.js

@@ -2,9 +2,12 @@ import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { WinglineError } from '../../errors.js';
+/** 输出只保留尾部这么多字节：`yes`、`tail -f` 这类跑飞的 gate 不能把内存吃光。 */
+export const GATE_OUTPUT_LIMIT_BYTES = 8 * 1024 * 1024;
 const TIMEOUT_MARK = '\n（gate 超时，已终止）';
+const OVERFLOW_MARK = `\n（gate 输出超过 ${GATE_OUTPUT_LIMIT_BYTES / 1024 / 1024} MB，已终止，只保留尾部）`;
 const WEEK_MS = 7 * 24 * 60 * 60 * 1000;
-/** 超时要杀整棵进程树：POSIX 杀进程组，Windows 用 taskkill /T。 */
+/** 超时、输出超限都要杀整棵进程树：POSIX 杀进程组，Windows 用 taskkill /T。 */
 function killTree(pid) {
     try {
         if (process.platform === 'win32') {
@@ -26,8 +29,10 @@ function spawnGate(command, opts) {
         // gate 是用户在 team.yaml 里写的完整 shell 命令行，必须经 shell 解释（2A spec 第 3 节约束 6，总纲 §2.4）；全项目只此一处。
         const child = spawn(command, { shell: true, cwd: opts.cwd, detached: process.platform !== 'win32', windowsHide: true });
         const chunks = [];
+        let kept = 0;
         let timedOut = false;
         let interrupted = false;
+        let overflowed = false;
         // 运行期间 Ctrl-C / SIGTERM：把 gate 的整个进程组一起杀掉，不留孤儿
         const onSignal = () => {
             interrupted = true;
@@ -42,16 +47,35 @@ function spawnGate(command, opts) {
             SIGNALS.forEach((s) => process.off(s, onSignal));
         };
         SIGNALS.forEach((s) => process.on(s, onSignal));
-        child.stdout.on('data', (d) => chunks.push(d));
-        child.stderr.on('data', (d) => chunks.push(d));
+        /** 只留尾部：超过上限就丢最前面的块，并终止 gate（整份输出既没必要也存不住）。 */
+        const collect = (d) => {
+            chunks.push(d);
+            kept += d.length;
+            if (kept <= GATE_OUTPUT_LIMIT_BYTES)
+                return;
+            if (!overflowed) {
+                overflowed = true;
+                killTree(child.pid);
+            }
+            while (chunks.length > 1 && kept > GATE_OUTPUT_LIMIT_BYTES)
+                kept -= chunks.shift().length;
+        };
+        child.stdout.on('data', collect);
+        child.stderr.on('data', collect);
         child.on('error', (err) => {
             cleanup();
             resolve({ passed: false, output: `无法启动 gate：${err.message}`, timedOut: false });
         });
         child.on('close', (code) => {
             cleanup();
-            const output = Buffer.concat(chunks).toString('utf8') + (timedOut ? TIMEOUT_MARK : '');
-            resolve({ passed: code === 0 && !timedOut && !interrupted, output, timedOut, ...(interrupted ? { interrupted } : {}) });
+            const output = Buffer.concat(chunks).toString('utf8') + (timedOut ? TIMEOUT_MARK : '') + (overflowed ? OVERFLOW_MARK : '');
+            resolve({
+                passed: code === 0 && !timedOut && !interrupted && !overflowed,
+                output,
+                timedOut,
+                ...(interrupted ? { interrupted } : {}),
+                ...(overflowed ? { overflowed } : {}),
+            });
         });
     });
 }

package/dist/commands/task/notify.d.ts

@@ -1,4 +1,4 @@
-import type { CommandDeps } from '../deps.js';
+import { type CommandDeps } from '../deps.js';
 export type ScreenState = 'clear' | 'at_prompt' | 'shell' | 'unknown';
 /** 逐条对应 spec 第 7.4 节：agent 或包装器正停在需要人确认的画面上。 */
 export declare const PROMPT_PATTERNS: readonly RegExp[];

package/dist/commands/task/notify.js

@@ -1,4 +1,5 @@
 import { WinglineError } from '../../errors.js';
+import { WAIT_SUBMIT_SEC } from '../deps.js';
 import { locatePost } from '../locate.js';
 /** 逐条对应 spec 第 7.4 节：agent 或包装器正停在需要人确认的画面上。 */
 export const PROMPT_PATTERNS = [
@@ -19,7 +20,6 @@ export const PROMPT_PATTERNS = [
 /** 终端已退回 shell：在那里打字会执行命令。只看最后一个非空行。 */
 const SHELL_PROMPT = /(?:(?:[$#]|(?<!\d)%)\s*$)|(?:^PS .*>\s*$)|(?:^[A-Za-z]:\\.*>\s*$)/;
 export const SCREEN_TAIL_LINES = 8;
-const WAIT_SUBMIT_SEC = 10;
 /** 纯函数：取 preview 最后 8 行，任一行命中 PROMPT_PATTERNS → at_prompt；否则最后一个非空行像 shell 提示符 → shell；空 → unknown；其余 clear。 */
 export function classifyPreview(preview) {
     const lines = preview.split('\n');

package/dist/commands/task/query.d.ts

@@ -56,6 +56,8 @@ export declare function showTask(deps: CommandDeps, a: {
     history?: boolean;
 }): Promise<ShownTask>;
 export type StaleReason = 'done_unfinished' | 'call_uncertain' | 'dead_assignee' | 'owner_idle' | 'bypassed' | 'blocked_waiting';
+/** 卡住原因的短标签：TUI 与文档共用（控制台前端只 import type，标签在 web/src/labels.ts 另放一份）。 */
+export declare const STALE_REASON_LABEL: Record<StaleReason, string>;
 export interface StaleItem {
     taskId: string;
     title: string;

package/dist/commands/task/query.js

@@ -116,6 +116,15 @@ export async function showTask(deps, a) {
         ...(a.history ? { history: deps.registry.listTaskLog(a.id) } : {}),
     };
 }
+/** 卡住原因的短标签：TUI 与文档共用（控制台前端只 import type，标签在 web/src/labels.ts 另放一份）。 */
+export const STALE_REASON_LABEL = {
+    done_unfinished: '已完成但未收尾',
+    call_uncertain: '调用结果不确定',
+    dead_assignee: '派发失主',
+    owner_idle: '主人迟迟未开始',
+    bypassed: '绕过闸门上报',
+    blocked_waiting: '等待决策',
+};
 export const DEFAULT_STALE = { ownerIdleMinutes: 30, uncertainMinutes: 1 };
 const MINUTE_MS = 60_000;
 const as = (owner) => owner ?? '<主人>';
@@ -130,7 +139,7 @@ function doneUnfinished(x) {
     });
 }
 /** 账本键 → 任务与重跑命令；oneshot:* 不归任何任务。 */
-function commandOfKey(x, key, t) {
+function commandOfKey(key, t) {
     const [kind] = key.split(':');
     if (kind === 'dispatch')
         return `wl task start ${t.id} --as ${as(t.claimedBy)}`;
@@ -178,7 +187,7 @@ function callUncertain(x, now, th) {
             return [];
         if (task && epochOfKey(r.id) < task.epoch)
             return [];
-        const command = task ? commandOfKey(x, r.id, task) : null;
+        const command = task ? commandOfKey(r.id, task) : null;
         return task && command ? [item(task, 'call_uncertain', r.updatedAt, command)] : [];
     });
 }

package/dist/registry/registry.d.ts

@@ -101,6 +101,8 @@ export interface PatrolStateRow {
     detail?: Record<string, unknown> | null;
 }
 export interface FrozenRow {
+    /** 冻结行自带的团队名：被冻结的可以是没登记的终端，所以别从地址里反推。 */
+    team: string;
     post: string;
     reason: string;
     signal: string | null;
@@ -283,6 +285,11 @@ export declare class Registry {
         id: number;
         at: string;
     }) | null;
+    /** 该信号主体最近一次 notify 事件（不受巡查事件保留窗口影响）；task_id 为 NULL 的主体与空串比较。 */
+    lastNotifyEventOf(team: string, post: string, signal: string, taskId: string): (PatrolEvent & {
+        id: number;
+        at: string;
+    }) | null;
     appendAudit(r: Omit<AuditRow, 'id' | 'at' | 'detail'> & {
         at?: string;
         detail?: unknown;
@@ -322,6 +329,12 @@ export declare class Registry {
     /** team 是否写过 actions 之一的事件。 */
     hasPatrolEventOf(team: string, actions: readonly string[]): boolean;
     prunePatrolEvents(before: string): number;
+    /**
+     * 已结束状态的日常清理：已清除的巡查行、已回答的提问、已定案且过保留期的任务账本行。
+     * 不动：pending/uncertain 行（可能还在重放）、代数键（restore:*、<team>:<post>:*，删了会让代数从头数起）、
+     * done:*:delivered:* 交付行（解冻时按冻结时间点数被跳过的任务）。
+     */
+    pruneFinishedState(before: string): void;
     /** finished_at > after（null 表示不限）的已完成判定，按 finished_at 升序。 */
     listFinishedVerdictsAfter(post: string, after: string | null): DoneVerdictRow[];
     /** 2A done 写下的交付记录（requests 里 done:%:delivered:<target> 且 done 的行）。 */

package/dist/registry/registry.js

@@ -74,7 +74,7 @@ const patrolRow = (r) => ({
     detail: r.detail === null || r.detail === undefined ? null : JSON.parse(r.detail),
 });
 const frozenRow = (r) => ({
-    post: r.post, reason: r.reason, signal: r.signal, frozenAt: r.frozen_at,
+    team: r.team, post: r.post, reason: r.reason, signal: r.signal, frozenAt: r.frozen_at,
 });
 const questionRow = (r) => ({
     team: r.team,
@@ -466,7 +466,9 @@ export class Registry {
     }
     /** unfreeze 用：该岗位所有巡查行回到 level 0 并标记已清除（spec 第 7 节）。画面信号的行不动：解冻不该清掉用量暂停，也不该在提示仍留屏时让它重新通知一次。 */
     resetPatrolForPost(post, at) {
-        this.db.prepare("UPDATE patrol_state SET level = 0, cleared_at = ?, last_nudged_at = NULL WHERE post = ? AND signal NOT IN ('context_low', 'usage_limit')").run(at, post);
+        this.db
+            .prepare("UPDATE patrol_state SET level = 0, cleared_at = ?, last_nudged_at = NULL, notify_count = 0, next_due_at = NULL WHERE post = ? AND signal NOT IN ('context_low', 'usage_limit')")
+            .run(at, post);
     }
     freezePost(a) {
         this.db
@@ -552,6 +554,13 @@ export class Registry {
         const r = this.db.prepare(`SELECT * FROM patrol_events WHERE team = ? AND action IN (${marks}) ORDER BY id DESC LIMIT 1`).get(team, ...actions);
         return r ? eventRow(r) : null;
     }
+    /** 该信号主体最近一次 notify 事件（不受巡查事件保留窗口影响）；task_id 为 NULL 的主体与空串比较。 */
+    lastNotifyEventOf(team, post, signal, taskId) {
+        const r = this.db
+            .prepare("SELECT * FROM patrol_events WHERE team = ? AND action = 'notify' AND post = ? AND signal = ? AND COALESCE(task_id, '') = ? ORDER BY id DESC LIMIT 1")
+            .get(team, post, signal, taskId);
+        return r ? eventRow(r) : null;
+    }
     // —— 阶段 3A：审计事件、团队任务日志、时间线游标 ——
     // 三者共用 pageRows 的分页语义：id 升序；不带 afterId 取最新 limit 条；带 afterId 取游标之后最早的 limit 条。
     appendAudit(r) {
@@ -627,6 +636,18 @@ export class Registry {
     prunePatrolEvents(before) {
         return Number(this.db.prepare('DELETE FROM patrol_events WHERE at < ?').run(before).changes);
     }
+    /**
+     * 已结束状态的日常清理：已清除的巡查行、已回答的提问、已定案且过保留期的任务账本行。
+     * 不动：pending/uncertain 行（可能还在重放）、代数键（restore:*、<team>:<post>:*，删了会让代数从头数起）、
+     * done:*:delivered:* 交付行（解冻时按冻结时间点数被跳过的任务）。
+     */
+    pruneFinishedState(before) {
+        this.db.prepare('DELETE FROM patrol_state WHERE cleared_at IS NOT NULL AND cleared_at < ?').run(before);
+        this.db.prepare('DELETE FROM questions WHERE answered_at IS NOT NULL AND answered_at < ?').run(before);
+        this.db.prepare(`DELETE FROM requests WHERE state = 'done' AND updated_at < ?
+       AND (id LIKE 'dispatch:%' OR id LIKE 'recover:%' OR id LIKE 'resolve:%' OR id LIKE 'oneshot:%'
+            OR (id LIKE 'done:%' AND id NOT LIKE 'done:%:delivered:%'))`).run(before);
+    }
     /** finished_at > after（null 表示不限）的已完成判定，按 finished_at 升序。 */
     listFinishedVerdictsAfter(post, after) {
         const sql = 'SELECT * FROM task_done WHERE post = ? AND finished_at IS NOT NULL AND finished_at > ? ORDER BY finished_at, task_id';

package/dist/server/api-read.js

@@ -1,7 +1,8 @@
 import { checkParam } from './http.js';
+import { WinglineError } from '../errors.js';
 import { ps } from '../commands/ps.js';
 import { dispatcherHealth } from '../commands/dispatcher/lifecycle.js';
-import { attention, dispatcherStatus } from '../commands/dispatcher/attention.js';
+import { attention, dispatcherStatus, pendingCount } from '../commands/dispatcher/attention.js';
 import { signalSummary } from '../commands/dispatcher/signal-summary.js';
 import { listTasks, showTask } from '../commands/task/query.js';
 import { listStale } from '../commands/task/query.js';
@@ -12,17 +13,11 @@ async function teamSummary(ctx, name) {
     const posts = await ps(ctx.deps, { team: name });
     const disp = dispatcherHealth(ctx.deps, name).state;
     const att = await attention(ctx.deps, name);
-    const attentionCount = (disp === 'stale' ? 1 : 0) +
-        att.frozen.length +
-        att.signals.length +
-        att.questions.length +
-        att.stale.length +
-        att.warnings.length;
     return {
         name,
         postsCount: posts.length,
         dispatcher: disp,
-        attentionCount,
+        attentionCount: pendingCount(att),
     };
 }
 function registerTeamRoutes(r) {
@@ -140,7 +135,7 @@ function registerPostRoutes(r) {
         const posts = await ps(ctx.deps, { team });
         const pRow = posts.find((p) => p.address === address);
         if (!pRow) {
-            throw new (await import('../errors.js')).WinglineError('input', 'invalid_param', `岗位 ${address} 不存在`);
+            throw new WinglineError('input', 'invalid_param', `岗位 ${address} 不存在`);
         }
         return await buildPostDetail(ctx, team, address, pRow);
     });
@@ -154,8 +149,15 @@ function registerLogRoute(r) {
         const post = ctx.query.get('post') ?? undefined;
         const since = ctx.query.get('since') ?? undefined;
         const source = ctx.query.get('source') ?? undefined;
+        // 与 wl log 的 --limit 同一口径：非正整数按用法错报，而不是 NaN 静默读空
         const limitStr = ctx.query.get('limit');
-        const limit = limitStr ? parseInt(limitStr, 10) : undefined;
+        let limit;
+        if (limitStr !== null) {
+            limit = Number(limitStr);
+            if (!(Number.isInteger(limit) && limit >= 1)) {
+                throw new WinglineError('input', 'limit_invalid', `limit ${limitStr} 无效：应为正整数`);
+            }
+        }
         return await readTimeline(ctx.deps, { team, task, post, since, source, limit });
     });
 }

package/dist/server/index.js

@@ -183,7 +183,15 @@ async function handleSse(req, res, team, sess, feeds, sseClients, warn) {
             sseClients.delete(res);
         });
         const lastEventId = req.headers['last-event-id'];
-        unsub = await feeds.subscribe(team, (chunk) => res.write(chunk), lastEventId);
+        // 背压：对端不读时 res.write 返回 false，继续写会把事件无限堆在内存里——直接断开；
+        // EventSource 会带 Last-Event-ID 自动重连，从断点补回，不丢事件。
+        const write = (chunk) => {
+            if (res.write(chunk))
+                return;
+            unsub?.();
+            res.destroy();
+        };
+        unsub = await feeds.subscribe(team, write, lastEventId);
         if (closed || req.destroyed || res.destroyed) {
             unsub();
             sseClients.delete(res);
@@ -196,7 +204,7 @@ async function handleSse(req, res, team, sess, feeds, sseClients, warn) {
         });
         res.flushHeaders();
         sseClients.add(res);
-        feeds.replaySnapshot(team, (chunk) => res.write(chunk));
+        feeds.replaySnapshot(team, write);
     }
     catch (err) {
         respondError(res, err, warn, `GET /api/teams/${team}/events`);

package/dist/server/sse.js

@@ -1,7 +1,7 @@
 import crypto from 'node:crypto';
 import { currentCursor, readTimelineAfter } from '../commands/log.js';
 import { ps } from '../commands/ps.js';
-import { attention } from '../commands/dispatcher/attention.js';
+import { attention, pendingCount } from '../commands/dispatcher/attention.js';
 import { dispatcherHealth } from '../commands/dispatcher/lifecycle.js';
 export function cursorFrom(lastEventId, start) {
     if (!lastEventId)
@@ -49,6 +49,8 @@ export class TeamFeeds {
                 pingTimer: null,
                 lastSnapshotHash: null,
                 lastSnapshot: null,
+                timelineBusy: false,
+                snapshotBusy: false,
             };
             this.loops.set(team, loop);
             this.startLoop(team, loop);
@@ -78,11 +80,27 @@ export class TeamFeeds {
     startLoop(team, loop) {
         // 1. timeline loop (2s)
         loop.timelineTimer = this.setTimer(async () => {
-            await this.tickTimeline(team, loop);
+            if (loop.timelineBusy)
+                return;
+            loop.timelineBusy = true;
+            try {
+                await this.tickTimeline(team, loop);
+            }
+            finally {
+                loop.timelineBusy = false;
+            }
         }, this.timelineMs);
         // 2. snapshot loop (5s)
         loop.snapshotTimer = this.setTimer(async () => {
-            await this.tickSnapshot(team, loop);
+            if (loop.snapshotBusy)
+                return;
+            loop.snapshotBusy = true;
+            try {
+                await this.tickSnapshot(team, loop);
+            }
+            finally {
+                loop.snapshotBusy = false;
+            }
         }, this.snapshotMs);
         // 3. ping loop (15s)
         loop.pingTimer = this.setTimer(() => {
@@ -118,13 +136,7 @@ export class TeamFeeds {
                 team,
                 posts,
                 dispatcher: disp,
-                attentionCounts: {
-                    frozen: att.frozen.length,
-                    signals: att.signals.length,
-                    questions: att.questions.length,
-                    stale: att.stale.length,
-                    warnings: att.warnings.length,
-                },
+                attention: pendingCount(att),
             };
             const serialized = JSON.stringify(data);
             const hash = crypto.createHash('sha256').update(serialized).digest('hex');

package/dist/spec/plan-change.js

@@ -18,10 +18,11 @@ function snakeKeys(v) {
         return v;
     return Object.fromEntries(Object.entries(v).map(([k, x]) => [snake(k), snakeKeys(x)]));
 }
-/** 把 TeamSpec 还原成 YAML 里的字段形态，供按字段比较。 */
+/** 把 TeamSpec 还原成 YAML 里的字段形态，供按字段比较。岗位级字段（plan_first / self_claim / tags）也进哈希，预演必须同样列出。 */
 function fieldView(s) {
     const links = {};
     const gates = {};
+    const posts = {};
     for (const p of s.posts) {
         const l = { reviewed_by: p.reviewedBy, hands_to: p.handsTo, consults: p.consults ?? [] };
         const filled = Object.fromEntries(Object.entries(l).filter(([, v]) => v.length > 0));
@@ -29,8 +30,9 @@ function fieldView(s) {
             links[p.id] = filled;
         if (p.gate)
             gates[p.id] = p.gate;
+        posts[p.id] = { plan_first: p.planFirst, self_claim: p.selfClaim, tags: p.tags };
     }
-    return { lead: s.lead, links, gates, budgets: snakeKeys(s.budgets), patrol: snakeKeys(s.patrol) };
+    return { lead: s.lead, links, gates, budgets: snakeKeys(s.budgets), patrol: snakeKeys(s.patrol), posts };
 }
 function flatten(v, prefix, out) {
     if (v && typeof v === 'object' && !Array.isArray(v) && Object.keys(v).length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@weiping/wingline-core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Wingline 核心：在 Orca 之上运行常驻 agent 团队的引擎（注册表、编排、巡查、恢复）",
   "license": "MIT",
   "type": "module",