opencode-workspace-scope 0.1.0 → 0.2.0-beta.1

package/README.md

@@ -1,34 +1,44 @@
 # opencode-workspace-scope
 
-全局安装、**sidecar 自激活**的 [opencode](https://opencode.ai) 插件，为多 git worktree 并行开发提供工作区作用域隔离。
+全局安装、**sidecar 自激活**的 [opencode2](https://opencode.ai)（V2）插件，为"一个项目涉及多个代码仓库"的并行开发场景提供工作区作用域隔离。
 
-每个并行工作区在 `.opencode/workspace-scope.jsonc` 里声明本工作区涉及的 worktree 路径与职责，插件据此：
+在 `.opencode/workspace-scope.jsonc` 里声明本项目涉及的各个仓库路径与职责（如前端仓库、后端仓库、编排根），插件据此：
 
-- 自动注入 `permission.external_directory` 白名单，**只放开本工作区的 worktree**，其余外部路径保持默认 ask；
-- 把"工作区根 + 各 worktree 路径及职责"注入 system prompt，让 AI 每轮都知道改哪里、哪些路径不能碰。
+- 在权限评估阶段**动态放行**已声明仓库的 `external_directory` 请求，其余外部路径保持默认 ask，配置中的显式 deny 仍然最终生效；
+- 把"工作区根 + 各仓库路径及职责"注入 system prompt，让 AI 每轮都知道改哪里、哪些路径不能碰。
 
-无 sidecar 的项目中插件完全 no-op，不影响任何正常使用。
+sidecar 只需在编排根（或任一仓库）放一份，其他并行会话通过向上查找自动继承作用域，配合 init 工具自动探测兄弟仓库，开箱即用、零重复配置。
+
+无 sidecar 的项目中插件不注册任何 hook，完全 no-op，不影响任何正常使用。
+
+> 仅适配 opencode2（V2 插件 API）。V1 版本见 `main` 分支，二者不可混用：V2 下加载 V1 插件会以 WARN 失败跳过。
 
 ## 安装
 
-全局安装（推荐，配合 sidecar 自激活）：
+已发布为 npm 包，通过 V2 CLI 全局安装：
 
 ```bash
-mkdir -p ~/.config/opencode/plugins
-ln -s /path/to/opencode-workspace-scope/src/index.ts ~/.config/opencode/plugins/workspace-scope.ts
-# 或按项目使用 npm：
-# npm install opencode-workspace-scope
+opencode2 plugin add opencode-workspace-scope@beta
+```
+
+或手动写入全局 `~/.config/opencode/opencode.json(c)` 的 `plugins` 数组（注意是复数 `plugins`，不是 V1 的 `plugin`）：
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": ["opencode-workspace-scope@beta"]
+}
 ```
 
-重启 opencode 后生效。
+重启 opencode2（`opencode2 service restart`）后生效。建议条目带版本/tag 固定，避免被 `plugin update` 升到不兼容版本。
 
 ## 快速开始
 
-1. 在某个工作区根目录启动 opencode，对它说：
+1. 在某个工作区根目录启动 opencode2，对它说：
 
    > 初始化这个工作区的 scope 配置
 
-   插件会调用 `workspace_scope_init` 工具：自动探测父目录下的兄弟 git 仓库作为候选 worktree，生成 `.opencode/workspace-scope.jsonc`（并自动写入 `.opencode/.gitignore`，不纳入版本管理），同时生成配套 JSON Schema。
+   插件会调用 `workspace_scope_init` 工具：自动探测父目录下的兄弟 git 仓库作为候选 worktree，生成 `.opencode/workspace-scope.jsonc`（并自动写入 `.opencode/.gitignore`，不纳入版本管理），同时生成配套 JSON Schema。也可让 AI 传入显式 worktrees 列表，覆盖任意仓库/目录。
 
 2. 编辑该文件，为每个 worktree 补充 `description`（职责说明，会注入 AI 上下文）：
 
@@ -49,19 +59,23 @@ ln -s /path/to/opencode-workspace-scope/src/index.ts ~/.config/opencode/plugins/
 
    `path` 支持绝对路径，也支持相对**工作区根目录**的相对路径（如 `../backend`）。
 
-3. **重启 opencode**，使 external_directory 权限生效（上下文注入无需重启）。
+   > `worktrees` 泛指本工作区涉及的各代码仓库/目录，不要求是 git worktree；可以是兄弟仓库、monorepo 子目录，或任意绝对/相对路径。
+
+3. **重启 opencode2**，使 external_directory 放行生效（上下文注入无需重启，sidecar 修改后每轮调用会重新加载）。
 
 ## 权限行为
 
-- 注入到 `permission.external_directory`：`"<worktree>/**: allow"`，采用"末尾追加、last-match-wins"合并，不覆盖你已有的其他规则；对每个 worktree 同时写入**词法路径与 realpath 两种 pattern**，避免符号链接祖先导致白名单失效；
-- 工作区根目录之外、且不在白名单内的路径：维持 opencode 默认 `ask`；
+- V2 插件 API 无 config hook，插件**不再改写配置**，改为注册 `permission.evaluate` hook：当 `external_directory` 请求的资源边界全部落在 sidecar 声明的 worktree（词法路径或 realpath）内时，把 `ask` 升级为 `allow`；
+- 只做 `ask → allow` 的单向升级：配置显式 `deny` 不会进入 hook（最终生效），已是 `allow` 的请求保持不变；部分命中的多资源请求**整体不放行**，避免越权放大；
+- 对每个 worktree 同时比对**词法路径与 realpath**，规避符号链接祖先导致匹配失效；
+- 工作区根目录之外、且不在声明范围内的路径：维持默认 `ask`；
 - sidecar 中不存在的路径会被跳过，不会崩溃；
 - **sidecar 向上查找**：从启动目录逐级向上找 `.opencode/workspace-scope.jsonc`（最多 10 层），嵌套子项目会继承父工作区的作用域（对齐 opencode 自身配置发现行为）；
-- 注意：`opencode --auto` 会把 `ask` 自动放行。若并行会话需要硬隔离，请在配置里为 `external_directory` 追加 `"*": "deny"` 兜底。
+- 注意：`/tmp` 等托管临时目录被 opencode2 内置豁免，不经过 `external_directory` 决策；并行会话需要硬隔离时请在配置中追加显式 deny 规则。
 
 ## 注入的上下文
 
-每轮请求会把以下块拼进 system prompt 主块（`output.system[0]`，无 `sessionID` 时不注入）：
+每轮模型调用（`session.context` hook）会把以下块 push 进 system parts（title 请求等无会话上下文的调用不注入）：
 
 ```
 ## Workspace Scope（由 workspace-scope 插件自动注入）
@@ -73,11 +87,10 @@ ln -s /path/to/opencode-workspace-scope/src/index.ts ~/.config/opencode/plugins/
 
 ## 设计约束
 
-- **自激活**：无 sidecar 时插件必须完全 no-op；
-- **权限只押 `external_directory`**：不依赖 read/edit 的路径 pattern（存在绝对/相对不对称问题，见 opencode issue #26524）；
-- **不改默认语义**：用户 `permission` 为字符串缩写（如 `"allow"`）时不改写；对象形式按"末尾追加 allow"合并；
-- **system.transform 原地变更**：只拼 `output.system[0]`，禁止整体赋值（静默 no-op，issue #25754）；
-- **零新增运行时依赖**：仅依赖 `@opencode-ai/plugin`。
+- **自激活**：无 sidecar 时 setup 不注册任何 hook，完全 no-op；
+- **权限只押 `external_directory`**：不依赖 read/edit 的路径 pattern；
+- **不改默认语义**：只升级 `ask → allow`，deny/allow 原样保留，多资源部分命中不放行；
+- **零新增运行时依赖**：仅依赖 `@opencode-ai/plugin`（beta）。
 
 ## 开发
 
@@ -85,10 +98,18 @@ ln -s /path/to/opencode-workspace-scope/src/index.ts ~/.config/opencode/plugins/
 npm install
 npm run typecheck   # tsc --noEmit
 npm run build       # 输出到 dist/
-bun /tmp/opencode/smoke.ts   # 冒烟测试（临时脚本，不入库）
 ```
 
-发布：`npm version patch && npm publish`（`prepublishOnly` 自动 typecheck + build）。
+本地联调：在测试工作区的 `.opencode/plugins/` 放一个转发文件（V2 自动发现该目录，直接 `.ts/.js` 文件形式最稳）：
+
+```ts
+// <测试工作区>/.opencode/plugins/ws-scope.ts
+export { default } from "/absolute/path/to/opencode-workspace-scope/dist/index.js"
+```
+
+注意本地包目录形式的插件需要依赖可解析（`@opencode-ai/plugin`），建议用上面的转发文件 + 仓库内 `node_modules`。
+
+发布：`npm version prerelease && npm publish --tag beta`（`prepublishOnly` 自动 typecheck + build）；V2 插件 API 仍在 beta，随 opencode2 版本升级需回归验证。
 
 ## License
 

package/dist/context.js

@@ -1,8 +1,9 @@
 export function buildScopeBlock(scope) {
     const { config } = scope;
+    const wsDesc = config.workspace.description ? ` — ${config.workspace.description}` : "";
     const lines = [
         "## Workspace Scope（由 workspace-scope 插件自动注入）",
-        `当前工作区：${config.name}（工作区根：${config.workspace.path}）`,
+        `当前工作区：${config.name}（工作区根：${config.workspace.path}）${wsDesc}`,
         "本次会话的修改范围仅限以下目录，其他路径一律视为外部目录、需用户确认后才可修改：",
         ...config.worktrees.map((w) => {
             const desc = w.description ? ` — ${w.description}` : "";

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import type { Plugin } from "@opencode-ai/plugin";
-export declare const WorkspaceScopePlugin: Plugin;
+import { Plugin } from "@opencode-ai/plugin";
+export declare const WorkspaceScopePlugin: Plugin.Plugin;
 export default WorkspaceScopePlugin;

package/dist/index.js

@@ -1,49 +1,54 @@
+import { Plugin } from "@opencode-ai/plugin";
 import { loadScope } from "./scope.js";
-import { buildExternalDirectory, mergePermission } from "./permissions.js";
+import { coveredByScope } from "./permissions.js";
 import { buildScopeBlock } from "./context.js";
-import { initTool } from "./init.js";
-export const WorkspaceScopePlugin = async ({ directory, worktree, client }) => {
-    const anchor = worktree || directory;
-    const logApplied = (sidecarPath) => {
-        try {
-            const result = client.app?.log?.({
-                body: {
-                    service: "workspace-scope",
-                    level: "info",
-                    message: `已应用工作区作用域 ${sidecarPath}`,
-                },
+import { INIT_ARGS_SCHEMA, INIT_TOOL_DESCRIPTION, runInit } from "./init.js";
+const log = (message) => {
+    console.log(`[workspace-scope] ${message}`);
+};
+export const WorkspaceScopePlugin = Plugin.define({
+    id: "opencode-workspace-scope",
+    async setup(ctx) {
+        // 对齐 V1 语义：优先项目规范根（原 worktree），回退会话目录
+        const anchor = ctx.location.project.canonical || ctx.location.directory;
+        const scope = loadScope(anchor);
+        if (scope)
+            log(`已应用工作区作用域 ${scope.sidecarPath}`);
+        if (scope) {
+            // 权限：不再改写配置，改为在评估阶段动态放行。
+            // 仅 escalate ask→allow；配置显式 deny 不会进入本 hook（最终生效）。
+            await ctx.permission.hook("evaluate", (event) => {
+                if (event.action !== "external_directory")
+                    return;
+                if (event.effect !== "ask")
+                    return;
+                const current = loadScope(anchor);
+                if (!current)
+                    return;
+                if (coveredByScope(event.resources, current)) {
+                    event.effect = "allow";
+                    event.message = "workspace-scope：目标路径位于本工作区声明的范围内";
+                }
+            });
+            // 上下文：每轮模型调用注入工作区块；V2 为可 push 数组，无 sessionID 时不会触发 title 请求
+            await ctx.session.hook("context", (event) => {
+                const current = loadScope(anchor);
+                if (!current)
+                    return;
+                event.system.push({ type: "text", text: buildScopeBlock(current) });
             });
-            if (result && typeof result.catch === "function") {
-                result.catch(() => { });
-            }
-        }
-        catch {
-            // ignore
         }
-    };
-    return {
-        config: async (cfg) => {
-            const scope = loadScope(anchor);
-            if (!scope)
-                return;
-            logApplied(scope.sidecarPath);
-            const external = buildExternalDirectory(scope);
-            if (Object.keys(external).length === 0)
-                return;
-            const anyCfg = cfg;
-            anyCfg.permission = mergePermission(anyCfg.permission, external);
-        },
-        "experimental.chat.system.transform": async (input, output) => {
-            if (!input.sessionID)
-                return;
-            const scope = loadScope(anchor);
-            if (!scope)
-                return;
-            output.system[0] = `${output.system[0] ?? ""}\n\n${buildScopeBlock(scope)}`;
-        },
-        tool: {
-            workspace_scope_init: initTool,
-        },
-    };
-};
+        // init 工具始终注册：sidecar 尚不存在时也要能引导创建
+        await ctx.tool.transform((editor) => {
+            editor.add({
+                name: "workspace_scope_init",
+                description: INIT_TOOL_DESCRIPTION,
+                input: INIT_ARGS_SCHEMA,
+                async execute(input) {
+                    return { content: runInit(anchor, input) };
+                },
+            });
+        });
+    },
+});
 export default WorkspaceScopePlugin;

package/dist/init.d.ts

@@ -1,21 +1,46 @@
-export declare const initTool: {
-    description: string;
-    args: {
-        name: import("zod").ZodOptional<import("zod").ZodString>;
-        workspaceDescription: import("zod").ZodOptional<import("zod").ZodString>;
-        worktrees: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-            name: import("zod").ZodString;
-            path: import("zod").ZodString;
-            description: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>>;
+export interface InitArgs {
+    name?: string;
+    workspaceDescription?: string;
+    worktrees?: Array<{
+        name: string;
+        path: string;
+        description?: string;
+    }>;
+}
+export declare const INIT_ARGS_SCHEMA: {
+    type: string;
+    properties: {
+        name: {
+            type: string;
+            description: string;
+        };
+        workspaceDescription: {
+            type: string;
+            description: string;
+        };
+        worktrees: {
+            type: string;
+            description: string;
+            items: {
+                type: string;
+                required: string[];
+                properties: {
+                    name: {
+                        type: string;
+                        description: string;
+                    };
+                    path: {
+                        type: string;
+                        description: string;
+                    };
+                    description: {
+                        type: string;
+                        description: string;
+                    };
+                };
+            };
+        };
     };
-    execute(args: {
-        name?: string | undefined;
-        workspaceDescription?: string | undefined;
-        worktrees?: {
-            name: string;
-            path: string;
-            description?: string | undefined;
-        }[] | undefined;
-    }, context: import("@opencode-ai/plugin").ToolContext): Promise<import("@opencode-ai/plugin").ToolResult>;
 };
+export declare const INIT_TOOL_DESCRIPTION = "\u521D\u59CB\u5316\u6216\u91CD\u5EFA\u5F53\u524D\u5DE5\u4F5C\u533A\u7684 workspace-scope \u914D\u7F6E\uFF08.opencode/workspace-scope.jsonc\uFF09\u3002\u4E0D\u4F20 worktrees \u65F6\u81EA\u52A8\u63A2\u6D4B\u7236\u76EE\u5F55\u4E0B\u7684\u5144\u5F1F git \u4ED3\u5E93\u4F5C\u4E3A\u5019\u9009 worktree\u3002\u751F\u6210\u7684 sidecar \u4E0D\u7EB3\u5165\u7248\u672C\u7BA1\u7406\uFF08\u81EA\u52A8\u5199\u5165 .gitignore\uFF09\uFF0C\u5E76\u9644\u5E26 JSON Schema\u3002";
+export declare function runInit(anchor: string, args: InitArgs): string;

package/dist/init.js

@@ -1,8 +1,28 @@
-import { tool } from "@opencode-ai/plugin";
 import { basename, dirname, join } from "node:path";
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, appendFileSync } from "node:fs";
 import { invalidateScope } from "./scope.js";
 import { WORKSPACE_SCOPE_SCHEMA } from "./schema.js";
+export const INIT_ARGS_SCHEMA = {
+    type: "object",
+    properties: {
+        name: { type: "string", description: "工作区名称，缺省使用当前目录名" },
+        workspaceDescription: { type: "string", description: "工作区职责说明" },
+        worktrees: {
+            type: "array",
+            description: "可选：显式指定 worktree 列表；缺省自动探测父目录兄弟 git 仓库",
+            items: {
+                type: "object",
+                required: ["name", "path"],
+                properties: {
+                    name: { type: "string", description: "仓库名，例如 frontend / backend" },
+                    path: { type: "string", description: "绝对路径" },
+                    description: { type: "string", description: "该路径职责说明，会注入 AI 上下文" },
+                },
+            },
+        },
+    },
+};
+export const INIT_TOOL_DESCRIPTION = "初始化或重建当前工作区的 workspace-scope 配置（.opencode/workspace-scope.jsonc）。不传 worktrees 时自动探测父目录下的兄弟 git 仓库作为候选 worktree。生成的 sidecar 不纳入版本管理（自动写入 .gitignore），并附带 JSON Schema。";
 function isGitRepo(p) {
     return existsSync(join(p, ".git"));
 }
@@ -51,60 +71,44 @@ function writeSchema(sidecarDir) {
         // ignore
     }
 }
-export const initTool = tool({
-    description: "初始化或重建当前工作区的 workspace-scope 配置（.opencode/workspace-scope.jsonc）。不传 worktrees 时自动探测父目录下的兄弟 git 仓库作为候选 worktree。生成的 sidecar 不纳入版本管理（自动写入 .gitignore），并附带 JSON Schema。",
-    args: {
-        name: tool.schema.string().optional().describe("工作区名称，缺省使用当前目录名"),
-        workspaceDescription: tool.schema.string().optional().describe("工作区职责说明"),
-        worktrees: tool.schema
-            .array(tool.schema.object({
-            name: tool.schema.string().describe("仓库名，例如 frontend / backend"),
-            path: tool.schema.string().describe("绝对路径"),
-            description: tool.schema.string().optional().describe("该路径职责说明，会注入 AI 上下文"),
-        }))
-            .optional()
-            .describe("可选：显式指定 worktree 列表；缺省自动探测父目录兄弟 git 仓库"),
-    },
-    async execute(args, context) {
-        const anchor = context.worktree || context.directory;
-        const sidecarDir = join(anchor, ".opencode");
-        mkdirSync(sidecarDir, { recursive: true });
-        const worktrees = args.worktrees && args.worktrees.length > 0 ? args.worktrees : detectSiblingRepos(anchor);
-        if (worktrees.length === 0) {
-            return [
-                "未探测到兄弟 git 仓库，也未收到显式 worktrees 参数。",
-                "请传入 worktrees（name+path+description），或确认已在 workspace 根目录启动 opencode。",
-            ].join("\n");
-        }
-        const filePath = join(sidecarDir, "workspace-scope.jsonc");
-        const content = {
-            $schema: "./workspace-scope.schema.json",
-            name: args.name || basename(anchor),
-            workspace: {
-                path: anchor,
-                description: args.workspaceDescription,
-            },
-            worktrees: worktrees.map((w) => ({
-                name: w.name,
-                path: w.path,
-                description: w.description,
-            })),
-        };
-        writeFileSync(filePath, JSON.stringify(content, null, 2));
-        writeSchema(sidecarDir);
-        ensureGitignore(sidecarDir, ["workspace-scope.jsonc", "workspace-scope.schema.json"]);
-        invalidateScope();
+export function runInit(anchor, args) {
+    const sidecarDir = join(anchor, ".opencode");
+    mkdirSync(sidecarDir, { recursive: true });
+    const worktrees = args.worktrees && args.worktrees.length > 0 ? args.worktrees : detectSiblingRepos(anchor);
+    if (worktrees.length === 0) {
         return [
-            `已生成 ${filePath}`,
-            "",
-            "内容：",
-            "```jsonc",
-            JSON.stringify(content, null, 2),
-            "```",
-            "",
-            "下一步：",
-            "1. 编辑该文件，为每个 worktree 补充 description（职责说明，会注入 AI 上下文）；",
-            "2. 重启 opencode 使 external_directory 权限生效（上下文注入无需重启）。",
+            "未探测到兄弟 git 仓库，也未收到显式 worktrees 参数。",
+            "请传入 worktrees（name+path+description），或确认已在 workspace 根目录启动 opencode。",
         ].join("\n");
