@weiping/wingline-core 0.1.0 → 0.2.0

package/dist/audit-table.d.ts

@@ -0,0 +1,11 @@
+import type { AuditTable } from './audit.js';
+import type { CommandDeps } from './commands/deps.js';
+/** 审计表里命令的最小形状：吃 deps 打头，后面参数不限于一个。 */
+type AnyCommand = (deps: CommandDeps, ...a: any[]) => Promise<unknown>;
+/** 取一张按调用方命令集定型的审计表；内容始终是同一张表。 */
+export declare function coreAuditTable<C extends {
+    [K in keyof C]: (deps: CommandDeps, ...a: any[]) => Promise<unknown>;
+}>(): AuditTable<C>;
+/** 宽松版：给不想定型的一方（如插件 worker）用。 */
+export declare const CORE_AUDIT: AuditTable<Record<string, AnyCommand>>;
+export {};

package/dist/audit-table.js

@@ -0,0 +1,85 @@
+/** 地址参数取 `@` 之后的团队名；解析不出（没有 `@`）记 `-`。 */
+const ofAddress = (a) => a.address.split('@')[1] ?? '-';
+/** 任务 id 的团队名从注册表查；查不到（任务不存在、已被清理）记 `-`。 */
+const byTask = (idOf) => (_a, ctx) => ctx.deps.registry.getTaskExt(idOf(_a))?.team ?? '-';
+const byGate = (gateId) => (_a, ctx) => ctx.deps.registry.getGate(gateId(_a))?.team ?? '-';
+/** 只有结果里才有团队名（up 成功时）；失败或没跑出结果记 `-`。 */
+const byResult = (_a, ctx) => ctx.result?.team ?? '-';
+const id = (a) => a.id;
+const ENTRIES = {
+    init: {
+        command: 'init',
+        team: byResult,
+        summary: (a, ctx) => ({ mode: a.mode, template: a.template, created: ctx.result?.created })
+    },
+    up: {
+        command: 'up',
+        team: byResult,
+        summary: (a) => ({ adoptRun: a.adoptRun, newRun: a.newRun, draft: a.draft })
+    },
+    down: { command: 'down', team: (a) => a.team, summary: (a) => ({ close: a.close }) },
+    restore: {
+        command: 'restore',
+        team: (a) => a.team,
+        skip: (a) => !!a.dryRun,
+        summary: (a) => ({ dryRun: !!a.dryRun, noTasks: !!a.noTasks, session: Object.keys(a.sessions ?? {}) })
+    },
+    send: { command: 'send', team: ofAddress, target: (a) => a.address, summary: (a) => ({ message: a.message }) },
+    createTask: {
+        command: 'task create',
+        team: (a) => a.team,
+        target: (_a, ctx) => ctx.result?.id ?? null,
+        summary: (a) => ({ title: a.title, post: a.post, tags: a.tags, parent: a.parent, as: a.as })
+    },
+    claimTask: { command: 'task claim', team: byTask(id), target: id, summary: (a) => ({ as: a.as }) },
+    releaseTask: { command: 'task release', team: byTask(id), target: id, summary: (a) => ({ as: a.as }) },
+    reassignTask: { command: 'task reassign', team: byTask(id), target: id, summary: (a) => ({ to: a.to }) },
+    startTask: { command: 'task start', team: byTask(id), target: id, summary: (a) => ({ as: a.as }) },
+    planTask: { command: 'task plan', team: byTask(id), target: id, summary: (a) => ({ text: a.text }) },
+    doneTask: { command: 'task done', team: byTask(id), target: id, summary: (a) => ({ as: a.as, resumeEpoch: a.resumeEpoch }) },
+    escalateTask: {
+        command: 'task escalate',
+        team: byTask(id),
+        target: (a) => a.id,
+        summary: (a) => ({ reason: a.reason, reopen: a.reopen, as: a.as })
+    },
+    resolveGate: {
+        command: 'task resolve',
+        team: byGate((a) => a.gateId),
+        target: (a) => a.gateId,
+        summary: (a) => ({ resolution: a.resolution, reassign: a.reassign, as: a.as })
+    },
+    recoverTask: { command: 'task recover', team: byTask(id), target: (a) => a.id, summary: (a) => ({ as: a.as }) },
+    dispatcherUp: { command: 'dispatcher up', team: (a) => a.team, summary: (a) => ({ platform: a.platform }) },
+    dispatcherDown: { command: 'dispatcher down', team: (a) => a.team, summary: (a) => ({ close: a.close }) },
+    freezePostCmd: { command: 'dispatcher freeze', team: ofAddress, target: (a) => a.address, summary: (a) => ({ reason: a.reason }) },
+    unfreezePostCmd: { command: 'dispatcher unfreeze', team: ofAddress, target: (a) => a.address },
+    hushCmd: { command: 'dispatcher hush', team: ofAddress, target: (a) => a.address, summary: (a) => ({ forMs: a.forMs }) },
+    unhushCmd: { command: 'dispatcher unhush', team: ofAddress, target: (a) => a.address },
+    dispatcherReply: {
+        command: 'dispatcher reply',
+        team: (a) => a.team,
+        target: (a) => a.messageId,
+        summary: (a) => ({ body: a.body, again: a.again })
+    },
+    saveSpecCmd: {
+        command: 'spec save',
+        team: (a) => a.team,
+        target: (_a, ctx) => ctx.result?.path ?? null,
+        summary: (a, ctx) => {
+            const r = ctx.result;
+            return { baseHash: a.baseHash?.slice(0, 16), running: a.running, wrote: r?.wrote, hash: r?.hash?.slice(0, 16) };
+        }
+    },
+    discardDraftCmd: {
+        command: 'spec discard-draft',
+        team: (a) => a.team,
+        summary: (_a, ctx) => ({ discarded: ctx.result?.discarded })
+    }
+};
+/** 取一张按调用方命令集定型的审计表；内容始终是同一张表。 */
+export function coreAuditTable() {
+    return ENTRIES;
+}
+/** 宽松版：给不想定型的一方（如插件 worker）用。 */
+export const CORE_AUDIT = coreAuditTable();

