@steerable/agent-shell 0.6.51 → 0.6.52

package/dist/project-home.js

@@ -2,7 +2,7 @@
  * 项目默认家目录：`Documents/<应用名>/<项目名>/`。
  *
  * 新建项目不再等于「选一个已有文件夹」——项目是带名字的容器，
- * 家目录由本模块分配并创建。用户另加的源文件夹是附加只读根，
+ * 家目录由本模块分配并创建。用户另加的源文件夹是额外可写根（含子目录），
  * 不替代这个家目录。
  */
 import fs from 'node:fs';

package/dist/project-registry.d.ts

@@ -4,8 +4,8 @@
  * 项目 = 名字 + 托管家目录 + 可选源文件夹。家目录默认建在
  * `Documents/<应用名>/<项目名>/`（见 project-home.ts）。chat 通过
  * `chat_sessions.project_id` 绑定项目；绑定后文件读写与命令执行被硬限制
- * 在家目录内（见 tool-router.ts 的 ToolExecContext.projectRoot）；源文件夹
- * 只放宽 local_read_file。
+ * 在家目录及其子目录内（见 tool-router.ts 的 ToolExecContext.projectRoot）；
+ * 源文件夹及其子目录同样可写。
  *
  * 持久化在 userData/agent-projects.json。存储通过 {@link ProjectKvStore}
  * 接口注入：main.ts 用 electron-store 实现，单测用内存实现——本模块不
