openvisio-agent 0.19.12 → 0.20.0

package/src/mastra-harness.mjs

@@ -12,18 +12,31 @@ const MCP_TOOL_NAMES = [
   'update_ticket', 'list_channels', 'list_message_thread', 'list_activity',
   'post_message', 'react_message', 'list_codebases', 'get_codebase',
   'codebase_tree', 'create_codebase_branch', 'create_codebase_commit',
-  'create_pull_request', 'write_codebase_file', 'comment_ticket',
+  'create_pull_request', 'write_codebase_file', 'create_task_comment', 'comment_ticket',
 ]
 const CHAT_SAFE_MCP_READS = new Set([
   '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 COORDINATION_TOOLS = ['update_ticket', 'post_message', 'react_message', 'comment_ticket']
+const COORDINATION_TOOLS = ['update_ticket', 'post_message', 'react_message', 'create_task_comment', 'comment_ticket']
 
 const clean = (value, max = 300) => String(value ?? '').replace(/\s+/g, ' ').trim().slice(0, max)
 const json = (value) => { try { return JSON.stringify(value) } catch { return String(value ?? '') } }
 
+// ACP model negotiation has no AbortSignal parameter. Race every remote wait,
+// including a stream that stops cooperating, against the cycle's deadline.
+async function abortable(operation, signal) {
+  signal.throwIfAborted()
+  let onAbort
+  const canceled = new Promise((_, reject) => {
+    onAbort = () => reject(signal.reason || new Error('ACP cycle canceled'))
+    signal.addEventListener('abort', onAbort, { once: true })
+  })
+  try { return await Promise.race([Promise.resolve().then(operation), canceled]) }
+  finally { signal.removeEventListener('abort', onAbort) }
+}
+
 function commandFor(agent) {
   if (agent === 'opencode') return { command: onPath('opencode') || 'opencode', args: ['acp'] }
   if (agent === 'codex') {
@@ -66,7 +79,8 @@ export function acpPermissionResponse(request, { canCode = false, canCoordinate
   // accepting an opaque MCP approval cannot grant a mutation or local access.
   const allow = canCode || CHAT_SAFE_MCP_READS.has(name) || (canCoordinate && COORDINATION_TOOLS.includes(name)) || (opaqueMcpApproval && proxyProtected)
   const preferred = allow ? 'allow_once' : 'reject_once'
-  const selected = options.find((option) => option.kind === preferred) || options.find((option) => option.kind.startsWith(allow ? 'allow' : 'reject'))
+  const validOptions = options.filter((option) => option && typeof option.optionId === 'string' && option.optionId && ['allow_once', 'allow_always', 'reject_once', 'reject_always'].includes(option.kind))
+  const selected = validOptions.find((option) => option.kind === preferred) || validOptions.find((option) => option.kind === (allow ? 'allow_always' : 'reject_always'))
   return selected ? { outcome: { outcome: 'selected', optionId: selected.optionId } } : { outcome: { outcome: 'cancelled' } }
 }
 
@@ -78,24 +92,62 @@ function contentText(content) {
 }
 
 export function createMastraAcpRunner({
-  agent, mcpUrl, mcpHeaders = {}, workdir, canCode = !!workdir, canCoordinate = false, maxCycleMs,
-  log = () => {}, debug = false, model, onTool, systemPrompt = '', AcpAgentClass = AcpAgent,
+  agent, mcpUrl, mcpHeaders = {}, workdir, canCode = !!workdir, canCoordinate = false, maxCycleMs = 20 * 60_000,
+  log = () => {}, debug = false, model, onTool, onEvent, systemPrompt = '', AcpAgentClass = AcpAgent,
 }) {
   const runtime = commandFor(agent)
   if (!runtime) return null
+  if (!Number.isFinite(maxCycleMs) || maxCycleMs <= 0 || maxCycleMs > 2_147_483_647) throw new Error('ACP maxCycleMs must be a positive supported timeout')
   let active = null
   let persistent = null
   let persistentKey = ''
   let sessionHasPrompted = false
   let negotiatedRequested = ''
   let negotiatedSelected = ''
+  let persistentSessionToken = null
+  let lastProcessEvent = null
+  const disconnected = new WeakSet()
   const defaultCwd = workdir || process.cwd()
+  const redact = (value) => Object.values(mcpHeaders).filter(Boolean).reduce((safe, secret) => safe.split(String(secret)).join('[redacted]'), String(value))
+  const notify = (type, data) => {
+    try { Promise.resolve(onEvent?.(type, data)).catch(() => {}) } catch { /* diagnostics cannot block work */ }
+  }
+  const disconnect = (acp, status = 'disconnected') => {
+    acp.connection.disconnect()
+    if (!disconnected.has(acp)) {
+      disconnected.add(acp)
+      lastProcessEvent?.('process.stopped', { status })
+    }
+  }
 
   async function runCycle(prompt, cycleModel, cycleOptions = {}) {
+    if (active) throw new Error('ACP session already has an active cycle')
     const cycleCwd = cycleOptions.workdir || defaultCwd
     const controller = new AbortController()
     let timedOut = false
     const startedAt = performance.now()
+    const cycleId = cycleOptions.cycleId ?? null
+    const emit = (type, data = {}) => notify(type, { cycleId, attempt: cycleOptions.attempt || 1, provider: agent, runtime: 'mastra-acp', workdir: cycleCwd, watcherPid: process.pid, runtimePid: null, ...data })
+    const progress = new Map()
+    const flushProgress = () => {
+      for (const [messageId, entry] of progress) {
+        if (entry.sent === entry.text) continue
+        emit('output.progress', { messageId, text: entry.text })
+        entry.sent = entry.text
+        entry.emittedAt = performance.now()
+      }
+    }
+    const observeCommentary = (update) => {
+      const messageId = clean(update.messageId || 'commentary', 200)
+      let entry = progress.get(messageId)
+      if (!entry) {
+        if (progress.size >= 16) { flushProgress(); progress.delete(progress.keys().next().value) }
+        entry = { text: '', sent: '', emittedAt: 0 }
+        progress.set(messageId, entry)
+      }
+      entry.text = redact(entry.text + contentText(update.content)).slice(-8000)
+      if (!entry.sent || performance.now() - entry.emittedAt >= 100) flushProgress()
+    }
     const before = canCode ? repositorySnapshot(cycleCwd) : Promise.resolve(null)
     let firstEventMs = null
     let policyBlock = null
@@ -126,7 +178,9 @@ export function createMastraAcpRunner({
     }] : [{ type: 'http', name: 'openvisio-team', url: mcpUrl, headers }]
     const sessionKey = JSON.stringify([cycleCwd, disabledMcpTools, mcpServers])
     if (!persistent || persistentKey !== sessionKey) {
-      persistent?.connection.disconnect()
+      if (persistent) disconnect(persistent)
+      const sessionToken = {}
+      persistentSessionToken = sessionToken
       persistent = new AcpAgentClass({
         id: `openvisio-${agent}-${Date.now()}`,
         name: `OpenVisio ${agent}`,
@@ -155,11 +209,21 @@ export function createMastraAcpRunner({
         },
         persistSession: true,
         onPermissionRequest: async (request) => acpPermissionResponse(request, { canCode, canCoordinate, proxyProtected }),
-        // codex-acp publishes account-status extension notifications. They are
-        // useful to interactive clients but should be silent in a background
-        // watcher, and the stock Mastra ACP client intentionally knows only ACP.
+        // Filter Codex's explicit commentary phase before Mastra converts
+        // agent_message_chunk into plain text and discards its phase metadata.
+        // The final result must not include earlier progress announcements.
+        // Unannotated output remains compatible with older ACP adapters.
         createClient: agent === 'codex' ? (client) => new Proxy(client, {
           get(target, property, receiver) {
+            if (property === 'sessionUpdate') return async (notification) => {
+              const update = notification?.update
+              if (update?.sessionUpdate === 'agent_message_chunk' && update?._meta?.codex?.phase === 'commentary') {
+                if (active?.sessionToken === sessionToken && (!active.acp.connection.sessionId || active.acp.connection.sessionId === notification.sessionId)) active.observeCommentary(update)
+                return
+              }
+              return target.sessionUpdate(notification)
+            }
+            // Account-status extensions are intentionally silent in a watcher.
             if (property === 'extNotification') return async () => {}
             return Reflect.get(target, property, receiver)
           },
@@ -171,9 +235,11 @@ export function createMastraAcpRunner({
       negotiatedSelected = ''
     }
     const acp = persistent
-    active = { acp, controller }
+    active = { acp, controller, observeCommentary, sessionToken: persistentSessionToken }
+    lastProcessEvent = emit
+    emit('process.started', { status: acp.connection.sessionId ? 'reused' : 'connecting', sessionId: acp.connection.sessionId || null })
     const invalidate = () => {
-      acp.connection.disconnect()
+      disconnect(acp)
       if (persistent === acp) {
         persistent = null
         persistentKey = ''
@@ -188,10 +254,10 @@ export function createMastraAcpRunner({
     try {
       if (requestedModel) {
         if (requestedModel !== negotiatedRequested) {
-          const availableModels = await acp.getAvailableModels()
+          const availableModels = await abortable(() => acp.getAvailableModels(), controller.signal)
           const resolution = resolveAvailableModel(requestedModel, availableModels)
           if (resolution.selected) {
-            await acp.setModel(resolution.selected)
+            await abortable(() => acp.setModel(resolution.selected), controller.signal)
             selectedModel = resolution.selected
             if (selectedModel !== requestedModel) log(`model ${requestedModel} resolved to available ${selectedModel} [${resolution.reason}]`)
           } else {
@@ -206,35 +272,65 @@ export function createMastraAcpRunner({
       log(`running ${agent} cycle via Mastra ACP…${selectedModel || requestedModel ? ` [${selectedModel || requestedModel}]` : ' [runtime default]'}`)
       const fullPrompt = systemPrompt && !sessionHasPrompted ? `${systemPrompt}\n\n${prompt}` : prompt
       sessionHasPrompted = true
-      for await (const event of acp.connection.promptStream(fullPrompt, controller.signal)) {
+      const stream = acp.connection.promptStream(fullPrompt, controller.signal)[Symbol.asyncIterator]()
+      let readyReported = false
+      while (true) {
+        const next = await abortable(() => stream.next(), controller.signal)
+        if (next.done) break
+        const event = next.value
+        if (!readyReported) {
+          readyReported = true
+          emit('process.ready', { status: 'running', model: selectedModel || requestedModel || null, sessionId: acp.connection.sessionId || null })
+        }
         firstEventMs ??= Math.round(performance.now() - startedAt)
         if (event.type === 'text') { outputText += event.text; continue }
         const update = event.update || {}
+        if (update.sessionUpdate === 'plan') {
+          const entries = (Array.isArray(update.entries) ? update.entries : []).slice(0, 100).map((entry) => ({
+            content: clean(redact(entry?.content || ''), 2000),
+            status: ['pending', 'in_progress', 'completed'].includes(entry?.status) ? entry.status : 'unknown',
+            priority: ['low', 'medium', 'high'].includes(entry?.priority) ? entry.priority : undefined,
+          })).filter((entry) => entry.content)
+          emit('plan.updated', { entries })
+          continue
+        }
         if (update.sessionUpdate === 'agent_message_chunk') {
+          if (update?._meta?.codex?.phase === 'commentary') { observeCommentary(update); continue }
           outputText += contentText(update.content)
           continue
         }
         if (!['tool_call', 'tool_call_update'].includes(update.sessionUpdate)) continue
         const prior = tools.get(update.toolCallId) || {}
-        const merged = { ...prior, ...update, order: ++toolSequence }
+        // Metadata-only updates after completion cannot move an earlier tool
+        // past a later result message and rewrite the observed execution order.
+        const order = prior.status === 'completed' && (!update.status || update.status === 'completed') ? prior.order : ++toolSequence
+        const merged = { ...prior, ...update, order }
         tools.set(update.toolCallId, merged)
         const name = toolName(merged)
         const label = name || clean(merged.title, 100) || 'tool'
+        const terminal = ['completed', 'failed'].includes(merged.status)
+        const eventType = terminal && prior.status !== merged.status ? 'tool.finished' : prior.toolCallId ? 'tool.updated' : 'tool.started'
+        const locations = (Array.isArray(merged.locations) ? merged.locations : []).slice(0, 30).map((location) => ({
+          path: clean(redact(location?.path || ''), 1000),
+          ...(Number.isInteger(location?.line) ? { line: location.line } : {}),
+        })).filter((location) => location.path)
+        emit(eventType, { toolCallId: clean(merged.toolCallId, 200), name: clean(redact(label), 300), title: clean(redact(merged.title || label), 2000), status: merged.status || 'pending', kind: clean(merged.kind, 100), locations })
         try { onTool?.(label) } catch { /* status is best-effort */ }
         if (debug && update.sessionUpdate === 'tool_call') log(`  → tool ${label}`)
         if (name) {
           calls.add(name)
-          if (merged.status === 'failed') errors.set(name, clean(json(merged.rawOutput) || merged.title))
+          if (merged.status === 'failed') errors.set(name, clean(redact(json(merged.rawOutput) || merged.title)))
           else if (merged.status === 'completed') errors.delete(name)
         }
       }
+      controller.signal.throwIfAborted()
       // Only final, completed tool states are evidence. Started/failed edits and
       // board mutations cannot stand in for completed repository work.
       for (const tool of [...tools.values()].sort((a, b) => a.order - b.order)) {
         const name = toolName(tool)
         if (tool.status === 'failed') policyBlock ||= codexPolicyBlock(json(tool.rawOutput))
         if (tool.status !== 'completed') continue
-        didMessage ||= name === 'post_message'
+        didMessage ||= ['post_message', 'create_task_comment', 'comment_ticket'].includes(name)
         didChannelMessage ||= name === 'post_message'
         didResultMessage ||= name === 'post_message' && didRepoMutation
         didMcpTaskRead ||= ['list_tasks', 'get_ticket'].includes(name)
@@ -248,10 +344,12 @@ export function createMastraAcpRunner({
       }
       const beforeState = await before
       const after = canCode ? await repositorySnapshot(cycleCwd) : null
+      controller.signal.throwIfAborted()
       if (beforeState != null && after != null && beforeState !== after) { didCode = true; didRepoMutation = true }
-      const redact = (value) => Object.values(mcpHeaders).filter(Boolean).reduce((safe, secret) => safe.split(String(secret)).join('[redacted]'), String(value))
       for (const [name, detail] of errors) log(`MCP ${name} failed: ${redact(detail)}`)
       log(`${agent} cycle done via Mastra ACP (${errors.size ? 'tool-errors' : 'ok'})`)
+      flushProgress()
+      if (outputText.trim()) emit('output.final', { text: redact(outputText.trim()).slice(0, 8000), status: policyBlock ? 'blocked' : 'ok' })
       return {
         type: 'result', subtype: policyBlock ? 'blocked' : 'ok', policyBlock, timings: { firstEventMs, totalMs: Math.round(performance.now() - startedAt) }, runtime: 'mastra-acp', model: selectedModel || null, requestedModel: requestedModel || null, outputText: outputText.trim(),
         mcpCalls: [...calls], mcpErrors: [...errors.keys()], mcpErrorDetails: Object.fromEntries(errors),
@@ -262,7 +360,10 @@ export function createMastraAcpRunner({
       const canceled = controller.signal.aborted
       const subtype = timedOut ? 'timeout' : canceled ? 'canceled' : 'error'
       const errorDetail = [error?.message, error?.data ? json(error.data) : ''].filter(Boolean).join(': ')
-      const safeError = Object.values(mcpHeaders).filter(Boolean).reduce((safe, secret) => safe.split(String(secret)).join('[redacted]'), errorDetail)
+      const safeError = redact(errorDetail)
+      flushProgress()
+      if (outputText.trim()) emit('output.final', { text: redact(outputText.trim()).slice(0, 8000), status: subtype })
+      emit('process.error', { status: subtype, summary: clean(safeError, 2000) })
       log(`${agent} cycle done via Mastra ACP (${subtype}${!canceled && safeError ? ': ' + clean(safeError, 1200) : ''})`)
       invalidate()
       return {
@@ -272,6 +373,8 @@ export function createMastraAcpRunner({
         didMcpTaskRead, didMcpTaskUpdate,
       }
     } finally {
+      flushProgress()
+      if (!disconnected.has(acp)) emit('process.ready', { status: 'idle', sessionId: acp.connection.sessionId || null })
       clearTimeout(timer)
       if (active?.acp === acp) active = null
     }
@@ -281,8 +384,10 @@ export function createMastraAcpRunner({
     if (!active) return
     const { acp, controller } = active
     controller.abort()
-    try { await acp.connection.cancel() } catch { /* already stopped */ }
-    acp.connection.disconnect()
+    // The canceled cycle must release its lane even if ACP never acknowledges
+    // cancel. Disconnect terminates the transport and its pending requests.
+    try { Promise.resolve(acp.connection.cancel()).catch(() => {}) } catch { /* already stopped */ }
+    disconnect(acp, 'canceled')
     if (persistent === acp) {
       persistent = null
       persistentKey = ''
@@ -293,7 +398,8 @@ export function createMastraAcpRunner({
   }
 
   const close = () => {
-    persistent?.connection.disconnect()
+    active?.controller.abort()
+    if (persistent) disconnect(persistent)
     persistent = null
     persistentKey = ''
     sessionHasPrompted = false

package/src/mcp-http.mjs

@@ -1,8 +1,51 @@
+const selectResponse = (messages, id) => {
+  const responses = messages.flat().filter((message) => message && typeof message === 'object' && !Array.isArray(message) && !message.method)
+  const exact = responses.find((message) => message.id === id)
+  if (exact) return exact
+  // Older stateless adapters omit the JSON-RPC envelope. Keep supporting them,
+  // but never mistake a response to a different request for this one.
+  return responses.find((message) => message.id == null) || null
+}
+
+const parseBody = (body, id) => {
+  let messages
+  try {
+    if (/^\s*[\[{]/.test(body)) messages = [JSON.parse(body)]
+    else {
+      messages = body.split(/\r?\n\r?\n/).map((event) => event.split(/\r?\n/)
+        .filter((line) => line.startsWith('data:')).map((line) => line.slice(5).replace(/^ /, '')).join('\n'))
+        .filter(Boolean).map((data) => JSON.parse(data))
+      if (!messages.length && !body.trim()) messages = [{}]
+    }
+  } catch { throw new Error('MCP returned a non-JSON response') }
+  return selectResponse(messages, id)
+}
+
 const parsePayload = async (res) => {
-  const body = await res.text()
-  const data = body.split(/\r?\n/).filter((line) => line.startsWith('data:')).map((line) => line.slice(5).trim()).pop()
-  try { return JSON.parse(data || body || '{}') }
-  catch { throw new Error('MCP returned a non-JSON response') }
+  const payload = parseBody(await res.text(), res.requestId)
+  if (!payload) throw new Error('MCP returned no matching JSON-RPC response')
+  return payload
+}
+
+const readBody = async (res, id) => {
+  if (id == null || !/text\/event-stream/i.test(res.headers.get('content-type') || '') || !res.body?.getReader) return res.text()
+  const reader = res.body.getReader(), decoder = new TextDecoder()
+  let buffered = ''
+  try {
+    while (true) {
+      const { done, value } = await reader.read()
+      buffered += decoder.decode(value, { stream: !done })
+      let boundary
+      while ((boundary = /\r?\n\r?\n/.exec(buffered))) {
+        const event = buffered.slice(0, boundary.index)
+        buffered = buffered.slice(boundary.index + boundary[0].length)
+        if (!event.split(/\r?\n/).some((line) => line.startsWith('data:'))) continue
+        const payload = parseBody(event, id)
+        if (payload) return JSON.stringify(payload)
+      }
+      if (done) return buffered
+    }
+  } finally { void reader.cancel().catch(() => {}) }
 }
 
 // Streamable HTTP permits both stateful servers (initialize returns
@@ -17,6 +60,8 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
   let initializePromise = null
   let toolsPromise = null
   let toolsCache = null
+  let generation = 0
+  const redact = (value) => apiKey ? String(value).split(apiKey).join('[redacted]') : String(value)
 
   const post = async (message, withSession = true) => {
     const controller = new AbortController()
@@ -43,18 +88,20 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
           },
           body: JSON.stringify(message),
         })
-        const body = await res.text()
-        return { ok: res.ok, status: res.status, headers: res.headers, text: async () => body }
+        const body = await readBody(res, message.id)
+        return { ok: res.ok, status: res.status, headers: res.headers, requestId: message.id, text: async () => body }
       })()])
-    } finally { clearTimeout(timer) }
+    } catch (error) { throw new Error(redact(error?.message || error)) }
+    finally { clearTimeout(timer) }
   }
 
-  const reset = () => { initialized = false; sessionId = ''; toolsCache = null }
+  const reset = () => { generation++; initialized = false; sessionId = ''; toolsCache = null; initializePromise = null; toolsPromise = null }
 
   const initialize = () => {
     if (initialized) return Promise.resolve()
     if (initializePromise) return initializePromise
-    initializePromise = (async () => {
+    const requestGeneration = generation
+    const promise = (async () => {
       const res = await post({
         jsonrpc: '2.0',
         id: ++rpcId,
@@ -63,15 +110,18 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
       }, false)
       if (!res.ok) throw new Error('MCP initialize HTTP ' + res.status)
       const payload = await parsePayload(res)
-      if (payload.error) throw new Error(`MCP initialize: ${payload.error.message || 'protocol error'}`)
+      if (payload.error) throw new Error(`MCP initialize: ${redact(payload.error.message || 'protocol error')}`)
+      if (requestGeneration !== generation) return initialize()
       sessionId = res.headers.get('mcp-session-id') || ''
 
       const ready = await post({ jsonrpc: '2.0', method: 'notifications/initialized' })
+      if (requestGeneration !== generation) return initialize()
       if (!ready.ok) { reset(); throw new Error('MCP initialized HTTP ' + ready.status) }
       initialized = true
       if (!sessionId) log('MCP initialized in stateless mode (no session id required)')
-    })().finally(() => { initializePromise = null })
-    return initializePromise
+    })().finally(() => { if (initializePromise === promise) initializePromise = null })
+    initializePromise = promise
+    return promise
   }
 
   const callTool = async (name, args = {}, retried = false) => {
@@ -87,17 +137,17 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
     if (!res.ok) {
       // Only a stateful transport can have an expired session. A stateless 4xx
       // belongs to the tool request itself and must not trigger an initialize loop.
-      if (hadSession && !retried && [400, 404, 409, 410].includes(res.status)) {
+      if (hadSession && !retried && res.status === 404) {
         if (sessionId === requestSession) reset()
         return callTool(name, args, true)
       }
       throw new Error(`MCP ${name} HTTP ${res.status}`)
     }
     const payload = await parsePayload(res)
-    if (payload.error) throw new Error(`MCP ${name}: ${payload.error.message || 'tool error'}`)
+    if (payload.error) throw new Error(`MCP ${name}: ${redact(payload.error.message || 'tool error')}`)
     const result = payload.result ?? payload
     if (result?.isError) {
-      const detail = String(result.content?.find?.((item) => item?.type === 'text')?.text || 'tool error').split(apiKey).join('[redacted]')
+      const detail = redact(result.content?.find?.((item) => item?.type === 'text')?.text || 'tool error')
       throw new Error(`MCP ${name}: ${detail}`)
     }
     return result
@@ -105,18 +155,20 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
 
   const requestTools = async (retried = false, cursor, collected = [], cursors = new Set()) => {
     await initialize()
+    const requestGeneration = generation
     const requestSession = sessionId
     const hadSession = !!sessionId
     const res = await post({ jsonrpc: '2.0', id: ++rpcId, method: 'tools/list', params: cursor ? { cursor } : {} })
     if (!res.ok) {
-      if (hadSession && !retried && [400, 404, 409, 410].includes(res.status)) {
+      if (hadSession && !retried && res.status === 404) {
         if (sessionId === requestSession) reset()
         return requestTools(true)
       }
       throw new Error(`MCP tools/list HTTP ${res.status}`)
     }
     const payload = await parsePayload(res)
-    if (payload.error) throw new Error(`MCP tools/list: ${payload.error.message || 'protocol error'}`)
+    if (payload.error) throw new Error(`MCP tools/list: ${redact(payload.error.message || 'protocol error')}`)
+    if (requestGeneration !== generation) return requestTools(retried)
     const tools = payload.result?.tools ?? payload.tools
     if (!Array.isArray(tools)) throw new Error('MCP tools/list returned no tool array')
     const combined = [...collected, ...tools]
@@ -136,8 +188,9 @@ export function createMcpHttpClient({ url, apiKey, identifier, clientVersion, fe
   const listTools = (refresh = false) => {
     if (!refresh && toolsCache) return Promise.resolve(toolsCache)
     if (toolsPromise) return toolsPromise
-    toolsPromise = requestTools().finally(() => { toolsPromise = null })
-    return toolsPromise
+    const promise = requestTools().finally(() => { if (toolsPromise === promise) toolsPromise = null })
+    toolsPromise = promise
+    return promise
   }
 
   const mode = () => !initialized ? 'uninitialized' : sessionId ? 'stateful' : 'stateless'

package/src/memory.mjs

@@ -12,6 +12,7 @@ const sameRef = (a, b) => a != null && b != null && String(a) === String(b)
 // reported. It is intentionally not an LLM transcript or vector store: stable
 // backend ids make exact recall cheaper and prevent old work from being replayed.
 export function createByoMemoryGraph({ path, maxNodes = 1000, now = () => Date.now() }) {
+  if (!Number.isSafeInteger(maxNodes) || maxNodes < 1) throw new Error('Invalid BYO memory capacity')
   let raw = {}
   try { raw = JSON.parse(readFileSync(path, 'utf8')) } catch { /* first run */ }
   const nodes = new Map((Array.isArray(raw.nodes) ? raw.nodes : []).filter((node) => node?.key).map((node) => [String(node.key), node]))
@@ -108,6 +109,10 @@ export function createMastraMemory({ ledgerPath, databasePath, resourceId, maxNo
   const memory = new Memory({ storage, options: { lastMessages: 12, semanticRecall: false, workingMemory: { enabled: false } } })
   const threads = new Map()
   const pending = new Map()
+  const scopedThreadId = (refs) => {
+    const id = memoryThreadId(refs)
+    return id ? `resource:${encodeURIComponent(String(resourceId))}:${id}` : ''
+  }
 
   const ensureThread = (threadId) => {
     if (!threads.has(threadId)) {
@@ -120,7 +125,7 @@ export function createMastraMemory({ ledgerPath, databasePath, resourceId, maxNo
   }
 
   const queueMessage = (entry) => {
-    const threadId = memoryThreadId(entry?.refs)
+    const threadId = scopedThreadId(entry?.refs)
     if (!threadId) return
     const write = (pending.get(threadId) || Promise.resolve()).then(async () => {
       await ensureThread(threadId)
@@ -142,7 +147,7 @@ export function createMastraMemory({ ledgerPath, databasePath, resourceId, maxNo
   }
 
   const context = async (refs = {}, limit = 8) => {
-    const threadId = memoryThreadId(refs)
+    const threadId = scopedThreadId(refs)
     if (!threadId) return ''
     // Writes for unrelated tickets must never delay a conversation reply.
     await pending.get(threadId)
@@ -151,6 +156,14 @@ export function createMastraMemory({ ledgerPath, databasePath, resourceId, maxNo
       const items = recalled.messages.map(messageText).filter(Boolean).slice(-limit)
       if (items.length) return ['RELEVANT VERIFIED MEMORY (do not repeat completed/delivered actions):', ...items.map((item) => `- ${item}`)].join('\n')
     } catch { /* fall through to the migration-safe ledger */ }
+    // Preserve pre-namespace history only when Mastra verifies that the legacy
+    // thread belongs to this resource. New writes use isolated IDs even if two
+    // agents share the same database and ticket numbers.
+    try {
+      const legacy = await memory.recall({ threadId: memoryThreadId(refs), resourceId, perPage: limit })
+      const items = legacy.messages.map(messageText).filter(Boolean).slice(-limit)
+      if (items.length) return ['RELEVANT VERIFIED MEMORY (do not repeat completed/delivered actions):', ...items.map((item) => `- ${item}`)].join('\n')
+    } catch { /* no legacy thread owned by this resource */ }
     return ledger.context(refs, limit)
   }
 

package/src/pr-push.mjs

@@ -15,9 +15,9 @@ const gitText = (cwd, args, spawn = spawnSync) => {
 
 const safeRemote = (value) => {
   const remote = String(value || '').trim()
-  if (/^https?:\/\//i.test(remote) || /^ssh:\/\//i.test(remote)) {
+  if (/^https:\/\//i.test(remote) || /^ssh:\/\//i.test(remote)) {
     const parsed = new URL(remote)
-    if (parsed.username || parsed.password) throw new Error('Origin contains credentials in its URL. Move credentials to your Git credential manager before authorizing PR pushes.')
+    if (parsed.password || (parsed.protocol !== 'ssh:' && parsed.username)) throw new Error('Origin contains credentials in its URL. Move credentials to your Git credential manager before authorizing PR pushes.')
     return remote
   }
   if (/^[^@\s]+@[^:\s]+:[^\s]+$/.test(remote)) return remote
@@ -27,6 +27,7 @@ const safeRemote = (value) => {
 export function isSafeAgentBranch(value) {
   const branch = String(value || '')
   return /^agent\/[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(branch) &&
+    branch.split('/').every((part) => !part.startsWith('.') && !part.endsWith('.lock')) &&
     !branch.includes('..') && !branch.includes('//') && !branch.includes('@{') &&
     !/[~^:?*\[\\]/.test(branch) && !/[/.]$/.test(branch)
 }
@@ -52,7 +53,15 @@ function readAuthorizations(path) {
 }
 
 function readPolicy(path) {
-  try { return JSON.parse(readFileSync(path, 'utf8')) } catch { return {} }
+  try {
+    const value = JSON.parse(readFileSync(path, 'utf8'))
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return {}
+    return { ...value,
+      authorizations: Array.isArray(value.authorizations) ? value.authorizations.filter((entry) => entry && typeof entry.root === 'string' && typeof entry.remote === 'string') : [],
+      workspaces: Array.isArray(value.workspaces) ? value.workspaces.filter((entry) => entry && typeof entry.root === 'string' && isAbsolute(entry.root)) : [],
+      revoked: Array.isArray(value.revoked) ? value.revoked.filter((entry) => typeof entry === 'string') : [],
+    }
+  } catch { return {} }
 }
 
 const within = (root, path) => {
@@ -63,10 +72,10 @@ const within = (root, path) => {
 
 function policyAllows(identity, policy) {
   const roots = [identity.root, identity.commonDir].filter(Boolean)
-  if ((policy.revoked || []).some((entry) => roots.includes(entry))) return false
-  return (policy.authorizations || []).some((entry) => entry.remote === identity.remote &&
+  if ((Array.isArray(policy.revoked) ? policy.revoked : []).some((entry) => roots.includes(entry))) return false
+  return (Array.isArray(policy.authorizations) ? policy.authorizations : []).some((entry) => entry && entry.remote === identity.remote &&
     (entry.root === identity.root || (entry.commonDir && entry.commonDir === identity.commonDir))) ||
-    (policy.workspaces || []).some((entry) => roots.some((root) => within(entry.root, root)))
+    (Array.isArray(policy.workspaces) ? policy.workspaces : []).some((entry) => typeof entry?.root === 'string' && isAbsolute(entry.root) && roots.some((root) => within(entry.root, root)))
 }
 
 // Connecting a coding workspace grants routine PR delivery once, including
@@ -128,7 +137,10 @@ export function authorizePrPush({ cwd = process.cwd(), authPath = DEFAULT_AUTH_P
 }
 
 export function revokePrPush({ cwd = process.cwd(), authPath = DEFAULT_AUTH_PATH, spawn = spawnSync } = {}) {
-  const { root, commonDir } = repositoryPushIdentity(cwd, spawn)
+  // Revocation must still work if origin was removed or replaced with an unsafe
+  // URL; only a future authorization or push needs to validate the destination.
+  const root = realpathSync(gitText(cwd, ['rev-parse', '--show-toplevel'], spawn))
+  const commonDir = realpathSync(resolve(root, gitText(root, ['rev-parse', '--git-common-dir'], spawn)))
   const policy = readPolicy(authPath)
   const before = readAuthorizations(authPath)
   const authorizations = before.filter((entry) => entry?.root !== root)
@@ -138,7 +150,8 @@ export function revokePrPush({ cwd = process.cwd(), authPath = DEFAULT_AUTH_PATH
 
 export function pushPrBranch({ cwd = process.cwd(), authPath = DEFAULT_AUTH_PATH, spawn = spawnSync } = {}) {
   const identity = repositoryPushIdentity(cwd, spawn)
-  validatePrPushAuthorization({ ...identity, ...readPolicy(authPath) })
+  const { authorizations, workspaces, revoked } = readPolicy(authPath)
+  validatePrPushAuthorization({ ...identity, authorizations, workspaces, revoked })
   const destination = `HEAD:refs/heads/${identity.branch}`
   // The helper runs outside Codex's workspace sandbox after the user authorizes
   // it. Disable repository hooks so an edited pre-push hook cannot widen this

package/src/runner-pool.mjs

@@ -1,12 +1,19 @@
 // Bounded LRU of warm sessions, pinned while in use. Never evict an active
 // session, and never share history between tickets or conversation threads.
-export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now = Date.now }) {
+export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now = Date.now, onError = () => {} }) {
+  if (!Number.isInteger(capacity) || capacity < 1) throw new Error('runner pool capacity must be a positive integer')
+  if (!Number.isFinite(idleMs) || idleMs <= 0) throw new Error('runner pool idleMs must be positive and finite')
   const entries = new Map()
+  let closed = false
+  const report = (error) => { try { Promise.resolve(onError(error)).catch(() => {}) } catch { /* reporting cannot strand cleanup */ } }
+  const dispose = (entry) => {
+    try { Promise.resolve(entry.runner.close?.()).catch(report) } catch (error) { report(error) }
+  }
   function prune() {
     for (const [key, entry] of entries) {
       if (!entry.busy && (now() - entry.usedAt >= idleMs || entries.size > capacity)) {
-        entry.runner.close?.()
         entries.delete(key)
+        dispose(entry)
       }
     }
   }
@@ -14,6 +21,7 @@ export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now =
   timer.unref?.()
   return {
     acquire(key, options) {
+      if (closed) throw new Error('Session pool is closed')
       prune()
       let entry = entries.get(key)
       if (entry?.busy) throw new Error('Session already has an active cycle')
@@ -30,9 +38,12 @@ export function createRunnerPool({ create, capacity = 8, idleMs = 300_000, now =
       prune()
     },
     close() {
+      if (closed) return
+      closed = true
       clearInterval(timer)
-      for (const entry of entries.values()) entry.runner.close?.()
+      const closing = [...entries.values()]
       entries.clear()
+      for (const entry of closing) dispose(entry)
     },
   }
 }