@weiping/wingline 0.0.0-stage → 0.1.0

package/dist/console.js

@@ -0,0 +1,136 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { WinglineError, commandLine, consoleWorktree, createConsoleServer, nodeOnPath, openTab, pidAlive, readConsoleFile, removeConsoleFileIfMine, requestLink, selfCommand, writeConsoleFile, } from '@weiping/wingline-core';
+/** 构建后前端位于 dist/web，与本文件编译出的 dist/console.js 同级。 */
+const WEB_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), 'web');
+/** 与 cli.ts 读的是同一份：/api/session 回给前端的版本号。 */
+const PACKAGE_VERSION = JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version;
+const SIGNALS = ['SIGINT', 'SIGTERM', 'SIGHUP'];
+/** 新起服务的就绪确认：每 200ms 轮询一次 console.json，最多 10 秒。 */
+const READY_POLL_MS = 200;
+const READY_CONFIRM_MS = 10_000;
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** 已在运行的服务：pid 存活且能拿到新登录链接；否则视为没有服务（spec 4.1）。 */
+async function liveServer(home) {
+    const f = readConsoleFile(home);
+    if (!f || !pidAlive(f.pid))
+        return null;
+    const link = await requestLink(f);
+    return link ? { port: f.port, link } : null;
+}
+/** 在 Orca 里起的控制台终端要能重新执行本 CLI：POSIX 用单引号，Windows 用双引号 + PATH 上的 node。 */
+function launchLine(deps) {
+    return commandLine(selfCommand({
+        platform: process.platform,
+        node: process.execPath,
+        script: process.argv[1] ?? '',
+        args: ['console'],
+        home: deps.home,
+        orca: deps.orcaPath,
+        nodeOnPath: process.platform === 'win32' ? nodeOnPath(deps) : undefined,
+    }), process.platform);
+}
+/** --open 且没有服务：在 Orca 里新开 console@wingline 终端，轮询 console.json 直到服务可连（默认最多 10 秒）。 */
+async function startInOrca(deps, a) {
+    const worktree = consoleWorktree(deps, a.worktree);
+    await deps.orca.terminalCreate({ worktree, title: 'console@wingline', command: launchLine(deps) });
+    const confirmMs = a.confirmMs ?? READY_CONFIRM_MS;
+    const nap = a.sleep ?? sleep;
+    // 轮次计数给测试一条快路，墙钟兜住真实上界：某次 poll+sleep 变慢（慢盘、忙机器）时不会把 10 秒拖成 50 秒。
+    const deadline = Date.now() + confirmMs;
+    for (let waited = 0; waited < confirmMs && Date.now() < deadline; waited += READY_POLL_MS) {
+        const live = await liveServer(deps.home);
+        if (live)
+            return live.link;
+        await nap(READY_POLL_MS);
+    }
+    throw new WinglineError('uncertain', 'console_start_unconfirmed', `已在 Orca 中启动控制台，但 ${confirmMs / 1000} 秒内没有就绪`, {
+        hint: '到 console@wingline 终端里查看输出',
+    });
+}
+/**
+ * 先关服务、再删 console.json（关闭失败也删）：另一个 wl 进程读到文件时服务一定还能连上，
+ * 不会读到指向已关闭服务的文件（复审 I-3 的残余窗口）。
+ */
+export async function stopServer(srv, cleanup) {
+    try {
+        await srv.close();
+    }
+    finally {
+        cleanup();
+    }
+}
+/** 前台运行：起服务、写 console.json，阻塞到收到 SIGINT/SIGTERM/SIGHUP 后关闭并删除自己的 console.json。 */
+async function foreground(deps, a) {
+    const srv = await createConsoleServer(deps, {
+        port: a.port, webRoot: a.webRoot ?? WEB_ROOT, version: PACKAGE_VERSION,
+    }).catch((err) => {
+        if (err.code === 'EADDRINUSE') {
+            throw new WinglineError('input', 'console_port_in_use', `端口 ${a.port} 已被占用`, { hint: '用 --port 换一个端口' });
+        }
+        throw err;
+    });
+    try {
+        writeConsoleFile(deps.home, { pid: process.pid, port: srv.port, startedAt: new Date().toISOString(), controlKey: srv.controlKey });
+    }
+    catch (err) {
+        // 写不进去只影响“别的 wl 进程找到这个服务”（--link / --open 复用），服务本身照常运行
+        deps.warn(`写 console.json 失败，其他 wl 进程将找不到这个控制台：${err instanceof Error ? err.message : String(err)}`);
+    }
+    const ready = { outcome: 'started', url: srv.loginUrl(), port: srv.port };
+    a.onReady?.(ready);
+    await new Promise((resolve) => {
+        const stop = () => {
+            for (const s of SIGNALS)
+                process.off(s, stop);
+            void stopServer(srv, () => removeConsoleFileIfMine(deps.home, process.pid)).then(resolve, resolve);
+        };
+        for (const s of SIGNALS)
+            process.on(s, stop);
+    });
+    return ready;
+}
+export async function consoleCmd(deps, a) {
+    const live = await liveServer(deps.home);
+    if (a.link) {
+        if (!live)
+            throw new WinglineError('input', 'console_not_running', '控制台没有在运行', { hint: '运行 wl console --open 启动并打开' });
+        return { outcome: 'link', url: live.link, port: live.port };
+    }
+    if (a.open) {
+        const url = live?.link ?? (await startInOrca(deps, a));
+        let worktree;
+        try {
+            worktree = consoleWorktree(deps, a.worktree);
+        }
+        catch (err) {
+            if (err instanceof WinglineError && err.code === 'console_no_worktree') {
+                return { outcome: 'opened', url, tab: 'unsupported', tabReason: 'worktree' };
+            }
+            throw err;
+        }
+        const tab = await openTab(deps, url, worktree);
+        return { outcome: 'opened', url, tab };
+    }
+    if (live)
+        return { outcome: 'link', url: live.link, port: live.port };
+    return foreground(deps, a);
+}
+/** 启动就绪时打印（前台服务还在跑）。 */
+export function renderReady(r) {
+    return `控制台服务已启动（端口 ${r.port}）\n登录链接：${r.url}\n`;
+}
+/** 最终结果（服务停止后，或其他三种结果）。 */
+export function renderConsole(r) {
+    if (r.outcome === 'started')
+        return '控制台服务已停止\n';
+    if (r.outcome === 'link')
+        return `控制台登录链接：${r.url}\n`;
+    if (r.tab === 'opened')
+        return `已在 Orca 中打开控制台：${r.url}\n`;
+    if (r.tabReason === 'worktree') {
+        return `控制台链接：${r.url}\n提示：没有运行中的团队，无法确定工作区（console_no_worktree），请运行 wl up 或用 --worktree 指定，也可直接在浏览器打开链接\n`;
+    }
+    return `控制台链接：${r.url}\n提示：当前 Orca 不支持在内置浏览器中打开标签页（console_tab_unsupported），请在浏览器中打开上面的链接\n`;
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/main.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// 警告过滤必须先于 node:sqlite 的加载，所以 cli.js 用动态导入。
+process.removeAllListeners('warning');
+process.on('warning', (w) => {
+    if (w.name === 'ExperimentalWarning' && w.message.includes('SQLite'))
+        return;
+    process.stderr.write(`(${w.name}) ${w.message}\n`);
+});
+const { run } = await import('./cli.js');
+process.exitCode = await run(process.argv.slice(2), { stdout: process.stdout, stderr: process.stderr, env: process.env, stdin: process.stdin });
+export {};

package/dist/output.d.ts

@@ -0,0 +1,80 @@
+import { type DoneResult, type DownResult, type PsRow, type RestoreAllResult, type RestoreResult, type SendResultRow, type ShownTask, type StaleItem, type TaskRow, type TimelineEvent, type UpResult, type AttentionReport, type DispatcherHealth, type DispatcherStatus, type createTask, type escalateTask, type reassignTask, type recoverTask, type resolveGate, type startTask } from '@weiping/wingline-core';
+/** 调度员状态的一行文字；从未启动过（never）返回 null，调用方据此不显示。 */
+export declare function dispatcherLine(h: DispatcherHealth): string | null;
+export declare function renderPs(rows: PsRow[]): string;
+export declare function renderUp(r: UpResult, opts?: {
+    newRun?: boolean;
+}): string;
+export declare function renderSend(r: SendResultRow): string;
+export declare function renderDown(r: DownResult): string;
+export interface ErrorDoc {
+    kind: string;
+    code: string;
+    message: string;
+    hint?: string;
+    detail?: unknown;
+}
+export declare function errorDoc(err: unknown): ErrorDoc;
+export declare function renderError(doc: ErrorDoc): string;
+type Awaited2<F extends (...a: never[]) => Promise<unknown>> = Awaited<ReturnType<F>>;
+export declare function renderCreate(r: Awaited2<typeof createTask>, post: string | undefined): string;
+export declare function renderList(rows: TaskRow[]): string;
+export declare function renderStale(items: StaleItem[]): string;
+export declare function closureLine(c: NonNullable<DoneResult['closure']>): string;
+export declare function renderShow(t: ShownTask): string;
+export declare function renderReassign(r: Awaited2<typeof reassignTask>, id: string, to: string): string;
+export declare function renderStart(r: Awaited2<typeof startTask>, id: string, as: string | undefined): string;
+export declare function renderDone(r: DoneResult): string;
+export declare function renderEscalate(r: Awaited2<typeof escalateTask>): string;
+export declare function renderResolve(r: Awaited2<typeof resolveGate>): string;
+export declare function renderRecover(r: Awaited2<typeof recoverTask>, id: string): string;
+export declare function renderDispatcherUp(r: {
+    address: string;
+    outcome: 'already_running' | 'started';
+    handle?: string;
+}): string;
+export declare function renderDispatcherDown(r: {
+    address: string;
+    outcome: 'noop' | 'closed' | 'already_gone';
+}): string;
+export declare function renderDispatcherStatus(s: DispatcherStatus): string;
+export declare function renderUnfreeze(r: {
+    skipped: Array<{
+        taskId: string;
+        command: string;
+    }>;
+}, address: string): string;
+/** spec 第 6.5 节的分节顺序；调度员失联时放最前。 */
+export declare function renderAttention(r: AttentionReport): string;
+export declare function renderRestore(r: RestoreResult): string;
+export declare function renderRestoreAll(r: RestoreAllResult): string;
+export declare function renderAutostartInstall(r: {
+    platform: string;
+    file: string;
+    command: string[];
+    logPath: string;
+    waitOrca: string;
+}): string;
+export declare function renderAutostartUninstall(r: {
+    file: string;
+    removed: boolean;
+}): string;
+export declare function renderAutostartStatus(r: {
+    installed: boolean;
+    platform: string;
+    user?: string;
+    location: string;
+    command: string[];
+    commandMissing: string[];
+    logTail: string[];
+    linger?: boolean;
+    logPath: string;
+}): string;
+export declare function renderTimelineEvent(e: TimelineEvent): string;
+/**
+ * 跨天插一行日期；返回逐条打印的函数，`--follow` 与一次性输出共用同一套格式，
+ * 这样 follow 出来的样子和 `wl log` 一样。
+ */
+export declare function logPrinter(): (e: TimelineEvent) => string;
+export declare const renderLog: (events: TimelineEvent[]) => string;
+export {};

package/dist/output.js

@@ -0,0 +1,335 @@
+import { WinglineError, } from '@weiping/wingline-core';
+const UP_LABEL = { already_live: '已在岗', launched: '已拉起', failed: '失败', uncertain: '不确定' };
+const RUN_LABEL = {
+    created: '已新建', adopted: '已找回', kept: '协调者保持不变', reclaimed: '已重新认领', deferred: '本轮跳过（lead 未就绪）',
+    failed: '失败', uncertain: '不确定', ambiguous: '候选不唯一', lost: '原 Run 已丢失',
+};
+const DOWN_LABEL = { stopped: '已停止', closed: '已关闭', uncertain: '不确定', already_gone: '终端已不存在' };
+function table(head, rows) {
+    const widths = head.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+    const line = (cells) => cells.map((c, i) => c.padEnd(widths[i])).join('  ').trimEnd();
+    return [line(head), ...rows.map(line)].join('\n') + '\n';
+}
+const teamOfAddress = (address) => address.slice(address.indexOf('@') + 1);
+const minutesOrSeconds = (ms) => (ms < 60_000 ? `${Math.round(ms / 1000)} 秒前` : `${Math.floor(ms / 60_000)} 分钟前`);
+/** 调度员状态的一行文字；从未启动过（never）返回 null，调用方据此不显示。 */
+export function dispatcherLine(h) {
+    const age = h.ageMs === undefined ? '' : `（心跳 ${minutesOrSeconds(h.ageMs)}）`;
+    if (h.state === 'running')
+        return `调度员：运行中${age}`;
+    if (h.state === 'stale')
+        return `调度员：失联${age}`;
+    return h.state === 'stopped' ? '调度员：已停止' : null;
+}
+function dispatcherTitles(rows) {
+    const seen = new Set();
+    const lines = [];
+    for (const r of rows) {
+        const team = teamOfAddress(r.address);
+        const line = r.dispatcher && dispatcherLine(r.dispatcher);
+        if (!line || seen.has(team))
+            continue;
+        seen.add(team);
+        lines.push(`团队 ${team}  ${line}`);
+    }
+    return lines.length ? lines.join('\n') + '\n' : '';
+}
+export function renderPs(rows) {
+    if (rows.length === 0)
+        return '没有已登记的岗位。用 wl up <team.yaml> 拉起团队。\n';
+    return dispatcherTitles(rows) + table(['ADDRESS', 'AGENT', 'STATUS', 'HANDLE', 'WORKTREE', 'LEAD'], rows.map((r) => [r.address, r.agent, r.status, r.handle ?? '-', r.worktree, r.isLead ? 'yes' : '']));
+}
+export function renderUp(r, opts = {}) {
+    const lines = r.posts.map((p) => {
+        const detail = [p.reason, p.retry && `重试：${p.retry}`].filter(Boolean).join('；');
+        return `${p.address}  ${UP_LABEL[p.outcome]}${detail ? `  ${detail}` : ''}`;
+    });
+    const reset = opts.newRun && r.run?.outcome === 'created' ? '旧 Run 里的任务不会再出现在 wl task list 中（它们仍在 Orca 里）\n' : '';
+    return `团队 ${r.team}\n${lines.join('\n')}\n${renderRun(r)}${reset}${renderDead(r)}`;
+}
+function renderRun(r) {
+    if (!r.run)
+        return '';
+    const run = r.run;
+    const head = `Run  ${RUN_LABEL[run.outcome]}${run.runId ? `  ${run.runId}` : ''}`;
+    const detail = [run.reason, run.retry && `重试：${run.retry}`].filter(Boolean).join('；');
+    const candidates = (run.candidates ?? []).map((c) => `\n  候选 ${c.id}（${c.createdAt}）`).join('');
+    return `${head}${detail ? `  ${detail}` : ''}${candidates}\n`;
+}
+function renderDead(r) {
+    if (!r.deadAssignees?.length)
+        return '';
+    const lines = r.deadAssignees.map((d) => `  ${d.taskId}  ${d.title}  归属 ${d.owner ?? '-'}  恢复：${d.command}`);
+    return `派给已消失终端的任务：\n${lines.join('\n')}\n`;
+}
+export function renderSend(r) {
+    return `${r.address}  已送达\n`;
+}
+export function renderDown(r) {
+    const lines = r.posts.map((p) => `${p.address}  ${DOWN_LABEL[p.outcome]}${p.reason ? `  ${p.reason}` : ''}`);
+    return `团队 ${r.team}\n${lines.join('\n')}\n`;
+}
+export function errorDoc(err) {
+    if (err instanceof WinglineError) {
+        return {
+            kind: err.kind, code: err.code, message: err.message,
+            ...(err.hint ? { hint: err.hint } : {}),
+            ...(err.detail !== undefined && err.code === 'close_unconfirmed' ? { detail: err.detail } : {}),
+        };
+    }
+    return { kind: 'internal', code: 'internal', message: err instanceof Error ? err.message : String(err) };
+}
+export function renderError(doc) {
+    const detail = doc.code === 'close_unconfirmed' ? renderDown(doc.detail) : '';
+    return `${detail}错误：${doc.message}\n${doc.hint ? `提示：${doc.hint}\n` : ''}`;
+}
+/** 派发之后通知结果的人读说明。 */
+function deliveryLine(address, taskId, d) {
+    const who = address ?? '<岗位地址>';
+    if (d.delivery === 'not_notified') {
+        return `${who} 此刻在提示/无法读取画面上，没有打字通知；任务已派发。等对方空闲后可以 wl send ${who} "你有新任务 ${taskId}，见 wl task show ${taskId}"\n`;
+    }
+    if (d.delivery === 'queued')
+        return `${who} 手上有任务 ${d.busyWith ?? ''}，新任务已排队\n`;
+    if (d.delivery === 'notified_unconfirmed')
+        return `${who} 已通知，但没有确认对方开始处理\n`;
+    if (d.delivery === 'notified')
+        return `${who} 已通知\n`;
+    return '';
+}
+export function renderCreate(r, post) {
+    return `任务 ${r.id} 已创建\n${deliveryLine(post, r.id, r)}`;
+}
+export function renderList(rows) {
+    if (rows.length === 0)
+        return '没有任务。\n';
+    return table(['ID', 'STATUS', 'OWNER', 'TAGS', 'TITLE'], rows.map((t) => [t.id, t.status, t.claimedBy ?? '-', t.tags.join(',') || '-', t.title]));
+}
+export function renderStale(items) {
+    if (items.length === 0)
+        return '没有卡住的任务。\n';
+    const reasons = [...new Set(items.map((i) => i.reason))];
+    return reasons
+        .map((reason) => `${reason}\n${items.filter((i) => i.reason === reason).map((i) => `  ${i.taskId} ${i.title} ${i.reason} → ${i.command}`).join('\n')}\n`)
+        .join('');
+}
+const SOURCE_LABEL = { explicit: '显式', implicit: '隐式', human: '人' };
+export function closureLine(c) {
+    const targets = (c.targets ?? []).join('、');
+    if (c.kind === 'handed_to')
+        return `已转交给 ${targets}\n`;
+    if (c.kind === 'sent_for_review')
+        return `已送审给 ${targets}\n`;
+    return c.kind === 'escalated' ? '已转人工决策\n' : '已直接完成\n';
+}
+export function renderShow(t) {
+    const head = [`${t.id}  ${t.title}`, `状态 ${t.status}  主人 ${t.claimedBy ?? '-'}  标签 ${t.tags.join(',') || '-'}`];
+    if (t.plan)
+        head.push(`计划 ${t.plan}`);
+    if (t.outcome)
+        head.push(`上报 ${t.outcome}（${t.reportedBy ?? '-'}）`);
+    const closure = t.closure ? closureLine(t.closure) : '';
+    const history = (t.history ?? []).map((h) => `${h.at} ${h.actor}（${SOURCE_LABEL[h.actorSource]}）${h.action}${h.detail ? ` ${h.detail}` : ''}`);
+    return `${head.join('\n')}\n${closure}${history.length ? history.join('\n') + '\n' : ''}`;
+}
+export function renderReassign(r, id, to) {
+    const n = r.notify;
+    const tail = n.outcome === 'not_notified' ? `；没有打字通知（${n.reason}），可以 wl send ${to} "任务 ${id} 转给了你，见 wl task show ${id}"` : '';
+    return `任务 ${id} 已改派给 ${to}${tail}\n`;
+}
+export function renderStart(r, id, as) {
+    const head = r.already ? `任务 ${id} 已经在进行中\n` : `任务 ${id} 已开始\n`;
+    return head + deliveryLine(as, id, r);
+}
+const LINK_LABEL = {
+    notified: '已通知', notified_unconfirmed: '已通知（未确认）', not_notified: '没有打字通知', self: '就是你自己', queued: '已排队',
+    skipped_offline: '岗位不在线，未派发', skipped_frozen: '岗位已冻结，未派发',
+};
+function linkReason(l) {
+    if (l.delivery !== 'not_notified')
+        return '';
+    return `（${l.reason ?? '未知'}）；可以 wl send ${l.target} "你有新任务 ${l.taskId}，见 wl task show ${l.taskId}"`;
+}
+export function renderDone(r) {
+    if (r.outcome === 'gate_failed')
+        return `gate 未通过，输出见 ${r.gateOutputPath}\n`;
+    if (r.outcome === 'gate_failed_after_bypass') {
+        return `任务已被直接上报，补跑 gate 未通过，输出见 ${r.gateOutputPath}；已通知牵头岗\n`;
+    }
+    if (r.outcome === 'escalated') {
+        return `连续 gate 失败，已转人工决策：gate ${r.gateId}；wl task resolve ${r.gateId} --resolution <决定>\n`;
+    }
+    const links = (r.linkedTasks ?? []).map((l) => `  ${l.target}  子任务 ${l.taskId}  ${LINK_LABEL[l.delivery]}${linkReason(l)}\n`).join('');
+    return `${r.replayed ? '（这一轮早已完成，以下是存下的结果）\n' : ''}已完成\n${r.closure ? closureLine(r.closure) : ''}${links}`;
+}
+export function renderEscalate(r) {
+    const back = r.tookBackDispatch ? '任务已从岗位手里收回，resolve 后回到 ready\n' : '';
+    return `已转人工决策：gate ${r.gateId}（任务状态 ${r.status}）\n${back}处理：wl task resolve ${r.gateId} --resolution <决定>\n`;
+}
+export function renderResolve(r) {
+    return `任务 ${r.taskId} 现在 ${r.status}，主人 ${r.claimedBy ?? '-'}\n`;
+}
+export function renderRecover(r, id) {
+    const head = `任务 ${id}：${r.status}（第 ${r.epoch} 轮）${r.reason ? `，${r.reason}` : ''}\n`;
+    return head + deliveryLine(r.owner ?? undefined, id, r);
+}
+export function renderDispatcherUp(r) {
+    return r.outcome === 'started' ? `${r.address} 已启动${r.handle ? `（终端 ${r.handle}）` : ''}\n` : `${r.address} 已在运行\n`;
+}
+export function renderDispatcherDown(r) {
+    const label = { noop: '未改动（加 --close 才会关闭终端）', closed: '终端已关闭', already_gone: '终端已不存在' }[r.outcome];
+    return `${r.address}  ${label}\n`;
+}
+export function renderDispatcherStatus(s) {
+    const at = (x) => (x ? `${x.at}（${x.outcome}）` : '无');
+    const head = `团队 ${s.team}  ${dispatcherLine(s.health) ?? '调度员：从未启动'}\n`;
+    const body = `上次收件箱检查：${at(s.lastCheck)}\n上次巡查：${at(s.lastScan)}\n冻结岗位 ${s.frozen}  静音岗位 ${s.hushed}  待处理事项 ${s.attentionItems}\n`;
+    return head + body + s.warnings.map((w) => `警告：${w}\n`).join('');
+}
+export function renderUnfreeze(r, address) {
+    const skipped = r.skipped.map((s) => `  ${s.taskId}  ${s.command}\n`).join('');
+    return `${address} 已解冻\n` + (skipped ? `冻结期间被跳过的派发（按需手动处理）：\n${skipped}` : '');
+}
+/** spec 第 6.5 节的分节顺序；调度员失联时放最前。 */
+export function renderAttention(r) {
+    const sections = [];
+    const dispatcher = `调度员：${dispatcherLine(r.dispatcher)?.replace('调度员：', '') ?? '从未启动'}`;
+    if (r.warnings.length)
+        sections.push(['告警：', ...r.warnings.map((w) => `  ${w}`)].join('\n'));
+    if (r.dispatcher.state === 'stale')
+        sections.push(dispatcher + `\n  重新启动：wl dispatcher up ${r.team}`);
+    if (r.frozen.length) {
+        sections.push(['冻结的岗位：', ...r.frozen.map((f) => `  ${f.post}  ${f.reason}（${f.frozenAt}，跳过 ${f.skippedChildren} 个子任务）  wl dispatcher unfreeze ${f.post}`)].join('\n'));
+    }
+    if (r.signals.length) {
+        sections.push(['处理中的信号：', ...r.signals.map((s) => `  L${s.level} ${s.signal}${s.summary ? `（${s.summary}）` : ''}  ${s.post}${s.taskId ? `  ${s.taskId}` : ''}${s.command ? `  ${s.command}` : ''}`)].join('\n'));
+    }
+    if (r.questions.length) {
+        sections.push(['待回答的问题：', ...r.questions.map((q) => `  ${q.messageId}  ${q.asker}：${q.body}${q.options.length ? `（选项：${q.options.join(' / ')}）` : ''}  wl dispatcher reply ${r.team} ${q.messageId} --body <回答>`)].join('\n'));
+    }
+    sections.push(...staleSections(r));
+    if (r.dispatcher.state !== 'stale')
+        sections.push(dispatcher);
+    return sections.join('\n') + '\n';
+}
+function staleSections(r) {
+    const gates = r.stale.filter((i) => i.reason === 'blocked_waiting');
+    const rest = r.stale.filter((i) => i.reason !== 'blocked_waiting');
+    const line = (i) => `  ${i.taskId}  ${i.title}  ${i.reason}  归属 ${i.owner ?? '-'}  ${i.command}`;
+    const out = [];
+    const unavailable = r.unavailable.length ? `不可用（${r.unavailable.join('；')}）` : null;
+    for (const [title, items] of [['待决的 gate', gates], ['其余卡住的任务', rest]]) {
+        if (unavailable)
+            out.push(`${title}：${unavailable}`);
+        else if (items.length)
+            out.push([`${title}：`, ...items.map(line)].join('\n'));
+    }
+    return out;
+}
+// —— wl restore / wl log ——
+const RESTORE_LABEL = {
+    kept: '仍在运行', resumed: '已接回原会话', fresh: '新起（上下文已丢失）',
+    ambiguous: '候选不唯一', uncertain: '不确定', failed: '失败',
+};
+/** 一行岗位结果；候选不唯一时把候选逐条列出来，并给出重试命令。 */
+function restorePostLines(p, team) {
+    const out = [`  ${p.address}  ${RESTORE_LABEL[p.outcome]}${p.reason ? `  ${p.reason}` : ''}${p.sessionId ? `  会话 ${p.sessionId}` : ''}`];
+    for (const c of p.candidates ?? []) {
+        out.push(`      候选 ${c.sessionId}  最后活动 ${c.updatedAt ?? '-'}  ${c.messageCount ?? 0} 条消息`);
+    }
+    if (p.note)
+        out.push(`      注：${p.note}`);
+    const retry = p.retry ?? (p.outcome === 'ambiguous' && p.candidates?.length ? `wl restore ${team} --session ${p.address.split('@')[0]}=<id>` : undefined);
+    if (retry)
+        out.push(`      试：${retry}`);
+    return out;
+}
+export function renderRestore(r) {
+    const head = `团队 ${r.team}${r.dryRun ? '（dry-run：只看不改）' : ''}`;
+    const run = r.run ? [`  ${r.run.runId ?? '-'}  ${RUN_LABEL[r.run.outcome]}`] : [];
+    const dispatcher = [`  ${r.dispatcher.action === 'restarted' ? '已重启' : r.dispatcher.action === 'left' ? '保持不动' : '未拉起'}  ${r.dispatcher.state}${r.dispatcher.reason ? `  ${r.dispatcher.reason}` : ''}`];
+    const tasks = r.tasks.length
+        ? r.tasks.map((t) => `  ${t.taskId || '-'}  ${t.owner || '-'}  ${TASK_OUTCOME[t.outcome]}${t.reason ? `  ${t.reason}` : ''}${t.retry ? `\n      重试：${t.retry}` : ''}`)
+        : ['  无'];
+    return [
+        head,
+        '岗位：', ...r.posts.flatMap((p) => restorePostLines(p, r.team)),
+        'Run：', ...run,
+        '调度员：', ...dispatcher,
+        '任务：', ...tasks,
+    ].join('\n') + '\n';
+}
+export function renderRestoreAll(r) {
+    if (r.teams.length === 0)
+        return '没有处于运行状态的团队，无需恢复\n';
+    return r.teams.map((t) => t.result
+        ? renderRestore(t.result)
+        : `团队 ${t.team}\n  失败：${t.error.code}  ${t.error.message}${t.error.hint ? `\n  提示：${t.error.hint}` : ''}\n`).join('\n');
+}
+const quoteWord = (w) => (/[\s"']/.test(w) ? JSON.stringify(w) : w);
+export function renderAutostartInstall(r) {
+    return [
+        `已安装自启动（${r.platform === 'darwin' ? 'macOS launchd' : 'Linux systemd 用户服务'}）`,
+        `  位置：${r.file}`,
+        `  命令：${r.command.map(quoteWord).join(' ')}`,
+        `  登录后最多等 Orca 就绪 ${r.waitOrca}；日志：${r.logPath}`,
+        ...(r.platform === 'darwin' ? ['macOS 上安装即执行一次 wl restore --all，结果见上面的日志。'] : []),
+    ].join('\n') + '\n';
+}
+export function renderAutostartUninstall(r) {
+    return r.removed ? `已卸载自启动：${r.file}（日志保留）\n` : '没有安装过自启动，无需卸载\n';
+}
+export function renderAutostartStatus(r) {
+    const lines = [r.installed ? '自启动：已安装' : '自启动：未安装', `  位置：${r.location}`];
+    if (r.installed)
+        lines.push(`  命令：${r.command.map(quoteWord).join(' ')}`);
+    if (r.commandMissing.length > 0)
+        lines.push(`  ⚠ 命令里的 ${r.commandMissing.join('、')} 已经不存在（Node 路径已变化），请重新执行 wl autostart install`);
+    if (r.platform === 'linux' && r.installed && r.linger === false) {
+        lines.push(`  ⚠ 用户 ${r.user ?? '<user>'} 没有开启 linger：无界面或 SSH 场景需要 loginctl enable-linger ${r.user ?? '<user>'}`);
+    }
+    lines.push(r.logTail.length > 0 ? `日志 ${r.logPath}（最后 ${r.logTail.length} 行）：` : `日志 ${r.logPath}：暂无`, ...r.logTail.map((l) => `  ${l}`));
+    return lines.join('\n') + '\n';
+}
+const TASK_OUTCOME = { recovered: '已恢复', queued: '已排队', ready: '本就不该重派', skipped: '未恢复', failed: '恢复失败' };
+const TIMELINE_SOURCE = { task: '任务', patrol: '巡查', command: '命令' };
+const SUMMARY_MAX = 120;
+/** 复审 I-1b：actor/action/target 来自用户可控的 --as 与正文列，控制字符会伪造出额外的日志行。 */
+const CONTROL = /[\x00-\x1f\x7f]/g;
+const flat = (s) => s.replace(CONTROL, ' ');
+const pad2 = (n) => String(n).padStart(2, '0');
+/** 摘要压成一行，最长 SUMMARY_MAX 字；末尾的空列不留。 */
+function eventSummary(e) {
+    const raw = typeof e.detail === 'string' ? e.detail : e.detail === null || e.detail === undefined ? '' : JSON.stringify(e.detail);
+    const flat = raw.replace(/[\r\n\t]+/g, ' ').trim();
+    const body = [e.outcome ?? '', flat].filter(Boolean).join(' ');
+    return body.length <= SUMMARY_MAX ? body : `${body.slice(0, SUMMARY_MAX)}…`;
+}
+export function renderTimelineEvent(e) {
+    const d = new Date(e.at);
+    const cols = [
+        `${pad2(d.getHours())}:${pad2(d.getMinutes())}:${pad2(d.getSeconds())}`,
+        TIMELINE_SOURCE[e.source], flat(e.actor) || '-', flat(e.action), e.target === null ? '' : flat(e.target), eventSummary(e),
+    ];
+    while (cols.length && cols.at(-1) === '')
+        cols.pop();
+    return cols.join('  ');
+}
+/**
+ * 跨天插一行日期；返回逐条打印的函数，`--follow` 与一次性输出共用同一套格式，
+ * 这样 follow 出来的样子和 `wl log` 一样。
+ */
+export function logPrinter() {
+    let day = '';
+    return (e) => {
+        const d = new Date(e.at);
+        const today = `${d.getFullYear()}-${pad2(d.getMonth() + 1)}-${pad2(d.getDate())}`;
+        const head = today === day ? '' : day ? `—— ${today} ——\n` : '';
+        day = today;
+        return `${head}${renderTimelineEvent(e)}\n`;
+    };
+}
+export const renderLog = (events) => {
+    const print = logPrinter();
+    return events.map(print).join('');
+};

package/dist/tui/app.d.ts

@@ -0,0 +1,28 @@
+import { attention, listTasks, ps, readTimeline, readTimelineAfter, type CommandDeps, type WriteCommands } from '@weiping/wingline-core';
+import { reduce, initialTuiState } from './reduce.js';
+import { renderView } from './render.js';
+import type { Effect, TuiData, TuiIo, TuiState } from './types.js';
+export { initialTuiState, reduce, renderView };
+export type { Effect, TuiData, TuiState };
+/** 读取数据用的函数；测试里可以替换其中任意一个。 */
+export interface TuiReader {
+    ps: typeof ps;
+    attention: typeof attention;
+    listTasks: typeof listTasks;
+    readTimeline: typeof readTimeline;
+    readTimelineAfter: typeof readTimelineAfter;
+}
+export interface RunTuiOptions {
+    signal?: AbortSignal;
+    /** 写命令表；缺省是带 `tui:` 审计前缀的那一份。 */
+    commands?: WriteCommands;
+    read?: Partial<TuiReader>;
+    /** 岗位与待办的刷新间隔，缺省 5 秒。 */
+    dataMs?: number;
+    /** 时间线的刷新间隔，缺省 2 秒。 */
+    timelineMs?: number;
+    /** 每画一帧调用一次（测试观察屏幕内容用）。 */
+    onFrame?: (lines: string[]) => void;
+}
+/** 全屏终端视图。结束（q / Ctrl-C / 信号 / abort）时 resolve；出错时先恢复终端再 reject。 */
+export declare function runTui(deps: CommandDeps, team: string, io: TuiIo, o?: RunTuiOptions): Promise<void>;