@@ -18,8 +18,8 @@ export interface ProjectRecord {
     /** 托管家目录（绝对路径）。默认 `Documents/<应用名>/<项目名>/`。 */
     folderPath: string;
     /**
-     * 附加源文件夹（已有代码目录）。只放宽读取，不替代家目录，也不放宽写入。
-     * 旧记录没有此字段，读取时按空列表处理。
+     * 附加源文件夹（已有代码目录）。与家目录一样可读写，范围含各自子目录。
+     * 不替代家目录。旧记录没有此字段，读取时按空列表处理。
      */
     sourceFolders?: string[];
     /**

package/dist/project-registry.js

@@ -4,8 +4,8 @@
  * 项目 = 名字 + 托管家目录 + 可选源文件夹。家目录默认建在
  * `Documents/<应用名>/<项目名>/`（见 project-home.ts）。chat 通过
  * `chat_sessions.project_id` 绑定项目；绑定后文件读写与命令执行被硬限制
- * 在家目录内（见 tool-router.ts 的 ToolExecContext.projectRoot）；源文件夹
- * 只放宽 local_read_file。
+ * 在家目录及其子目录内（见 tool-router.ts 的 ToolExecContext.projectRoot）；
+ * 源文件夹及其子目录同样可写。
  *
  * 持久化在 userData/agent-projects.json。存储通过 {@link ProjectKvStore}
  * 接口注入：main.ts 用 electron-store 实现，单测用内存实现——本模块不

package/dist/sidecar/boot.d.ts

@@ -9,10 +9,13 @@ export interface HostSidecarDeps {
     /** W4-2 围栏：chatId → 项目家目录或无项目对话工作区。 */
     resolveProjectRoot: (chatId: string) => Promise<string | null>;
     /**
-     * 项目模式之外额外放行的只读根（会话附件目录等）。文件写入仍只受
-     * projectRoot 围栏约束；这些根只放宽 local_read_file 的读取范围。
+     * 额外只读根（会话附件目录、源文件夹）。只放宽 local_read_file，含子目录。
      */
     resolveAdditionalReadRoots?: (chatId: string) => string[] | Promise<string[]>;
+    /**
+     * 额外可写根（项目源文件夹）。放宽写入、编辑和命令 cwd，含各自子目录。
+     */
+    resolveAdditionalWriteRoots?: (chatId: string) => string[] | Promise<string[]>;
     /** W4-1 审批反向通道处理器（宿主审批弹窗的应答入口）。 */
     approvalHandler: ReturnType<typeof createApprovalBridge>['handler'];
     /**

package/dist/sidecar/boot.js

@@ -214,6 +214,7 @@ export async function startHostSidecar(deps) {
             // root so ToolRouter's cwd/path confinement applies.
             resolveProjectRoot: deps.resolveProjectRoot,
             resolveAdditionalReadRoots: deps.resolveAdditionalReadRoots,
+            resolveAdditionalWriteRoots: deps.resolveAdditionalWriteRoots,
         }));
         // W4-1: approval algebra reverse channel — the sidecar's
         // ApprovalExecutor(HostApprover) asks here; the renderer modal answers

package/dist/sidecar/reverse-approval.d.ts

@@ -29,6 +29,8 @@ export interface ApprovalPromptRequest {
     mode: string;
     category: string;
     round: number;
+    /** Chat that asked. The renderer only shows the card in that composer. */
+    chatId?: string;
 }
 export interface ApprovalBridgeDeps {
     /**

package/dist/sidecar/reverse-approval.js

@@ -43,6 +43,7 @@ export function createApprovalBridge(deps) {
                 return deny('no renderer window available to approve the call');
             }
             const requestId = randomUUID();
+            const chatId = typeof p.chatId === 'string' && p.chatId ? p.chatId : undefined;
             const prompt = {
                 requestId,
                 toolName,
@@ -52,6 +53,7 @@ export function createApprovalBridge(deps) {
                 mode: typeof p.mode === 'string' ? p.mode : 'other',
                 category: typeof p.category === 'string' ? p.category : toolName,
                 round: typeof p.round === 'number' ? p.round : 0,
+                ...(chatId ? { chatId } : {}),
             };
             deps.onLog?.(`approval: prompting for ${toolName} (${prompt.mode}/${prompt.category})`);
             return await new Promise((resolve) => {

package/dist/sidecar/reverse-tools.d.ts

@@ -21,9 +21,13 @@ export interface ReverseToolDeps {
      */
     resolveProjectRoot?: (chatId: string) => Promise<string | null>;
     /**
-     * 额外放行的只读根（会话附件目录等）。写入仍只受 projectRoot 围栏约束，
-     * 这里只放宽 local_read_file 的读取范围。
+     * 额外只读根（会话附件目录、源文件夹）。只放宽读取，含各自子目录。
      */
     resolveAdditionalReadRoots?: (chatId: string) => string[] | Promise<string[]>;
+    /**
+     * 额外可写根（项目源文件夹）。放宽写入、编辑和命令 cwd，含各自子目录。
+     * 附件目录不进这里。
+     */
+    resolveAdditionalWriteRoots?: (chatId: string) => string[] | Promise<string[]>;
 }
 export declare function createToolInvokeHandler(deps: ReverseToolDeps): SidecarReverseHandler;

package/dist/sidecar/reverse-tools.js