-    },
-});
+    }
+    const filePath = join(sidecarDir, "workspace-scope.jsonc");
+    const content = {
+        $schema: "./workspace-scope.schema.json",
+        name: args.name || basename(anchor),
+        workspace: {
+            path: anchor,
+            description: args.workspaceDescription,
+        },
+        worktrees: worktrees.map((w) => ({
+            name: w.name,
+            path: w.path,
+            description: w.description,
+        })),
+    };
+    writeFileSync(filePath, JSON.stringify(content, null, 2));
+    writeSchema(sidecarDir);
+    ensureGitignore(sidecarDir, ["workspace-scope.jsonc", "workspace-scope.schema.json"]);
+    invalidateScope();
+    return [
+        `已生成 ${filePath}`,
+        "",
+        "内容：",
+        "```jsonc",
+        JSON.stringify(content, null, 2),
+        "```",
+        "",
+        "下一步：",
+        "1. 编辑该文件，为每个 worktree 补充 description（职责说明，会注入 AI 上下文）；",
+        "2. 重启 opencode 使 external_directory 权限生效（上下文注入无需重启）。",
+    ].join("\n");
+}

package/dist/permissions.d.ts

@@ -1,4 +1,13 @@
 import type { ScopeResult } from "./scope.js";
-export declare function buildExternalDirectory(scope: ScopeResult): Record<string, string>;
-export declare function mergeExternalDirectory(current: unknown, allows: Record<string, string>): Record<string, string>;
-export declare function mergePermission(current: unknown, external: Record<string, string>): unknown;
+/**
+ * 归一化 external_directory 资源：去掉结尾通配与斜杠、展开 ~，
+ * 得到目录边界路径（V2 中资源通常以 "dir/*" 形式出现且已规范化）。
+ */
+export declare function normalizeBoundary(resource: string): string;
+/** 单个 external_directory 资源边界是否落在作用域声明的 worktree（词法路径或 realpath）内 */
+export declare function inScope(resource: string, scope: ScopeResult): boolean;
+/**
+ * 全部资源都命中作用域才放行；部分命中时保持默认（ask），
+ * 避免把边界外资源一并放行造成越权放大。
+ */
+export declare function coveredByScope(resources: ReadonlyArray<string>, scope: ScopeResult): boolean;

