@co0ontty/wand 4.76.0 → 4.77.0-beta.g6c4df97

package/dist/message-truncator.js

@@ -22,56 +22,272 @@ const MESSAGE_WINDOW_SIZE = 40;
  */
 const MESSAGE_BLOCK_WINDOW = 60;
 /**
- * 块级窗口：取完整历史「最近 blockBudget 个内容块」并做 transport 截断。
- * 从最新 turn 往回累计块数，能整条放下就整条放，放不下的那条（最旧的入窗 turn）
- * 只取其尾部若干块，并通过 leadingBlockOffset 告知客户端「这条 turn 还有更早的块」。
- * 客户端先按块翻完这条 turn 的头部，再按 turn 往前翻更早的整条。
+ * 首次下发（首屏）的载荷上限：截断后的聊天 JSON 体积。整段历史在这个体积内就不做窗口化 ——
+ * 一条提示词 + 一段长回复的会话不该因为几十个默认收起的工具块就出现「更早消息」。
+ * 超出的会话才按下面的预算从尾部切：客户端先翻这条 turn 的头部块，再按 turn 往前翻。
  */
-export function blockWindowMessagesForTransport(all, cardDefaults, blockBudget = MESSAGE_BLOCK_WINDOW) {
+export const MESSAGE_FIRST_PAINT_BYTES = 1024 * 1024;
+/**
+ * 吸附回退的额外载荷上限：折叠段往回吃掉的体积超过它就改为跳过整段，
+ * 而不是把整段拉进首屏（窗口的目标是压住首屏载荷，吸附不能反过来把它撑大）。
+ */
+const MAX_BLOCK_SNAP_BACK_BYTES = 128 * 1024;
+/** 每个块在客户端是否「默认收起」（思考块 + 默认收起的工具卡片，与传输截断同一口径）。 */
+export function collapsedBlockFlags(content, cardDefaults) {
+    const toolNameById = new Map();
+    for (const block of content) {
+        if (block.type === "tool_use")
+            toolNameById.set(block.id, block.name);
+    }
+    return content.map((block) => {
+        switch (block.type) {
+            case "thinking":
+                return cardDefaults.thinking !== true;
+            case "tool_use":
+                return isToolDefaultCollapsed(block.name, cardDefaults);
+            case "tool_result":
+                return isToolDefaultCollapsed(toolNameById.get(block.tool_use_id) ?? "", cardDefaults);
+            default:
+                return false;
+        }
+    });
+}
+/**
+ * 单块在传输层的大致字节数（与 truncateMessagesForTransport 的截断口径一致，
+ * 否则「体积预算」会把已经截断的大块算得过重）。
+ */
+function blockTransportBytes(block, cardDefaults, toolNameById) {
+    switch (block.type) {
+        case "text":
+            return block.text.length;
+        case "thinking":
+            return block.thinking.length;
+        case "tool_use": {
+            const use = block;
+            let bytes = use.id.length + use.name.length + 32;
+            if (use.input)
+                bytes += JSON.stringify(use.input)?.length ?? 0;
+            if (use.description)
+                bytes += use.description.length;
+            return bytes;
+        }
+        case "tool_result": {
+            const result = block;
+            const raw = getContentString(result.content);
+            const collapsed = isToolDefaultCollapsed(toolNameById.get(result.tool_use_id) ?? "", cardDefaults);
+            const truncated = collapsed && !result.is_error &&
+                !contentHasStructuredImage(result.content) && raw.length > TRUNCATION_THRESHOLD;
+            return truncated ? SUMMARY_LENGTH + 4 : raw.length;
+        }
+        default:
+            return 0;
+    }
+}
+/**
+ * 一段内容在传输层的估算体积。`limit` 用来提前收尾：一旦确认超过它就不再往下算
+ * （预算判定只需要知道「超了」，不需要精确值）。
+ */
+export function contentTransportBytes(content, cardDefaults, limit = Number.POSITIVE_INFINITY) {
+    const toolNameById = new Map();
+    for (const block of content) {
+        if (block.type === "tool_use")
+            toolNameById.set(block.id, block.name);
+    }
+    let total = 0;
+    for (const block of content) {
+        total += blockTransportBytes(block, cardDefaults, toolNameById) + 32;
+        if (total > limit)
+            return total;
+    }
+    return total;
+}
+/**
+ * 整段历史（或一条 turn）在可见条数 / 载荷两个预算内是否放得下。
+ * 任一预算被突破就立即返回 false，不把整段内容算完。
+ */
+function fitsBudgets(turns, cardDefaults, visibleBudget, byteBudget) {
+    let visible = 0;
+    let bytes = 0;
+    for (let i = turns.length - 1; i >= 0; i -= 1) {
+        const content = turns[i].content;
+        visible += visibleBlockCount(content, cardDefaults, content.length);
+        if (visible > visibleBudget)
+            return false;
+        bytes += contentTransportBytes(content, cardDefaults, byteBudget - bytes);
+        if (bytes > byteBudget)
+            return false;
+    }
+    return true;
+}
+/**
+ * 从尾部往前取到两个预算用完为止，返回该起点：
+ * 默认收起的工具 / 思考块不占可见条数预算（它们在客户端合并成一条折叠条），只算体积。
+ */
+function cutStartByBudget(content, cardDefaults, visibleBudget, byteBudget) {
+    if (content.length === 0)
+        return 0;
+    const collapsed = collapsedBlockFlags(content, cardDefaults);
+    const toolNameById = new Map();
+    for (const block of content) {
+        if (block.type === "tool_use")
+            toolNameById.set(block.id, block.name);
+    }
+    let visible = 0;
+    let bytes = 0;
+    let cut = content.length;
+    for (let i = content.length - 1; i >= 0; i -= 1) {
+        const nextVisible = visible + (collapsed[i] ? 0 : 1);
+        const nextBytes = bytes + blockTransportBytes(content[i], cardDefaults, toolNameById) + 32;
+        if (nextVisible > visibleBudget || nextBytes > byteBudget)
+            break;
+        visible = nextVisible;
+        bytes = nextBytes;
+        cut = i;
+    }
+    // 至少保留最后一块：单个巨块超预算时也得给客户端一点内容。
+    return cut >= content.length ? content.length - 1 : cut;
+}
+/** 段内最靠左的坐标：从 index 往回吃掉同一段折叠块。 */
+function collapsedRunStart(collapsed, index) {
+    let start = index;
+    while (start > 0 && collapsed[start - 1])
+        start -= 1;
+    return start;
+}
+/** 段内最靠右的坐标：从 index 往后吃掉同一段折叠块。 */
+function collapsedRunEnd(collapsed, index) {
+    let end = index;
+    while (end < collapsed.length && collapsed[end])
+        end += 1;
+    return end;
+}
+/**
+ * 把块级窗口 / 翻页的起点吸附到「语义干净」的位置：
+ *
+ * 1. 起点落在默认收起的折叠段中间 → 回到该段起点（整段入窗）。半截工具段在客户端
+ *    会渲染成一个少了前几个调用的折叠条，用户看着就是「更早消息缺了一块」。
+ * 2. 起点是配对的 tool_result（它的 tool_use 被切在前面）→ 回到 tool_use，否则客户端
+ *    顶部会冒出一张「无头结果」卡。
+ * 3. 需要往回吃掉的体积超过 MAX_BLOCK_SNAP_BACK_BYTES（或本页范围内吃不下）时不再
+ *    往回吸附，改为跳到该段之后（整段都是默认收起的内容，跳过去不会藏掉可见内容）。
+ *
+ * 返回吸附后的起点；起点越界时回退到 0（整条 turn 入窗，保证窗口不为空）。
+ */
+export function alignedBlockStart(content, cardDefaults, rawStart, forwardLimit = content.length) {
+    const total = content.length;
+    const start = Math.min(Math.max(rawStart, 0), total);
+    if (start <= 0 || total === 0)
+        return 0;
+    const collapsed = collapsedBlockFlags(content, cardDefaults);
+    const useIndexById = new Map();
+    content.forEach((block, index) => {
+        if (block.type === "tool_use")
+            useIndexById.set(block.id, index);
+    });
+    let cursor = start;
+    for (let guard = 0; guard <= total; guard += 1) {
+        let next = collapsed[cursor] ? collapsedRunStart(collapsed, cursor) : cursor;
+        const head = content[next];
+        if (head?.type === "tool_result") {
+            const useIndex = useIndexById.get(head.tool_use_id);
+            if (useIndex !== undefined && useIndex < next)
+                next = useIndex;
+        }
+        if (next === cursor)
+            break;
+        cursor = next;
+    }
+    const snapBackBytes = contentTransportBytes(content.slice(cursor, start), cardDefaults);
+    if (snapBackBytes <= MAX_BLOCK_SNAP_BACK_BYTES)
+        return cursor;
+    // 折叠段太长：不再往回吃，跳到该段之后，保证首屏载荷不因吸附膨胀。
+    const skipped = collapsed[cursor] ? collapsedRunEnd(collapsed, cursor) : cursor;
+    if (skipped >= total)
+        return 0;
+    // 跳不到更晚的位置（只可能还是往回吃）或超过本页末尾时保持原切点。
+    if (skipped <= start || skipped >= forwardLimit)
+        return start;
+    return skipped;
+}
+/** [0, end) 里用户可感知的块数（默认收起的工具 / 思考块不计入）。 */
+export function visibleBlockCount(content, cardDefaults, end) {
+    const limit = Math.min(Math.max(end, 0), content.length);
+    const collapsed = collapsedBlockFlags(content, cardDefaults);
+    let count = 0;
+    for (let i = 0; i < limit; i += 1) {
+        if (!collapsed[i])
+            count += 1;
+    }
+    return count;
+}
+/**
+ * 块级窗口：默认取整段历史（只要它在预算内），超出的才从最新 turn 往回累计，
+ * 能整条放下就整条放，放不下的那条（最旧的入窗 turn）只取其尾部若干块，
+ * 并通过 leadingBlockOffset 告知客户端「这条 turn 还有更早的块」。
+ *
+ * 预算口径：`blockBudget` 数的是**用户可感知的条数**（默认收起的工具 / 思考块不计入），
+ * 另外叠加一层载荷上限 —— 否则一段长工具调用会把预算吃光，把用户自己的提示词挤出首屏，
+ * 一条提示词的会话也会莫名出现「更早消息」。
+ */
+export function blockWindowMessagesForTransport(all, cardDefaults, blockBudget = MESSAGE_BLOCK_WINDOW, byteBudget = MESSAGE_FIRST_PAINT_BYTES) {
     const turns = all ?? [];
     const total = turns.length;
     if (total === 0) {
-        return { messages: [], messageOffset: 0, messageTotal: 0, leadingBlockOffset: 0, leadingBlockTotal: 0 };
+        return {
+            messages: [],
+            messageOffset: 0,
+            messageTotal: 0,
+            leadingBlockOffset: 0,
+            leadingBlockTotal: 0,
+            leadingVisibleCount: 0,
+        };
+    }
+    const visibleBudget = Math.max(1, blockBudget);
+    // 整段历史放得下就不做窗口化：短会话（一条提示词 + 一段长回复）不该出现「更早消息」。
+    if (fitsBudgets(turns, cardDefaults, visibleBudget, byteBudget)) {
+        const last = turns[total - 1];
+        return {
+            messages: truncateMessagesForTransport(turns, cardDefaults),
+            messageOffset: 0,
+            messageTotal: total,
+            leadingBlockOffset: 0,
+            leadingBlockTotal: last.content.length,
+            leadingVisibleCount: 0,
+        };
     }
-    const budget = Math.max(1, blockBudget);
     let startTurn = total - 1;
     let leadingBlockOffset = 0;
-    let acc = 0;
-    for (let i = total - 1; i >= 0; i--) {
-        const n = turns[i].content.length;
-        if (i === total - 1) {
-            // 最新一条 turn 必须入窗：整条放得下就整条，放不下取尾部 budget 块。
-            if (n <= budget) {
-                acc = n;
-                startTurn = i;
-                leadingBlockOffset = 0;
-            }
-            else {
-                startTurn = i;
-                leadingBlockOffset = n - budget;
-                acc = budget;
-                break;
-            }
-        }
-        else if (acc + n <= budget) {
-            acc += n;
+    let accVisible = 0;
+    let accBytes = 0;
+    for (let i = total - 1; i >= 0; i -= 1) {
+        const content = turns[i].content;
+        const visible = visibleBlockCount(content, cardDefaults, content.length);
+        const bytes = contentTransportBytes(content, cardDefaults, byteBudget - accBytes);
+        if (accVisible + visible <= visibleBudget && accBytes + bytes <= byteBudget) {
+            accVisible += visible;
+            accBytes += bytes;
             startTurn = i;
             leadingBlockOffset = 0;
+            continue;
         }
-        else {
-            const remaining = budget - acc;
-            if (remaining > 0) {
-                startTurn = i;
-                leadingBlockOffset = n - remaining;
-                acc += remaining;
-            }
+        // 放不下：按剩余预算切进这条 turn 的尾部；预算已耗尽则到此为止。
+        const remainVisible = visibleBudget - accVisible;
+        const remainBytes = byteBudget - accBytes;
+        if (i !== total - 1 && (remainVisible <= 0 || remainBytes <= 0))
             break;
-        }
+        startTurn = i;
+        leadingBlockOffset = cutStartByBudget(content, cardDefaults, Math.max(remainVisible, 1), Math.max(remainBytes, 1));
+        break;
     }
+    // 最旧入窗 turn 的切点吸附到干净边界：不切开折叠的工具段，也不留下无头 tool_result。
+    const headContent = turns[startTurn].content;
+    const startOffset = leadingBlockOffset > 0
+        ? alignedBlockStart(headContent, cardDefaults, leadingBlockOffset)
+        : 0;
     const windowedTurns = [];
     for (let i = startTurn; i < total; i++) {
-        if (i === startTurn && leadingBlockOffset > 0) {
-            windowedTurns.push({ ...turns[i], content: turns[i].content.slice(leadingBlockOffset) });
+        if (i === startTurn && startOffset > 0) {
+            windowedTurns.push({ ...turns[i], content: turns[i].content.slice(startOffset) });
         }
         else {
             windowedTurns.push(turns[i]);
@@ -81,8 +297,9 @@ export function blockWindowMessagesForTransport(all, cardDefaults, blockBudget =
         messages: truncateMessagesForTransport(windowedTurns, cardDefaults),
         messageOffset: startTurn,
         messageTotal: total,
-        leadingBlockOffset,
-        leadingBlockTotal: turns[startTurn].content.length,
+        leadingBlockOffset: startOffset,
+        leadingBlockTotal: headContent.length,
+        leadingVisibleCount: visibleBlockCount(headContent, cardDefaults, startOffset),
     };
 }
 /**

package/dist/missions.d.ts

@@ -1,8 +1,10 @@
-import type { AgentActivityItem, CreateMissionInput, CreateReviewCommentInput, MissionDetails, MissionDiff, MissionReviewComment } from "./mission-types.js";
+import type { AgentActivityItem, AgentActivityState, CreateMissionInput, CreateReviewCommentInput, MissionDetails, MissionDiff, MissionReviewComment } from "./mission-types.js";
 import type { SessionRegistry } from "./session-registry.js";
 import type { StructuredSessionManager } from "./structured-session-manager.js";
 import type { WandStorage } from "./storage.js";
-import type { ProcessEvent } from "./types.js";
+import type { ConversationTurn, ProcessEvent, SessionSnapshot } from "./types.js";
+export declare function hasUnansweredQuestion(messages: ConversationTurn[] | undefined): boolean;
+export declare function activityState(snapshot: SessionSnapshot, event?: ProcessEvent): AgentActivityState;
 /**
  * Deep task-orchestration module. Callers create missions and review diffs
  * without coordinating session/worktree/storage details.

package/dist/missions.js

@@ -60,7 +60,7 @@ function sessionSummary(snapshot) {
     }
     return cleanActivityText(snapshot.summary?.trim() || "", 160);
 }
-function hasUnansweredQuestion(messages) {
+export function hasUnansweredQuestion(messages) {
     if (!messages?.length || messages[messages.length - 1]?.role === "user")
         return false;
     const answered = new Set();
@@ -81,7 +81,7 @@ function hasUnansweredQuestion(messages) {
     }
     return false;
 }
-function activityState(snapshot, event) {
+export function activityState(snapshot, event) {
     if (snapshot.pendingEscalation || snapshot.permissionBlocked)
         return "needs_permission";
     if (hasUnansweredQuestion(snapshot.messages))

package/dist/process-manager.d.ts

@@ -69,6 +69,7 @@ export declare class ProcessManager extends EventEmitter {
         workspaceId?: string;
         workspaceTaskId?: string;
         interactiveShell?: boolean;
+        systemPrompt?: string;
     }): Promise<SessionSnapshot>;
     list(): SessionSnapshot[];
     /** Return lightweight snapshots for the session list (no output/messages). */

package/dist/process-manager.js

@@ -13,7 +13,7 @@ import { buildChildEnv, isRunningAsRoot } from "./env-utils.js";
 import { buildLanguageDirective, buildManagedAutonomyDirective } from "./language-prompt.js";
 import { prepareSessionWorktree } from "./git-worktree.js";
 import { getProviderCommandSessionId, getProviderResumeCommandSessionId } from "./resume-policy.js";
-import { normalizeThinkingEffort, thinkingEffortToClaudeCliEffort, thinkingEffortToClaudeSlashEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToGrokEffort, thinkingEffortToPiLevel, thinkingEffortToQoderEffort } from "./structured-provider-common.js";
+import { commandWithSystemPrompt, composeSystemFallback, normalizeThinkingEffort, systemPromptFlag, thinkingEffortToClaudeCliEffort, thinkingEffortToClaudeSlashEffort, thinkingEffortToCodexReasoningEffort, thinkingEffortToGrokEffort, thinkingEffortToPiLevel, thinkingEffortToQoderEffort } from "./structured-provider-common.js";
 import { consumePtyInputForTopic, createPtyTopicLineBuffer, provisionalSessionTopic, SessionTopicCoordinator, sessionTopicBlocklistForSnapshot, shouldAcceptGeneratedSessionTitle, shouldGenerateSessionTopicFromInput, } from "./session-topic.js";
 import { getErrorMessage } from "./error-utils.js";
 import { recordIterationPrompt } from "./iteration-log.js";
@@ -1034,6 +1034,12 @@ export class ProcessManager extends EventEmitter {
         const selectedModel = opts?.model?.trim() || undefined;
         const initialThinkingEffort = normalizeThinkingEffort(opts?.thinkingEffort);
         let processedCommand = this.processCommandForMode(command, effectiveMode, provider, selectedModel, initialThinkingEffort);
+        // 会话级系统提示：provider 有系统提示开关就走开关（PTY 与结构化行为一致），没有就并进首条输入。
+        const systemPrompt = opts?.systemPrompt?.trim() || undefined;
+        const initialInputText = initialInput && systemPrompt && !systemPromptFlag(provider)
+            ? composeSystemFallback(systemPrompt, initialInput)
+            : initialInput;
+        processedCommand = commandWithSystemPrompt(processedCommand, provider, systemPrompt);
         const isCodexProvider = provider === "codex";
         const isOpenCodeProvider = provider === "opencode";
         const existingProviderSessionId = provider
@@ -1069,6 +1075,7 @@ export class ProcessManager extends EventEmitter {
             id,
             sessionSource: opts?.sessionSource ?? inheritedSessionSource ?? "interactive",
             automationId: opts?.automationId ?? inheritedAutomationId,
+            systemPrompt: systemPrompt ?? null,
             workspaceId: opts?.workspaceId ?? inheritedWorkspaceId,
             workspaceTaskId: opts?.workspaceTaskId ?? inheritedWorkspaceTaskId,
             provider,
@@ -1189,7 +1196,7 @@ export class ProcessManager extends EventEmitter {
         record.status = "running";
         let initialInputSent = false;
         const sendInitialInput = () => {
-            if (initialInputSent || !initialInput)
+            if (initialInputSent || !initialInputText)
                 return;
             initialInputSent = true;
             const current = this.sessions.get(id);
@@ -1197,20 +1204,20 @@ export class ProcessManager extends EventEmitter {
                 process.stderr.write(`[wand] Cannot send initial input: session not ready\n`);
                 return;
             }
-            process.stderr.write(`[wand] Sending initial input (${initialInput.length} chars)\n`);
+            process.stderr.write(`[wand] Sending initial input (${initialInputText.length} chars)\n`);
             if (current.ptyBridge) {
-                current.ptyBridge.onUserInput(initialInput);
+                current.ptyBridge.onUserInput(initialInputText);
             }
-            child.write(initialInput);
+            child.write(initialInputText);
             child.write("\r");
         };
         this.bindTerminalProcess(record, child, (chunk) => {
-            if (initialInput && !initialInputSent && (chunk.includes("❯") || chunk.includes("›")))
+            if (initialInputText && !initialInputSent && (chunk.includes("❯") || chunk.includes("›")))
                 sendInitialInput();
         });
         this.emitEvent({ type: "started", sessionId: id, data: this.snapshot(record) });
-        if (initialInput)
-            this.maybeGenerateSessionTopic(id, initialInput);
+        if (initialInputText)
+            this.maybeGenerateSessionTopic(id, initialInputText);
         if (launchPlan.commandToWrite) {
             child.write(launchPlan.commandToWrite);
             child.write("\r");
@@ -1893,6 +1900,8 @@ export class ProcessManager extends EventEmitter {
             sessionKind: "pty",
             sessionSource: record.sessionSource ?? "interactive",
             automationId: record.automationId,
+            // 会话级系统提示要跟着快照回库（persist 就是走 snapshot），否则重启后 resume 会丢掉角色与规则。
+            systemPrompt: record.systemPrompt ?? null,
             provider: record.provider,
             providerCliActive: record.providerCliActive,
             providerCliExitCode: record.providerCliExitCode,

package/dist/prompt-optimizer.js

@@ -10,17 +10,17 @@ export class PromptOptimizeError extends Error {
 }
 function buildOptimizePrompt(userInput, language) {
     const lang = (language || "").trim() || "中文";
-    return [
-        `你是一名提示词优化助手。请把用户写给编码 AI 的「原始提示词」改写得更清晰、结构化、可执行，便于 AI 理解并完成任务。`,
-        `要求：`,
-        `1. 保留用户原意和所有关键信息（文件路径、变量名、技术名词、数字、约束等），不要删减事实，也不要新增臆测的需求。`,
-        `2. 必要时拆分为「目标 / 上下文 / 约束 / 验收标准」几个部分；如果原文很短或很简单，则只做语句润色，不要硬塞结构。`,
-        `3. 用${lang}输出。语气克制专业，不寒暄、不解释你做了什么。`,
-        `4. 只输出优化后的提示词正文，不要包裹在代码块或引号里，不要加任何前后缀（比如「优化后：」之类）。`,
-        ``,
-        `原始提示词：`,
-        userInput,
-    ].join("\n");
+    return {
+        system: [
+            `你是一名提示词优化助手。请把用户写给编码 AI 的「原始提示词」改写得更清晰、结构化、可执行，便于 AI 理解并完成任务。`,
+            `要求：`,
+            `1. 保留用户原意和所有关键信息（文件路径、变量名、技术名词、数字、约束等），不要删减事实，也不要新增臆测的需求。`,
+            `2. 必要时拆分为「目标 / 上下文 / 约束 / 验收标准」几个部分；如果原文很短或很简单，则只做语句润色，不要硬塞结构。`,
+            `3. 用${lang}输出。语气克制专业，不寒暄、不解释你做了什么。`,
+            `4. 只输出优化后的提示词正文，不要包裹在代码块或引号里，不要加任何前后缀（比如「优化后：」之类）。`,
+        ].join("\n"),
+        prompt: `原始提示词：\n${userInput}`,
+    };
 }
 export async function optimizePrompt(rawText, language, cwd, ai = {}) {
     const text = (rawText || "").trim();
@@ -30,10 +30,10 @@ export async function optimizePrompt(rawText, language, cwd, ai = {}) {
     if (text.length > MAX_INPUT_LENGTH) {
         throw new PromptOptimizeError(`输入过长（${text.length} 字符），请缩短到 ${MAX_INPUT_LENGTH} 以内。`, "INPUT_TOO_LONG");
     }
-    const prompt = buildOptimizePrompt(text, language);
+    const request = buildOptimizePrompt(text, language);
     let raw;
     try {
-        raw = await callConfiguredAiText(prompt, cwd ?? process.cwd(), language, ai);
+        raw = await callConfiguredAiText(request, cwd ?? process.cwd(), language, ai);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);

package/dist/server-ai-team-routes.d.ts

@@ -0,0 +1,11 @@
+import type { Express } from "express";
+import { type AiTeamRunner } from "./ai-team-runner.js";
+import { type AiTeam } from "./ai-team-types.js";
+import type { WandStorage } from "./storage.js";
+/** 团队页「直接开工」自动建卡的标记（§4.2 / Q3）：看板靠它区分团队卡与手写卡。 */
+export declare const TEAM_DIRECT_LABEL = "team_direct";
+export declare function parseAiTeamInput(value: unknown, existing: AiTeam | null, now: string): AiTeam;
+export declare function registerAiTeamRoutes(app: Express, deps: {
+    storage: WandStorage;
+    runner: AiTeamRunner;
+}): void;