@@ -74,6 +74,9 @@ export function createToolInvokeHandler(deps) {
         const additionalReadRoots = p.context?.chatId
             ? await Promise.resolve(deps.resolveAdditionalReadRoots?.(p.context.chatId) ?? [])
             : [];
+        const additionalWriteRoots = p.context?.chatId
+            ? await Promise.resolve(deps.resolveAdditionalWriteRoots?.(p.context.chatId) ?? [])
+            : [];
         if (name === 'local_exec_shell') {
             const classification = classifyShellCommand(String(toolArgs.command ?? ''));
             if (classification.severity === 'critical') {
@@ -94,7 +97,11 @@ export function createToolInvokeHandler(deps) {
             ? normalizeToolPolicy(p.context.toolPolicy)
             : null;
         const toolPolicy = normalizedPolicy && normalizedPolicy.mode !== 'all' ? normalizedPolicy : null;
-        const execContext = projectRoot || additionalReadRoots.length > 0 || p.context?.chatId || toolPolicy
+        const execContext = projectRoot ||
+            additionalReadRoots.length > 0 ||
+            additionalWriteRoots.length > 0 ||
+            p.context?.chatId ||
+            toolPolicy
             ? {
                 projectRoot,
                 chatId: p.context?.chatId,
@@ -102,6 +109,7 @@ export function createToolInvokeHandler(deps) {
                 // worktree_* 工具按它把任务绑定到来源对话。
                 ...(toolPolicy ? { toolPolicy } : {}),
                 ...(additionalReadRoots.length > 0 ? { additionalReadRoots } : {}),
+                ...(additionalWriteRoots.length > 0 ? { additionalWriteRoots } : {}),
             }
             : undefined;
         try {

package/dist/sidecar/types.d.ts

@@ -333,12 +333,15 @@ export interface SidecarChatStreamRequest {
      * executor with the six-tool orchestration family (agent_spawn /
      * agent_send / agent_wait / agent_close / agent_list / agent_interrupt).
      * When delegation is also on (it is by default), both surfaces share one
-     * agent pool — one maxParallel budget, one lineage space. */
+     * agent pool — one maxParallel budget, one lineage space.
+     * `childMaxRounds` / `childMaxToolErrors` default to the parent loop's
+     * limits. */
     orchestration?: {
         enabled?: boolean;
         maxDepth?: number;
         maxParallel?: number;
         childMaxRounds?: number;
+        childMaxToolErrors?: number;
     };
     /**
      * Sub-agent delegation (delegate-on-pool). ON BY DEFAULT on the sidecar —
@@ -451,6 +454,12 @@ export interface SidecarChatStreamRequest {
         mode: 'host' | 'auto';
         timeoutMs?: number;
         storePath?: string;
+        /**
+         * Project home, source folders, and other configured write roots.
+         * File tools whose targets all sit inside these directories skip the
+         * host prompt. Independent of whether the OS exec sandbox is on.
+         */
+        writableRoots?: string[];
     };
 }
 /**

package/dist/storage/write-lease-error.js

@@ -6,9 +6,12 @@ export function acquireWriteLeaseOrExit(acquire, loadElectron = () => import('el
     }
     catch (error) {
         if (error instanceof StoreAlreadyOwnedError) {
+            console.error(`[bs] 本地数据库正在被另一个进程使用（${error.lockPath}）。\n` +
+                '[bs] 再打开一次桌面应用会回到已经打开的窗口。\n' +
+                '[bs] 如果终端里的 pnpm dev:bs 占着数据库，请先在那个终端按 Ctrl+C 停掉，再重新打开。');
             void loadElectron()
                 .then(({ app, dialog }) => {
-                dialog.showErrorBox('无法启动', '另一个实例正在运行并占用本地数据库。请先关闭该实例，再重新打开应用。');
+                dialog.showErrorBox('无法再开一个', '再打开一次应用时，会回到已经打开的窗口。\n\n这次没有回到那个窗口，是因为本地数据库正被另一个进程占用。如果终端里还在跑 pnpm dev:bs，先停掉它，再重新打开。');
                 app.exit(1);
             })
                 .catch(() => exitProcess(1));

package/dist/tool-presentation.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 一等工具的展示声明。
+ *
+ * 卡片种类和标题从这里按工具名取，不从名字前缀猜测。
+ * 未声明的名字（MCP、插件、场景包）落到 generic / other，`declared: false`。
+ * 宿主在 executed_actions 上盖 `view`，卡片读这份声明。
+ */
+export declare const TOOL_CARDS: readonly ["generic", "terminal", "diff", "search", "read", "web"];
+export type ToolCard = (typeof TOOL_CARDS)[number];
+export declare const TOOL_KINDS: readonly ["read", "edit", "delete", "move", "search", "execute", "fetch", "other"];
+export type ToolKind = (typeof TOOL_KINDS)[number];
+export interface ToolCallView {
+    card: ToolCard;
+    kind: ToolKind;
+    title: string;
+    /** 名字在声明表里。false 表示通用回退，不是从名字前缀推断出来的。 */
+    declared: boolean;
+}
+/**
+ * 取一次调用的展示。`result` 缺省时只根据参数出标题；结果到达后用同一声明补计数和状态。
+ */
+export declare function presentToolCall(name: string, args: unknown, result?: unknown): ToolCallView;
+export declare function declaredToolNames(): readonly string[];

package/dist/tool-presentation.js

@@ -0,0 +1,266 @@
+/**
+ * 一等工具的展示声明。
+ *
+ * 卡片种类和标题从这里按工具名取，不从名字前缀猜测。
+ * 未声明的名字（MCP、插件、场景包）落到 generic / other，`declared: false`。
+ * 宿主在 executed_actions 上盖 `view`，卡片读这份声明。
+ */
+export const TOOL_CARDS = ['generic', 'terminal', 'diff', 'search', 'read', 'web'];
+export const TOOL_KINDS = [
+    'read',
+    'edit',
+    'delete',
+    'move',
+    'search',
+    'execute',
+    'fetch',
+    'other',
+];
+function clip(text, max = 60) {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    if (!trimmed)
+        return '';
+    return trimmed.length > max ? `${trimmed.slice(0, max - 1)}…` : trimmed;
+}
+function str(args, key) {
+    const value = args[key];
+    return typeof value === 'string' ? value : '';
+}
+function dataOf(result) {
+    if (!result || typeof result !== 'object')
+        return null;
+    const data = result.data;
+    if (data && typeof data === 'object' && !Array.isArray(data)) {
+        return data;
+    }
+    return result;
+}
+function failed(result) {
+    return Boolean(result && typeof result === 'object' && result.success === false);
+}
+function commandTitle(args) {
+    return clip(str(args, 'command')) || 'shell';
+}
+function pathTitle(args, fallback) {
+    return clip(str(args, 'path') || str(args, 'file') || str(args, 'target'), 72) || fallback;
+}
+function webSearchTitle(args, result) {
+    const query = str(args, 'query');
+    const head = `搜索“${clip(query, 40) || '…'}”`;
+    if (result === undefined || failed(result))
+        return head;
+    const data = dataOf(result);
+    const count = data && typeof data.result_count === 'number' ? data.result_count : null;
+    return count === null ? head : `${head} → ${count} 条结果`;
+}
+function shortUrl(raw) {
+    if (!raw)
+        return '未知地址';
+    try {
+        const url = new URL(raw);
+        const path = url.pathname === '/' ? '' : url.pathname;
+        return clip(`${url.host}${path}`, 48);
+    }
+    catch {
+        return clip(raw, 48);
+    }
+}
+function webFetchTitle(args, result) {
+    const head = `抓取 ${shortUrl(str(args, 'url'))}`;
+    if (result === undefined || failed(result))
+        return head;
+    const data = dataOf(result);
+    if (!data)
+        return head;
+    const parts = [];
+    if (typeof data.status === 'number')
+        parts.push(String(data.status));
+    if (typeof data.bytes === 'number' && Number.isFinite(data.bytes)) {
+        parts.push(data.bytes < 1024 ? `${data.bytes} B` : `${(data.bytes / 1024).toFixed(1)} KB`);
+    }
+    if (data.truncated === true)
+        parts.push('已截断');
+    return parts.length > 0 ? `${head} → ${parts.join(' · ')}` : head;
+}
+function taskRunTitle(args, result) {
+    const task = clip(str(args, 'task'));
+    if (!task)
+        return '后台任务';
+    const status = dataOf(result)?.status;
+    if (status === 'blocked')
+        return `${task} · 等待依赖`;
+    if (args.worktree === true)
+        return `${task} · 隔离工作区`;
+    return task;
+}
+function jobIdTitle(args, fallback) {
+    const id = str(args, 'job_id') || str(args, 'taskId');
+    return id ? id.slice(0, 8) : fallback;
+}
+function runCodeTitle(args, result) {
+    const description = clip(str(args, 'description'), 40) || '程序';
+    if (failed(result))
+        return `程序「${description}」失败`;
+    const calls = dataOf(result)?.calls;
+    const count = Array.isArray(calls) ? calls.length : 0;
+    return count > 0 ? `程序「${description}」· ${count} 个内层工具` : `程序「${description}」`;
+}
+function goalTitle(args, fallback) {
+    return clip(str(args, 'objective'), 72) || fallback;
+}
+const PRESENTERS = {
+    local_exec_shell: { card: 'terminal', kind: 'execute', title: commandTitle },
+    pwsh: { card: 'terminal', kind: 'execute', title: commandTitle },
+    bash: { card: 'terminal', kind: 'execute', title: commandTitle },
+    bash_session: { card: 'terminal', kind: 'execute', title: commandTitle },
+    write_stdin: {
+        card: 'terminal',
+        kind: 'execute',
+        title: (args) => clip(str(args, 'chars'), 40) || str(args, 'sessionId').slice(0, 8) || 'stdin',
+    },
+    local_run_snippet: {
+        card: 'terminal',
+        kind: 'execute',
+        title: (args) => clip(str(args, 'code'), 48) || str(args, 'language') || 'snippet',
+    },
+    local_run_script: {
+        card: 'terminal',
+        kind: 'execute',
+        title: (args) => str(args, 'scriptId') || 'script',
+    },
+    run_code: { card: 'generic', kind: 'execute', title: runCodeTitle },
+    run_js: { card: 'generic', kind: 'execute', title: runCodeTitle },
+    wait_js: {
+        card: 'generic',
+        kind: 'execute',
+        title: (args) => str(args, 'id').slice(0, 8) || 'wait_js',
+    },
+    local_read_file: { card: 'read', kind: 'read', title: (args) => pathTitle(args, 'read') },
+    read_file: { card: 'read', kind: 'read', title: (args) => pathTitle(args, 'read') },
+    view_image: { card: 'read', kind: 'read', title: (args) => pathTitle(args, 'image') },
+    capture_display: {
+        card: 'read',
+        kind: 'read',
+        title: (args) => clip(str(args, 'target'), 48) || 'display',
+    },
+    local_list_scripts: { card: 'read', kind: 'read', title: () => '已保存的脚本' },
+    local_write_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'write') },
+    write_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'write') },
+    local_edit_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'edit') },
+    edit_file: { card: 'diff', kind: 'edit', title: (args) => pathTitle(args, 'edit') },
+    apply_patch: { card: 'diff', kind: 'edit', title: () => 'apply_patch' },
+    grep: {
+        card: 'search',
+        kind: 'search',
+        title: (args) => clip(str(args, 'pattern')) || 'grep',
+    },
+    glob: {
+        card: 'search',
+        kind: 'search',
+        title: (args) => clip(str(args, 'pattern')) || 'glob',
+    },
+    tool_search: {
+        card: 'search',
+        kind: 'search',
+        title: (args) => clip(str(args, 'query')) || 'tool_search',
+    },
+    web_search: { card: 'web', kind: 'search', title: webSearchTitle },
+    web_fetch: { card: 'web', kind: 'fetch', title: webFetchTitle },
+    task_run: { card: 'generic', kind: 'other', title: taskRunTitle },
+    task_send: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => clip(str(args, 'message')) || '转达任务',
+    },
+    task_status: {
+        card: 'generic',
+        kind: 'read',
+        title: (args, result) => {
+            const id = str(args, 'taskId');
+            if (id)
+                return id.slice(0, 8);
+            const total = dataOf(result)?.total;
+            return typeof total === 'number' ? `${total} 个任务` : '本会话';
+        },
+    },
+    task_result: {
+        card: 'generic',
+        kind: 'read',
+        title: (args) => jobIdTitle(args, '收取结果'),
+    },
+    job_list: {
+        card: 'generic',
+        kind: 'read',
+        title: (_args, result) => {
+            const total = dataOf(result)?.total;
+            return typeof total === 'number' ? `${total} 个任务` : '后台任务';
+        },
+    },
+    job_output: { card: 'generic', kind: 'read', title: (args) => jobIdTitle(args, '任务输出') },
+    job_kill: { card: 'generic', kind: 'delete', title: (args) => jobIdTitle(args, '结束任务') },
+    worktree_create: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => str(args, 'name') || '新建工作区',
+    },
+    worktree_list: { card: 'read', kind: 'read', title: () => '工作区列表' },
+    worktree_remove: {
+        card: 'generic',
+        kind: 'delete',
+        title: (args) => str(args, 'name') || '移除工作区',
+    },
+    get_goal: { card: 'generic', kind: 'read', title: () => '当前目标' },
+    create_goal: { card: 'generic', kind: 'other', title: (args) => goalTitle(args, '新建目标') },
+    update_goal: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => {
+            const action = str(args, 'action');
+            const objective = clip(str(args, 'objective'), 48);
+            return objective ? `${action || 'update'} ${objective}` : action || '更新目标';
+        },
+    },
+    present_files: { card: 'generic', kind: 'other', title: () => '交付文件' },
+    local_open_path: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => pathTitle(args, 'open'),
+    },
+    todo_write: { card: 'generic', kind: 'other', title: () => '待办' },
+    ask_user: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => clip(str(args, 'intro') || str(args, 'question')) || '提问',
+    },
+    skill: { card: 'generic', kind: 'read', title: (args) => str(args, 'name') || 'skill' },
+    delegate_subagent: {
+        card: 'generic',
+        kind: 'other',
+        title: (args) => clip(str(args, 'task')) || str(args, 'subagent_type') || '子代理',
+    },
+    mcp_list_tools: { card: 'generic', kind: 'fetch', title: () => 'MCP 工具' },
+    mcp_tool_exec: {
+        card: 'generic',
+        kind: 'fetch',
+        title: (args) => str(args, 'toolName') || 'MCP',
+    },
+    plugin_list: { card: 'generic', kind: 'read', title: () => '插件' },
+    plugin_enable: { card: 'generic', kind: 'other', title: (args) => str(args, 'name') || '启用插件' },
+    plugin_disable: { card: 'generic', kind: 'delete', title: (args) => str(args, 'name') || '停用插件' },
+    plugin_reload: { card: 'generic', kind: 'other', title: (args) => str(args, 'name') || '重载插件' },
+};
+/**
+ * 取一次调用的展示。`result` 缺省时只根据参数出标题；结果到达后用同一声明补计数和状态。
+ */
+export function presentToolCall(name, args, result) {
+    const record = args && typeof args === 'object' && !Array.isArray(args) ? args : {};
+    const presenter = PRESENTERS[name];
+    if (!presenter) {
+        return { card: 'generic', kind: 'other', title: name, declared: false };
+    }
+    const title = presenter.title(record, result).trim() || name;
+    return { card: presenter.card, kind: presenter.kind, title, declared: true };
+}
+export function declaredToolNames() {
+    return Object.keys(PRESENTERS);
+}

