@steerable/agent-shell 0.6.20 → 0.6.22

package/dist/local-backend/skills/00-identity/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: identity
-description: Defines the product agent's core role, working environment, and language convention. Always loaded as the foundational skill. Brand placeholders ({agentName}) are rendered from the product-injected brand.
+description: Defines the core role, working environment, and language convention. Always loaded as the foundational skill. {agentName} is the current chat agent display name (product brand if none).
 priority: 1000
 tags: [identity, base]
 ---

package/dist/local-backend/task-service.d.ts

@@ -29,7 +29,7 @@ import type { ToolRouter } from '../tool-router.js';
 import { streamCoreLoopTurn } from './coreloop-stream.js';
 import type { WorktreeService } from './worktree-service.js';
 import { type PersistedTurnBlock } from './turn-timeline.js';
-/** 任务表的最小读写面（生产 = localStore；测试注入内存实现）。 */
+/** 任务表的最小异步读写面（生产注入 scoped store；测试注入内存实现）。 */
 export interface TaskStore {
     createTask(input: {
         chatId: string;
@@ -39,22 +39,22 @@ export interface TaskStore {
         recordId?: string | null;
         dependsOn?: string[] | null;
         initialStatus?: 'blocked' | 'running';
-    }): TaskRecord;
-    getTask(taskId: string): TaskRecord | null;
-    listTasks(chatId?: string, limit?: number): TaskRecord[];
-    updateTask(taskId: string, updates: Partial<Pick<TaskRecord, 'status' | 'answer' | 'error' | 'worktreeState' | 'traceId' | 'recordId'>>): TaskRecord | null;
+    }): Promise<TaskRecord>;
+    getTask(taskId: string): Promise<TaskRecord | null>;
+    listTasks(chatId?: string, limit?: number): Promise<TaskRecord[]>;
+    updateTask(taskId: string, updates: Partial<Pick<TaskRecord, 'status' | 'answer' | 'error' | 'worktreeState' | 'traceId' | 'recordId'>>): Promise<TaskRecord | null>;
     /** 回写推理时间线；缺省实现可为空（测试假 store 内存覆盖）。 */
