@steerable/agent-shell 0.6.61 → 0.6.63

package/dist/local-backend/router.js

@@ -9,6 +9,7 @@ import { llmService, getSidecarSupervisor, whenSidecarSupervisor } from '../llm/
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 import { buildWorldState, getActiveCoreLoopStreamId, streamCoreLoopTurn, } from './coreloop-stream.js';
 import { driveWithAutoContinue, resolveAutoContinueMax, } from './auto-continue-helper.js';
+import { buildActiveGoalContext, buildGoalContinuationPrompt, shouldContinueGoal, } from './goal-continuation-helper.js';
 import { buildAmbientDelegateRoster, buildDelegateDispatchInstruction, buildDelegateRosterHint, buildMentionDelegateRoster, BUILTIN_SUBAGENT_PROFILES, mergeTurnSubagentParam, } from './subagent-profiles.js';
 import { resolveMentionedAgentIds } from './mention-targets.js';
 import { presentToolCall } from '../tool-presentation.js';
@@ -214,6 +215,10 @@ export class LocalBackendRouter {
         this.resolveStore = options.resolveStore ?? (() => options.store);
         this.broadcast = options.broadcast ?? null;
         this.taskService = options.taskService ?? null;
+        const goals = this.toolRouter.goals?.();
+        goals?.onChange((chatId, goal) => {
+            this.broadcast?.('goal-changed', { chatId, goal });
+        });
     }
     get store() {
         return this.storeContext.getStore() ?? this.defaultStore;
@@ -229,6 +234,78 @@ export class LocalBackendRouter {
         const { method } = request;
         const url = new URL(request.path, 'http://local.backend');
         const pathname = url.pathname;
+        const goalMatch = pathname.match(/^\/api\/v2\/chats\/([^/]+)\/goal$/);
+        if (goalMatch) {
+            const chatId = goalMatch[1];
+            const chat = await this.store.getChat(chatId);
+            if (!chat)
+                return { status: 404, data: { detail: 'chat not found' } };
+            const goals = this.toolRouter.goals();
+            if (method === 'GET') {
+                const result = await goals.get(chatId);
+                return { status: 200, data: { goal: result.goal ?? null } };
+            }
+            if (method === 'POST') {
+                const payload = this.toRecord(request.body);
+                const action = String(payload.action || '');
+                if (action === 'set') {
+                    const result = await goals.create(chatId, String(payload.objective || ''));
+                    if (result.success && result.goal) {
+                        this.startGoalWake(chatId, result.goal);
+                    }
+                    return {
+                        status: result.success ? 200 : 409,
+                        data: result.success ? { goal: result.goal } : { detail: result.error, goal: result.goal },
+                    };
+                }
+                if (action === 'clear') {
+                    const result = await goals.clear(chatId);
+                    return { status: 200, data: { goal: result.goal ?? null } };
+                }
+                const current = (await goals.get(chatId)).goal;
+                if (!current)
+                    return { status: 404, data: { detail: 'goal not found' } };
+                const result = await goals.update({
+                    chatId,
+                    id: current.id,
+                    revision: current.revision,
+                    action,
+                    actor: 'user',
+                    objective: typeof payload.objective === 'string' ? payload.objective : undefined,
+                });
+                if (result.success && result.goal && action === 'resume') {
+                    this.startGoalWake(chatId, result.goal);
+                }
+                return {
+                    status: result.success ? 200 : 400,
+                    data: result.success ? { goal: result.goal } : { detail: result.error, goal: result.goal },
+                };
+            }
+            return this.notFound('Not found');
+        }
+        const loopsMatch = pathname.match(/^\/api\/v2\/chats\/([^/]+)\/loops$/);
+        if (loopsMatch && method === 'GET') {
+            const chatId = loopsMatch[1];
+            if (!await this.store.getChat(chatId)) {
+                return { status: 404, data: { detail: 'chat not found' } };
+            }
+            return {
+                status: 200,
+                data: { loops: this.toolRouter.listMonitoredLoops(chatId) },
+            };
+        }
+        const loopMatch = pathname.match(/^\/api\/v2\/chats\/([^/]+)\/loops\/([^/]+)$/);
+        if (loopMatch && method === 'DELETE') {
+            const chatId = loopMatch[1];
+            if (!await this.store.getChat(chatId)) {
+                return { status: 404, data: { detail: 'chat not found' } };
+            }
+            const success = this.toolRouter.stopMonitoredLoop(chatId, loopMatch[2]);
+            return {
+                status: success ? 200 : 404,
+                data: success ? { success: true } : { detail: 'loop not found' },
+            };
+        }
         if (method === 'GET' && pathname === '/api/v2/auth/me') {
             const authProvider = getAuthProvider();
             if (authProvider) {
@@ -1949,6 +2026,18 @@ export class LocalBackendRouter {
             return packHttp;
         return this.fallbackResponse(method, pathname);
     }
+    startGoalWake(chatId, goal) {
+        void this.wakeChat(chatId, {
+            trigger: 'goal',
+            message: buildGoalContinuationPrompt(goal),
+            sourceId: goal.id,
+        }).catch((error) => {
+            console.warn('[goal] chat wake failed', {
+                chatId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        });
+    }
     /**
      * 对未显式实现的路由做"温柔降级"：GET 返回空集合/空对象，不让 UI 因 404 抛错跳到
      * not-found；其他方法返回 success:true 让前端流程继续。所有兜底都在主进程终端
@@ -1995,7 +2084,78 @@ export class LocalBackendRouter {
      * - 结束：标准 SSE `[DONE]` 串。
      */
     handleStream(request, emit, options = {}) {
-        return this.storeContext.run(this.resolveStore(request.principal), () => this.handleStreamScoped(request, emit, options));
+        return this.storeContext.run(this.resolveStore(request.principal), async () => {
+            const result = await this.handleStreamScoped(request, emit, options);
+            await this.continueActiveGoal(request, result, options);
+            return result;
+        });
+    }
+    /**
+     * Start one host-initiated turn in an idle chat, then continue an active
+     * goal if that turn still leaves work to do.
+     */
+    async wakeChat(chatId, input) {
+        return this.storeContext.run(this.store, async () => {
+            this.broadcast?.('chat-turn-started', {
+                chatId,
+                trigger: input.trigger,
+                sourceId: input.sourceId,
+            });
+            const result = await this.handleStreamScoped({
+                method: 'POST',
+                path: `/api/v2/chats/${encodeURIComponent(chatId)}/send`,
+                body: {
+                    message: input.message,
+                    internal: true,
+                    trigger: input.trigger,
+                    sourceId: input.sourceId,
+                },
+            }, () => { });
+            this.broadcast?.('chat-turn-finished', {
+                chatId,
+                trigger: input.trigger,
+                sourceId: input.sourceId,
+                status: result.turn?.completionStatus ?? result.status,
+            });
+            if (result.status === 409)
+                return { started: false, reason: 'busy', status: result.status };
+            if (result.status !== 200)
+                return { started: false, reason: 'failed', status: result.status };
+            await this.continueActiveGoal({
+                method: 'POST',
+                path: `/api/v2/chats/${encodeURIComponent(chatId)}/send`,
+                body: { internal: true, trigger: input.trigger, sourceId: input.sourceId },
+            }, result, {});
+            return { started: true, status: result.status };
+        });
+    }
+    async continueActiveGoal(request, result, options) {
+        if (!result.turn)
+            return;
+        const pathname = new URL(request.path, 'http://local.backend').pathname;
+        const match = pathname.match(/^\/api\/v2\/chats\/([^/]+)\/(?:send|run|agent)$/);
+        if (!match)
+            return;
+        const chatId = decodeURIComponent(match[1]);
+        const goals = this.toolRouter.goals();
+        const current = (await goals.get(chatId)).goal;
+        if (!current)
+            return;
+        const recorded = await goals.recordTurn(chatId, current.id);
+        if (!recorded)
+            return;
+        if (!shouldContinueGoal({
+            phase: recorded.phase,
+            completionStatus: result.turn.completionStatus,
+            madeProgress: result.turn.madeProgress,
+            aborted: options.signal?.aborted === true,
+        }))
+            return;
+        await this.wakeChat(chatId, {
+            trigger: 'goal',
+            message: buildGoalContinuationPrompt(recorded),
+            sourceId: recorded.id,
+        });
     }
     async handleStreamScoped(request, emit, options = {}) {
         const signal = options.signal;
@@ -2042,7 +2202,7 @@ export class LocalBackendRouter {
             emit(this.sse('error', { message: 'chat not found' }));
             return { status: 404 };
         }
-        return this.withChatWriteLock(chatId, emit, async () => {
+        return this.withChatWriteLock(chatId, emit, async (emit) => {
             // W7-1: resume=true（仅 send 路由）续跑 durable record 里被中断的 turn，
             // 不追加新用户消息；与 regenerate 互斥（regenerate 有自己的路径参数语义）。
             const isResume = !regenerateMatch && payload.resume === true;
@@ -2183,8 +2343,21 @@ export class LocalBackendRouter {
             const chatAgents = await this.store.listChatAgents();
             const mentionedAgentIds = resolveMentionedAgentIds(payload, userMessageText, chatAgents);
             if (!regenerateMatch && !isResume) {
-                const userMeta = mentionedAgentIds.length > 0
-                    ? JSON.stringify({ mentionedAgentIds })
+                const internal = payload.internal === true &&
+                    (payload.trigger === 'goal' || payload.trigger === 'loop') &&
+                    typeof payload.sourceId === 'string';
+                const userMetadata = {
+                    ...(mentionedAgentIds.length > 0 ? { mentionedAgentIds } : {}),
+                    ...(internal
+                        ? {
+                            internal: true,
+                            trigger: payload.trigger,
+                            sourceId: payload.sourceId,
+                        }
+                        : {}),
+                };
+                const userMeta = Object.keys(userMetadata).length > 0
+                    ? JSON.stringify(userMetadata)
                     : null;
                 const userMessage = await this.store.addMessage(chatId, 'user', userMessageText, userMeta);
                 currentUserMessageId = userMessage.id;
@@ -2497,9 +2670,14 @@ export class LocalBackendRouter {
         const runtimeEnvironment = this.buildRuntimeEnvironmentContext(chatMode);
         // 名录进 realityCheck：两条系统提示拼装路径（技能拼装 / 用户整段覆盖）
         // 都会带上它，且位置在末尾——不动技能正文那段 prompt cache 前缀。
+        const activeGoal = (await this.toolRouter.goals().get(chatId)).goal;
+        const goalContext = activeGoal?.phase === 'active'
+            ? buildActiveGoalContext(activeGoal.objective)
+            : '';
         const realityCheck = runtimeEnvironment +
             this.buildToolRealityCheck(turnTools, polluted, chatMode) +
-            buildDelegateRosterHint([...delegates.mention, ...delegates.ambient]);
+            buildDelegateRosterHint([...delegates.mention, ...delegates.ambient]) +
+            goalContext;
         // 用户显式覆盖（payload.systemPrompt 优先 / settings.systemPrompt 自定义了且非默认值次之）走
         // "整段替换"路径，保持旧行为可被外部完全控制；否则交给 skill-based
         // SystemPromptBuilder 根据本轮可用工具动态拼装。
@@ -3069,12 +3247,23 @@ export class LocalBackendRouter {
             emit(this.sse('error', { code: 'chat_busy', message: '该会话正在另一个进程中运行' }));
             return { status: 409 };
         }
+        let doneChunk;
+        let result;
         try {
-            return await body();
+            result = await body((chunk) => {
+                if (chunk === 'data: [DONE]\n\n') {
+                    doneChunk = chunk;
+                    return;
+                }
+                emit(chunk);
+            });
         }
         finally {
             lease.release();
         }
+        if (doneChunk)
+            emit(doneChunk);
+        return result;
     }
     sse(event, data) {
         return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
@@ -3447,6 +3636,7 @@ export class LocalBackendRouter {
                 sinceMs: turnStartedAtMs,
                 actions: executedActions,
                 projectRoot: workspaceRoot,
+                finalText: assistantText,
             });
         }
         catch (turnFilesErr) {
@@ -3553,7 +3743,13 @@ export class LocalBackendRouter {
             assistantText,
             completionStatus,
         });
-        return { status: 200 };
+        return {
+            status: 200,
+            turn: {
+                completionStatus,
+                madeProgress: executedActions.length > 0 || assistantText.length > 0,
+            },
+        };
     }
     /**
      * 回合结束后生成下一轮用户输入建议。只走一次 LLM 判断

package/dist/local-backend/skills/10-goal/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: goal
 displayName: Goal tracking
-description: 把一句话需求变成有验收标准的目标，用 todo_write 建清单、执行中更新状态、收尾逐条给出证据。适合多步骤、跨回合、需要明确「到底做完没有」的任务。
+description: 把明确要求长期跟踪的目标交给原生 goal 状态与自动续跑；目标会跨回合持续，直到完成、暂停或真实阻塞。
 priority: 500
 tags: [workflow, planning, goal]
 disable-model-invocation: true
@@ -9,51 +9,31 @@ disable-model-invocation: true
 
 # 目标跟踪（Goal）
 
-用户希望这次不是随手做一件事，而是**盯住一个目标直到真正达成**。本技能的顺序是固定的：先立目标 → 落成清单 → 执行并更新 → 逐条验收。
+用法：`/goal <目标>`。
 
-## 1. 先立目标（不要跳过）
+- 目标为空时显示 `Usage: /goal <目标>`。
+- Goal 没有时间、token 或回合上限。以 `30m`、`2h` 等时限开头时，明确说明暂不支持时限，然后去掉时限创建目标。
+- “每隔 / 每天 / every”是重复工作，应使用 `/loop`。
 
-开工前，用不超过 6 行把目标说清楚：
+## 启动
 
-- **目标**：一句话描述「做完之后世界变成什么样」，必须是结果，不是动作。
-  - ✅ 「本地能一条命令跑通测试并全绿」
-  - ❌ 「去看看测试」
-- **验收标准**：2-4 条可检验的条件，每条都要能用一次工具调用或一段真实输出来证明。
-- **不做什么**：明确本次不处理的范围，避免越做越大。
+1. 用一句话重述完整目标，并保留用户要求的每个交付物与验收证据。
+2. 恰好调用一次 `create_goal`。不要自行创建 goal 文件；不要用 `todo_write` 代替 goal。
+3. 创建失败时明确说明目标没有启动，不要重试创建。
+4. 创建成功后，本回合立即完成第一个具体工作单元；不能只规划或只创建目标就结束。
 
-信息不足时，**先问最关键的 1-3 个问题再动手**，不要靠猜设定验收标准。用户已经给足信息时不要明知故问。
+## 持续执行
 
-## 2. 落成清单（todo_write）
+- 目标跨回合存在。保持原目标完整，不得为了本回合能收尾而缩小范围或降低验收标准。
+- 以当前工作区、命令输出、测试结果与外部状态为准；旧对话只用于定位。
+- 多步骤工作可以用 `todo_write` 显示进度，但 todo 只是可见计划，不是 goal 状态，也不能替代实际工作。
 
-目标确认后立刻调 `todo_write` 建清单：
+## 完成核对
 
-- 每条对应一个可独立验证的步骤，通常 3-8 条；一步就能做完的事不用本技能。
-- 步骤顺序即执行顺序；有依赖关系的写在后面。
-- 验收标准本身也要有对应条目（例如「跑一次测试确认全绿」），否则收尾时没有证据。
+决定完成前先假定“尚未完成”：
 
-## 3. 执行并更新状态
+- 从目标和引用的文件、方案、issue 中逐条导出要求。
+- 为每项要求找到范围匹配的当前证据；缺失、间接或不确定的证据都视为未完成。
+- 意图、部分进展、旧输出和“没发现问题”不能证明完成。
 
-- 开始某条 → 标 `in_progress`，**同时只能有一条**。
-- 某条做完 → 立刻标 `completed`，不要攒到最后一起改。
-- 范围变化（发现某步不必做、或必须新增一步）→ **重写清单**并用一句话说明为什么变，不要偷偷跳过。
-- 清单还有未完成项时，**不允许**用纯文本汇报进度然后停手。
-
-## 4. 收尾验收
-
-所有条目完成后，按验收标准逐条给结论，每条都要带**真实证据**（工具返回的输出、文件路径、退出码、页面变化），不要只写「已完成」。
-
-格式：
-
-```
-目标：<一句话>
-- [x] 验收1：<结论> —— 证据：<真实输出摘要 / 文件路径>
-- [x] 验收2：<结论> —— 证据：<...>
-- [ ] 验收3：未达成 —— 原因：<真实原因>，建议：<下一步>
-```
-
-有未达成项时**如实列出**并给出下一步，不要为了收尾而宣称成功。
-
-## 与其他机制的关系
-
-- 目标很大、可以并行或上下文很重 → 子任务用 `delegate_subagent` 委派，跨回合的长任务用 `task_run`（有先后关系用 `dependsOn` 串起来），主线仍然靠本清单跟踪。
-- 用户只想先看方案、暂时不执行 → 让他切到输入框底部的 **Plan 模式**，那里会产出可确认的计划；本技能负责的是「认领目标并做完」。
+只有全部要求都有直接证据且没有剩余工作时，才调用 `update_goal`，action 为 `complete`。用户明确要求暂停时才用 `pause`。同一真实阻塞连续出现至少三个目标回合、且没有任何安全的下一步时，才用 `blocked` 并给出具体原因。

package/dist/local-backend/skills/11-loop/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: loop
 displayName: Repeat on a schedule
-description: 按固定间隔或自选节奏重复执行同一件事（如「每 5 分钟查一次构建状态」）。支持本轮内有限次循环和 task_run 后台长循环，必须先定好间隔、终止条件与最大次数。
+description: 按固定间隔重复任务，或监控到终态后自动停止；用原生 loop 工具启动受监控后台 shell，并在每次标记输出时唤醒当前会话。
 priority: 500
 tags: [workflow, automation, loop]
 disable-model-invocation: true
@@ -9,63 +9,26 @@ disable-model-invocation: true
 
 # 循环执行（Loop）
 
-用法：`/loop [间隔] <要重复做的事>`，间隔写在前后都认。
+用法：`/loop [间隔] <要重复做的事>`。
 
-- `/loop 5m 查一下构建状态`
-- `/loop 每 30 秒看一次日志有没有 ERROR`
-- `/loop 盯着下载进度`（没写间隔 = 由你自己定节奏）
+- 支持前置或后置间隔，如 `5m 查构建`、`查构建 every 5 minutes`。
+- 单位统一为秒传给工具：`30s` → 30，`5m` → 300，`2h` → 7200。
+- 没写间隔时，根据结果值得再次检查的时间选择一个合理间隔，并明确告知用户。
+- prompt 为空时显示 `Usage: /loop [间隔] <prompt>`。
+- 区分有限监控与长期周期任务。`监控构建直到结束` 有终态；`每小时汇总日志` 没有终态，除非用户另行指定。
 
-## 1. 先定三要素（缺一不可）
+## 启动
 
-开始循环前必须确定并**用一句话告诉用户**：
+1. 用真实工具立即执行 prompt 一次；不要先等待。
+2. 有限监控在首次执行后检查终态。若任务已经成功、失败、取消或到达用户指定的其他终态，报告最终结果，不创建 loop。
+3. 仍需继续时调用 `loop_create`，传入自包含的 `prompt` 与正整数 `intervalSeconds`。有限监控的 prompt 必须写明要检查的对象、当前状态的取得方式和终止条件；长期周期任务不得虚构终止条件。
+4. 告知用户：首轮已经执行、循环间隔、loop id，以及有限监控会在终态自动停止，长期周期任务会持续到调用 `loop_stop` 或宿主退出。
 
-| 要素 | 规则 |
-| --- | --- |
-| **间隔** | 用户给了就按用户的；没给就自己选一个合理值（秒级任务 10-30s，分钟级 1-5m）并说明理由 |
-| **终止条件** | 「什么情况下算成功、可以停」。用户没说就自己拟一个并告知，例如「状态变成 success 就停」 |
-| **最大次数** | 硬上限，默认不超过 10 轮。到达上限必须停下汇报，不允许自动续命 |
+`loop_create` 会启动独立的受监控后台 shell。每次到点时，shell 输出标记，运行时据此唤醒当前会话并再次执行 prompt。唤醒消息包含 loop id；有限监控确认终态后必须调用 `loop_stop`，再报告最终结果。证据不足时保留 loop，等待下一次唤醒。不要自己在当前回合里 `sleep`，不要用 `task_run` 模拟循环，也不要创建重复 loop。
 
-用户只说「一直盯着」而没有终止条件时，仍然要自己设一个上限并说明——**绝不允许无限循环**。
+## 查看与停止
 
-## 2. 选机制
-
-| 场景 | 机制 |
-| --- | --- |
-| 总时长在几分钟内、用户想实时看到每轮结果 | **本轮内循环**（见下方 A） |
-| 单轮间隔长、总时长跨越本次回答、或用户要继续聊别的 | **后台任务循环**（见下方 B） |
-
-判断不了时问用户一句：「要我现在盯着（几分钟内出结果），还是放后台跑？」
-
-### A. 本轮内循环
-
-一轮 = 等待 → 执行 → 汇报变化。等待用 `local_exec_shell`，按真实 shell 选方言：
-
-| shell | 等待命令 |
-| --- | --- |
-| PowerShell（Windows 默认） | `Start-Sleep -Seconds 30` |
-| bash / zsh | `sleep 30` |
-
-- 等待命令的 `timeout` 参数要大于间隔本身，否则会被判超时掐断。
-- 每轮只汇报**变化**（「第 3 轮：状态仍为 running，日志新增 2 行报错」），不要把同样的内容重复贴一遍。
-- 达成终止条件、或到达最大次数 → 立刻停止并给结论。
-
-### B. 后台任务循环（task_run）
-
-把**整个循环**写进一次 `task_run` 的 `task` 里——后台任务是独立的推理循环，看不到本对话，指令必须自包含，至少包含：
-
-1. 要重复执行的具体动作（含命令、路径、判断依据）
-2. 每轮间隔与等待方式
-3. 终止条件与最大轮数
-4. 结束时要带回什么结论
-
-发起后告诉用户 `taskId`，以及三个跟进方式：`task_status` 查进度、`task_result` 取最终结论、`task_send` 中途改范围或加信息；任务面板里可以随时停止。
-
-**不要**用 `task_run` 起一个「只睡一觉然后再起一个任务」的链条来模拟定时器——一次任务里跑完所有轮次。
-
-## 3. 纪律
-
-- **先跑一轮再进入等待**：用户要的是结果，不是先等 5 分钟。
-- **不重复起同一个循环**：新建之前先用 `task_status` 看有没有同目的的任务还在跑；有就复用或先停掉。
-- **连续 2 轮同样失败就停**：把真实报错告诉用户并给建议，不要一直重试刷屏。
-- **每轮都必须真调工具**：没有真实 tool_call 就等于这一轮没跑，不允许凭空写「第 2 轮仍在进行」。
-- 用户说停 → 立刻停止本轮内循环；后台任务则说明用 `task_send` 还是任务面板停止，不要再起新的循环。
+- 用户要求查看时调用 `loop_list`。
+- 用户要求停止时，先用 `loop_list` 找到当前会话中匹配的 loop，再调用 `loop_stop`。
+- 多个 loop 都可能匹配且无法确定时，列出候选并询问用户。
+- 停止后不要再创建替代 loop。

package/dist/local-backend/skills/85-local-exec/SKILL.md

@@ -27,7 +27,7 @@ match: any
 - 命令可能改文件、装包、删数据时（destructive 类操作），**先**简单告诉用户你要执行什么，**再**发 tool_call；不要中间停手等用户确认（用户已经请求了）。
 - `local_exec_shell` 返回包含 `stdout` / `stderr` / `exitCode`。非 0 退出码视为失败：把 stderr 摘要给用户，并建议下一步。
 - 路径不存在 / 权限不足时，把 fs 错误原文告诉用户，**不要**反复重试同一个路径。
-- **交付文件要声明**：用户要的产出（表格、PPT、文档、报告、图片、导出包）写好后，在最终回复前调用 `present_files` 声明它们，脚本/命令生成的也一样。辅助脚本、临时文件、只为自查渲染效果导出的预览图、中间导出副本**不要**声明——它们会自动列在「已编辑文件」里。
+- **交付文件要声明**：用户要的产出（表格、幻灯片、文档、报告、图片、导出包）写好后，在最终回复前调用 `present_files`。每份独立交付文件都写 `purpose: "output"`；需要记录预览或中间文件时分别写 `purpose: "preview"` / `"intermediate"`，它们不会生成交付卡片。脚本、命令生成的文件也一样。最终回复用行内代码写出每份独立交付文件的完整路径。辅助脚本、临时文件、只为自查渲染效果导出的预览图和中间导出副本不要标为 output。
 
 
 - **超时 ≠ 失败，严禁原样重跑启动命令**：返回里出现 `timedOut: true` 时，只是 shell 等待被掐断——如果命令是启动 GUI / 长时间运行的程序（如 Qt 界面软件），该程序**很可能仍在运行**，用户可能正在里面操作。此时**不要**再次执行同一条启动命令（会把程序重复启动多次）。正确做法：先确认进程是否在运行（如 `Get-Process`）；确实需要长时间等待时传更大的 `timeout` 参数；启动 GUI 程序时优先用不阻塞的方式（PowerShell `Start-Process "app.exe"`），启动成功即视为完成，不要等它退出。

package/dist/local-backend/skills/86-proactive-coding/SKILL.md

@@ -47,5 +47,5 @@ match: any
 
 - **没跑过的代码不要说"运行结果如下"。** 只有看到 `local_run_snippet` 的真实返回（`exitCode: 0` + `stdout`）才能汇报结果；非 0 退出码就读 `stderr` 改代码重跑（最多迭代 2-3 次，还不行就如实说明卡点）。
 - 脚本里读写用户文件时，路径用用户提供的真实路径或项目内相对路径；不要编造路径。
-- 脚本产生的**交付物**（报表、转换后的文件）要落到用户能找到的地方（项目目录或用户指定路径），并在回复里给出完整路径，最终回复前用 `present_files` 声明——scratch 目录是临时区，不是交付位置。
+- 脚本产生的**交付物**（报表、转换后的文件）要落到用户能找到的地方（项目目录或用户指定路径），最终回复前用 `present_files` 以 `purpose: "output"` 声明，并在回复里用行内代码给出完整路径——scratch 目录是临时区，不是交付位置。
 - 代码保持简单直接：能 20 行解决就不要写 100 行；不要引入与任务无关的"工程化"。

package/dist/local-backend/turn-file-selection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * 本轮哪些文件升成交付卡片。
+ *
+ * 证据优先级：生成流程结构化结果 > 最终回复引用 > present_files > 文件扫描。
+ * 启发式只纠正没有明确 purpose 的 present_files 和扫描结果；明确标为 output
+ * 的同名 PDF 与幻灯片会同时保留。
+ */
+export type ArtifactPurpose = 'output' | 'preview' | 'intermediate';
+export type DeliveryEvidenceSource = 'generation' | 'final-reference' | 'present-files';
+export interface DeliveryEvidence {
+    path: string;
+    source: DeliveryEvidenceSource;
+    /** present_files 的旧调用没有 purpose，此时才允许启发式纠错。 */
+    purpose?: ArtifactPurpose;
+}
+/**
+ * 选出本轮交付卡片的路径。结构化证据不会被文件名启发式覆盖。
+ */
+export declare function selectDeliverablePaths(files: readonly {
+    path: string;
+}[], evidence: readonly DeliveryEvidence[]): Set<string>;