package/dist/audit.js

@@ -4,7 +4,7 @@ import { actorOf, resolveActor } from './commands/task/identity.js';
 export const WRITE_COMMANDS = [
     'up', 'down', 'restore', 'send', 'createTask', 'claimTask', 'releaseTask', 'reassignTask', 'startTask', 'planTask',
     'doneTask', 'escalateTask', 'resolveGate', 'recoverTask', 'dispatcherUp', 'dispatcherDown', 'freezePostCmd',
-    'unfreezePostCmd', 'hushCmd', 'unhushCmd', 'dispatcherReply',
+    'unfreezePostCmd', 'hushCmd', 'unhushCmd', 'dispatcherReply', 'init',
 ];
 /** 换行与控制字符换成空格（一一对应，长度不变），超长截断并标明原长。 */
 const CONTROL = /[\x00-\x1f\x7f]/g;

package/dist/commands/about.d.ts

@@ -1,12 +1,23 @@
 import type { ConsoleFile } from '../server/control.js';
 import type { CommandDeps } from './deps.js';
 import { type DispatcherHealth } from './dispatcher/lifecycle.js';
+import { type AutostartStatus, type AutostartSys } from './autostart/index.js';
 export interface AboutItem {
     key: string;
     value: string | number | boolean | null;
     source: 'env' | 'default' | 'registry' | 'file' | 'orca';
     note?: string;
 }
+export type AboutAutostart = ({
+    supported: true;
+} & AutostartStatus & {
+    platform: string;
+    user?: string;
+    logPath: string;
+}) | {
+    supported: false;
+    reason: string;
+};
 export interface AboutTeam {
     name: string;
     specPath: string;
@@ -19,7 +30,9 @@ export declare function about(deps: CommandDeps, o: {
     version: string;
     consoleFile: ConsoleFile | null;
     env?: NodeJS.ProcessEnv;
+    autostartSys?: AutostartSys;
 }): Promise<{
     items: AboutItem[];
     teams: AboutTeam[];
+    autostart: AboutAutostart;
 }>;

package/dist/commands/about.js

@@ -3,6 +3,8 @@ import path from 'node:path';
 import { WinglineError } from '../errors.js';
 import { draftPathOf } from '../spec/draft.js';
 import { dispatcherHealth } from './dispatcher/lifecycle.js';
+import { autostartStatusOf } from './autostart/index.js';
+import { realAutostartSys } from './autostart/sys.js';
 import { inRange } from './version-range.js';
 /** 目录下所有文件的字节数之和；目录不存在算 0。 */
 function dirBytes(dir) {
@@ -57,6 +59,15 @@ function consoleItems(f) {
         { key: 'console.startedAt', value: f.startedAt, source: 'file' },
     ];
 }
+/** 开机自启状态：取不到（平台不支持 / 权限不足）时显式说原因，不抛错。 */
+async function autostartItem(deps, sys) {
+    try {
+        return { supported: true, ...(await autostartStatusOf(deps, sys)) };
+    }
+    catch (err) {
+        return { supported: false, reason: err instanceof Error ? err.message : String(err) };
+    }
+}
 /** 控制台“关于与诊断”页的数据：只读，取不到的项目显式标 null，不影响其余各项。 */
 export async function about(deps, o) {
     const env = o.env ?? deps.env;
@@ -80,5 +91,5 @@ export async function about(deps, o) {
         draft: fs.existsSync(draftPathOf(t.specPath)),
         dispatcher: dispatcherHealth(deps, t.name).state,
     }));
