openvisio-agent 0.19.12 → 0.20.0

package/scenarios/transport.scenarios.mjs

@@ -0,0 +1,407 @@
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+import { once } from 'node:events'
+import { execFileSync } from 'node:child_process'
+import { mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { createMcpHttpClient } from '../src/mcp-http.mjs'
+import { toolAllowed, toolWithoutCredentialInputs, proxyToolPolicyFromEnvironment } from '../src/codex-mcp-proxy.mjs'
+import { authorizePrPush, configurePrPublishing, isSafeAgentBranch, pushPrBranch, repositoryHasPrPushAuthorization, repositoryPushIdentity, revokePrPush, validatePrPushAuthorization } from '../src/pr-push.mjs'
+import { createByoMemoryGraph, createMastraMemory } from '../src/memory.mjs'
+import { releaseAuthorizedPause } from '../src/authorization-resume.mjs'
+import { createTaskTypeLookup } from '../src/task-types.mjs'
+import { mapConcurrent } from '../src/concurrency.mjs'
+
+// Every row is independently runnable. The matrix varies actual operations,
+// transport failures, policy boundaries, and persistence states, not ticket IDs
+// solely to inflate the case count. HTTP and Git integration rows are local.
+export const scenarios = []
+const add = (id, category, description, run) => scenarios.push({ id: `transport-${id}`, category, description, run })
+const response = ({ status = 200, body = '{}', sessionId = '', contentType = 'application/json' } = {}) => ({
+  ok: status >= 200 && status < 300, status,
+  headers: { get: (name) => ({ 'mcp-session-id': sessionId, 'content-type': contentType })[name.toLowerCase()] || null },
+  text: async () => body,
+})
+const fixture = ({ session = false, handler, requestTimeoutMs = 500 } = {}) => {
+  const calls = [], counts = new Map()
+  const client = createMcpHttpClient({ url: 'https://workspace.example.test/mcp', apiKey: 'fixture-secret', identifier: 'alex', clientVersion: 'scenario', requestTimeoutMs,
+    fetchImpl: async (_url, init) => {
+      const request = JSON.parse(init.body)
+      const count = (counts.get(request.method) || 0) + 1
+      counts.set(request.method, count)
+      calls.push({ request, headers: init.headers, signal: init.signal })
+      const custom = await handler?.(request, count, init)
+      if (custom) return custom
+      if (request.method === 'initialize') return response({ sessionId: session ? `session-${count}` : '', body: JSON.stringify({ id: request.id, result: {} }) })
+      if (request.method === 'notifications/initialized') return response({ status: 202, body: '' })
+      if (request.method === 'tools/list') return response({ body: JSON.stringify({ id: request.id, result: { tools: [] } }) })
+      return response({ body: JSON.stringify({ id: request.id, result: { content: [{ type: 'text', text: 'delivered' }] } }) })
+    },
+  })
+  return { client, calls, counts }
+}
+const temp = async (run) => {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), 'openvisio-scenario-')))
+  try { return await run(dir) } finally { rmSync(dir, { recursive: true, force: true }) }
+}
+const tick = () => new Promise((resolve) => setImmediate(resolve))
+
+const operations = ['list_projects', 'list_tasks', 'get_ticket', 'get_channel_messages', 'post_message', 'update_ticket', 'comment_ticket', 'react_message']
+for (const name of operations) for (const session of [false, true]) for (const status of [400, 401, 403, 404, 409, 410, 422, 429, 500, 503]) {
+  add(`http-${name}-${session ? 'stateful' : 'stateless'}-${status}`, 'MCP HTTP failures', `${name} receives HTTP ${status} in ${session ? 'stateful' : 'stateless'} mode; only an expired session may replay the request`, async () => {
+    const { client, counts } = fixture({ session, handler: (request, count) => request.method === 'tools/call' && count === 1 ? response({ status }) : null })
+    if (session && status === 404) {
+      assert.equal((await client.callTool(name)).content[0].text, 'delivered')
+      assert.equal(counts.get('initialize'), 2)
+      assert.equal(counts.get('tools/call'), 2)
+    } else {
+      await assert.rejects(client.callTool(name), new RegExp(`HTTP ${status}`))
+      assert.equal(counts.get('initialize'), 1)
+      assert.equal(counts.get('tools/call'), 1)
+    }
+  })
+}
+
+const encodings = {
+  json: (payload) => JSON.stringify(payload),
+  sse: (payload) => `event: message\ndata: ${JSON.stringify(payload)}\n\n`,
+  'sse-crlf': (payload) => `event: message\r\ndata: ${JSON.stringify(payload)}\r\n\r\n`,
+  'sse-multiline': (payload) => `data: {"id":${payload.id},\ndata: "result":${JSON.stringify(payload.result)}}\n\n`,
+  'sse-trailing-notification': (payload) => `data: ${JSON.stringify(payload)}\n\ndata: {"jsonrpc":"2.0","method":"notifications/progress","params":{"progress":99}}\n\n`,
+  'sse-other-response': (payload) => `: heartbeat\n\ndata: {"id":9999,"result":{"content":[]}}\n\ndata: ${JSON.stringify(payload)}\n\n`,
+}
+for (const [encoding, encode] of Object.entries(encodings)) for (const name of ['get_ticket', 'post_message', 'update_ticket', 'comment_ticket']) {
+  add(`framing-${name}-${encoding}`, 'MCP framing', `${name} recognizes its exact response in ${encoding} framing`, async () => {
+    const { client } = fixture({ handler: (request) => request.method === 'tools/call' ? response({ body: encode({ id: request.id, result: { content: [{ type: 'text', text: 'correct response ✓' }] } }) }) : null })
+    assert.equal((await client.callTool(name)).content[0].text, 'correct response ✓')
+  })
+}
+
+for (const stage of ['initialize', 'tools/list', 'tools/call']) for (const kind of ['rpc', 'network', 'malformed']) for (const session of [false, true]) {
+  add(`errors-${stage.replace('/', '-')}-${kind}-${session}`, 'MCP diagnostics', `${stage} ${kind} failure remains retryable by its caller and never exposes watcher credentials in ${session ? 'stateful' : 'stateless'} mode`, async () => {
+    let fail = true
+    const { client } = fixture({ session, handler: (request) => {
+      if (request.method !== stage || !fail) return null
+      if (kind === 'network') throw new Error('connection failed fixture-secret')
+      return response({ body: kind === 'rpc' ? JSON.stringify({ id: request.id, error: { message: 'fixture-secret denied' } }) : 'broken fixture-secret JSON' })
+    } })
+    const run = () => stage === 'initialize' ? client.initialize() : stage === 'tools/list' ? client.listTools() : client.callTool('post_message')
+    await assert.rejects(run(), (error) => !error.message.includes('fixture-secret'))
+    fail = false
+    await run()
+  })
+}
+
+for (const name of operations) for (const schemaKey of ['inputSchema', 'input_schema', 'both']) {
+  add(`credentials-${name}-${schemaKey}`, 'MCP credential ownership', `${name} ${schemaKey} exposes business inputs while trusted transport replaces forged identity fields`, async () => {
+    const schema = { type: 'object', properties: { project_id: { type: 'number' }, agent_api_key: { type: 'string' }, agent_identifier: { type: 'string' } }, required: ['project_id', 'agent_api_key', 'agent_identifier'] }
+    const original = { name, ...(schemaKey !== 'input_schema' ? { inputSchema: structuredClone(schema) } : {}), ...(schemaKey !== 'inputSchema' ? { input_schema: structuredClone(schema) } : {}) }
+    const stripped = toolWithoutCredentialInputs(original)
+    for (const key of ['inputSchema', 'input_schema']) if (original[key]) {
+      assert.deepEqual(stripped[key].required, ['project_id'])
+      assert.deepEqual(Object.keys(stripped[key].properties), ['project_id'])
+      assert.ok(original[key].properties.agent_api_key)
+    }
+    const { client, calls } = fixture()
+    await client.callTool(name, { project_id: 4, agent_api_key: 'forged', agent_identifier: 'other-agent' })
+    const last = calls.at(-1)
+    assert.equal(last.headers['x-agent-api-key'], 'fixture-secret')
+    assert.deepEqual(last.request.params.arguments, { project_id: 4, agent_api_key: 'fixture-secret', agent_identifier: 'alex' })
+  })
+}
+
+for (const key of ['OPENVISIO_CODEX_ALLOWED_TOOLS', 'OPENVISIO_CODEX_DISABLED_TOOLS']) for (const malformed of ['', '{', '{}', 'true', '"get_ticket"', '[42]', '[null]', '[""]']) {
+  add(`policy-${key.toLowerCase()}-${encodeURIComponent(malformed) || 'empty'}`, 'MCP lane policy', `Malformed ${key} value ${JSON.stringify(malformed)} fails closed before a proxy can expose tools`, () => {
+    assert.throws(() => proxyToolPolicyFromEnvironment({ [key]: malformed }), /Invalid MCP tool policy/)
+  })
+}
+for (const name of operations) for (const lane of ['read', 'coordinate', 'coding']) {
+  add(`lane-${lane}-${name}`, 'MCP lane policy', `${lane} lane exposes ${name} only when its explicit capabilities permit it`, () => {
+    const allowed = lane === 'coding' ? null : new Set(lane === 'read' ? operations.slice(0, 4) : operations)
+    const disabled = new Set(['react_message'])
+    const policy = proxyToolPolicyFromEnvironment({ OPENVISIO_CODEX_ALLOWED_TOOLS: JSON.stringify(allowed ? [...allowed] : null), OPENVISIO_CODEX_DISABLED_TOOLS: JSON.stringify([...disabled]) })
+    assert.equal(toolAllowed(name, policy), name !== 'react_message' && (lane !== 'read' || operations.slice(0, 4).includes(name)))
+    assert.equal(toolAllowed('', policy), false)
+  })
+}
+
+const branchCases = [
+  ['agent/fix', true], ['agent/ticket-77', true], ['agent/ui/comments-v2', true], ['agent/OPEN-77', true], ['agent/fix_loader.2', true], ['agent/a/b/c', true],
+  ['main', false], ['master', false], ['develop', false], ['release/v1', false], ['agent/', false], ['agent/../main', false], ['agent/.hidden/x', false],
+  ['agent/x/.hidden', false], ['agent/a.lock', false], ['agent/a.lock/x', false], ['agent/a..b', false], ['agent/a//b', false], ['agent/a/', false],
+  ['agent/a.', false], ['agent/a@{1}', false], ['agent/a:main', false], ['agent/a b', false], ['agent/a\nb', false], ['agent/a?b', false],
+  ['agent/a*b', false], ['agent/a[b', false], ['agent/a\\b', false], ['agent/~a', false], ['agent/-delete', false],
+]
+for (const [index, [branch, valid]] of branchCases.entries()) for (const grant of ['exact', 'workspace', 'common-dir']) {
+  add(`branch-${index}-${grant}`, 'PR authorization', `${grant} permission ${valid ? 'allows' : 'refuses'} Git branch ${JSON.stringify(branch)} without broadening the agent/* rule`, () => {
+    const root = '/coding/repo', commonDir = '/coding/repo/.git', remote = 'git@github.com:org/repo.git'
+    const policy = grant === 'workspace' ? { workspaces: [{ root: '/coding' }] } : { authorizations: [{ root: grant === 'exact' ? root : '/external/worktree', commonDir: grant === 'common-dir' ? commonDir : undefined, remote }] }
+    assert.equal(isSafeAgentBranch(branch), valid)
+    const run = () => validatePrPushAuthorization({ root, commonDir, remote, branch, ...policy })
+    if (valid) assert.equal(run(), true)
+    else assert.throws(run, /Refusing to push branch/)
+  })
+}
+for (const root of ['/coding/repo', '/coding/repo/nested', '/coding-repo', '/coding/../elsewhere', '/elsewhere', '/coding']) for (const revoked of [false, true]) {
+  add(`workspace-boundary-${encodeURIComponent(root)}-${revoked}`, 'PR authorization', `Workspace grant checks canonical containment for ${root} with revocation ${revoked}`, () => {
+    const allowed = ['/coding/repo', '/coding/repo/nested', '/coding'].includes(root) && !revoked
+    const run = () => validatePrPushAuthorization({ root, commonDir: root + '/.git', remote: 'git@github.com:org/repo.git', branch: 'agent/fix', workspaces: [{ root: '/coding' }], revoked: revoked ? [root] : [] })
+    if (allowed) assert.equal(run(), true)
+    else assert.throws(run, /AUTH_REQUIRED/)
+  })
+}
+
+for (let mask = 0; mask < 16; mask++) for (const authorized of [false, true]) {
+  add(`authorization-resume-${mask}-${authorized}`, 'Authorization recovery', `Resume checks policy and preserves unrelated ticket gates for state mask ${mask} and local permission ${authorized}`, () => {
+    const state = {
+      blocked: new Set(['unrelated', ...(mask & 1 ? ['4:77'] : [])]),
+      repos: new Map([['unrelated', '/other'], ...(mask & 2 ? [['4:77', '/coding/repo']] : [])]),
+      failed: new Map([['unrelated', 'revision'], ...(mask & 4 ? [['4:77', 'revision']] : [])]),
+      seen: new Set(['unrelated', ...(mask & 8 ? ['4:77'] : [])]),
+      authorized: (repo) => { assert.equal(repo, '/coding/repo'); return authorized },
+    }
+    const shouldResume = !!(mask & 1) && !!(mask & 2) && authorized
+    assert.equal(releaseAuthorizedPause('4:77', state), shouldResume)
+    for (const collection of [state.blocked, state.repos, state.failed, state.seen]) assert.equal(collection.has('unrelated'), true)
+    if (shouldResume) for (const collection of [state.blocked, state.repos, state.failed, state.seen]) assert.equal(collection.has('4:77'), false)
+    assert.equal(releaseAuthorizedPause('absent', state), false)
+  })
+}
+
+const columns = [['Done', 'done'], ['Completed', 'done'], ['Closed', 'done'], ['Cancelled', 'done'], ['Archived', 'done'], ['Resolved', 'done'], ['In Review', 'review'], ['Testing', 'review'], ['QA', 'review'], ['Quality Assurance', 'review'], ['Approval', 'review'], ['In Progress', 'active'], ['Todo', 'active'], ['Incomplete', 'active']]
+for (const [label, classification] of columns) for (const field of ['types', 'task_types', 'taskTypes']) for (const stringId of [false, true]) {
+  add(`columns-${label.toLowerCase().replaceAll(' ', '-')}-${field}-${stringId}`, 'Board column discovery', `${field} recognizes ${JSON.stringify(label)} with a ${stringId ? 'string' : 'numeric'} ID and caches only its project`, async () => {
+    const calls = []
+    const lookup = createTaskTypeLookup({ load: async (project) => { calls.push(project); return { [field]: [{ id: stringId ? '7' : 7, name: label }] } } })
+    const [first, duplicate] = await Promise.all([lookup(4), lookup('4')])
+    assert.equal(first, duplicate)
+    assert.equal(first.done.has(7), classification === 'done')
+    assert.equal(first.review.has(7), classification === 'review')
+    assert.equal(calls.length, 1)
+    await lookup(5)
+    assert.equal(calls.length, 2)
+  })
+}
+for (const [index, id] of [null, undefined, '', 'abc', -1, 0, 1.5, Infinity, NaN, '9007199254740992', true, false, ['7']].entries()) {
+  add(`invalid-column-id-${index}`, 'Board column discovery', `Malformed terminal column ID ${String(id)} cannot suppress an actionable ticket`, async () => {
+    const lookup = createTaskTypeLookup({ load: async () => ({ types: [null, { id, name: 'Done' }, { id, name: 'Testing' }] }) })
+    const value = await lookup(4)
+    assert.equal(value.done.size, 0)
+    assert.equal(value.review.size, 0)
+  })
+}
+
+for (const count of [0, 1, 2, 7, 30]) for (const concurrency of [1, 2, 3, 8]) {
+  add(`concurrent-${count}-${concurrency}`, 'Bounded reconciliation', `${count} projects preserve ordering under concurrency ${concurrency}`, async () => {
+    let active = 0, peak = 0
+    const inputs = Array.from({ length: count }, (_, index) => index)
+    const result = await mapConcurrent(inputs, concurrency, async (value, index) => {
+      assert.equal(value, index)
+      peak = Math.max(peak, ++active)
+      await tick()
+      active--
+      return value * 3
+    })
+    assert.deepEqual(result, inputs.map((value) => value * 3))
+    assert.equal(peak, Math.min(count, concurrency))
+    assert.equal(active, 0)
+  })
+}
+
+for (const kind of ['ticket', 'thread']) for (const state of ['received', 'queued', 'running', 'blocked', 'completed', 'rendered']) for (const restarted of [false, true]) {
+  add(`memory-${kind}-${state}-${restarted}`, 'Durable replay memory', `${kind} ${state} observation stays deduplicated and isolated ${restarted ? 'after recreation' : 'in its current runtime'}`, () => temp(async (dir) => {
+    const path = join(dir, 'ledger.json')
+    const refs = kind === 'ticket' ? { projectId: 4, ticketId: 77 } : { channelId: 21, threadId: 600 }
+    const otherRefs = kind === 'ticket' ? { projectId: 5, ticketId: 77 } : { channelId: 21, threadId: 601 }
+    let stamp = 0
+    let graph = createByoMemoryGraph({ path, now: () => ++stamp })
+    const entry = { key: 'event:source', kind, state, summary: 'source acceptance criteria', refs }
+    const first = graph.remember(entry)
+    assert.equal(graph.remember(entry), first)
+    graph.remember({ ...entry, key: 'event:other', summary: 'unrelated private context', refs: otherRefs })
+    if (restarted) graph = createByoMemoryGraph({ path })
+    assert.equal(graph.has(entry.key, state), true)
+    assert.equal(graph.recall(refs).length, 1)
+    assert.match(graph.context(refs), /source acceptance criteria/)
+    assert.doesNotMatch(graph.context(refs), /unrelated private context/)
+  }))
+}
+
+add('cache-expiration-and-recovery', 'Board column discovery', 'Column changes become visible at TTL and failed reads do not poison the next lookup', async () => {
+  let now = 0, calls = 0, fail = false
+  const lookup = createTaskTypeLookup({ now: () => now, ttlMs: 10, load: async () => {
+    calls++
+    if (fail) throw new Error('temporary outage')
+    return { types: [{ id: calls, name: 'Done' }] }
+  } })
+  assert.equal((await lookup(4)).done.has(1), true)
+  now = 9
+  assert.equal((await lookup(4)).done.has(1), true)
+  now = 10; fail = true
+  await assert.rejects(lookup(4), /temporary outage/)
+  fail = false
+  assert.equal((await lookup(4)).done.has(3), true)
+})
+add('cache-capacity', 'Board column discovery', 'Column cache evicts older projects after 100 entries instead of growing without bound', async () => {
+  let calls = 0
+  const lookup = createTaskTypeLookup({ load: async () => { calls++; return { types: [] } } })
+  for (let project = 0; project <= 100; project++) await lookup(project)
+  await lookup(0)
+  assert.equal(calls, 102)
+})
+add('authorization-awaiting-decision', 'Authorization recovery', 'An asynchronous or non-boolean permission result cannot unlock a policy block prematurely', () => {
+  for (const result of [Promise.resolve(false), 'yes', {}, 1, null]) {
+    const state = { blocked: new Set(['4:77']), repos: new Map([['4:77', '/repo']]), failed: new Map([['4:77', 'revision']]), seen: new Set(['4:77']), authorized: () => result }
+    assert.equal(releaseAuthorizedPause('4:77', state), false)
+    assert.equal(state.blocked.has('4:77'), true)
+  }
+})
+add('concurrency-failure-drains-active', 'Bounded reconciliation', 'A failed project stops new scheduling and drains already-started work before returning the error', async () => {
+  const started = [], finished = []
+  await assert.rejects(mapConcurrent([0, 1, 2, 3, 4], 2, async (value) => {
+    started.push(value)
+    if (value === 0) throw new Error('project unavailable')
+    await tick(); finished.push(value)
+  }), /project unavailable/)
+  assert.deepEqual(started, [0, 1])
+  assert.deepEqual(finished, [1])
+})
+add('memory-bounded-edges', 'Durable replay memory', 'Memory capacity removes incident edges and keeps the newest verified states', () => temp(async (dir) => {
+  let stamp = 0
+  const graph = createByoMemoryGraph({ path: join(dir, 'ledger.json'), maxNodes: 2, now: () => ++stamp })
+  graph.remember({ key: 'old', refs: { channelId: 1, threadId: 1 } })
+  graph.remember({ key: 'middle', refs: { channelId: 1, threadId: 2 } })
+  graph.connect('old', 'middle', 'answered')
+  graph.remember({ key: 'new', refs: { channelId: 1, threadId: 3 } })
+  assert.equal(graph.has('old'), false)
+  const saved = JSON.parse(readFileSync(join(dir, 'ledger.json'), 'utf8'))
+  assert.equal(saved.nodes.length, 2)
+  assert.equal(saved.edges.length, 0)
+}))
+add('memory-shared-database-resource-isolation', 'Mastra persistence integration', 'Two agents sharing a database can remember the same ticket without overwriting each other’s thread ownership', () => temp(async (dir) => {
+  const databasePath = join(dir, 'shared.db'), refs = { projectId: 4, ticketId: 77 }
+  const a = createMastraMemory({ ledgerPath: join(dir, 'alex.json'), databasePath, resourceId: 'alex' })
+  const b = createMastraMemory({ ledgerPath: join(dir, 'robin.json'), databasePath, resourceId: 'robin' })
+  a.remember({ key: 'same', summary: 'Alex private verification', refs })
+  await a.settled()
+  b.remember({ key: 'same', summary: 'Robin private verification', refs })
+  await b.settled()
+  // Empty ledgers make this test prove database isolation, not JSON fallback.
+  const restored = (resourceId) => createMastraMemory({ ledgerPath: join(dir, `${resourceId}-empty.json`), databasePath, resourceId })
+  const a2 = restored('alex'), b2 = restored('robin')
+  assert.match(await a2.context(refs), /Alex private verification/)
+  assert.doesNotMatch(await a2.context(refs), /Robin private verification/)
+  assert.match(await b2.context(refs), /Robin private verification/)
+  await Promise.all([a2.settled(), b2.settled()])
+}))
+
+add('git-setup-worktree-revoke-regrant', 'Git authorization integration', 'Real Git worktrees inherit setup, revocation survives restart, and reauthorization works even after origin is restored', () => temp(async (dir) => {
+  const workspace = join(dir, 'workspace'), repo = join(workspace, 'repo'), worktree = join(dir, 'ticket-77')
+  const options = { authPath: join(dir, 'policy.json'), rulePath: join(dir, 'rules') }
+  configurePrPublishing({ workspace, ...options }); mkdirSync(repo)
+  const git = (...args) => execFileSync('git', args, { cwd: repo, stdio: 'pipe' })
+  git('init'); git('-c', 'core.hooksPath=/dev/null', '-c', 'user.name=Scenario', '-c', 'user.email=scenario@example.test', 'commit', '--allow-empty', '-m', 'fixture')
+  git('remote', 'add', 'origin', 'ssh://git@github.com/org/repo.git')
+  git('worktree', 'add', '-b', 'agent/ticket-77', worktree)
+  assert.equal(repositoryHasPrPushAuthorization({ cwd: worktree, ...options }), true)
+  git('remote', 'remove', 'origin')
+  revokePrPush({ cwd: worktree, ...options })
+  git('remote', 'add', 'origin', 'ssh://git@github.com/org/repo.git')
+  configurePrPublishing({ workspace, ...options })
+  assert.equal(repositoryHasPrPushAuthorization({ cwd: repo, ...options }), false)
+  authorizePrPush({ cwd: repo, ...options })
+  assert.equal(repositoryHasPrPushAuthorization({ cwd: worktree, ...options }), true)
+}))
+add('git-symlink-and-multiple-pushurls', 'Git authorization integration', 'Symlinks cannot escape workspace scope and the push helper pins one verified origin URL with hooks disabled', () => temp(async (dir) => {
+  const workspace = join(dir, 'workspace'), outside = join(dir, 'outside'), options = { authPath: join(dir, 'policy.json'), rulePath: join(dir, 'rules') }
+  configurePrPublishing({ workspace, ...options }); mkdirSync(outside)
+  execFileSync('git', ['init', outside], { stdio: 'pipe' })
+  execFileSync('git', ['-C', outside, 'remote', 'add', 'origin', 'https://github.com/org/repo.git'], { stdio: 'pipe' })
+  symlinkSync(outside, join(workspace, 'escape'))
+  assert.equal(repositoryHasPrPushAuthorization({ cwd: join(workspace, 'escape'), ...options }), false)
+  const calls = []
+  const spawn = (_command, args) => {
+    calls.push(args)
+    return { status: 0, stdout: args[0] === 'rev-parse' ? outside : args[0] === 'remote' ? 'https://github.com/org/repo.git' : args[0] === 'branch' ? 'agent/fix' : '' }
+  }
+  authorizePrPush({ cwd: outside, spawn, ...options })
+  pushPrBranch({ cwd: outside, spawn, ...options })
+  assert.deepEqual(calls.at(-1), ['-c', `core.hooksPath=${process.platform === 'win32' ? 'NUL' : '/dev/null'}`, 'push', '-u', 'https://github.com/org/repo.git', 'HEAD:refs/heads/agent/fix'])
+}))
+
+for (const [index, remote] of ['https://user:secret@github.com/org/repo.git', 'ssh://git:secret@github.com/org/repo.git', 'http://github.com/org/repo.git', 'file:///repo', '/repo', 'ext::command'].entries()) {
+  add(`unsafe-origin-${index}`, 'PR authorization', `Repository origin form ${remote.split('@').at(-1)} cannot broaden the constrained push helper`, () => temp(async (dir) => {
+    const spawn = (_command, args) => ({ status: 0, stdout: args[0] === 'rev-parse' ? dir : args[0] === 'remote' ? remote : 'agent/fix' })
+    assert.throws(() => repositoryPushIdentity(dir, spawn), /credentials|HTTPS or SSH/)
+  }))
+}
+add('malformed-authorization-file', 'PR authorization', 'Malformed policy collections fail closed and main setup can repair them without throwing', () => temp(async (dir) => {
+  const workspace = join(dir, 'workspace'), authPath = join(dir, 'policy.json'), rulePath = join(dir, 'rules')
+  for (const value of [null, [], { workspaces: {} }, { authorizations: [null], workspaces: [null], revoked: {} }]) {
+    writeFileSync(authPath, JSON.stringify(value))
+    configurePrPublishing({ workspace, authPath, rulePath })
+    const saved = JSON.parse(readFileSync(authPath, 'utf8'))
+    assert.deepEqual(saved.workspaces, [{ root: workspace }])
+  }
+}))
+
+const localHttp = async (handle, run) => {
+  const server = createServer((request, response) => {
+    let body = ''
+    request.on('data', (chunk) => { body += chunk })
+    request.on('end', () => { void Promise.resolve(handle(JSON.parse(body), request, response)).catch((error) => { response.statusCode = 500; response.end(error.message) }) })
+  })
+  server.listen(0, '127.0.0.1'); await once(server, 'listening')
+  try { await run(`http://127.0.0.1:${server.address().port}/mcp`) }
+  finally { server.closeAllConnections(); await new Promise((resolve) => server.close(resolve)) }
+}
+add('local-http-open-sse-stream', 'MCP HTTP integration', 'A streamed tool result completes before a server closes its SSE connection', async () => {
+  await localHttp((message, _request, res) => {
+    if (message.method === 'notifications/initialized') { res.writeHead(202); res.end(); return }
+    if (message.method === 'initialize') { res.setHeader('content-type', 'application/json'); res.end(JSON.stringify({ id: message.id, result: {} })); return }
+    res.writeHead(200, { 'content-type': 'text/event-stream' })
+    res.write('event: message\ndata: {"method":"notifications/progress","params":{}}\n\n')
+    res.write(`data: {"id":${message.id},\ndata: "result":{"content":[{"type":"text","text":"stream delivered ✓"}]}}\n\n`)
+    // Intentionally never end: receipt of the matching response is completion.
+  }, async (url) => {
+    const client = createMcpHttpClient({ url, apiKey: 'local-only', identifier: 'alex', requestTimeoutMs: 500 })
+    assert.equal((await client.callTool('post_message')).content[0].text, 'stream delivered ✓')
+  })
+})
+add('local-http-ambiguous-mutation-timeout', 'MCP HTTP integration', 'An accepted mutation whose response stalls is reported once without an automatic duplicate write', async () => {
+  let mutations = 0
+  await localHttp((message, _request, res) => {
+    if (message.method === 'tools/call') { mutations++; res.writeHead(200, { 'content-type': 'application/json' }); res.write('{'); return }
+    res.end('{}')
+  }, async (url) => {
+    const client = createMcpHttpClient({ url, apiKey: 'local-only', identifier: 'alex', requestTimeoutMs: 200 })
+    await assert.rejects(client.callTool('post_message'), /timed out/)
+    assert.equal(mutations, 1)
+  })
+})
+add('reset-during-initialize', 'MCP reset races', 'A stale initialize response cannot restore the session that a reset invalidated', async () => {
+  let release
+  const held = new Promise((resolve) => { release = resolve })
+  const { client, calls, counts } = fixture({ session: true, handler: async (request, count) => {
+    if (request.method === 'initialize' && count === 1) { await held; return response({ sessionId: 'stale-session', body: JSON.stringify({ id: request.id, result: {} }) }) }
+  } })
+  const old = client.initialize(); await tick()
+  client.reset(); await client.initialize(); release(); await old
+  await client.callTool('get_ticket')
+  assert.equal(counts.get('initialize'), 2)
+  assert.equal(calls.at(-1).headers['mcp-session-id'], 'session-2')
+})
+add('reset-during-tool-discovery', 'MCP reset races', 'An old tool discovery cannot overwrite the new session’s capability cache', async () => {
+  let release
+  const held = new Promise((resolve) => { release = resolve })
+  const { client } = fixture({ session: true, handler: async (request, count) => {
+    if (request.method !== 'tools/list') return null
+    if (count === 1) await held
+    return response({ body: JSON.stringify({ id: request.id, result: { tools: [{ name: count === 1 ? 'old_tool' : 'new_tool' }] } }) })
+  } })
+  const old = client.listTools(); await tick(); client.reset()
+  assert.equal((await client.listTools())[0].name, 'new_tool')
+  release(); assert.equal((await old)[0].name, 'new_tool')
+  assert.equal((await client.listTools())[0].name, 'new_tool')
+})