openvisio-agent 0.19.12 → 0.20.0

package/scenarios/runtime.scenarios.mjs

@@ -0,0 +1,451 @@
+import assert from 'node:assert/strict'
+import { acpPermissionResponse, createMastraAcpRunner } from '../src/mastra-harness.mjs'
+import { createCycleQueue } from '../src/cycle-queue.mjs'
+import { createRunnerPool } from '../src/runner-pool.mjs'
+import { resolveAvailableModel, resolveClaudeModel, claudeFallbackModels } from '../src/model-selection.mjs'
+import { buildOpencodeConfig } from '../src/opencode-config.mjs'
+
+export const scenarios = []
+const add = (id, category, description, run) => scenarios.push({ id: `runtime-${id}`, category, description, run })
+const deferred = () => { let resolve; const promise = new Promise((done) => { resolve = done }); return { promise, resolve } }
+const tick = () => new Promise((done) => setImmediate(done))
+const permissionOptions = [{ optionId: 'yes', kind: 'allow_once' }, { optionId: 'no', kind: 'reject_once' }]
+const modes = [
+  { name: 'reply', canCode: false, canCoordinate: false },
+  { name: 'coordination', canCode: false, canCoordinate: true },
+  { name: 'coding', canCode: true, canCoordinate: false },
+]
+const readTools = ['list_agents', 'list_projects', 'list_tasks', 'list_task_types', 'get_ticket', 'list_channels', 'list_message_thread', 'list_activity', 'list_codebases', 'get_codebase', 'codebase_tree']
+const coordinationTools = ['update_ticket', 'post_message', 'react_message', 'comment_ticket']
+const repositoryTools = ['create_codebase_branch', 'create_codebase_commit', 'create_pull_request', 'write_codebase_file']
+const localTools = ['bash', 'read', 'edit', 'task']
+const formats = [
+  { name: 'codex-title', call: (tool) => ({ title: `mcp__openvisio-team-watcher__${tool}` }) },
+  { name: 'opencode-title', call: (tool) => ({ title: `openvisio-team-watcher_${tool}` }) },
+  { name: 'structured-name', call: (tool) => ({ title: 'Tool invocation', rawInput: { toolName: tool } }) },
+]
+
+// Tool identity, runtime representation, and lane capability are independent
+// dimensions: every row checks the actual permission boundary, not a snapshot.
+for (const tool of [...readTools, ...coordinationTools, ...repositoryTools, ...localTools]) {
+  for (const mode of modes) for (const format of formats) {
+    add(`permission-${mode.name}-${format.name}-${tool}`, 'runtime-permissions', `${mode.name} handles ${tool} from ${format.name} with only that lane's authority`, async () => {
+      const permitted = mode.canCode || readTools.includes(tool) || (mode.canCoordinate && coordinationTools.includes(tool))
+      const result = acpPermissionResponse({ options: permissionOptions, toolCall: format.call(tool) }, mode)
+      assert.equal(result.outcome.optionId, permitted ? 'yes' : 'no')
+    })
+  }
+}
+
+for (const mode of modes) for (const proxyProtected of [false, true]) for (const metadata of ['missing', 'true', 'false', 'string']) {
+  add(`opaque-${mode.name}-${proxyProtected}-${metadata}`, 'runtime-permissions', `Opaque ${metadata} MCP approval in ${mode.name}, private proxy ${proxyProtected}`, async () => {
+    const flag = { true: true, false: false, string: 'true' }[metadata]
+    const request = { options: permissionOptions, toolCall: { title: 'unknown local tool' }, ...(metadata === 'missing' ? {} : { _meta: { is_mcp_tool_approval: flag } }) }
+    const result = acpPermissionResponse(request, { ...mode, proxyProtected })
+    assert.equal(result.outcome.optionId, mode.canCode || (proxyProtected && flag === true) ? 'yes' : 'no')
+  })
+}
+
+const optionCases = [
+  { name: 'empty', options: [], yes: null, no: null },
+  { name: 'reversed', options: [...permissionOptions].reverse(), yes: 'yes', no: 'no' },
+  { name: 'allow-only', options: [permissionOptions[0]], yes: 'yes', no: null },
+  { name: 'reject-only', options: [permissionOptions[1]], yes: null, no: 'no' },
+  { name: 'persistent-fallback', options: [{ optionId: 'a', kind: 'allow_always' }, { optionId: 'r', kind: 'reject_always' }], yes: 'a', no: 'r' },
+  { name: 'once-preferred', options: [{ optionId: 'persistent', kind: 'allow_always' }, ...permissionOptions], yes: 'yes', no: 'no' },
+  { name: 'malformed-before-valid', options: [null, {}, { kind: 4 }, ...permissionOptions], yes: 'yes', no: 'no' },
+  { name: 'invalid-id', options: [{ optionId: null, kind: 'allow_once' }, { optionId: 5, kind: 'reject_once' }], yes: null, no: null },
+  { name: 'unknown-kind', options: [{ optionId: 'a', kind: 'allow_future' }, { optionId: 'r', kind: 'reject_future' }], yes: null, no: null },
+  { name: 'empty-id', options: [{ optionId: '', kind: 'allow_once' }, { optionId: '', kind: 'reject_once' }], yes: null, no: null },
+]
+for (const canCode of [false, true]) for (const row of optionCases) {
+  add(`permission-options-${canCode}-${row.name}`, 'runtime-permissions', `Permission options ${row.name} fail closed or select the appropriate ${canCode ? 'allow' : 'reject'} choice`, async () => {
+    const result = acpPermissionResponse({ options: row.options, toolCall: { title: 'shell' } }, { canCode })
+    const expected = canCode ? row.yes : row.no
+    assert.deepEqual(result, expected == null ? { outcome: { outcome: 'cancelled' } } : { outcome: { outcome: 'selected', optionId: expected } })
+  })
+}
+
+const efforts = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra']
+for (const provider of ['', 'vendor-a/', 'vendor-b/']) for (const effort of efforts) for (const representation of ['string', 'object']) {
+  const requested = `${provider}fixture-model[${effort}]`
+  add(`model-exact-${provider || 'bare'}-${effort}-${representation}`, 'runtime-models', `Preserve ${requested} when advertised as ${representation}; never substitute another effort or provider`, async () => {
+    const ids = ['vendor-c/fixture-model[medium]', `${provider}different-generation[${effort}]`, requested]
+    const available = representation === 'object' ? ids.map((modelId) => ({ modelId })) : ids
+    const result = resolveAvailableModel(requested, available)
+    assert.equal(result.selected, requested)
+    assert.equal(result.reason, 'exact')
+  })
+}
+for (const provider of ['', 'vendor-a/', 'vendor-b/']) for (const preferredEffort of efforts) {
+  add(`model-implicit-effort-${provider || 'bare'}-${preferredEffort}`, 'runtime-models', `Unspecified effort for ${provider || 'bare'} fixture uses configured ${preferredEffort} and preserves model identity`, async () => {
+    const selected = `${provider}fixture-model[${preferredEffort}]`
+    const result = resolveAvailableModel(`${provider}fixture-model`, efforts.map((effort) => `${provider}fixture-model[${effort}]`), { preferredEffort })
+    assert.equal(result.selected, selected)
+  })
+}
+for (const effort of efforts) for (const mismatch of ['provider', 'generation', 'effort']) {
+  add(`model-no-substitution-${effort}-${mismatch}`, 'runtime-models', `Reject an advertised ${mismatch} mismatch for an explicit ${effort} model`, async () => {
+    const requested = `vendor-a/fixture-one[${effort}]`
+    const choice = mismatch === 'provider' ? `vendor-b/fixture-one[${effort}]` : mismatch === 'generation' ? `vendor-a/fixture-two[${effort}]` : `vendor-a/fixture-one[${effort === 'low' ? 'high' : 'low'}]`
+    assert.throws(() => resolveAvailableModel(requested, [choice]), /substitution is disabled/)
+  })
+}
+for (const model of ['vendor-a/model-v1', 'vendor-b/model-v2[high]', 'fixture-alias', '']) {
+  add(`model-unadvertised-${model || 'default'}`, 'runtime-models', `Runtime with no advertised list preserves explicit model ${model || '(default)'}`, async () => {
+    assert.equal(resolveAvailableModel(model, []).selected, model)
+    assert.equal(resolveClaudeModel(` ${model} `), model)
+    assert.deepEqual(claudeFallbackModels(model), [])
+  })
+}
+
+const groupPatterns = {
+  distinct: [1, 2, 3, 4, 5, 6, 7, 8],
+  shared: [1, 1, 1, 1, 1, 1, 1, 1],
+  alternating: [1, 2, 1, 2, 1, 2, 1, 2],
+  'zero-resource': [0, 0, 1, 0, 1, 2, 2, 0],
+  'blocked-head': [1, 1, 1, 2, 3, 1, 2, 4],
+  'ungrouped-mixed': ['', 1, '', 1, 2, '', 2, ''],
+}
+for (const [pattern, groups] of Object.entries(groupPatterns)) for (const concurrency of [1, 2, 3, 6]) for (const outcome of ['success', 'failure', 'cancel']) {
+  add(`queue-${pattern}-${concurrency}-${outcome}`, 'runtime-queue', `Queue ${pattern} resources at concurrency ${concurrency} under ${outcome} preserves isolation, ordering, and progress`, async () => {
+    const gates = groups.map(deferred), started = [], running = new Map(), errors = [], canceled = []
+    const queue = createCycleQueue({ concurrency, groupKey: (item) => item.group, onError: (error) => errors.push(error.message), run: async (item) => {
+      assert.ok(running.size < concurrency)
+      if (item.group !== '') assert.equal([...running.values()].includes(item.group), false, 'same mutable resource overlapped')
+      running.set(item.id, item.group)
+      started.push(item.id)
+      await gates[item.id].promise
+      running.delete(item.id)
+      if (outcome === 'failure' && item.id % 3 === 1) throw new Error(`failure-${item.id}`)
+      return { status: 'done', id: item.id }
+    } })
+    const promises = groups.map((group, id) => queue.enqueue({ id, group }, `ticket:${id}`))
+    assert.equal(queue.enqueue({ id: 999 }, 'ticket:0'), promises[0], 'replayed active source has a single promise')
+    if (outcome === 'cancel') queue.cancel((item) => item.id % 2 === 1, (item) => canceled.push(item.id))
+    for (let round = 0; queue.size && round < 20; round++) {
+      assert.ok(running.size > 0, 'pending queue must always make progress when no group is busy')
+      const id = [...running.keys()].at(outcome === 'failure' ? -1 : 0)
+      gates[id].resolve()
+      await tick()
+    }
+    assert.equal(queue.size, 0)
+    const results = await Promise.all(promises)
+    assert.equal(new Set(started).size, started.length)
+    for (const group of new Set(groups.filter((group) => group !== ''))) {
+      const order = started.filter((id) => groups[id] === group)
+      assert.deepEqual(order, [...order].sort((a, b) => a - b), 'same-resource FIFO changed')
+    }
+    for (let id = 0; id < groups.length; id++) {
+      assert.equal(queue.has(`ticket:${id}`), false)
+      const expected = outcome === 'cancel' && !started.includes(id) ? 'canceled' : outcome === 'failure' && id % 3 === 1 ? 'failed' : 'done'
+      assert.equal(results[id].status, expected)
+    }
+    assert.equal(errors.length, outcome === 'failure' ? 3 : 0)
+    assert.ok(canceled.every((id) => id % 2 === 1))
+  })
+}
+
+for (const failureKind of ['sync', 'async']) for (const phase of ['run', 'cancel']) {
+  add(`queue-hook-failure-${phase}-${failureKind}`, 'runtime-queue', `${failureKind} ${phase} hook failure cannot strand workers or create unhandled rejections`, async () => {
+    const gates = [deferred(), deferred()], errors = []
+    const queue = createCycleQueue({ concurrency: 2, run: async ({ id }) => { await gates[id].promise; if (phase === 'run') throw new Error(`run-${id}`) }, onError: (error) => {
+      errors.push(error.message)
+      if (failureKind === 'sync') throw new Error('logger failed')
+      return Promise.reject(new Error('logger failed'))
+    } })
+    const tasks = [queue.enqueue({ id: 0 }), queue.enqueue({ id: 1 })]
+    if (phase === 'cancel') queue.cancel(() => true, ({ id }) => {
+      if (failureKind === 'sync') throw new Error(`cancel-${id}`)
+      return Promise.reject(new Error(`cancel-${id}`))
+    })
+    gates.forEach((gate) => gate.resolve())
+    await Promise.all(tasks)
+    await tick()
+    assert.equal(errors.length, 2)
+    assert.equal(queue.size, 0)
+  })
+}
+
+for (const capacity of [1, 2, 4]) for (const state of ['idle', 'busy', 'recently-released', 'lru']) for (const elapsed of [0, 99, 100]) {
+  add(`pool-${capacity}-${state}-${elapsed}`, 'runtime-pool', `Warm pool capacity ${capacity}, ${state} session at ${elapsed} ms obeys expiry and pins active work`, async () => {
+    let now = 0, created = 0
+    const closed = []
+    const pool = createRunnerPool({ capacity, idleMs: 100, now: () => now, create: (options) => ({ id: ++created, options, close() { closed.push(this.id) } }) })
+    try {
+      const first = pool.acquire('project:1:ticket:1:cwd:a', { cwd: 'a' })
+      if (state !== 'busy') pool.release('project:1:ticket:1:cwd:a')
+      now = elapsed
+      if (state === 'busy') {
+        assert.throws(() => pool.acquire('project:1:ticket:1:cwd:a'), /active/)
+        pool.acquire('project:1:ticket:1:cwd:b', { cwd: 'b' })
+        assert.equal(closed.includes(first.id), false)
+      } else if (state === 'recently-released') {
+        const latest = pool.acquire('project:1:ticket:1:cwd:a')
+        pool.release('project:1:ticket:1:cwd:a')
+        now += 99
+        assert.equal(pool.acquire('project:1:ticket:1:cwd:a'), latest)
+      } else if (state === 'lru') {
+        for (let id = 0; id < capacity; id++) { pool.acquire(`other:${id}`); pool.release(`other:${id}`) }
+        assert.ok(closed.includes(first.id), 'least recently acquired idle session must leave a full cache')
+      } else {
+        const again = pool.acquire('project:1:ticket:1:cwd:a')
+        assert.equal(again === first, elapsed < 100)
+      }
+    } finally { pool.close() }
+    assert.equal(closed.length, created)
+    assert.equal(new Set(closed).size, created, 'session closed more than once')
+  })
+}
+for (const phase of ['eviction', 'close']) for (const failureKind of ['sync', 'async']) {
+  add(`pool-cleanup-${phase}-${failureKind}`, 'runtime-pool', `${failureKind} session close error during ${phase} does not retain stale sessions or skip remaining cleanup`, async () => {
+    let closed = 0
+    const errors = []
+    const pool = createRunnerPool({ capacity: 1, create: () => ({ close() { closed++; if (failureKind === 'sync') throw new Error('close failed'); return Promise.reject(new Error('close failed')) } }), onError: (error) => errors.push(error.message) })
+    pool.acquire('a')
+    if (phase === 'eviction') pool.release('a')
+    pool.acquire('b')
+    pool.close()
+    pool.close()
+    await tick()
+    assert.equal(closed, 2)
+    assert.equal(errors.length, 2)
+    assert.throws(() => pool.acquire('c'), /closed/)
+  })
+}
+for (const [name, options] of [
+  ['zero-capacity', { capacity: 0 }], ['negative-capacity', { capacity: -1 }], ['fractional-capacity', { capacity: 1.5 }],
+  ['infinite-capacity', { capacity: Infinity }], ['zero-expiry', { idleMs: 0 }], ['negative-expiry', { idleMs: -1 }],
+  ['infinite-expiry', { idleMs: Infinity }], ['nan-expiry', { idleMs: NaN }],
+]) add(`pool-invalid-${name}`, 'runtime-pool', `Invalid ${name} configuration fails before starting any timer`, async () => { assert.throws(() => createRunnerPool({ ...options, create: () => ({}) }), /positive/) })
+
+function fakeAcp({ events = [], negotiate, select, stream, cancel } = {}) {
+  const state = { instances: [], prompts: [], modelReads: 0, modelSets: [], disconnects: 0, cancels: 0 }
+  class FakeAcp {
+    constructor(options) {
+      state.instances.push(options)
+      this.connection = {
+        async *promptStream(prompt, signal) {
+          state.prompts.push(prompt)
+          if (stream) { yield* stream(prompt, signal); return }
+          for (const event of events) yield event
+        },
+        disconnect() { state.disconnects++ },
+        async cancel() { state.cancels++; if (cancel) await cancel() },
+      }
+    }
+    async getAvailableModels() { state.modelReads++; return negotiate ? negotiate() : [{ modelId: 'fixture-model[medium]' }] }
+    async setModel(id) { state.modelSets.push(id); if (select) await select(id) }
+  }
+  return { state, FakeAcp }
+}
+const toolEvent = (id, title, status, extras = {}) => ({ type: 'session-update', update: { sessionUpdate: 'tool_call', toolCallId: id, title, status, ...extras } })
+const headers = { 'x-agent-api-key': 'fixture-secret-key', 'x-agent-identifier': 'fixture-agent' }
+async function withRunner(fake, options, run) {
+  const runner = createMastraAcpRunner({ agent: 'codex', maxCycleMs: 1000, AcpAgentClass: fake.FakeAcp, ...options })
+  try { return await run(runner) } finally { runner.close() }
+}
+
+const evidenceTools = [
+  { name: 'get_ticket', expected: 'didMcpTaskRead' }, { name: 'list_tasks', expected: 'didMcpTaskRead' },
+  { name: 'update_ticket', expected: 'didMcpTaskUpdate' }, { name: 'post_message', expected: 'didMessage' },
+  { name: 'write_codebase_file', expected: 'didRepoMutation' }, { name: 'create_codebase_commit', expected: 'didRepoMutation' },
+  { name: 'create_pull_request', expected: null }, { name: 'create_codebase_branch', expected: null },
+]
+for (const tool of evidenceTools) for (const status of ['pending', 'in_progress', 'completed', 'failed']) {
+  add(`evidence-${tool.name}-${status}`, 'runtime-evidence', `${status} ${tool.name} grants only completed, appropriate evidence`, async () => {
+    const fake = fakeAcp({ events: [toolEvent('call', `openvisio-team ${tool.name}`, status, { rawOutput: status === 'failed' ? 'server unavailable' : {} })] })
+    await withRunner(fake, {}, async (runner) => {
+      const result = await runner.runCycle('fixture task')
+      for (const flag of ['didMcpTaskRead', 'didMcpTaskUpdate', 'didRepoMutation', 'didMessage']) {
+        assert.equal(result[flag], status === 'completed' && flag === tool.expected, flag)
+      }
+      assert.equal(result.mcpErrors.includes(tool.name), status === 'failed')
+      assert.deepEqual(result.mcpCalls, [tool.name])
+    })
+  })
+}
+
+for (const terminal of ['completed', 'failed', 'in_progress']) for (const ordering of ['message-before-edit', 'message-after-edit', 'same-call-update']) {
+  add(`evidence-order-${ordering}-${terminal}`, 'runtime-evidence', `${ordering} with ${terminal} repository tool derives delivery evidence from final successful ordering`, async () => {
+    const edit = toolEvent('edit', 'write_codebase_file', terminal)
+    const message = toolEvent('message', 'post_message', 'completed')
+    const events = ordering === 'message-before-edit' ? [message, edit] : ordering === 'message-after-edit' ? [edit, message] : [toolEvent('edit', 'write_codebase_file', 'in_progress'), message, { update: { sessionUpdate: 'tool_call_update', toolCallId: 'edit', status: terminal } }]
+    const fake = fakeAcp({ events })
+    await withRunner(fake, {}, async (runner) => {
+      const result = await runner.runCycle('task')
+      assert.equal(result.didRepoMutation, terminal === 'completed')
+      assert.equal(result.didMessage, true)
+      assert.equal(result.didResultMessage, terminal === 'completed' && ordering === 'message-after-edit')
+    })
+  })
+}
+
+for (const agent of ['codex', 'opencode']) for (const phase of ['model-list', 'model-set', 'stream']) for (const action of ['timeout', 'cancel', 'close']) {
+  add(`interruption-${agent}-${phase}-${action}`, 'runtime-lifecycle', `${agent} ${action} releases a cycle stalled in ${phase} and never reports success`, async () => {
+    const entered = deferred(), never = deferred()
+    const stall = () => { entered.resolve(); return never.promise }
+    const fake = fakeAcp({
+      ...(phase === 'model-list' ? { negotiate: stall } : {}),
+      ...(phase === 'model-set' ? { select: stall } : {}),
+      ...(phase === 'stream' ? { stream: async function* () { await stall() } } : {}),
+      cancel: () => never.promise,
+    })
+    await withRunner(fake, { agent, maxCycleMs: action === 'timeout' ? 20 : 1000 }, async (runner) => {
+      const task = runner.runCycle('task', phase === 'stream' ? undefined : 'fixture-model')
+      await entered.promise
+      if (action === 'cancel') await runner.cancelCurrent()
+      if (action === 'close') runner.close()
+      const result = await task
+      assert.equal(result.subtype, action === 'timeout' ? 'timeout' : 'canceled')
+      assert.ok(fake.state.disconnects >= 1)
+      assert.equal(result.didCode, false)
+    })
+  })
+}
+
+for (const agent of ['codex', 'opencode']) for (const mode of modes) for (const transport of ['private', 'http', 'none']) {
+  add(`session-config-${agent}-${mode.name}-${transport}`, 'runtime-session-config', `${agent} ${mode.name} session exposes the correct ${transport} MCP transport and local tool policy`, async () => {
+    const fake = fakeAcp()
+    await withRunner(fake, { agent, ...mode, workdir: '/fixture/isolated-runtime-test', ...(transport !== 'none' ? { mcpUrl: 'https://fixture.invalid/mcp' } : {}), ...(transport === 'private' ? { mcpHeaders: headers } : {}) }, async (runner) => {
+      await runner.runCycle('task')
+      const config = fake.state.instances[0]
+      const server = config.session.mcpServers[0]
+      if (transport === 'none') assert.equal(config.session.mcpServers.length, 0)
+      if (transport === 'http') assert.equal(server.type, 'http')
+      if (transport === 'private') {
+        assert.equal(server.command, process.execPath)
+        const env = Object.fromEntries(server.env.map(({ name, value }) => [name, value]))
+        const allowed = JSON.parse(env.OPENVISIO_CODEX_ALLOWED_TOOLS)
+        if (mode.canCode) assert.equal(allowed, null)
+        else {
+          assert.ok(allowed.includes('get_ticket'))
+          assert.equal(allowed.includes('update_ticket'), mode.canCoordinate)
+          assert.equal(allowed.includes('write_codebase_file'), false)
+        }
+      }
+      if (agent === 'opencode') {
+        const value = JSON.parse(config.env.OPENCODE_CONFIG_CONTENT)
+        if (mode.canCode) assert.equal(value.permission, undefined)
+        else {
+          assert.equal(value.permission.bash, 'deny')
+          assert.equal(value.permission['openvisio-team-watcher_*'], 'allow')
+        }
+        assert.equal(value.mcp['openvisio-team'].enabled, false)
+      } else assert.equal(config.env.INITIAL_AGENT_MODE, mode.canCode ? 'agent' : 'read-only')
+    })
+  })
+}
+
+for (const change of ['same', 'cwd', 'disabled-tools', 'model']) {
+  add(`session-reuse-${change}`, 'runtime-lifecycle', `Warm ACP ${change} change preserves only compatible context and model negotiation`, async () => {
+    const fake = fakeAcp({ negotiate: async () => [{ modelId: 'fixture-model[medium]' }, { modelId: 'fixture-model[high]' }] })
+    await withRunner(fake, { systemPrompt: 'stable charter' }, async (runner) => {
+      await runner.runCycle('first', 'fixture-model[medium]')
+      await runner.runCycle('second', change === 'model' ? 'fixture-model[high]' : 'fixture-model[medium]', change === 'cwd' ? { workdir: '/fixture/other-worktree' } : change === 'disabled-tools' ? { disabledMcpTools: ['post_message'] } : {})
+      const reset = change === 'cwd' || change === 'disabled-tools'
+      assert.equal(fake.state.instances.length, reset ? 2 : 1)
+      assert.equal(fake.state.modelReads, change === 'same' ? 1 : 2)
+      assert.equal(fake.state.prompts[0], 'stable charter\n\nfirst')
+      assert.equal(fake.state.prompts[1], reset ? 'stable charter\n\nsecond' : 'second')
+    })
+  })
+}
+
+for (const localTool of localTools) {
+  add(`opencode-local-denial-${localTool}`, 'runtime-session-config', `OpenCode reply configuration denies inherited ${localTool} access globally and at agent level`, async () => {
+    const config = buildOpencodeConfig({ canCode: false, mcpUrl: 'https://fixture.invalid/mcp', mcpHeaders: headers })
+    assert.equal(config.permission[localTool], 'deny')
+    assert.equal(config.agent['openvisio-reply'].permission[localTool], 'deny')
+    assert.equal(config.mcp['openvisio-team'].oauth, false)
+    assert.equal(config.mcp['openvisio-team'].headers['x-agent-api-key'], 'fixture-secret-key')
+  })
+}
+
+for (const ordering of ['message-first', 'edit-first']) for (const metadata of ['status-only', 'output-only']) {
+  add(`evidence-late-metadata-${ordering}-${metadata}`, 'runtime-evidence', `Late ${metadata} for a completed tool preserves ${ordering} execution order`, async () => {
+    const edit = toolEvent('edit', 'write_codebase_file', 'completed')
+    const message = toolEvent('message', 'post_message', 'completed')
+    const first = ordering === 'message-first' ? message : edit
+    const second = ordering === 'message-first' ? edit : message
+    const fake = fakeAcp({ events: [first, second, { update: { sessionUpdate: 'tool_call_update', toolCallId: first.update.toolCallId, ...(metadata === 'status-only' ? { status: 'completed' } : { rawOutput: { duration: 3 } }) } }] })
+    await withRunner(fake, {}, async (runner) => {
+      const result = await runner.runCycle('task')
+      assert.equal(result.didResultMessage, ordering === 'edit-first')
+    })
+  })
+}
+
+for (const secretKind of ['key', 'identifier']) {
+  add(`error-redaction-${secretKind}`, 'runtime-evidence', `Failed MCP ${secretKind} is redacted in structured result details as well as logs`, async () => {
+    const secret = secretKind === 'key' ? headers['x-agent-api-key'] : headers['x-agent-identifier']
+    const logs = []
+    const fake = fakeAcp({ events: [toolEvent('failed', 'get_ticket', 'failed', { rawOutput: `Server error exposed ${secret}` })] })
+    await withRunner(fake, { mcpHeaders: headers, log: (line) => logs.push(line) }, async (runner) => {
+      const result = await runner.runCycle('task')
+      assert.equal(JSON.stringify(result.mcpErrorDetails).includes(secret), false)
+      assert.equal(logs.join('\n').includes(secret), false)
+      assert.match(result.mcpErrorDetails.get_ticket, /\[redacted\]/)
+    })
+  })
+}
+
+for (const action of ['cancel', 'close']) {
+  add(`graceful-stream-${action}`, 'runtime-lifecycle', `A stream that ends normally after ${action} must still report cancellation`, async () => {
+    const entered = deferred()
+    const fake = fakeAcp({ stream: async function* (_, signal) {
+      entered.resolve()
+      await new Promise((resolve) => signal.addEventListener('abort', resolve, { once: true }))
+    } })
+    await withRunner(fake, {}, async (runner) => {
+      const task = runner.runCycle('task')
+      await entered.promise
+      if (action === 'cancel') await runner.cancelCurrent()
+      else runner.close()
+      assert.equal((await task).subtype, 'canceled')
+    })
+  })
+}
+
+add('same-session-concurrent-cycle', 'runtime-lifecycle', 'Concurrent direct calls cannot share a warm session or overwrite the first cancellation handle', async () => {
+  const entered = deferred(), gate = deferred()
+  const fake = fakeAcp({ stream: async function* () { entered.resolve(); await gate.promise; yield { type: 'text', text: 'first result' } } })
+  await withRunner(fake, {}, async (runner) => {
+    const task = runner.runCycle('first')
+    await entered.promise
+    await assert.rejects(runner.runCycle('second'), /already has an active cycle/)
+    gate.resolve()
+    assert.equal((await task).outputText, 'first result')
+    assert.deepEqual(fake.state.prompts, ['first'])
+  })
+})
+
+for (const [name, maxCycleMs] of [['zero', 0], ['negative', -1], ['nan', NaN], ['infinite', Infinity], ['overflow', 2_147_483_648]]) {
+  add(`timeout-config-${name}`, 'runtime-lifecycle', `Invalid ${name} deadline cannot silently become Node's one-millisecond timeout`, async () => {
+    const fake = fakeAcp()
+    assert.throws(() => createMastraAcpRunner({ agent: 'codex', maxCycleMs, AcpAgentClass: fake.FakeAcp }), /positive supported timeout/)
+    assert.equal(fake.state.instances.length, 0)
+  })
+}
+
+for (const concurrency of [1, 2, 3, 6]) for (const outcome of ['success', 'failure', 'cancel']) {
+  add(`queue-settlement-${concurrency}-${outcome}`, 'runtime-lifecycle', `Shutdown at concurrency ${concurrency} waits for ${outcome} worker cleanup without polling or losing queued promises`, async () => {
+    const gate = deferred()
+    let cleaned = 0, settled = false
+    const queue = createCycleQueue({ concurrency, run: async () => {
+      try { await gate.promise; if (outcome === 'failure') throw new Error('runtime failed during shutdown') }
+      finally { cleaned++ }
+    } })
+    const jobs = Array.from({ length: concurrency + 2 }, (_, id) => queue.enqueue({ id }))
+    if (outcome === 'cancel') queue.cancel(() => true)
+    const completion = queue.settled().then(() => { settled = true })
+    await tick()
+    assert.equal(settled, false, 'settlement resolved before active worker cleanup')
+    gate.resolve()
+    await completion
+    await Promise.all(jobs)
+    assert.equal(cleaned, outcome === 'cancel' ? concurrency : concurrency + 2)
+    assert.equal(queue.size, 0)
+    await queue.settled()
+  })
+}