Skip to content

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.md
index 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 nothing
from the store, does not depend on `store.isAvailable()`, and keeps
running while the store is unavailable. When a Host-owned store exists,
the shell stays bound to the verified caller root; before every command it
re-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 with
approval enabled, unless the approval configuration sets `shell_exec` to
`false`. Cron, internal and approval-disabled tasks keep their existing
approval 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 process
running with the Host UID, which can already alter or delete those files
directly (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.json
index 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.json
index 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.ts
index 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.ts
index 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 resum
const 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.ts
index 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.ts
index 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: GfsExecutionCapabilityInput
diff --git a/mcp-host/src/agent/taskExecutor.ts b/mcp-host/src/agent/taskExecutor.ts
index 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
)
: baseController
diff --git a/mcp-host/src/core/tools/__tests__/shell.detachedStdio.test.ts b/mcp-host/src/core/tools/__tests__/shell.detachedStdio.test.ts
index 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.json
index 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",