package/dist/tool-router.d.ts

@@ -7,6 +7,7 @@ import type { WorktreeService } from './local-backend/worktree-service.js';
 import type { ToolContribution, ToolMode, ToolExposure } from './scenario/pack.js';
 export type { ToolMode, ToolExposure } from './scenario/pack.js';
 import { type AgentToolPolicy } from './local-backend/agent-capability.js';
+import { GoalStore } from './goal-store.js';
 /** 已注册 MCP 服务的动态工具名前缀：`mcp__<serverKey>__<toolName>`。 */
 export declare const MCP_DYNAMIC_TOOL_PREFIX = "mcp__";
 /**
@@ -27,17 +28,23 @@ export interface ToolCall {
  * 单次工具执行的调用上下文（按 chat 解析，随每次 execute 传入）。
  *
  * `projectRoot` 是项目模式的硬沙箱根：非空时
- *   - local_read_file / local_write_file 的路径必须落在根内（LocalExecutor 围栏）
- *   - local_exec_shell 的 cwd 默认改为项目根；显式给的 cwd 越界则直接拒绝
+ *   - 读路径必须落在根内，或落在 additionalReadRoots 内（含各自子目录）
+ *   - 写路径必须落在根内，或落在 additionalWriteRoots 内（含各自子目录）
+ *   - local_exec_shell 的 cwd 默认改为项目根；显式 cwd 必须落在上述可写根内
  * 无项目对话（null/缺省）行为与之前完全一致。
  */
 export interface ToolExecContext {
     projectRoot?: string | null;
     /**
-     * 项目模式之外额外放行的只读根（会话附件目录等）。只放宽
-     * local_read_file 的读取范围，写入/编辑仍只受 projectRoot 围栏约束。
+     * 额外只读根（会话附件目录、源文件夹）。只放宽 local_read_file。
+     * 每个根包含其全部子目录。
      */
     additionalReadRoots?: string[] | null;
+    /**
+     * 额外可写根（项目源文件夹）。放宽写入、编辑和命令 cwd。
+     * 每个根包含其全部子目录。附件目录不在这里。
+     */
+    additionalWriteRoots?: string[] | null;
     /**
      * 4.6a：调用发生的 chat。task_run / task_status / task_result 需要它把
      * 任务绑定到来源对话（任务表按 chatId 归组）；reverse-tools 从
@@ -141,6 +148,10 @@ export declare class ToolRouter {
         taskService: TaskService;
         worktreeService: WorktreeService;
     } | null): void;
+    /** 会话目标的持久化。缺省写到用户数据目录；测试注入临时文件。 */
+    private goalStore;
+    setGoalStore(store: GoalStore | null): void;
+    private goals;
     setWebTools(delegate: WebToolDelegate | null, names?: readonly string[]): void;
     setHostedWebSearch(handler: ((args: Record<string, unknown>) => Promise<unknown>) | null): void;
     /**
@@ -168,6 +179,10 @@ export declare class ToolRouter {
      * destructive，走宿主审批链。
      */
     private listPluginToolSchemas;
+    /**
+     * 内容搜索、PowerShell、会话目标。后台任务的 job_* 跟 task 服务一起出场。
+     */
+    private listParityToolSchemas;
     /**
      * 4.6a/4.6b 任务与 worktree 工具的 schema。task_run 立即返回
      * （任务在后台独立流里跨 turn 跑完）；worktree_* 操作绑定项目的
@@ -204,6 +219,8 @@ export declare class ToolRouter {
      * 项目围栏按 chat 解析）。schema 出场 ⇒ 服务已接线，这里只缺 chatId 时
      * 抛错（reverse-tools 总是透传；缺了就是接线 bug，响亮失败）。
      */
+    private executeGoalTool;
+    private executeJobTool;
     private requireTaskContext;
     /**
      * Agent 写出 `…/skills/<name>/SKILL.md` 且该目录还不在已知 skill root 上时，
@@ -211,12 +228,13 @@ export declare class ToolRouter {
      */
     private autoInstallSkillOnSuccess;
     /**
-     * 项目模式硬沙箱（cwd 维度）：projectRoot 非空时，cwd 默认收到项目根；
-     * 模型显式给的 cwd 越界则返回错误结果。相对 cwd 按项目根解析（而不是
-     * 进程 cwd），符合"在项目里干活"的直觉。
+     * 项目模式硬沙箱（cwd 维度）：有可写根时，cwd 默认收到项目家目录；
+     * 模型显式给的 cwd 必须落在家目录或额外可写根（源文件夹）内，含各自子目录。
+     * 相对 cwd 按家目录解析（而不是进程 cwd）。
      *
      * 注意边界：shell 命令文本里内嵌的绝对路径无法可靠解析，围栏只覆盖
-     * cwd 与文件读写工具——系统提示里已告知模型只在项目目录内操作。
+     * cwd 与文件读写工具。命令实际写盘还受 exec 沙箱的 writableRoots 约束，
+     * 那些根同样包含子目录。
      *
      * local_exec_shell 与 local_run_snippet 共用本 helper。
      */