From 2d8a3be3cd0bbf30a4a8a5441fde4e179862378c Mon Sep 17 00:00:00 2001 From: sidreyas Date: Sun, 22 Nov 2026 11:12:29 +0530 Subject: [PATCH 1/3] fix(server): preserve Claude read-only MCP hints with native permission checks An unrelated Claude MCP deny rule, such as mcp__buildkite__create_build, stripped the read-only hint from every MCP App tool, so read-only background calls asked for approval and were then refused by the adapter's broad deny guard. When Claude advertises mcp_call_check_permissions_v1 and the thread runs in Full Access with readable rules and no ask rule that may cover MCP tools, keep read-only hints and send mcp_call with check_permissions, so Claude's own evaluator applies exact, wildcard and alias rules to the actual tool. Older CLIs, unreadable rules, ask rules, other permission modes and tools without a read-only annotation keep the conservative path. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/ClaudeAdapterV2.test.ts | 99 +++++++++++++++---- .../Adapters/ClaudeAdapterV2.ts | 43 +++++++- 2 files changed, 119 insertions(+), 23 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index e1665b1bafb3e..afb5aa7f56b83 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -6741,6 +6741,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { >, toolName = "mcp__probe_server__show_weather", toolUseResult: unknown = { content: '{"tempC":21}', structuredContent: { tempC: 21 } }, + runtimePolicy = CLAUDE_TEST_RUNTIME_POLICY, ) { const mcpRequests: Array = []; const harness = yield* makeWakeHarnessWithOptions({ @@ -6778,6 +6779,7 @@ describe("ClaudeAdapterV2 background wake turns", () => { attemptId: RunAttemptId.make("mcp-app"), text: "Show the weather", attachments: [], + runtimePolicy, }), ); const id = "weather-app-call"; @@ -7094,28 +7096,82 @@ describe("ClaudeAdapterV2 background wake turns", () => { called: false, readOnly: false, }, + { + case: "native permission checks and an unrelated deny rule", + rules: [{ behavior: "deny", rule: "mcp__buildkite__create_build" }], + nativeChecks: true, + checked: true, + called: true, + readOnly: true, + }, + { + case: "native checks and an ask rule for a hidden alias containing __", + rules: [{ behavior: "ask", rule: "mcp__finance__prod" }], + nativeChecks: true, + called: true, + readOnly: false, + }, + { + case: "native checks with unreadable permission rules", + rules: "unreadable", + nativeChecks: true, + called: false, + readOnly: false, + }, + { + case: "native checks outside Full Access", + rules: [{ behavior: "deny", rule: "mcp__buildkite__create_build" }], + nativeChecks: true, + approvalRequired: true, + called: false, + readOnly: false, + }, + { + case: "native checks for a tool without a read-only annotation", + rules: [{ behavior: "deny", rule: "mcp__buildkite__create_build" }], + nativeChecks: true, + mutating: true, + called: false, + readOnly: false, + }, ] as const)("applies Claude's permission rules to MCP app calls with $case", (testCase) => Effect.gen(function* () { const server = "server" in testCase ? testCase.server : PROBE_SERVER_STATUS.name; const tool = "tool" in testCase ? testCase.tool : "refresh_weather"; - const { harness, mcpRequests } = yield* runClaudeMcpAppToolTurn(MCP_APP_CAPABILITIES, { - mcpServerStatus: Effect.succeed([ - { - ...PROBE_SERVER_STATUS, - name: server, - tools: [{ ...PROBE_SERVER_STATUS.tools[1], name: tool }], - }, - ]), - listPermissionRules: - testCase.rules === "unreadable" - ? Effect.fail( - new ClaudeAdapterV2.ClaudeAgentSdkQueryRunnerError({ - method: "listPermissionRules", - cause: new Error("Unsupported control request subtype"), - }), - ) - : Effect.succeed(testCase.rules), - }); + const { harness, mcpRequests } = yield* runClaudeMcpAppToolTurn( + "nativeChecks" in testCase + ? [...MCP_APP_CAPABILITIES, "mcp_call_check_permissions_v1"] + : MCP_APP_CAPABILITIES, + { + mcpServerStatus: Effect.succeed([ + { + ...PROBE_SERVER_STATUS, + name: server, + tools: [ + { + ...PROBE_SERVER_STATUS.tools[1], + name: tool, + ...("mutating" in testCase ? { annotations: { destructive: false } } : {}), + }, + ], + }, + ]), + listPermissionRules: + testCase.rules === "unreadable" + ? Effect.fail( + new ClaudeAdapterV2.ClaudeAgentSdkQueryRunnerError({ + method: "listPermissionRules", + cause: new Error("Unsupported control request subtype"), + }), + ) + : Effect.succeed(testCase.rules), + }, + undefined, + undefined, + "approvalRequired" in testCase + ? { ...CLAUDE_TEST_RUNTIME_POLICY, runtimeMode: "approval-required" } + : CLAUDE_TEST_RUNTIME_POLICY, + ); const mcpApps = harness.runtime.mcpApps!; const target = { providerThread: harness.providerThread, server }; const [listed] = yield* mcpApps.listTools(target); @@ -7127,6 +7183,13 @@ describe("ClaudeAdapterV2 background wake turns", () => { ); const exit = yield* Effect.exit(mcpApps.callTool({ ...target, tool, arguments: {} })); assert.equal(Exit.isSuccess(exit), testCase.called); + if ("nativeChecks" in testCase && testCase.called) { + assert.deepInclude(mcpRequests, { + tool: "mcp__probe_server__refresh_weather", + arguments: {}, + ...("checked" in testCase ? { checkPermissions: true } : {}), + }); + } assert.equal( mcpRequests.some( (request) => typeof request === "object" && request !== null && "arguments" in request, diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index b120f9feb5e5a..3054ce96c990d 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -747,6 +747,7 @@ export interface ClaudeAgentSdkQuerySession { readonly callMcpTool: (input: { readonly tool: string; readonly arguments: Record; + readonly checkPermissions?: boolean; }) => Effect.Effect; readonly listPermissionRules: Effect.Effect< ReadonlyArray, @@ -1074,18 +1075,34 @@ function claudeRulesMayCoverMcpTools( }); } +function claudeCanCheckReadOnlyMcpCalls( + capabilities: ReadonlySet, + permissionMode: PermissionMode, + rules: ReadonlyArray | null, +): boolean { + // Idle cards cannot answer CLI approval requests; keep T3's existing prompts outside this path. + return ( + capabilities.has("mcp_call_check_permissions_v1") && + permissionMode === "bypassPermissions" && + rules !== null && + !claudeRulesMayCoverMcpTools(rules, ["ask"]) + ); +} + /** * Claude reports `annotations` as `readOnly`/`destructive`/`openWorld`; apps expect MCP's `*Hint` names. - * Card calls skip Claude's permission check, so `readOnlyHint`, which skips T3's prompt, needs readable - * rules (null when not) with no ask or deny rule that may cover the tool. + * Unchecked card calls skip Claude's permission check, so there `readOnlyHint`, which skips T3's prompt, + * needs readable rules (null when not) with no ask or deny rule that may cover the tool. */ function claudeMcpToolForApps( tool: NonNullable[number], rules: ReadonlyArray | null, + checkReadOnlyPermissions: boolean, ) { const annotations = tool.annotations ?? {}; const readOnlyHint = annotations.readOnly !== true || + checkReadOnlyPermissions || (rules !== null && !claudeRulesMayCoverMcpTools(rules, ["ask", "deny"])) ? annotations.readOnly : undefined; @@ -1987,6 +2004,7 @@ export const layerQueryRunner: Layer.Layer< tool: call.tool, arguments: call.arguments, result_not_for_model: true, + ...(call.checkPermissions === true ? { check_permissions: true } : {}), }), catch: (cause) => queryRunnerError(cause, "callMcpTool"), }), @@ -14554,7 +14572,14 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( const rules = yield* liveQuery.query.listPermissionRules.pipe( Effect.orElseSucceed(() => null), ); - return (status?.tools ?? []).map((tool) => claudeMcpToolForApps(tool, rules)); + const checkReadOnlyPermissions = claudeCanCheckReadOnlyMcpCalls( + liveQuery.capabilities, + liveQuery.permissionMode, + rules, + ); + return (status?.tools ?? []).map((tool) => + claudeMcpToolForApps(tool, rules, checkReadOnlyPermissions), + ); }), callTool: Effect.fn("ClaudeAdapterV2.callMcpTool")(function* (call) { const { liveQuery, statuses } = yield* mcpAppServerStatuses( @@ -14572,7 +14597,6 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( detail: "Another tool on this MCP server has the same Claude tool name.", }); } - // mcp_call skips Claude's permission check, so its deny rules are applied here. const rules = yield* liveQuery.query.listPermissionRules.pipe( Effect.mapError( (cause) => @@ -14583,7 +14607,15 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( }), ), ); - if (claudeRulesMayCoverMcpTools(rules, ["deny"])) { + const checkPermissions = + sameName[0]?.annotations?.readOnly === true && + claudeCanCheckReadOnlyMcpCalls( + liveQuery.capabilities, + liveQuery.permissionMode, + rules, + ); + // Unchecked mcp_call skips Claude's permission check; only the checked path resolves hidden aliases. + if (!checkPermissions && claudeRulesMayCoverMcpTools(rules, ["deny"])) { return yield* new ProviderAdapter.ProviderAdapterProtocolError({ driver: CLAUDE_PROVIDER, detail: `A Claude deny rule may cover ${tool}, so it was not called.`, @@ -14594,6 +14626,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( .callMcpTool({ tool, arguments: call.arguments, + ...(checkPermissions ? { checkPermissions: true } : {}), }) .pipe( Effect.mapError( From dace83f4895908f4b79dd39279a5b56047aee19d Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sun, 22 Nov 2026 06:17:34 +0000 Subject: [PATCH 2/3] fix(server): let Claude enforce ask rules on checked MCP app calls T3's broad ask matcher treated any mcp__ ask rule as covering every MCP App tool, so an unrelated ask rule still withheld read-only hints and sent calls back through the broad deny guard. With check_permissions, Claude evaluates ask rules itself and routes a matching ask to canUseTool, which prompts during a turn and refuses when idle. Co-Authored-By: Claude Opus 5.5 --- .../orchestration-v2/Adapters/ClaudeAdapterV2.test.ts | 10 +++++++--- .../src/orchestration-v2/Adapters/ClaudeAdapterV2.ts | 5 ++--- 2 files changed, 9 insertions(+), 6 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index afb5aa7f56b83..5a108fa43fe62 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -7105,11 +7105,15 @@ describe("ClaudeAdapterV2 background wake turns", () => { readOnly: true, }, { - case: "native checks and an ask rule for a hidden alias containing __", - rules: [{ behavior: "ask", rule: "mcp__finance__prod" }], + case: "native permission checks and unrelated ask and deny rules", + rules: [ + { behavior: "ask", rule: "mcp__atlassian__createJiraIssue" }, + { behavior: "deny", rule: "mcp__buildkite__create_build" }, + ], nativeChecks: true, + checked: true, called: true, - readOnly: false, + readOnly: true, }, { case: "native checks with unreadable permission rules", diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 3054ce96c990d..929dab5951578 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -1080,12 +1080,11 @@ function claudeCanCheckReadOnlyMcpCalls( permissionMode: PermissionMode, rules: ReadonlyArray | null, ): boolean { - // Idle cards cannot answer CLI approval requests; keep T3's existing prompts outside this path. + // Under bypass, canUseTool prompts for an ask during a turn and refuses it when idle, so asks stay enforced. return ( capabilities.has("mcp_call_check_permissions_v1") && permissionMode === "bypassPermissions" && - rules !== null && - !claudeRulesMayCoverMcpTools(rules, ["ask"]) + rules !== null ); } From db3f76180a5520ce9ec7532d53f4cdff0f5a57ad Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Sun, 22 Nov 2026 06:27:03 +0000 Subject: [PATCH 3/3] Revert "fix(server): let Claude enforce ask rules on checked MCP app calls" This reverts commit dace83f4895908f4b79dd39279a5b56047aee19d. With native checks, an ask rule that really covers a read-only app tool reaches canUseTool, which refuses it when no turn is active. Cards load between turns, so the frame lost its confirmation and the call failed, where main asks and then runs it. Any MCP ask rule again keeps the frame's confirmation and the unchecked call. Co-Authored-By: Claude Opus 5.5 --- .../orchestration-v2/Adapters/ClaudeAdapterV2.test.ts | 10 +++------- .../src/orchestration-v2/Adapters/ClaudeAdapterV2.ts | 5 +++-- 2 files changed, 6 insertions(+), 9 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 5a108fa43fe62..afb5aa7f56b83 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -7105,15 +7105,11 @@ describe("ClaudeAdapterV2 background wake turns", () => { readOnly: true, }, { - case: "native permission checks and unrelated ask and deny rules", - rules: [ - { behavior: "ask", rule: "mcp__atlassian__createJiraIssue" }, - { behavior: "deny", rule: "mcp__buildkite__create_build" }, - ], + case: "native checks and an ask rule for a hidden alias containing __", + rules: [{ behavior: "ask", rule: "mcp__finance__prod" }], nativeChecks: true, - checked: true, called: true, - readOnly: true, + readOnly: false, }, { case: "native checks with unreadable permission rules", diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index 929dab5951578..3054ce96c990d 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -1080,11 +1080,12 @@ function claudeCanCheckReadOnlyMcpCalls( permissionMode: PermissionMode, rules: ReadonlyArray | null, ): boolean { - // Under bypass, canUseTool prompts for an ask during a turn and refuses it when idle, so asks stay enforced. + // Idle cards cannot answer CLI approval requests; keep T3's existing prompts outside this path. return ( capabilities.has("mcp_call_check_permissions_v1") && permissionMode === "bypassPermissions" && - rules !== null + rules !== null && + !claudeRulesMayCoverMcpTools(rules, ["ask"]) ); }