-    saveTaskProcess?(taskId: string, processJson: string): void;
+    saveTaskProcess?(taskId: string, processJson: string): Promise<void>;
 }
 export interface TaskServiceDeps {
-    store: TaskStore;
+    store: TaskStore | (() => TaskStore);
     toolRouter: ToolRouter;
     worktreeService: WorktreeService;
     /** chatId → 绑定项目（无项目对话返回 null）。与 router.resolveChatProject 同源。 */
-    resolveChatProject: (chatId: string) => {
+    resolveChatProject: (chatId: string) => Promise<{
         name: string;
         folderPath: string;
-    } | null;
+    } | null>;
     /** 任务终态 / 推理过程广播（renderer 任务面板与右侧过程栏）。 */
     broadcast?: (eventName: 'task-updated' | 'task-process', payload: Record<string, unknown>) => void;
     /** 测试缝：替换真实流驱动（默认 streamCoreLoopTurn）。 */
@@ -68,6 +68,7 @@ export declare class TaskService {
     private readonly deps;
     private readonly running;
     constructor(deps: TaskServiceDeps);
+    private get store();
     /**
      * task_run 工具的实现：落任务表 + 点火独立流，立即返回。
      * 任何同步可知的失败（无 sidecar、worktree 建不起来）都抛给工具层，
@@ -113,21 +114,21 @@ export declare class TaskService {
     private cancelProcessFlush;
     private executeTask;
     /** task_status 工具：单任务或本 chat 全部任务的快照。 */
-    status(chatId: string, taskId?: string): Record<string, unknown>;
+    status(chatId: string, taskId?: string): Promise<Record<string, unknown>>;
     /** task_result 工具：取终态任务的完整结果。 */
-    result(chatId: string, taskId: string): Record<string, unknown>;
+    result(chatId: string, taskId: string): Promise<Record<string, unknown>>;
     /** 喂给模型的任务视图（完整字段，answer 截断防爆上下文）。 */
     private toModelView;
     /**
      * 右侧过程栏：当前推理时间线。running 且进程内有流 = live；
      * 表上 running 但本进程没流 = 上次崩溃残留（stale）。
      */
-    getProcess(taskId: string): {
+    getProcess(taskId: string): Promise<{
         task: TaskRecord;
         timeline: PersistedTurnBlock[];
         live: boolean;
         stale: boolean;
-    } | null;
+    } | null>;
     /** 合并任务 worktree 到主仓（UI「合并到主仓」按钮的路由实现）。 */
     mergeTaskWorktree(taskId: string): Promise<TaskRecord>;
     /** 丢弃任务 worktree（UI「丢弃」按钮的路由实现）。 */

package/dist/local-backend/task-service.js

@@ -55,6 +55,9 @@ export class TaskService {
     constructor(deps) {
         this.deps = deps;
     }
+    get store() {
+        return typeof this.deps.store === 'function' ? this.deps.store() : this.deps.store;
+    }
     /**
      * task_run 工具的实现：落任务表 + 点火独立流，立即返回。
      * 任何同步可知的失败（无 sidecar、worktree 建不起来）都抛给工具层，
@@ -76,13 +79,13 @@ export class TaskService {
         const dependsOn = input.dependsOn?.length ? input.dependsOn : null;
         let blockedBy = [];
         if (dependsOn) {
-            const deps = dependsOn.map((id) => {
-                const dep = this.deps.store.getTask(id);
+            const deps = await Promise.all(dependsOn.map(async (id) => {
+                const dep = await this.store.getTask(id);
                 if (!dep || dep.chatId !== input.chatId) {
                     throw new Error(`task_run: 依赖任务不存在或不属于本会话：${id}`);
                 }
                 return dep;
-            });
+            }));
             const failed = deps.filter((d) => d.status === 'failed');
             if (failed.length) {
                 throw new Error(`task_run: 依赖任务已失败（${failed.map((d) => d.id.slice(0, 8)).join('、')}）——`
@@ -108,7 +111,7 @@ export class TaskService {
             }
         }
         const blocked = blockedBy.length > 0;
-        const record = this.deps.store.createTask({
+        const record = await this.store.createTask({
             chatId: input.chatId,
             task,
             worktreePath,
@@ -117,7 +120,7 @@ export class TaskService {
             initialStatus: blocked ? 'blocked' : 'running',
         });
         const recordId = `task:${record.id}`;
-        this.deps.store.updateTask(record.id, { recordId });
+        await this.store.updateTask(record.id, { recordId });
         if (!blocked) {
             this.ignite(record.id, input.chatId, task, recordId, worktreePath);
         }
@@ -137,7 +140,7 @@ export class TaskService {
         const text = message.trim();
         if (!text)
             return { success: false, error: 'task_send: message 不能为空' };
-        const task = this.deps.store.getTask(taskId);
+        const task = await this.store.getTask(taskId);
         if (!task || task.chatId !== chatId) {
             return { success: false, error: `任务不存在：${taskId}` };
         }
@@ -178,15 +181,15 @@ export class TaskService {
      * completed 的点火；任一依赖 failed 的标 failed（fail fast，错误
      * 指明是哪个依赖挂了）。
      */
-    maybeUnblock(chatId) {
-        const blocked = this.deps.store
-            .listTasks(chatId, 100)
+    async maybeUnblock(chatId) {
+        const blocked = (await this.store
+            .listTasks(chatId, 100))
             .filter((t) => t.status === 'blocked' && t.dependsOn?.length);
         for (const task of blocked) {
-            const deps = task.dependsOn.map((id) => this.deps.store.getTask(id));
+            const deps = await Promise.all(task.dependsOn.map((id) => this.store.getTask(id)));
             const failedDep = deps.find((d) => d?.status === 'failed');
             if (failedDep) {
-                this.deps.store.updateTask(task.id, {
+                await this.store.updateTask(task.id, {
                     status: 'failed',
                     error: `依赖任务失败：${failedDep.id.slice(0, 8)}（${failedDep.error ?? '无错误信息'}）`,
                 });
@@ -195,7 +198,7 @@ export class TaskService {
             }
             const allCompleted = deps.every((d) => d?.status === 'completed');
             if (allCompleted) {
-                this.deps.store.updateTask(task.id, { status: 'running' });
+                await this.store.updateTask(task.id, { status: 'running' });
                 this.ignite(task.id, task.chatId, task.task, task.recordId ?? `task:${task.id}`, task.worktreePath);
                 this.deps.broadcast?.('task-updated', { chatId, taskId: task.id });
             }
@@ -217,7 +220,7 @@ export class TaskService {
             .finally(() => {
             this.running.delete(taskId);
             // 一个任务到终态，可能让同 chat 的 blocked 任务依赖就绪——调度点火。
-            this.maybeUnblock(chatId);
+            void this.maybeUnblock(chatId);
         });
         this.running.set(taskId, entry);
     }
@@ -235,7 +238,7 @@ export class TaskService {
                 timeline: entry.timeline,
                 live: true,
             });
-            this.deps.store.saveTaskProcess?.(taskId, JSON.stringify(entry.timeline));
+            void this.store.saveTaskProcess?.(taskId, JSON.stringify(entry.timeline));
         };
         if (when === 'immediate') {
             this.cancelProcessFlush(taskId);
@@ -259,7 +262,7 @@ export class TaskService {
         const getSupervisor = this.deps.getSupervisor ?? getSidecarSupervisor;
         const supervisor = getSupervisor();
         if (!supervisor) {
-            this.deps.store.updateTask(taskId, {
+            await this.store.updateTask(taskId, {
                 status: 'failed',
                 error: 'sidecar 未运行',
             });
@@ -267,7 +270,7 @@ export class TaskService {
             return;
         }
         const settings = llmService.getSettings();
-        const project = this.deps.resolveChatProject(chatId);
+        const project = await this.deps.resolveChatProject(chatId);
         // 4.6b 整合：worktree 任务的围栏根 = worktree 路径（更紧——任务摸不到
         // 主检出）；否则沿用项目根。writableRoots 同理收窄。
         const fenceRoot = worktreePath ?? project?.folderPath ?? null;
@@ -397,14 +400,14 @@ export class TaskService {
                 traceId = failureTraceId;
             }
         }
-        this.deps.store.updateTask(taskId, {
+        await this.store.updateTask(taskId, {
             status,
             answer: answer.trim() || null,
             error,
             ...(traceId ? { traceId } : {}),
         });
         this.cancelProcessFlush(taskId);
-        this.deps.store.saveTaskProcess?.(taskId, JSON.stringify(entry.timeline));
+        await this.store.saveTaskProcess?.(taskId, JSON.stringify(entry.timeline));
         this.deps.broadcast?.('task-updated', { chatId, taskId });
         this.deps.broadcast?.('task-process', {
             chatId,
@@ -414,15 +417,15 @@ export class TaskService {
         });
     }
     /** task_status 工具：单任务或本 chat 全部任务的快照。 */
-    status(chatId, taskId) {
+    async status(chatId, taskId) {
         if (taskId) {
-            const task = this.deps.store.getTask(taskId);
+            const task = await this.store.getTask(taskId);
             if (!task || task.chatId !== chatId) {
                 return { success: false, error: `任务不存在：${taskId}` };
             }
             return { success: true, task: this.toModelView(task) };
         }
-        const tasks = this.deps.store.listTasks(chatId, 50);
+        const tasks = await this.store.listTasks(chatId, 50);
         return {
             success: true,
             total: tasks.length,
@@ -430,8 +433,8 @@ export class TaskService {
         };
     }
     /** task_result 工具：取终态任务的完整结果。 */
-    result(chatId, taskId) {
-        const task = this.deps.store.getTask(taskId);
+    async result(chatId, taskId) {
+        const task = await this.store.getTask(taskId);
         if (!task || task.chatId !== chatId) {
             return { success: false, error: `任务不存在：${taskId}` };
         }
@@ -473,8 +476,8 @@ export class TaskService {
      * 右侧过程栏：当前推理时间线。running 且进程内有流 = live；
      * 表上 running 但本进程没流 = 上次崩溃残留（stale）。
      */
-    getProcess(taskId) {
-        const task = this.deps.store.getTask(taskId);
+    async getProcess(taskId) {
+        const task = await this.store.getTask(taskId);
         if (!task)
             return null;
         const entry = this.running.get(taskId);
@@ -509,7 +512,7 @@ export class TaskService {
     }
     /** 合并任务 worktree 到主仓（UI「合并到主仓」按钮的路由实现）。 */
     async mergeTaskWorktree(taskId) {
-        const task = this.deps.store.getTask(taskId);
+        const task = await this.store.getTask(taskId);
         if (!task)
             throw new Error(`任务不存在：${taskId}`);
         if (!task.worktreePath || !task.worktreeBranch) {
@@ -523,13 +526,13 @@ export class TaskService {
         }
         const name = path.basename(task.worktreePath);
         await this.deps.worktreeService.mergeWorktree(task.chatId, name, `task(${taskId.slice(0, 8)}): ${task.task.slice(0, 60)}`);
-        const updated = this.deps.store.updateTask(taskId, { worktreeState: 'merged' });
+        const updated = await this.store.updateTask(taskId, { worktreeState: 'merged' });
         this.deps.broadcast?.('task-updated', { chatId: task.chatId, taskId });
         return updated;
     }
     /** 丢弃任务 worktree（UI「丢弃」按钮的路由实现）。 */
     async discardTaskWorktree(taskId) {
-        const task = this.deps.store.getTask(taskId);
+        const task = await this.store.getTask(taskId);
         if (!task)
             throw new Error(`任务不存在：${taskId}`);
         if (!task.worktreePath) {
@@ -545,7 +548,7 @@ export class TaskService {
         await this.deps.worktreeService.removeWorktree(task.chatId, name, {
             deleteBranch: true,
         });
-        const updated = this.deps.store.updateTask(taskId, { worktreeState: 'discarded' });
+        const updated = await this.store.updateTask(taskId, { worktreeState: 'discarded' });
         this.deps.broadcast?.('task-updated', { chatId: task.chatId, taskId });
         return updated;
     }

package/dist/local-backend/turn-files.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 回合产物文件收集（「本轮写了哪些文件」列表）。
+ *
+ * 四个来源取并集：
+ *
+ *  1. 工作区扫描（递归）：回合的可写根（项目根 + 场景包工作区，与 exec
+ *     沙箱同源）里 mtime/birthtime ≥ 回合开始时间的文件。覆盖脚本/命令
+ *     间接写出的产物（如运行脚本生成的文档、报表）——这类路径无法从
+ *     工具参数解析。
+ *  2. 显式写工具参数：local_write_file / local_edit_file 的 path。覆盖
+ *    「完整权限」模式下写到可写根之外的路径（如 ~/Downloads）。
+ *  3. exec cwd 浅扫描（仅顶层一层、跳过点文件）：local_exec_shell /
+ *     local_run_snippet 的实际工作目录（显式 cwd；缺省按 executor 规则
+ *     回落到项目根或 home）。覆盖「脚本在 cwd 落盘」——无项目对话的
+ *     exec 默认 cwd 是 home，产物（如 ~/季度报告.pdf）不在任何递归根里。
+ *  4. 命令/代码文本里的绝对路径字面量：exec 命令、snippet 代码中出现的
+ *     绝对路径（含 ~/ 前缀与引号包裹形式），stat + 时间水位线验证后并入。
+ *     覆盖脚本写到与 cwd 无关的任意位置（如 doc.save('/tmp/x/a.pdf')）。
+ *
+ * 来源 3/4 都是「猜候选、靠 stat + mtime/birthtime 水位线证伪」：命令里
+ * 提到的既有文件（ls /etc/hosts）时间戳旧、不会被误收；不存在的路径
+ * stat 即失败。因此解析不需要可靠——与沙箱围栏「命令内嵌绝对路径无法
+ * 可靠解析所以不拦」不同，展示面可以承受启发式，漏报才伤体验。
+ *
+ * 单趟末次扫描、无基线快照：kind 标签靠 birthtime（macOS/Windows/新版
+ * Linux 文件系统可用）；birthtime 不可用时降级为 'modified'，列表本身
+ * 的准确性不依赖 birthtime。
+ *
+ * 扫描是有界 best-effort：忽略依赖/构建缓存目录，深度与遍历条目数有硬顶，
+ * 超限直接截断返回已收集部分——产物列表是展示面，永远不该拖垮回合收尾。
+ */
+export interface TurnFile {
+    /** 绝对路径（点击打开直接用）。 */
+    path: string;
+    /** created = 本轮新建；modified = 已有文件被改动。 */
+    kind: 'created' | 'modified';
+    /** 字节数（展示用）。 */
+    size: number;
+}
+/** 扫描入参里只需要工具行动的这几个字段（与 router 的 executedActions 行结构对齐）。 */
+export interface TurnFileAction {
+    tool?: unknown;
+    arguments?: unknown;
+    success?: unknown;
+}
+/**
+ * 收集本轮产物文件。`sinceMs` 是回合开始的 epoch ms；`projectRoot` 用于把
+ * 写工具的相对路径参数解析成绝对路径（与 local-executor 的项目根解析一致）。
+ * `homeDir` 仅测试注入用，默认 os.homedir()——exec 缺省 cwd 的回落值。
+ */
+export declare function collectTurnFiles(options: {
+    roots: string[];
+    sinceMs: number;
+    actions?: readonly TurnFileAction[];
+    projectRoot?: string | null;
+    homeDir?: string;
+}): Promise<TurnFile[]>;

package/dist/local-backend/turn-files.js

@@ -0,0 +1,285 @@
+/**
+ * 回合产物文件收集（「本轮写了哪些文件」列表）。
+ *
+ * 四个来源取并集：
+ *
+ *  1. 工作区扫描（递归）：回合的可写根（项目根 + 场景包工作区，与 exec
+ *     沙箱同源）里 mtime/birthtime ≥ 回合开始时间的文件。覆盖脚本/命令
+ *     间接写出的产物（如运行脚本生成的文档、报表）——这类路径无法从
+ *     工具参数解析。
+ *  2. 显式写工具参数：local_write_file / local_edit_file 的 path。覆盖
+ *    「完整权限」模式下写到可写根之外的路径（如 ~/Downloads）。
+ *  3. exec cwd 浅扫描（仅顶层一层、跳过点文件）：local_exec_shell /
+ *     local_run_snippet 的实际工作目录（显式 cwd；缺省按 executor 规则
+ *     回落到项目根或 home）。覆盖「脚本在 cwd 落盘」——无项目对话的
+ *     exec 默认 cwd 是 home，产物（如 ~/季度报告.pdf）不在任何递归根里。
+ *  4. 命令/代码文本里的绝对路径字面量：exec 命令、snippet 代码中出现的
+ *     绝对路径（含 ~/ 前缀与引号包裹形式），stat + 时间水位线验证后并入。
+ *     覆盖脚本写到与 cwd 无关的任意位置（如 doc.save('/tmp/x/a.pdf')）。
+ *
+ * 来源 3/4 都是「猜候选、靠 stat + mtime/birthtime 水位线证伪」：命令里
+ * 提到的既有文件（ls /etc/hosts）时间戳旧、不会被误收；不存在的路径
+ * stat 即失败。因此解析不需要可靠——与沙箱围栏「命令内嵌绝对路径无法
+ * 可靠解析所以不拦」不同，展示面可以承受启发式，漏报才伤体验。
+ *
+ * 单趟末次扫描、无基线快照：kind 标签靠 birthtime（macOS/Windows/新版
+ * Linux 文件系统可用）；birthtime 不可用时降级为 'modified'，列表本身
+ * 的准确性不依赖 birthtime。
+ *
+ * 扫描是有界 best-effort：忽略依赖/构建缓存目录，深度与遍历条目数有硬顶，
+ * 超限直接截断返回已收集部分——产物列表是展示面，永远不该拖垮回合收尾。
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+/** 这些目录要么体量巨大（node_modules/target），要么是框架内部状态（.steerable），扫了只有噪音。 */
+const IGNORED_DIR_NAMES = new Set([
+    'node_modules',
+    '.git',
+    '.hg',
+    '.svn',
+    '__pycache__',
+    '.venv',
+    'venv',
+    '.tox',
+    '.next',
+    '.nuxt',
+    '.cache',
+    'target',
+    '.steerable',
+]);
+const IGNORED_FILE_NAMES = new Set(['.DS_Store']);
+/** 单次扫描的遍历上限：深度 10、条目 10 万、结果 100 条。 */
+const MAX_DEPTH = 10;
+const MAX_VISITED = 100_000;
+const MAX_FILES = 100;
+/** 显式写工具：参数里的 path 并入产物列表（覆盖可写根之外的写入）。 */
+const WRITE_TOOL_NAMES = new Set(['local_write_file', 'local_edit_file']);
+/** exec 类工具：cwd 浅扫描与命令文本路径字面量的来源。 */
+const EXEC_TOOL_NAMES = new Set(['local_exec_shell', 'local_run_snippet']);
+/** 每条命令/代码文本最多提取的路径字面量个数（防超长命令刷 stat）。 */
+const MAX_PATH_LITERALS_PER_ACTION = 50;
+/**
+ * Linux overlay/tmpfs 常把 mtime/birthtime 截到 1s。回合开始后立刻写出的
+ * 产物会 stat 成略早于 sinceMs，被水位线丢掉。1s 容差远小于一轮对话，
+ * 只影响展示列表，允许把回合前 1s 内的文件算进来。
+ */
+const TOUCHED_SLACK_MS = 1000;
+/**
+ * 引号包裹的绝对路径字面量：python 代码里的 doc.save('/x/a.pdf')、shell
+ * 里的 "/x/a.pdf"。要求以 /、~/ 或 Windows 盘符开头、带扩展名结尾。
+ * 贪婪匹配到闭引号再回溯到最后一个点——目录名里带点（.venv/python3.11）
+ * 不会把路径截断在中间。
+ */
+const QUOTED_PATH_PATTERN = /['"]((?:~\/|\/|[A-Za-z]:[\\/])[^'"]{1,300}\.[A-Za-z0-9]{1,10})['"]/g;
+/**
+ * 裸绝对路径字面量（无引号、无空格）：shell 重定向/参数里常见的写法。
+ * 排除引号/空白/shell 元字符；URL 的 // 开头被 (?!\/) 挡掉；同样贪婪到
+ * token 尾再回溯到最后一个点，(?![A-Za-z0-9]) 保证扩展名不被截断。
+ */
+const BARE_PATH_PATTERN = /(?:~\/|\/(?!\/))[^\s"'`<>|;,()[\]{}\\*?]{1,300}\.[A-Za-z0-9]{1,10}(?![A-Za-z0-9])|[A-Za-z]:\\[^\s"'`<>|;,*?]{1,300}\.[A-Za-z0-9]{1,10}(?![A-Za-z0-9])/g;
+/**
+ * 收集本轮产物文件。`sinceMs` 是回合开始的 epoch ms；`projectRoot` 用于把
+ * 写工具的相对路径参数解析成绝对路径（与 local-executor 的项目根解析一致）。
+ * `homeDir` 仅测试注入用，默认 os.homedir()——exec 缺省 cwd 的回落值。
+ */
+export async function collectTurnFiles(options) {
+    const { roots, sinceMs, projectRoot = null } = options;
+    const homeDir = options.homeDir ?? os.homedir();
+    const byPath = new Map();
+    for (const root of roots) {
+        await scanRoot(root, sinceMs, byPath);
+    }
+    const shallowRoots = new Set();
+    for (const action of options.actions ?? []) {
+        await collectWriteToolPath(action, sinceMs, projectRoot, byPath);
+        const cwd = execCwdOf(action, projectRoot, homeDir);
+        if (cwd && !isCoveredByRoots(cwd, roots))
+            shallowRoots.add(cwd);
+        await collectPathLiterals(action, sinceMs, homeDir, byPath);
+    }
+    for (const dir of shallowRoots) {
+        await scanShallow(dir, sinceMs, byPath);
+    }
+    return [...byPath.values()]
+        .sort((a, b) => a.path.localeCompare(b.path))
+        .slice(0, MAX_FILES);
+}
+async function scanRoot(root, sinceMs, out) {
+    const state = { visited: 0 };
+    await walk(path.resolve(root), sinceMs, 0, state, out);
+}
+async function walk(dir, sinceMs, depth, state, out) {
+    if (depth > MAX_DEPTH || state.visited >= MAX_VISITED)
+        return;
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        // 根目录被删/无权限：跳过该根，不影响其他根。
+        return;
+    }
+    for (const entry of entries) {
+        if (state.visited >= MAX_VISITED)
+            return;
+        state.visited += 1;
+        const full = path.join(dir, entry.name);
+        // 不跟随符号链接：避免链接环把扫描拖出根外。
+        if (entry.isSymbolicLink())
+            continue;
+        if (entry.isDirectory()) {
+            if (IGNORED_DIR_NAMES.has(entry.name))
+                continue;
+            await walk(full, sinceMs, depth + 1, state, out);
+            continue;
+        }
+        if (!entry.isFile() || IGNORED_FILE_NAMES.has(entry.name))
+            continue;
+        const file = await statTurnFile(full, sinceMs);
+        if (file)
+            out.set(full, file);
+    }
+}
+/** stat 一个文件，命中「本轮触碰过」则返回 TurnFile，否则 null。 */
+async function statTurnFile(full, sinceMs) {
+    let stat;
+    try {
+        stat = await fs.stat(full);
+    }
+    catch {
+        // 扫描窗口内被删掉的文件直接略过。
+        return null;
+    }
+    // 路径字面量可能指到目录（如 xxx.app 包）；产物列表只收文件。
+    if (!stat.isFile())
+        return null;
+    const touched = stat.mtimeMs + TOUCHED_SLACK_MS >= sinceMs ||
+        stat.birthtimeMs + TOUCHED_SLACK_MS >= sinceMs;
+    if (!touched)
+        return null;
+    return { path: full, kind: kindOf(stat, sinceMs), size: stat.size };
+}
+function kindOf(stat, sinceMs) {
+    // birthtime 不可用的文件系统返回 0/负值——此时无法区分新建与修改，
+    // 统一标 modified（标签降级，不漏文件）。
+    return stat.birthtimeMs >= sinceMs ? 'created' : 'modified';
+}
+async function collectWriteToolPath(action, sinceMs, projectRoot, out) {
+    if (typeof action.tool !== 'string' || !WRITE_TOOL_NAMES.has(action.tool))
+        return;
+    // success === false 的调用没写成；undefined（流中未落定）按成功处理——
+    // 文件是否真存在由下面的 stat 把关。
+    if (action.success === false)
+        return;
+    const args = action.arguments;
+    if (!args || typeof args !== 'object')
+        return;
+    const raw = args.path;
+    if (typeof raw !== 'string' || !raw.trim())
+        return;
+    const full = path.isAbsolute(raw)
+        ? path.normalize(raw)
+        : projectRoot
+            ? path.resolve(projectRoot, raw)
+            : null;
+    if (!full || out.has(full))
+        return;
+    const file = await statTurnFile(full, sinceMs);
+    if (file)
+        out.set(full, file);
+}
+/**
+ * exec 行动的实际工作目录（与 tool-router / local-executor 的解析规则对齐）：
+ * 显式 cwd 展开 ~ 后按绝对/相对解析（相对在项目模式下按项目根、否则按
+ * 进程 cwd）；缺省 cwd 回落到项目根，无项目时回落到 home——无项目对话里
+ * 脚本产物最常见的落点。
+ */
+function execCwdOf(action, projectRoot, homeDir) {
+    if (typeof action.tool !== 'string' || !EXEC_TOOL_NAMES.has(action.tool))
+        return null;
+    const args = action.arguments;
+    if (!args || typeof args !== 'object')
+        return null;
+    const raw = args.cwd;
+    const cwdArg = typeof raw === 'string' ? raw.trim() : '';
+    if (!cwdArg)
+        return projectRoot ?? homeDir;
+    const expanded = cwdArg.startsWith('~') ? path.join(homeDir, cwdArg.slice(1)) : cwdArg;
+    if (path.isAbsolute(expanded))
+        return path.normalize(expanded);
+    return projectRoot ? path.resolve(projectRoot, expanded) : path.resolve(expanded);
+}
+/** cwd 已落在某个递归根之内时无需再浅扫（递归扫描已覆盖且更深）。 */
+function isCoveredByRoots(cwd, roots) {
+    return roots.some((root) => {
+        const rel = path.relative(path.resolve(root), cwd);
+        return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+    });
+}
+/**
+ * exec cwd 的浅扫描：只看顶层一层、跳过点文件。home 顶层的变化几乎全是
+ * 工具状态（.zsh_history 之类），点文件过滤掉它们；真正的产物文档极少
+ * 以点开头。浅扫不递归——home 这种根递归起来既慢又全是无关变化。
+ */
+async function scanShallow(dir, sinceMs, out) {
+    let entries;
+    try {
+        entries = await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch {
+        // cwd 被删/无权限：跳过，不影响其他来源。
+        return;
+    }
+    for (const entry of entries) {
+        if (entry.name.startsWith('.') || IGNORED_FILE_NAMES.has(entry.name))
+            continue;
+        if (entry.isSymbolicLink() || !entry.isFile())
+            continue;
+        const full = path.join(dir, entry.name);
+        if (out.has(full))
+            continue;
+        const file = await statTurnFile(full, sinceMs);
+        if (file)
+            out.set(full, file);
+    }
+}
+/**
+ * 从 exec 命令 / snippet 代码文本里提取绝对路径字面量，stat + 水位线
+ * 验证后并入。覆盖脚本写到与 cwd 无关的任意位置。local_run_script 的
+ * 脚本内容在注册表里、行动参数只有 scriptId，不在此覆盖（其 cwd 语义
+ * 与 exec_shell 相同，浅扫描已兜底常见落点）。
+ */
+async function collectPathLiterals(action, sinceMs, homeDir, out) {
+    if (typeof action.tool !== 'string' || !EXEC_TOOL_NAMES.has(action.tool))
+        return;
+    const args = action.arguments;
+    if (!args || typeof args !== 'object')
+        return;
+    const record = args;
+    const text = [record.command, record.code]
+        .filter((value) => typeof value === 'string')
+        .join('\n');
+    if (!text)
+        return;
+    const candidates = new Set();
+    for (const pattern of [QUOTED_PATH_PATTERN, BARE_PATH_PATTERN]) {
+        pattern.lastIndex = 0;
+        for (const match of text.matchAll(pattern)) {
+            if (candidates.size >= MAX_PATH_LITERALS_PER_ACTION)
+                break;
+            const literal = match[1] ?? match[0];
+            const expanded = literal.startsWith('~/')
+                ? path.join(homeDir, literal.slice(2))
+                : literal;
+            candidates.add(path.normalize(expanded));
+        }
+    }
+    for (const full of candidates) {
+        if (out.has(full))
+            continue;
+        const file = await statTurnFile(full, sinceMs);
+        if (file)
+            out.set(full, file);
+    }
+}

package/dist/local-backend/worktree-service.d.ts

@@ -35,7 +35,7 @@ export declare function slugifyWorktreeName(raw: string): string;
 export declare class WorktreeService {
     private readonly deps;
     constructor(deps: {
-        resolveProject: (chatId: string) => WorktreeProject | null;
+        resolveProject: (chatId: string) => Promise<WorktreeProject | null>;
         runGit?: GitRunner;
     });
     private git;