package/dist/permissions.js

@@ -1,36 +1,32 @@
-import { existsSync } from "node:fs";
-function patternPath(p) {
-    return p.replaceAll("\\", "/") + "/**";
+import { isAbsolute, relative } from "node:path";
+import { homedir } from "node:os";
+/**
+ * 归一化 external_directory 资源：去掉结尾通配与斜杠、展开 ~，
+ * 得到目录边界路径（V2 中资源通常以 "dir/*" 形式出现且已规范化）。
+ */
+export function normalizeBoundary(resource) {
+    let p = resource.replaceAll("\\", "/");
+    if (p === "~" || p.startsWith("~/"))
+        p = homedir() + p.slice(1);
+    if (p.endsWith("/*"))
+        p = p.slice(0, -2);
+    return p.replace(/\/+$/, "");
 }
-export function buildExternalDirectory(scope) {
-    const rules = {};
-    for (const wt of scope.config.worktrees) {
-        if (!existsSync(wt.path))
-            continue;
-        rules[patternPath(wt.path)] = "allow";
-        if (wt.realpath !== wt.path)
-            rules[patternPath(wt.realpath)] = "allow";
-    }
-    return rules;
+function isWithin(candidate, root) {
+    if (candidate === root)
+        return true;
+    const rel = relative(root, candidate);
+    return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
 }
-export function mergeExternalDirectory(current, allows) {
-    if (current && typeof current === "object" && !Array.isArray(current)) {
-        return { ...current, ...allows };
-    }
-    if (typeof current === "string") {
-        return { "*": current, ...allows };
-    }
-    return allows;
+/** 单个 external_directory 资源边界是否落在作用域声明的 worktree（词法路径或 realpath）内 */
+export function inScope(resource, scope) {
+    const boundary = normalizeBoundary(resource);
+    return scope.config.worktrees.some((wt) => isWithin(boundary, wt.path) || isWithin(boundary, wt.realpath));
 }
-export function mergePermission(current, external) {
-    if (typeof current === "string")
-        return current;
-    if (!current || typeof current !== "object" || Array.isArray(current)) {
-        return { external_directory: external };
-    }
-    const base = current;
-    return {
-        ...base,
-        external_directory: mergeExternalDirectory(base.external_directory, external),
-    };
+/**
+ * 全部资源都命中作用域才放行；部分命中时保持默认（ask），
+ * 避免把边界外资源一并放行造成越权放大。
+ */
+export function coveredByScope(resources, scope) {
+    return resources.length > 0 && resources.every((r) => inScope(r, scope));
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "opencode-workspace-scope",
-  "version": "0.1.0",
-  "description": "全局安装、sidecar 自激活的 opencode 插件：按工作区配置自动生成 external_directory 权限，并把工作区 worktree 路径与职责注入 AI 上下文，支撑多 worktree 并行开发互不干扰。",
+  "version": "0.2.0-beta.1",
+  "description": "全局安装、sidecar 自激活的 opencode2 插件：在工作区权限评估时动态放行已声明 worktree 的 external_directory，并把工作区路径与职责注入 AI 上下文，支撑多 worktree 并行开发互不干扰。",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -21,6 +21,7 @@
   },
   "keywords": [
     "opencode",
+    "opencode2",
     "plugin",
     "worktree",
     "workspace",
@@ -28,7 +29,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@opencode-ai/plugin": "^1.18.3"
+    "@opencode-ai/plugin": "0.0.0-beta-19151"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",