-    return { items, teams };
+    return { items, teams, autostart: await autostartItem(deps, o.autostartSys ?? realAutostartSys()) };
 }

package/dist/commands/autostart/sys.d.ts

@@ -0,0 +1,3 @@
+import type { AutostartSys } from './index.js';
+/** 控制台服务在 core 内，需要同样的宿主信息：系统命令以参数数组启动（不经 shell），入口脚本取符号链接解析后的真实路径。 */
+export declare function realAutostartSys(): AutostartSys;

package/dist/commands/autostart/sys.js

@@ -0,0 +1,23 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+/** 控制台服务在 core 内，需要同样的宿主信息：系统命令以参数数组启动（不经 shell），入口脚本取符号链接解析后的真实路径。 */
+export function realAutostartSys() {
+    const exec = (file, args) => new Promise((resolve, reject) => {
+        const child = spawn(file, args, { shell: false });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (d) => { stdout += String(d); });
+        child.stderr.on('data', (d) => { stderr += String(d); });
+        child.on('error', reject);
+        child.on('close', (code) => resolve({ code: code ?? 1, stdout, stderr }));
+    });
+    const entry = process.argv[1] ?? '';
+    let script = path.resolve(entry);
+    try {
+        script = fs.realpathSync(entry);
+    }
+    catch { /* 保持 resolve 的结果 */ }
+    return { platform: process.platform, homeDir: os.homedir(), uid: process.getuid?.(), user: os.userInfo().username, node: process.execPath, script, exec, fs };
+}

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

