Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
fix(mcp-host): restore turn-wide shell_exec approval and bound EPERM probes
Alfredo Lopezaf77dee2a022
diff --git a/docs/operations/gfs-large-file-host-downloads.md b/docs/operations/gfs-large-file-host-downloads.mdindex 1a767214c..4ea3206b8 100644--- a/docs/operations/gfs-large-file-host-downloads.md+++ b/docs/operations/gfs-large-file-host-downloads.md@@ -120,20 +120,19 @@ a new ID, after fresh GFS authorization.`shell_exec` remains the trust boundary:- The working directory and `HOME` are the caller workspace. A supplied allowlisted or dynamic `HOME` cannot relocate execution outside it.-- Each command on this managed workspace surface requires fresh live user- approval. Consent authorizes the exact frozen invocation. It does not grant- `*`, another tool, an entire MCP server, a future shell call or unattended- execution. Deliberately turn-wide approvals on other surfaces retain their- proven scope. Persisted approvals without a scope are treated as individual- invocations.+- `shell_exec` follows the same approval rules as every other native tool,+ such as `http_request` (as before #979): approving one call authorizes the+ rest of that turn, and "always" approval authorizes later turns. A guardrail+ rule with `action: 'ask'` on `shell_exec` restores per-call approval.+ Persisted approvals without a scope are treated as individual invocations.- Combined retained command output is bounded to 1 MiB. Live progress is bounded to 64 KiB. Exceeding the output bound terminates the process group and returns a truthful `output_limit_exceeded` result.- `shell_exec` never calls the GFS download store (#1019). It takes nothingfrom the store, does not depend on `store.isAvailable()`, and keepsrunning while the store is unavailable. When a Host-owned store exists,the shell stays bound to the verified caller root; before every command itre-verifies that the caller root is still canonical. That check is per-user- directory scoping, not store state. Live approval of `shell_exec` and- `clerum__gfs_download` is forced only for channel tasks on a Host with+ directory scoping, not store state. Per-call live approval is forced only+ for `clerum__gfs_download`, and only for channel tasks on a Host withapproval enabled, unless the approval configuration sets `shell_exec` to`false`. Cron, internal and approval-disabled tasks keep their existingapproval policy.@@ -191,6 +190,11 @@ a new ID, after fresh GFS authorization.if the parent moved). The windows that remain can be won only by a processrunning with the Host UID, which can already alter or delete those filesdirectly (risk 3); winning one gives no capability beyond that.+8. A turn-wide or "always" approval of `shell_exec` also authorizes shell+ commands the model issues after it has read untrusted GFS content in the+ same turn (or, with "always", in later turns). The shell runs with the Host+ UID. Operators who need per-call approval add a guardrail rule with+ `action: 'ask'` for `shell_exec`.Partial reads are not possible, because publication is an atomic `rename` of`source.partial`.diff --git a/mcp-host/package-lock.json b/mcp-host/package-lock.jsonindex 36bbaa7f8..3c22560db 100644--- a/mcp-host/package-lock.json+++ b/mcp-host/package-lock.json@@ -1,12 +1,12 @@{"name": "clerum-mcp-host",- "version": "0.1.549",+ "version": "0.1.550","lockfileVersion": 3,"requires": true,"packages": {"": {"name": "clerum-mcp-host",- "version": "0.1.549",+ "version": "0.1.550","license": "SEE LICENSE IN LICENSE","dependencies": {"@anthropic-ai/sdk": "^0.32.0",diff --git a/mcp-host/package.json b/mcp-host/package.jsonindex 228af3c56..61132844a 100644--- a/mcp-host/package.json+++ b/mcp-host/package.json@@ -1,6 +1,6 @@{"name": "clerum-mcp-host",- "version": "0.1.549",+ "version": "0.1.550","description": "MCP Host - reads Host CRD and provides LLM access via OpenAI/Claude","main": "dist/main.js","engines": {diff --git a/mcp-host/src/agent/__tests__/taskExecutor.gfsBatchReceipt.integration.test.ts b/mcp-host/src/agent/__tests__/taskExecutor.gfsBatchReceipt.integration.test.tsindex 485a89118..e3f0ef5f0 100644--- a/mcp-host/src/agent/__tests__/taskExecutor.gfsBatchReceipt.integration.test.ts+++ b/mcp-host/src/agent/__tests__/taskExecutor.gfsBatchReceipt.integration.test.ts@@ -81,7 +81,7 @@ function shellQuote(value: string): string {return `'${value.replaceAll("'", "'\\''")}'`}-it('keeps the exact workspace receipt through same-batch image suspension, SQLite cold resume and fresh CLI consent', async () => {+it('keeps the exact workspace receipt through same-batch image suspension, SQLite cold resume and one turn-wide shell approval', async () => {root = await fs.mkdtemp(join(tmpdir(), 'gfs-batch-receipt-'))store = new GfsDownloadStore(root)await store.initialize()@@ -284,25 +284,19 @@ it('keeps the exact workspace receipt through same-batch image suspension, SQLit).toMatchObject(expected)const cold = new TaskExecutor(task, { ...deps, conversationManager: coldManager })await cold.rehydrateWaitingApproval(sessionKey, coldConversation.pending_approval!)+ // The shell approval covers the rest of the turn, so the follow-up shell+ // that processes the retained copy runs without a second approval.await cold.resumeAfterApproval(false)expect(onFail).not.toHaveBeenCalled()- expect(cold.executorState).toBe('waiting_approval')- expect(cold.pendingApproval?.tool_call_id).toBe('process-retained')- expect(cold.pendingApproval?.authorization_scope).toBe('exact_invocation')expect(requests[1].find(message => message.tool_call_id === firstShell.id)?.content).toContain('batch-approved')expect(requests[1].flatMap(message => message.contentParts ?? []).some(part => part.type === 'image')).toBe(false)- expect(contentRequests).toBe(1)- expect(releaseOwner).not.toHaveBeenCalled()-- await cold.resumeAfterApproval(false)- expect(onFail).not.toHaveBeenCalled()expect(cold.executorState).toBe('completed')expect(onComplete).toHaveBeenCalledExactlyOnceWith(task)- expect(onApprovalNeeded).toHaveBeenCalledTimes(2)+ expect(onApprovalNeeded).toHaveBeenCalledTimes(1)const output = requests[2].find(message => message.tool_call_id === 'process-retained')!.content// Shell output keeps the production safety envelope around the bounded proof.const proof = /\{"bytes":\d+,"sha256":"[0-9a-f]{64}"\}/.exec(output)?.[0]diff --git a/mcp-host/src/agent/__tests__/taskExecutor.gfsLiveApproval.integration.test.ts b/mcp-host/src/agent/__tests__/taskExecutor.gfsLiveApproval.integration.test.tsindex 7f0e2d399..1bdcc27c5 100644--- a/mcp-host/src/agent/__tests__/taskExecutor.gfsLiveApproval.integration.test.ts+++ b/mcp-host/src/agent/__tests__/taskExecutor.gfsLiveApproval.integration.test.ts@@ -12,6 +12,7 @@ import {} from '../../core/conversation/persistence/__tests__/testHelpers'import { SqliteConversationStore } from '../../core/conversation/persistence/sqliteConversationStore'import { SimpleEventEmitter } from '../../core/orchestration/eventEmitter'+import { HttpRequestTool } from '../../core/tools/httpRequest'import { type ChatMessage, FinishReason, type ToolCall } from '../../core/types'import { GfsDownloadStore } from '../../internalTools/gfsDownloadStore'import { TaskLifecycle } from '../../lifecycle/taskLifecycle'@@ -79,7 +80,8 @@ async function scenario(calls: ToolCall[],guardrailAsk = false,conversationManager = new ConversationManager(),- storeState: StoreState = 'available'+ storeState: StoreState = 'available',+ persistentShellApproval = true) {const root = await mkdtemp(join(tmpdir(), 'gfs-live-approval-'))roots.push(root)@@ -144,7 +146,7 @@ async function scenario(channelType: task.sourceMessage!.channelType,channelId: task.sourceMessage!.channelId,})- conversation.auto_approved_tools = new Set(['shell_exec'])+ conversation.auto_approved_tools = new Set(persistentShellApproval ? ['shell_exec'] : [])const lifecycle = new TaskLifecycle()lifecycle.register(task)@@ -202,32 +204,28 @@ async function scenario(}}-it('requires live shell approval despite persistent shell auto-approval', async () => {+// Shell approval follows the same turn and "always" rules as every other native+// tool (as before #979). Only clerum__gfs_download keeps per-call live approval.+it('runs shell without a new approval when shell_exec is persistently approved', async () => {const call = shellCall('first-shell-call', firstCommand)const s = await scenario([call])await s.executor.run()expect(s.onFail).not.toHaveBeenCalled()- expect(s.executor.executorState).toBe('waiting_approval')- expect(s.executor.pendingApproval).toMatchObject({- tool_name: call.name,- tool_call_id: call.id,- parameters: call.arguments,- })-- expect(s.onApprovalNeeded).toHaveBeenCalledTimes(1)- expect(s.providerCalls).toHaveLength(1)- expect(spawn).not.toHaveBeenCalled()+ // Witness: the command ran, with its exact arguments, and the turn finished.+ expect(spawn).toHaveBeenCalledTimes(1)+ expect(vi.mocked(spawn).mock.calls[0].slice(0, 2)).toEqual(['/bin/sh', ['-c', firstCommand]])+ expect(s.executor.executorState).toBe('completed')+ expect(s.onApprovalNeeded).not.toHaveBeenCalled()})-// X6 covers an unavailable store with source 'cron', where the forced live-// approval set never applies. These cases pin the channel path: delivery is-// withdrawn, yet persistent shell auto-approval still does not run a command.+// X6 covers an unavailable store with source 'cron'. These cases pin the channel+// path: delivery is withdrawn, and persistent shell approval still applies.it.each([['store closed', 'closed'] as const,['store never initialized', 'uninitialized'] as const,])(- 'requires live shell approval while the GFS download store is unavailable: %s',+ 'applies persistent shell approval while the GFS download store is unavailable: %s',async (_label, storeState) => {const call = shellCall('unavailable-store-shell-call', firstCommand)const s = await scenario([call], false, new ConversationManager(), storeState)@@ -240,38 +238,79 @@ it.each([// Witness: the executor consulted the unavailable store for this task.expect(isAvailable.mock.calls.length).toBeGreaterThan(0)expect(s.onFail).not.toHaveBeenCalled()- expect(s.executor.executorState).toBe('waiting_approval')- expect(s.executor.pendingApproval).toMatchObject({- tool_name: 'shell_exec',- tool_call_id: call.id,- parameters: call.arguments,- })- expect(s.onApprovalNeeded).toHaveBeenCalledTimes(1)- expect(s.providerCalls).toHaveLength(1)- expect(spawn).not.toHaveBeenCalled()+ expect(spawn).toHaveBeenCalledTimes(1)+ expect(vi.mocked(spawn).mock.calls[0].slice(0, 2)).toEqual(['/bin/sh', ['-c', firstCommand]])+ expect(s.executor.executorState).toBe('completed')+ expect(s.onApprovalNeeded).not.toHaveBeenCalled()})-it.each(['http_request', 'cron_manage'] as const)(- 'does not turn an exact GFS shell approval into turn-wide consent for %s',+it('one shell approval covers the rest of the turn: two shell calls, one approval', async () => {+ const firstCall = shellCall('first-shell-call', firstCommand)+ const secondCall = shellCall('second-shell-call', secondCommand)+ const s = await scenario(+ [firstCall, secondCall],+ false,+ new ConversationManager(),+ 'available',+ false+ )+ await s.executor.run()++ expect(s.executor.pendingApproval).toMatchObject({+ tool_name: 'shell_exec',+ tool_call_id: firstCall.id,+ authorization_scope: 'turn_tools',+ })+ expect(spawn).not.toHaveBeenCalled()+ await s.executor.resumeAfterApproval(false)++ expect(s.onFail).not.toHaveBeenCalled()+ // Witness: both commands ran, in order, after a single approval.+ expect(vi.mocked(spawn).mock.calls.map(call => call[1])).toEqual([+ ['-c', firstCommand],+ ['-c', secondCommand],+ ])+ const secondResult = s.providerCalls[2].find(+ message => message.role === 'tool' && message.tool_call_id === secondCall.id+ )+ expect(secondResult?.content).toContain('second-approved-result')+ expect(s.executor.executorState).toBe('completed')+ expect(s.onApprovalNeeded).toHaveBeenCalledTimes(1)+})++it.each(['http_request', 'shell_exec'] as const)(+ 'approval parity: %s asks once per turn and the approval covers the next call',async toolName => {- const fetchMock = vi.fn(async () => new Response('untrusted follow-up body', { status: 200 }))- vi.stubGlobal('fetch', fetchMock)- const s = await scenario([shellCall('gfs-shell', firstCommand), riskyFollowUp(toolName)])+ // http_request resolves and pins its own socket; the tool boundary is the witness.+ const httpExecute = vi+ .spyOn(HttpRequestTool.prototype, 'execute')+ .mockResolvedValue({ content: 'follow-up body', duration_ms: 1, is_error: false })+ const first: ToolCall =+ toolName === 'shell_exec'+ ? shellCall('parity-first', firstCommand)+ : { ...riskyFollowUp('http_request'), id: 'parity-first' }+ const s = await scenario(+ [first, riskyFollowUp('http_request')],+ false,+ new ConversationManager(),+ 'available',+ false+ )await s.executor.run()expect(s.executor.pendingApproval).toMatchObject({- tool_name: 'shell_exec',- authorization_scope: 'exact_invocation',+ tool_name: toolName,+ authorization_scope: 'turn_tools',})await s.executor.resumeAfterApproval(false)expect(s.onFail).not.toHaveBeenCalled()- expect(s.executor.executorState).toBe('waiting_approval')- expect(s.executor.pendingApproval).toMatchObject({ tool_name: toolName })- expect(s.onApprovalNeeded).toHaveBeenCalledTimes(2)- expect(s.releaseReceiptOwner).not.toHaveBeenCalled()- expect(fetchMock).not.toHaveBeenCalled()+ // Witness: the follow-up HTTP call ran without a new approval.+ expect(httpExecute).toHaveBeenCalledTimes(toolName === 'http_request' ? 2 : 1)+ expect(spawn).toHaveBeenCalledTimes(toolName === 'shell_exec' ? 1 : 0)+ expect(s.executor.executorState).toBe('completed')+ expect(s.onApprovalNeeded).toHaveBeenCalledTimes(1)})@@ -284,7 +323,9 @@ it.each(['http_request', 'cron_manage'] as const)(const s = await scenario([shellCall('legacy-shell', firstCommand), riskyFollowUp(followUp)],false,- manager+ manager,+ 'available',+ false)const listJobs = vi.spyOn(s.deps.cronScheduler!, 'getAllJobs')const fetchMock = vi.fn(async () => new Response('Unexpected remote result'))@@ -327,7 +368,9 @@ it('preserves separately explicit cron consent after a legacy SQLite shell resumconst s = await scenario([shellCall('legacy-shell', firstCommand), riskyFollowUp('cron_manage')],false,- new ConversationManager(handle.store)+ new ConversationManager(handle.store),+ 'available',+ false)await s.executor.run()handle.worker.db@@ -356,7 +399,9 @@ const resumeCases = [{ firstExit: 127, repeatedCommand: true, alwaysApprove: false, rehydrate: false },{ firstExit: 0, repeatedCommand: true, alwaysApprove: false, rehydrate: true },{ firstExit: 127, repeatedCommand: false, alwaysApprove: false, rehydrate: true },-].flatMap(c => [false, true].map(guardrailAsk => ({ ...c, guardrailAsk })))+ // A guardrail `action: 'ask'` rule is what keeps shell approval per call now+ // that shell_exec follows the turn and "always" rules of every native tool.+].map(c => ({ ...c, guardrailAsk: true }))it.each(resumeCases)('requires new approval after exit $firstExit (repeated=$repeatedCommand, persistent=$alwaysApprove, rehydrated=$rehydrate, guardrailAsk=$guardrailAsk)',@@ -428,7 +473,7 @@ it.each(resumeCases)(})-it.each([false, true])(+it.each([true])('reissues live approval without a frozen snapshot (guardrailAsk=%s)',async guardrailAsk => {const firstCall = shellCall('first-shell-call', firstCommand)diff --git a/mcp-host/src/agent/__tests__/taskExecutor.gfsPreparation.test.ts b/mcp-host/src/agent/__tests__/taskExecutor.gfsPreparation.test.tsindex 74548393f..cbc21eef2 100644--- a/mcp-host/src/agent/__tests__/taskExecutor.gfsPreparation.test.ts+++ b/mcp-host/src/agent/__tests__/taskExecutor.gfsPreparation.test.ts@@ -361,6 +361,7 @@ async function scenario(store,sessionKey: resolveTaskSessionKey(task),createCold: () => new TaskExecutor(task, deps),+ manager,get contentRequests() {return contentRequests},@@ -719,6 +720,25 @@ describe('TaskExecutor prepares admitted GFS files before its first model call',expect(test.contentRequests).toBe(0)})+ // shell_exec follows the turn and "always" approval rules; a configured+ // clerum__gfs_download approval stays per call (TaskExecutor live set).+ it('asks for each configured clerum__gfs_download despite turn and persistent approval', async () => {+ const test = await scenario({ mode: 'download-again', requireDownloadApproval: true })+ const conversation = await test.manager.getOrCreate(test.sessionKey)+ conversation.auto_approved_tools = new Set(['*', 'clerum__gfs_download'])+ await test.executor.run()++ expect(test.onFail).not.toHaveBeenCalled()+ expect(test.executor.executorState).toBe('waiting_approval')+ expect(test.executor.pendingApproval).toMatchObject({+ tool_name: 'clerum__gfs_download',+ tool_call_id: 'unit-download-again',+ authorization_scope: 'exact_invocation',+ })+ expect(test.onApprovalNeeded).toHaveBeenCalledTimes(1)+ expect(test.contentRequests).toBe(0)+ })+it('does not infer a preparation target from ordinary user text', async () => {const test = await scenario({ includeReference: false })await test.executor.run()diff --git a/mcp-host/src/agent/gfsExecutionCapability.ts b/mcp-host/src/agent/gfsExecutionCapability.tsindex acb44a5ac..e52301dc1 100644--- a/mcp-host/src/agent/gfsExecutionCapability.ts+++ b/mcp-host/src/agent/gfsExecutionCapability.ts@@ -44,8 +44,9 @@ export interface GfsExecutionCapabilityInput {/*** GFS workspace delivery requires an attended channel caller, live approval,* an explicit shell tool policy, and the Host-owned caller-bound store/root.- * Cron and internal tasks stay unattended; persistent approvals are handled at- * the live shell controller boundary, not by this static capability check.+ * Cron and internal tasks stay unattended. Turn and persistent approvals of+ * shell_exec follow the ordinary approval rules; only clerum__gfs_download is+ * forced to per-call approval, at the TaskExecutor controller boundary.*/export function gfsWorkspaceExecutionEnabled(input: GfsExecutionCapabilityInputdiff --git a/mcp-host/src/agent/taskExecutor.ts b/mcp-host/src/agent/taskExecutor.tsindex c1ddeeffe..0e5e52fdf 100644--- a/mcp-host/src/agent/taskExecutor.ts+++ b/mcp-host/src/agent/taskExecutor.ts@@ -2352,7 +2352,7 @@ export class TaskExecutor {appConfig.enableApproval &&this.task.source === 'channel' &&this.deps.approvalConfig?.tools?.shell_exec !== false- ? new Set(['shell_exec', 'clerum__gfs_download'])+ ? new Set(['clerum__gfs_download']): undefined): baseControllerdiff --git a/mcp-host/src/core/tools/__tests__/shell.detachedStdio.test.ts b/mcp-host/src/core/tools/__tests__/shell.detachedStdio.test.tsindex 9a6365b0f..ded045544 100644--- a/mcp-host/src/core/tools/__tests__/shell.detachedStdio.test.ts+++ b/mcp-host/src/core/tools/__tests__/shell.detachedStdio.test.ts@@ -665,4 +665,56 @@ describe('ShellTool single finalizer races (#1028 P1, hermetic child)', () => {])expect(vi.getTimerCount()).toBe(0)})++ it('R1-H1: a natural exit whose group probe always fails with EPERM is bounded by the execution timeout plus the cleanup budget', async () => {+ useFakeClock()+ const child = hermeticChild()+ vi.mocked(spawn).mockImplementationOnce(() => child as never)+ // EPERM means the group exists under another owner: never proof of absence.+ const signals: Array<{ pid: number; signal: unknown; at: number }> = []+ vi.spyOn(process, 'kill').mockImplementation((pid: number, signal?: string | number) => {+ signals.push({ pid, signal, at: performance.now() })+ if (signal === 0) throw Object.assign(new Error('kill EPERM'), { code: 'EPERM' })+ return true+ })+ const timeoutMs = 3 * SHELL_STDIO_DRAIN_MS + SHELL_STDIO_DRAIN_MS / 2+ const startedAt = performance.now()+ let settledAt: number | undefined+ const execution = new ShellTool(workspacePath, timeoutMs, []).execute({+ command: 'hermetic command',+ })+ void execution.then(() => {+ settledAt = performance.now()+ })+ child.stdout.emit('data', Buffer.from('natural output'))+ child.exitCode = 0+ child.emit('exit', 0, null)++ await vi.advanceTimersByTimeAsync(timeoutMs)+ // Witness: the drain poll probed the group and got EPERM before the timeout.+ const drainProbes = signals.filter(+ entry => entry.signal === 0 && entry.at < startedAt + timeoutMs+ )+ expect(drainProbes).toHaveLength(3)+ expect(signals.filter(entry => entry.signal === 'SIGTERM')).toEqual([+ { pid: -FAKE_PID, signal: 'SIGTERM', at: startedAt + timeoutMs },+ ])++ await vi.advanceTimersByTimeAsync(SHELL_TIMEOUT_CLEANUP_MS - 1)+ expect(settledAt).toBeUndefined()+ await vi.advanceTimersByTimeAsync(1)++ expect(settledAt).toBe(startedAt + timeoutMs + SHELL_TIMEOUT_CLEANUP_MS)+ const result = await execution+ expect(result.is_error).toBe(true)+ expect(result.content).toBe(+ `${notice('timeout')}stdout:\nnatural output\n\n${TIMEOUT_FOOTER(timeoutMs)}\n\n[process_group_termination_failed]`+ )+ // EPERM is an expected probe answer, so it logs no probe-failure warning.+ expect(heldWarnings()).toEqual([+ expect.objectContaining({ reason: 'timeout', processGroupTerminated: false }),+ ])+ expect(JSON.stringify(warn.mock.calls)).not.toContain('probe failed')+ expect(vi.getTimerCount()).toBe(0)+ })})diff --git a/scripts/ci/pinned-vitest-cases/mcp-host.json b/scripts/ci/pinned-vitest-cases/mcp-host.jsonindex 482c21444..ae90ba0b1 100644--- a/scripts/ci/pinned-vitest-cases/mcp-host.json+++ b/scripts/ci/pinned-vitest-cases/mcp-host.json@@ -135,17 +135,41 @@"suite": "shell.detachedStdio.test.ts","fullName": "ShellTool single finalizer races (#1028 P1, hermetic child) R1-H1: a natural exit whose group never disappears and whose stdio never closes is bounded by the execution timeout plus the cleanup budget"},+ {+ "suite": "shell.detachedStdio.test.ts",+ "fullName": "ShellTool single finalizer races (#1028 P1, hermetic child) R1-H1: a natural exit whose group probe always fails with EPERM is bounded by the execution timeout plus the cleanup budget"+ },{"suite": "config.toolProgressInterval.test.ts","fullName": "CLERUM_TOOL_PROGRESS_INTERVAL_MS (#1028 P2) P2-b: malformed and sub-second values stop startup with the exact message and do not echo the value"},{"suite": "taskExecutor.gfsLiveApproval.integration.test.ts",- "fullName": "requires live shell approval while the GFS download store is unavailable: store closed"+ "fullName": "applies persistent shell approval while the GFS download store is unavailable: store closed"+ },+ {+ "suite": "taskExecutor.gfsLiveApproval.integration.test.ts",+ "fullName": "applies persistent shell approval while the GFS download store is unavailable: store never initialized"+ },+ {+ "suite": "taskExecutor.gfsLiveApproval.integration.test.ts",+ "fullName": "runs shell without a new approval when shell_exec is persistently approved"},{"suite": "taskExecutor.gfsLiveApproval.integration.test.ts",- "fullName": "requires live shell approval while the GFS download store is unavailable: store never initialized"+ "fullName": "one shell approval covers the rest of the turn: two shell calls, one approval"+ },+ {+ "suite": "taskExecutor.gfsLiveApproval.integration.test.ts",+ "fullName": "approval parity: http_request asks once per turn and the approval covers the next call"+ },+ {+ "suite": "taskExecutor.gfsLiveApproval.integration.test.ts",+ "fullName": "approval parity: shell_exec asks once per turn and the approval covers the next call"+ },+ {+ "suite": "taskExecutor.gfsPreparation.test.ts",+ "fullName": "TaskExecutor prepares admitted GFS files before its first model call asks for each configured clerum__gfs_download despite turn and persistent approval"},{"suite": "gfsDownloadStore.test.ts",