@weiping/wingline-core 0.1.0 → 0.2.0

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/spec.d.ts

@@ -1,3 +1,4 @@
+import { type SpecEditOp } from '../spec/edit.js';
 import { type SpecError } from '../spec/load.js';
 import { type SpecPlan } from '../spec/plan-change.js';
 import type { CommandDeps } from './deps.js';
@@ -12,8 +13,9 @@ export interface SpecForEdit {
         hash: string | null;
     } | null;
     running: boolean;
+    files: Record<string, string>;
 }
-/** 编辑器加载：正式规格与草稿（如果有）各给出文本、解析结果与内容哈希。 */
+/** 编辑器加载：正式规格与草稿（如果有）各给出文本、解析结果与内容哈希，附上引用文档的正文。 */
 export declare function readSpecForEdit(deps: CommandDeps, team: string): SpecForEdit;
 export interface SpecEditResult {
     yaml: string;
@@ -21,20 +23,19 @@ export interface SpecEditResult {
     errors: SpecError[];
     preview: SpecPlan | null;
 }
-/** 校验一段 YAML（可先套用表单的一处修改）并预演；不写任何文件。 */
+/** 校验一段 YAML（可先套用编辑页的一处修改）并预演；不写任何文件。`files` 是还没落盘的文档正文。 */
 export declare function validateSpecEdit(deps: CommandDeps, a: {
     team: string;
     yaml: string;
-    set?: {
-        path: Array<string | number>;
-        value: unknown;
-    };
+    set?: SpecEditOp;
+    files?: Record<string, string>;
 }): SpecEditResult;
 export interface SaveSpecArgs {
     team: string;
     yaml: string;
     baseHash: string | null;
     running: boolean;
+    files?: Record<string, string>;
     retryRequest?: string;
 }
 /** 保存规格；两次保存相同内容天然幂等，所以 retryRequest 只是被路由校验格式，这里不用。 */
@@ -42,6 +43,7 @@ export declare function saveSpecCmd(deps: CommandDeps, a: SaveSpecArgs): Promise
     wrote: 'draft' | 'spec';
     path: string;
     hash: string;
+    docsUpdated: string[];
 }>;
 export declare function discardDraftCmd(deps: CommandDeps, a: {
     team: string;

package/dist/commands/spec.js

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
+import path from 'node:path';
 import { WinglineError } from '../errors.js';
-import { discardDraft, draftPathOf, fileHash, assertSpecSize, saveSpec } from '../spec/draft.js';
-import { setField } from '../spec/edit.js';
+import { assertSpecSize, checkSaveConflict, discardDraft, draftPathOf, fileHash, saveSpec } from '../spec/draft.js';
+import { DOC_LIMIT_BYTES, docRelsOf, readDocText, resolveDocPath, writeDocAtomic } from '../spec/doc.js';
+import { applySpecOp } from '../spec/edit.js';
 import { loadTeamSpec, validateSpecText } from '../spec/load.js';
 import { planSpecChange } from '../spec/plan-change.js';
 function teamOf(deps, team) {
@@ -18,7 +20,24 @@ const readText = (file) => {
         throw new WinglineError('input', 'spec_not_found', `读不到团队规格 ${file}`, { cause });
     }
 };
-/** 编辑器加载：正式规格与草稿（如果有）各给出文本、解析结果与内容哈希。 */
+/** 把规格（与草稿）引用的文档正文读出来；解析不了的相对路径跳过，不让整个编辑页打不开。 */
+function readDocs(dir, parseds) {
+    const files = {};
+    for (const parsed of parseds) {
+        for (const rel of docRelsOf(parsed)) {
+            if (rel in files)
+                continue;
+            try {
+                files[rel] = readDocText(resolveDocPath(dir, rel));
+            }
+            catch {
+                // resolveDocPath 拒绝的路径（越界、非 .md）：编辑页照样打开，只是不带这份正文
+            }
+        }
+    }
+    return files;
+}
+/** 编辑器加载：正式规格与草稿（如果有）各给出文本、解析结果与内容哈希，附上引用文档的正文。 */
 export function readSpecForEdit(deps, team) {
     const row = teamOf(deps, team);
     const view = (file) => {
@@ -26,11 +45,14 @@ export function readSpecForEdit(deps, team) {
         return { yaml, parsed: validateSpecText(yaml, row.specPath).parsed, hash: fileHash(file) };
     };
     const draftFile = draftPathOf(row.specPath);
+    const spec = view(row.specPath);
+    const draft = fs.existsSync(draftFile) ? view(draftFile) : null;
     return {
         specPath: row.specPath,
-        ...view(row.specPath),
-        draft: fs.existsSync(draftFile) ? view(draftFile) : null,
+        ...spec,
+        draft,
         running: row.status === 'up',
+        files: readDocs(path.dirname(row.specPath), [spec.parsed, draft?.parsed ?? null]),
     };
 }
 function currentSpec(specPath) {
@@ -43,23 +65,58 @@ function currentSpec(specPath) {
         throw err;
     }
 }
-/** 校验一段 YAML（可先套用表单的一处修改）并预演；不写任何文件。 */
+/** 校验一段 YAML（可先套用编辑页的一处修改）并预演；不写任何文件。`files` 是还没落盘的文档正文。 */
 export function validateSpecEdit(deps, a) {
     const row = teamOf(deps, a.team);
     assertSpecSize(a.yaml);
-    const yaml = a.set ? setField(a.yaml, a.set.path, a.set.value) : a.yaml;
+    // applySpecOp 已把缺省 op 转给 setField，这里不再分叉
+    const yaml = a.set ? applySpecOp(a.yaml, a.set) : a.yaml;
     assertSpecSize(yaml);
-    const { spec, parsed, errors } = validateSpecText(yaml, row.specPath);
+    const { spec, parsed, errors } = validateSpecText(yaml, row.specPath, { virtualFiles: new Set(Object.keys(a.files ?? {})) });
     const preview = spec ? planSpecChange(currentSpec(row.specPath), spec, { running: row.status === 'up', specPath: row.specPath }) : null;
     return { yaml, parsed, errors, preview };
 }
+const docFiles = (files) => {
+    if (files === undefined)
+        return {};
+    if (!files || typeof files !== 'object' || Array.isArray(files) || !Object.values(files).every((v) => typeof v === 'string')) {
+        throw new WinglineError('input', 'invalid_param', '参数 files 不合法');
+    }
+    return files;
+};
+/** 先校验规格、再查冲突（冲突时一个字节都不写）、最后把文档写到磁盘；team.yaml 由随后的 saveSpec 写。 */
+function writeDocs(specPath, yaml, files, a) {
+    const { parsed, errors } = validateSpecText(yaml, specPath, { virtualFiles: new Set(Object.keys(files)) });
+    if (errors.length > 0)
+        throw new WinglineError('input', 'spec_invalid', errors[0].message, { detail: { errors } });
+    checkSaveConflict({ specPath, text: yaml, baseHash: a.baseHash, running: a.running });
+    const referenced = new Set(docRelsOf(parsed));
+    for (const [rel, content] of Object.entries(files)) {
+        if (!referenced.has(rel))
+            throw new WinglineError('input', 'doc_not_referenced', `文档 ${rel} 没有被团队规格引用`);
+        if (Buffer.byteLength(content, 'utf8') > DOC_LIMIT_BYTES) {
+            throw new WinglineError('input', 'doc_too_large', `文档 ${path.basename(rel)} 超过 ${DOC_LIMIT_BYTES / 1024} KB 上限`);
+        }
+    }
+    const dir = path.dirname(specPath);
+    const docsUpdated = [];
+    for (const [rel, content] of Object.entries(files)) {
+        writeDocAtomic(resolveDocPath(dir, rel), content);
+        docsUpdated.push(rel);
+    }
+    return docsUpdated;
+}
 /** 保存规格；两次保存相同内容天然幂等，所以 retryRequest 只是被路由校验格式，这里不用。 */
 export async function saveSpecCmd(deps, a) {
     const row = teamOf(deps, a.team);
     if (a.running !== (row.status === 'up')) {
         throw new WinglineError('input', 'spec_conflict', '团队状态已变化，请重新加载');
     }
-    return saveSpec({ specPath: row.specPath, text: a.yaml, baseHash: a.baseHash, running: a.running });
+    assertSpecSize(a.yaml);
+    const files = docFiles(a.files);
+    const docsUpdated = writeDocs(row.specPath, a.yaml, files, { baseHash: a.baseHash, running: a.running });
+    const res = saveSpec({ specPath: row.specPath, text: a.yaml, baseHash: a.baseHash, running: a.running });
+    return { ...res, docsUpdated };
 }
 export async function discardDraftCmd(deps, a) {
     return discardDraft(teamOf(deps, a.team).specPath);

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/plan.d.ts

@@ -2,4 +2,5 @@ import type { CommandDeps } from '../deps.js';
 export declare function planTask(deps: CommandDeps, a: {
     id: string;
     text: string;
+    as?: string;
 }): Promise<void>;

package/dist/commands/task/plan.js

@@ -5,7 +5,7 @@ import { preflightTask } from './preflight.js';
 import { findTask } from './query.js';
 export async function planTask(deps, a) {
     const { team } = await preflightTask(deps, a.id);
-    const actor = await resolveActor(deps);
+    const actor = await resolveActor(deps, a.as);
     await deps.registry.withTeamLock(team.name, async () => {
         const task = await findTask(deps, team.name, a.id);
         if (task.status === 'completed' || task.status === 'failed') {

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/commands/templates.d.ts

@@ -0,0 +1,32 @@
+export type TeamTemplateId = 'duo' | 'solo' | 'trio';
+export type RoleKind = 'builder' | 'checker' | 'planner';
+export interface TeamTemplatePost {
+    id: string;
+    role: RoleKind;
+    agent: string;
+    model?: string;
+    launch?: string;
+    brief: string;
+}
+export interface TeamTemplate {
+    id: TeamTemplateId;
+    label: string;
+    summary: string;
+    lead: string;
+    posts: TeamTemplatePost[];
+    links: Record<string, Record<string, string[]>>;
+}
+export declare const TEAM_TEMPLATES: Record<TeamTemplateId, TeamTemplate>;
+export declare const ROLE_BRIEFS: Record<RoleKind, (team: string, post: string) => string>;
+export declare function renderTeamYaml(t: TeamTemplate, a: {
+    name: string;
+    repo: string;
+}): string;
+export declare function renderNorms(a: {
+    team: string;
+    posts: string[];
+}): string;
+export declare function renderBrief(role: RoleKind, a: {
+    team: string;
+    post: string;
+}): string;

package/dist/commands/templates.js

@@ -0,0 +1,120 @@
+const CHECKER_LAUNCH = 'codex --model gpt-6-astra -c model_reasoning_effort="high"';
+export const TEAM_TEMPLATES = {
+    duo: {
+        id: 'duo',
+        label: '双人协作',
+        summary: 'builder 负责实现，checker 负责独立审查',
+        lead: 'builder',
+        posts: [
+            { id: 'builder', role: 'builder', agent: 'claude', model: 'opus', brief: 'briefs/builder.md' },
+            { id: 'checker', role: 'checker', agent: 'codex', launch: CHECKER_LAUNCH, brief: 'briefs/checker.md' },
+        ],
+        links: { builder: { reviewed_by: ['checker'] } },
+    },
+    solo: {
+        id: 'solo',
+        label: '单人',
+        summary: '单岗位 builder 独立完成实现与自检',
+        lead: 'builder',
+        posts: [
+            { id: 'builder', role: 'builder', agent: 'claude', model: 'opus', brief: 'briefs/builder.md' },
+        ],
+        links: {},
+    },
+    trio: {
+        id: 'trio',
+        label: '三人流水线',
+        summary: 'planner 规划拆解，移交 builder 实现，checker 负责审查',
+        lead: 'planner',
+        posts: [
+            { id: 'planner', role: 'planner', agent: 'claude', model: 'opus', brief: 'briefs/planner.md' },
+            { id: 'builder', role: 'builder', agent: 'claude', model: 'opus', brief: 'briefs/builder.md' },
+            { id: 'checker', role: 'checker', agent: 'codex', launch: CHECKER_LAUNCH, brief: 'briefs/checker.md' },
+        ],
+        links: {
+            planner: { hands_to: ['builder'] },
+            builder: { reviewed_by: ['checker'] },
+        },
+    },
+};
+export const ROLE_BRIEFS = {
+    builder: (team, _post) => [
+        `你是 ${team} 团队的实现岗，负责把需求落成代码。`,
+        '',
+        '- 先读懂需求和现有代码，再说明方案，再实现。',
+        '- 优先写测试，再写实现；每次改动保持测试通过。',
+        `- 完成一个可审查的改动后，用 \`wl send checker@${team} "<摘要和文件列表>"\` 请审查岗审查。`,
+        '- 收到审查意见后，逐条回应：修改，或说明为什么不改。',
+        '- 需求不清时向牵头岗或用户确认，不要自行扩大范围。',
+    ].join('\n'),
+    checker: (team, _post) => [
+        `你是 ${team} 团队的审查岗，负责独立审查改动。`,
+        '',
+        '- 收到审查请求后，先看改动本身和相关测试，再给意见。',
+        '- 重点看：正确性、边界情况、测试是否真的覆盖了行为、是否引入不必要的复杂度。',
+        `- 意见分级：必须修改 / 建议修改 / 仅供参考；用 \`wl send builder@${team} "<意见>"\` 回复。`,
+        '- 你可以运行测试和只读命令，但不要直接改实现岗的代码；需要改动时把建议发给对方。',
+        '- 没有问题时明确回复"通过"，并说明你检查了什么。',
+    ].join('\n'),
+    planner: (team, _post) => [
+        `你是 ${team} 团队的规划岗，负责拆解需求与验收标准。`,
+        '',
+        '- 先读懂需求与现有代码结构，给出清晰的分步方案与边界条件。',
+        '- 将拆解好的子任务与验收标准写清楚，避免模糊描述。',
+        `- 方案就绪后，用 \`wl send builder@${team} "<方案与任务说明>"\` 移交实现岗。`,
+        '- 实现或审查过程中遇到范围变更时，及时更新方案并同步相关岗位。',
+        '- 拿不准的产品或架构取舍先向用户确认，不要替用户拍板。',
+    ].join('\n'),
+};
+export function renderTeamYaml(t, a) {
+    const repo = a.repo.startsWith('path:') ? a.repo : `path:${a.repo}`;
+    const lines = [
+        'version: 1',
+        `name: ${a.name}`,
+        `repo: ${JSON.stringify(repo)}`,
+        'norms: NORMS.md',
+        `lead: ${t.lead}`,
+        'posts:',
+    ];
+    for (const p of t.posts) {
+        lines.push(`  - id: ${p.id}`, `    agent: ${p.agent}`);
+        if (p.model)
+            lines.push(`    model: ${p.model}`);
+        if (p.launch)
+            lines.push(`    launch: '${p.launch}'`);
+        lines.push('    worktree: current', `    brief: [${p.brief}]`);
+    }
+    const linkEntries = Object.entries(t.links);
+    if (linkEntries.length > 0) {
+        lines.push('links:');
+        for (const [post, rels] of linkEntries) {
+            lines.push(`  ${post}:`);
+            for (const [rel, targets] of Object.entries(rels)) {
+                lines.push(`    ${rel}: [${targets.join(', ')}]`);
+            }
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function renderNorms(a) {
+    const lead = a.posts[0] ?? 'builder';
+    const peer = a.posts[1] ?? lead;
+    return [
+        `# ${a.team} 团队规范`,
+        '',
+        `在岗角色：${a.posts.join('、')}。`,
+        '',
+        '1. 改动前先用一两句话说明你打算怎么做，再动手。',
+        '2. 改完先自己跑测试，确认通过再汇报。',
+        `3. 需要其他岗位审查或回答时，用 \`wl send <地址> "<消息>"\` 联系，地址形如 \`${peer}@${a.team}\`。`,
+        '4. 消息写清楚：改了什么、在哪个文件、希望对方做什么。',
+        '5. 不修改其他岗位正在改的文件；拿不准时先问。',
+        '6. 小步提交，提交信息说明为什么改。',
+        `7. 遇到无法判断的事（需求不清、权限、破坏性操作），停下来问牵头岗 \`${lead}@${a.team}\`，不要猜。`,
+        '8. 收到消息后尽快回复；暂时无法处理时说明原因。',
+        '',
+    ].join('\n');
+}
+export function renderBrief(role, a) {
+    return `# ${a.post} 岗位说明\n\n${ROLE_BRIEFS[role](a.team, a.post)}\n`;
+}

package/dist/index.d.ts

@@ -9,18 +9,22 @@ export * from './orca/types.js';
 export * from './spec/hash.js';
 export * from './spec/load.js';
 export * from './spec/draft.js';
+export * from './spec/doc.js';
 export * from './spec/edit.js';
 export * from './spec/plan-change.js';
+export * from './spec/facade.js';
 export * from './commands/spec.js';
 export * from './commands/about.js';
 export * from './registry/registry.js';
 export * from './brief/render.js';
 export * from './audit.js';
+export * from './audit-table.js';
 export * from './commands/deps.js';
 export * from './commands/locate.js';
 export * from './commands/up.js';
 export * from './commands/restore/index.js';
 export * from './commands/autostart/index.js';
+export * from './commands/autostart/sys.js';
 export * from './commands/version-range.js';
 export * from './commands/ps.js';
 export * from './commands/send.js';
@@ -48,9 +52,12 @@ export * from './commands/task/escalate.js';
 export { HEARTBEAT_STALE_MS, HEARTBEAT_TAKEOVER_MS, dispatcherHealth, dispatcherLaunchCommand, dispatcherUp, dispatcherDown, type DispatcherHealth, type UpArgs as DispatcherUpArgs, } from './commands/dispatcher/lifecycle.js';
 export * from './commands/dispatcher/loop.js';
 export * from './commands/dispatcher/attention.js';
+export * from './commands/dispatcher/signal-summary.js';
 export * from './commands/dispatcher/controls.js';
 export * from './commands/dispatcher/inbox.js';
 export * from './commands/dispatcher/outlets.js';
 export * from './commands/dispatcher/signals.js';
 export * from './commands/dispatcher/advance.js';
 export * from './commands/dispatcher/orca-sync.js';
+export * from './commands/templates.js';
+export * from './commands/init.js';