@@ -21,6 +21,10 @@ export declare function dispatcherLaunchCommand(a: {
 export interface UpArgs {
     team: string;
     platform?: NodeJS.Platform;
+    /** 覆盖启动命令里的 node 可执行文件。插件 worker 的 process.execPath 是宿主（Orca）的二进制，必须传真实 node。 */
+    node?: string;
+    /** 覆盖启动命令里的 wingline 入口脚本。插件等宿主进程的 argv[1] 不是 wingline，必须显式传。 */
+    script?: string;
     confirmMs?: number;
     pollMs?: number;
     sleep?: (ms: number) => Promise<void>;

package/dist/commands/dispatcher/lifecycle.js

@@ -62,7 +62,13 @@ export async function dispatcherUp(deps, a) {
     }
     const platform = a.platform ?? process.platform;
     const command = dispatcherLaunchCommand({
-        platform, node: process.execPath, script: process.argv[1] ?? '', team: a.team, home: deps.home, orca: deps.orcaPath, nodeOnPath: platform === 'win32' ? nodeOnPath(deps) : undefined,
+        platform,
+        node: a.node ?? process.execPath,
+        script: a.script ?? process.argv[1] ?? '',
+        team: a.team,
+        home: deps.home,
+        orca: deps.orcaPath,
+        nodeOnPath: platform === 'win32' ? nodeOnPath(deps) : undefined,
     });
     const lead = deps.registry.listPosts(a.team).find((p) => p.isLead);
     const { handle } = await deps.orca.terminalCreate({ worktree: lead.worktree, title: address, command });

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/down.js

@@ -8,6 +8,7 @@ async function closePost(deps, post, specHash) {
         const located = await locatePost(orca, address);
         if (!located) {
             registry.setPostStatus(address, 'closed');
+            registry.finalizePostRequests(post.team, address.split('@')[0]);
             return { address, outcome: 'already_gone' };
         }
         const id = nextRequestId(registry, post.team, address.split('@')[0], 'close', specHash);
@@ -18,6 +19,8 @@ async function closePost(deps, post, specHash) {
         });
         registry.finishRequest(id, ptyKilled ? 'done' : 'uncertain', { ptyKilled });
         registry.setPostStatus(address, ptyKilled ? 'closed' : 'uncertain');
+        if (ptyKilled)
+            registry.finalizePostRequests(post.team, address.split('@')[0]);
         return ptyKilled ? { address, outcome: 'closed' } : { address, outcome: 'uncertain', reason: 'Orca 未确认进程已退出' };
     }
     catch (err) {

package/dist/commands/init.d.ts

@@ -0,0 +1,17 @@
+import { type CommandDeps } from './deps.js';
+import { type TeamTemplateId } from './templates.js';
+export type InitTeamMode = 'template' | 'import';
+export interface InitTeamArgs {
+    mode: InitTeamMode;
+    name?: string;
+    repo?: string;
+    template?: TeamTemplateId;
+    dir?: string;
+    specPath?: string;
+}
+export interface InitTeamResult {
+    team: string;
+    specPath: string;
+    created: boolean;
+}
+export declare function initTeamCmd(deps: CommandDeps, a: InitTeamArgs): Promise<InitTeamResult>;

package/dist/commands/init.js

@@ -0,0 +1,106 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { WinglineError } from '../errors.js';
+import { specHash } from '../spec/hash.js';
+import { loadTeamSpec } from '../spec/load.js';
+import { postAddress } from './deps.js';
+import { TEAM_TEMPLATES, renderBrief, renderNorms, renderTeamYaml, } from './templates.js';
+const TEAM_NAME_RE = /^[a-z0-9-]+$/;
+function writeTemplate(targetDir, tpl, name, repo) {
+    const briefsDir = path.join(targetDir, 'briefs');
+    fs.mkdirSync(briefsDir, { recursive: true });
+    const normsPath = path.join(targetDir, 'NORMS.md');
+    if (!fs.existsSync(normsPath)) {
+        fs.writeFileSync(normsPath, renderNorms({ team: name, posts: tpl.posts.map((p) => p.id) }), 'utf8');
+    }
+    for (const p of tpl.posts) {
+        const briefPath = path.join(targetDir, p.brief);
+        fs.mkdirSync(path.dirname(briefPath), { recursive: true });
+        if (!fs.existsSync(briefPath)) {
+            fs.writeFileSync(briefPath, renderBrief(p.role, { team: name, post: p.id }), 'utf8');
+        }
+    }
+    const specPath = path.join(targetDir, 'team.yaml');
+    fs.writeFileSync(specPath, renderTeamYaml(tpl, { name, repo }), 'utf8');
+    return specPath;
+}
+function registerSpec(deps, spec) {
+    const hash = specHash(spec);
+    deps.registry.upsertTeam({
+        name: spec.name,
+        specPath: spec.specPath,
+        specHash: hash,
+        runId: null,
+        coordinatorHandle: null,
+        status: 'stopped',
+    });
+    for (const p of spec.posts) {
+        deps.registry.upsertPost({
+            address: postAddress(p.id, spec.name),
+            team: spec.name,
+            agent: p.agent,
+            worktree: p.worktree,
+            handle: null,
+            status: 'offline',
+            isLead: p.id === spec.lead,
+            sessionMarker: null,
+            sessionId: null,
+            sessionAt: null,
+        });
+    }
+}
+function initFromTemplate(deps, a) {
+    const name = a.name ?? '';
+    if (!TEAM_NAME_RE.test(name)) {
+        throw new WinglineError('input', 'team_name_invalid', '团队名只能用小写字母、数字与连字符');
+    }
+    const rawRepo = a.repo?.trim() ?? '';
+    if (!rawRepo || /[\x00-\x1f\x7f]/.test(a.repo ?? '')) {
+        throw new WinglineError('input', 'invalid_param', rawRepo ? '代码库目录不能包含控制字符' : '缺少代码库目录');
+    }
+    const tplId = a.template ?? 'duo';
+    const tpl = TEAM_TEMPLATES[tplId];
+    if (!tpl) {
+        throw new WinglineError('input', 'invalid_param', `未知团队模板：${String(tplId)}`);
+    }
+    const targetDir = a.dir ? path.resolve(a.dir) : path.join(deps.home, 'teams', name);
+    const specPath = path.join(targetDir, 'team.yaml');
+    const repo = rawRepo.startsWith('path:') ? rawRepo : `path:${rawRepo}`;
+    const existing = deps.registry.getTeam(name);
+    if (existing) {
+        if (existing.specPath === specPath && fs.existsSync(specPath)) {
+            return { team: name, specPath, created: false };
+        }
+        throw new WinglineError('input', 'team_already_exists', `团队 ${name} 已存在（${existing.specPath}）`);
+    }
+    if (fs.existsSync(specPath)) {
+        throw new WinglineError('input', 'spec_already_exists', `配置文件已存在：${specPath}，请改用“导入已有配置”`);
+    }
+    writeTemplate(targetDir, tpl, name, repo);
+    const spec = loadTeamSpec(specPath);
+    registerSpec(deps, spec);
+    return { team: name, specPath, created: true };
+}
+function initFromImport(deps, a) {
+    const rawPath = a.specPath?.trim() ?? '';
+    if (!rawPath) {
+        throw new WinglineError('input', 'invalid_param', '缺少配置文件路径');
+    }
+    const spec = loadTeamSpec(rawPath);
+    const existing = deps.registry.getTeam(spec.name);
+    if (existing) {
+        if (existing.specPath === spec.specPath) {
+            return { team: spec.name, specPath: spec.specPath, created: false };
+        }
+        throw new WinglineError('input', 'team_already_exists', `同名团队 ${spec.name} 已登记在另一路径：${existing.specPath}`);
+    }
+    registerSpec(deps, spec);
+    return { team: spec.name, specPath: path.resolve(rawPath), created: true };
+}
+export async function initTeamCmd(deps, a) {
+    if (a.mode === 'template')
+        return initFromTemplate(deps, a);
+    if (a.mode === 'import')
+        return initFromImport(deps, a);
+    throw new WinglineError('input', 'invalid_param', `未知初始化模式：${String(a.mode)}`);
+}

package/dist/commands/launch.d.ts

@@ -7,14 +7,22 @@ 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;
     value: T;
 }>;
 export declare const stepDone: (reg: Registry, id: string) => boolean;
-/** 终端被关后重新拉起要换新 id，否则 Orca 会按旧 id 回放旧回执。 */
+/**
+ * 终端被关后重新拉起要换新 id，否则 Orca 会按旧 id 回放旧回执。
+ *
+ * 两段推进：
+ * ① brief 段（原语义，located 时也生效）：create+brief 都 done 才推进——
+ *    at_prompt 拒发后 brief 行缺失，重跑必须复用同一代把 brief 补发。
+ * ② 重启段（仅 !located，终端已消失）：create+wait 都 done 的代整代跳过——
+ *    没有 brief 行的岗位（wait 未确认就中断，brief 从未发生）原来会永远卡在
+ *    「create 已 done 的代」上，beginRequest 撞 request_already_done。
+ */
 export declare function lifetimeGen(l: Launch, post: string, located: boolean): number;
 /** 会话标记 `WLS-` + 8 位小写十六进制；restore 靠它引号精确搜索找回岗位会话（spec §4）。 */
 export declare function newSessionMarker(rand?: () => string): string;

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);
@@ -22,12 +21,24 @@ export async function recorded(reg, id, fn, ok = () => true) {
     return { confirmed, value };
 }
 export const stepDone = (reg, id) => reg.getRequest(id)?.state === 'done';
-/** 终端被关后重新拉起要换新 id，否则 Orca 会按旧 id 回放旧回执。 */
+/**
+ * 终端被关后重新拉起要换新 id，否则 Orca 会按旧 id 回放旧回执。
+ *
+ * 两段推进：
+ * ① brief 段（原语义，located 时也生效）：create+brief 都 done 才推进——
+ *    at_prompt 拒发后 brief 行缺失，重跑必须复用同一代把 brief 补发。
+ * ② 重启段（仅 !located，终端已消失）：create+wait 都 done 的代整代跳过——
+ *    没有 brief 行的岗位（wait 未确认就中断，brief 从未发生）原来会永远卡在
+ *    「create 已 done 的代」上，beginRequest 撞 request_already_done。
+ */
 export function lifetimeGen(l, post, located) {
     const done = (step, g) => stepDone(l.deps.registry, requestId(l.spec.name, post, step, l.hash, g));
     let g = 0;
     while (done('create', g) && done('brief', g))
         g++;
+    if (!located)
+        while (done('create', g) && done('wait', g))
+            g++;
     if (!located && done('create', g))
         g++;
     return g;

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` 的这一次会被旧提示误判为通过。