openvisio-agent 0.19.11 → 0.20.0

package/src/studio-cli.mjs

@@ -0,0 +1,60 @@
+import { spawn } from 'node:child_process'
+import { resolve } from 'node:path'
+import { OV_DIR } from './lib.mjs'
+
+export function studioOptions({ flags = {}, positional = [] } = {}) {
+  const supported = new Set(['port', 'no-open', 'demo', 'state-dir'])
+  if (positional.length) throw new Error('studio accepts options only. Use openvisio-agent studio --help.')
+  for (const key of Object.keys(flags)) if (!supported.has(key)) throw new Error(`Unknown studio option --${key}.`)
+  for (const key of ['demo', 'no-open']) if (flags[key] != null && flags[key] !== true) throw new Error(`--${key} does not accept a value.`)
+  const rawPort = flags.port ?? 4317
+  if (!['string', 'number'].includes(typeof rawPort) || !/^\d+$/.test(String(rawPort)) || !Number.isSafeInteger(Number(rawPort)) || Number(rawPort) > 65535) throw new Error('--port must be a number between 0 and 65535 (0 selects an available port).')
+  if (flags['state-dir'] != null && (typeof flags['state-dir'] !== 'string' || !flags['state-dir'].trim())) throw new Error('--state-dir requires a directory path.')
+  return { host: '127.0.0.1', port: Number(rawPort), stateDir: flags['state-dir'] ? resolve(flags['state-dir']) : OV_DIR, demo: !!flags.demo, openBrowser: !flags['no-open'] }
+}
+
+export function openStudioBrowser(url, { platform = process.platform, spawnProcess = spawn } = {}) {
+  const parsed = new URL(url)
+  if (parsed.protocol !== 'http:' || parsed.hostname !== '127.0.0.1') return Promise.resolve(false)
+  const command = platform === 'darwin' ? 'open' : platform === 'win32' ? 'rundll32' : 'xdg-open'
+  const args = platform === 'win32' ? ['url.dll,FileProtocolHandler', url] : [url]
+  return new Promise((resolveResult) => {
+    let child
+    try { child = spawnProcess(command, args, { stdio: 'ignore', detached: false, shell: false, windowsHide: true }) }
+    catch { resolveResult(false); return }
+    let settled = false
+    const done = (value) => { if (!settled) { settled = true; clearTimeout(timer); resolveResult(value) } }
+    const timer = setTimeout(() => { try { child.kill() } catch {} done(false) }, 5000)
+    timer.unref?.()
+    child.once('error', () => done(false))
+    child.once('exit', (code) => done(code === 0))
+  })
+}
+
+export async function runStudio(input, { startServer, openBrowser = openStudioBrowser, log = console.log, signals = process } = {}) {
+  const options = studioOptions(input)
+  const start = startServer || (await import('./studio-server.mjs')).startStudioServer
+  let server
+  try { server = await start(options) }
+  catch (error) {
+    if (error?.code === 'EADDRINUSE') throw new Error(`Port ${options.port} is already in use. Open the existing viewer or run openvisio-agent studio --port 0.`)
+    throw error
+  }
+  log(`Agent studio: ${server.url}`)
+  if (options.demo) log('Demo mode shows simulated activity. It does not start agents or model calls.')
+  else log('Showing local watcher activity. Updated watchers record new cycles automatically.')
+  log('Press Ctrl+C to close the viewer. Agents keep running.')
+  let closing
+  const close = () => {
+    if (closing) return closing
+    signals.removeListener('SIGINT', close)
+    signals.removeListener('SIGTERM', close)
+    closing = Promise.resolve().then(() => server.close())
+    closing.catch((error) => { log(`Viewer shutdown failed: ${error?.message || error}`); process.exitCode = 1 })
+    return closing
+  }
+  signals.once('SIGINT', close)
+  signals.once('SIGTERM', close)
+  if (options.openBrowser && !(await openBrowser(server.url))) log(`Open ${server.url} in your browser.`)
+  return { ...server, close }
+}

package/src/studio-server.mjs

@@ -0,0 +1,224 @@
+import { createHash } from 'node:crypto'
+import { constants } from 'node:fs'
+import { lstat, open, readdir, readFile, realpath } from 'node:fs/promises'
+import { createServer } from 'node:http'
+import { dirname, join, relative, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { isPrivateThoughtEvent, sanitizeJournalData } from './agent-journal.mjs'
+
+const MAX_EVENTS = 500, MAX_FILES = 32, MAX_FILE_BYTES = 256 * 1024, MAX_TOTAL_BYTES = 4 * 1024 * 1024
+const FRESH_MS = 45_000
+const DEFAULT_ASSETS = fileURLToPath(new URL('../studio/', import.meta.url))
+const pidAlive = (pid) => {
+  if (!Number.isSafeInteger(pid) || pid < 1) return false
+  try { process.kill(pid, 0); return true } catch (error) { return error.code === 'EPERM' }
+}
+
+function normalizeEvent(value) {
+  if (!value || value.schemaVersion !== 1 || typeof value.id !== 'string' || typeof value.runId !== 'string' || typeof value.agent?.identifier !== 'string' || !Number.isFinite(Date.parse(value.timestamp)) || typeof value.type !== 'string' || isPrivateThoughtEvent(value.type)) return null
+  return sanitizeJournalData(value)
+}
+
+async function tailEvents(path, maxBytes) {
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0))
+  try {
+    const entry = await handle.stat()
+    if (!entry.isFile()) return { events: [], bytes: 0 }
+    const count = Math.min(entry.size, maxBytes), offset = entry.size - count
+    const bytes = Buffer.alloc(count)
+    const { bytesRead } = await handle.read(bytes, 0, count, offset)
+    let text = bytes.subarray(0, bytesRead).toString('utf8')
+    if (offset) text = text.slice(text.indexOf('\n') + 1)
+    const lines = text.split('\n')
+    lines.pop() // A partial final line is retried on the next snapshot.
+    const events = []
+    for (const line of lines) {
+      if (Buffer.byteLength(line) > 32 * 1024) continue
+      try { const event = normalizeEvent(JSON.parse(line)); if (event) events.push(event) } catch { /* partial or corrupt record */ }
+    }
+    return { events, bytes: bytesRead }
+  } finally { await handle.close() }
+}
+
+async function readSmallLocalFile(path, maxBytes = 64 * 1024) {
+  const handle = await open(path, constants.O_RDONLY | (constants.O_NOFOLLOW || 0))
+  try {
+    const entry = await handle.stat()
+    if (!entry.isFile() || entry.size > maxBytes) return null
+    return await handle.readFile('utf8')
+  } finally { await handle.close() }
+}
+
+async function configuredAgents(stateDir) {
+  const entries = await readdir(stateDir, { withFileTypes: true }).catch(() => [])
+  const agents = []
+  // Only direct, conventionally named setup files are considered; never recurse
+  // into credential/config folders or expose their complete contents.
+  for (const entry of entries.filter((entry) => entry.isFile() && /^[a-z0-9][a-z0-9_-]{0,79}\.json$/i.test(entry.name)).slice(0, 64)) {
+    try {
+      const config = JSON.parse(await readSmallLocalFile(join(stateDir, entry.name)))
+      if (!config?.slug || entry.name !== `${config.slug}.json`) continue
+      const backend = config.mode === 'backend' && typeof config.identifier === 'string' && config.identifier && typeof config.apiKey === 'string'
+      const relay = typeof config.host === 'string' && typeof config.key === 'string'
+      if (!backend && !relay) continue
+      let pid = null, watcherAlive = null
+      const lock = await readSmallLocalFile(join(stateDir, `watch-${config.slug}.lock`), 64).catch(() => null)
+      if (/^\d+\s*$/.test(lock || '')) { pid = Number(lock.trim()); watcherAlive = pidAlive(pid) }
+      const identifier = backend ? config.identifier : config.slug
+      agents.push(sanitizeJournalData({ id: identifier, identifier, slug: config.slug, name: config.name || config.slug, provider: config.agent || 'claude', configured: true, runId: null, pid, watcherAlive, status: 'uninstrumented', lastSeen: null, lastEventType: null }))
+    } catch { /* unrelated, malformed or concurrently replaced setup file */ }
+  }
+  return agents
+}
+
+export async function readStudioSnapshot({ stateDir, now = Date.now }) {
+  const warnings = [], directory = join(stateDir, 'observability')
+  let files = []
+  try {
+    const entry = await lstat(directory)
+    if (!entry.isDirectory() || entry.isSymbolicLink()) throw new Error('Observability path is not a real directory')
+    const entries = await readdir(directory, { withFileTypes: true })
+    files = (await Promise.all(entries.filter((entry) => entry.isFile() && entry.name.endsWith('.jsonl')).slice(0, 256).map(async (entry) => {
+      const path = join(directory, entry.name)
+      const metadata = await lstat(path).catch(() => null)
+      return metadata?.isFile() && !metadata.isSymbolicLink() ? { path, modified: metadata.mtimeMs } : null
+    }))).filter(Boolean).sort((a, b) => b.modified - a.modified).slice(0, MAX_FILES)
+    if (entries.length > MAX_FILES) warnings.push('The viewer is showing a bounded tail of the most recently updated agent journals.')
+  } catch (error) { if (error.code !== 'ENOENT') warnings.push('Agent journals are currently unavailable.') }
+  const collected = []
+  let remaining = MAX_TOTAL_BYTES
+  for (const file of files) {
+    if (remaining <= 0) break
+    try {
+      const result = await tailEvents(file.path, Math.min(MAX_FILE_BYTES, remaining))
+      remaining -= result.bytes
+      collected.push(...result.events)
+    } catch { /* rotation or removal raced the read; retry next snapshot */ }
+  }
+  const events = [...new Map(collected.map((event) => [event.id, event])).values()].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp) || (a.runId === b.runId ? Number(a.sequence || 0) - Number(b.sequence || 0) : 0))
+  const latest = new Map()
+  for (const event of events) latest.set(event.agent.identifier, event)
+  const configured = await configuredAgents(stateDir)
+  const agentsById = new Map(configured.map((agent) => [agent.identifier, agent]))
+  for (const event of latest.values()) {
+    const age = now() - Date.parse(event.timestamp)
+    const online = age >= -5000 && age <= FRESH_MS && event.type !== 'runtime.stopped' && pidAlive(event.pid)
+    const existing = agentsById.get(event.agent.identifier)
+    agentsById.set(event.agent.identifier, { ...existing, id: event.agent.identifier, identifier: event.agent.identifier, slug: event.agent.slug || event.agent.identifier, name: existing?.name || event.agent.slug || event.agent.identifier, provider: event.agent.provider || 'unknown', runId: event.runId, pid: Number.isSafeInteger(event.pid) ? event.pid : null, watcherAlive: online, status: online ? 'online' : 'offline', lastSeen: event.timestamp, lastEventType: event.type })
+  }
+  const agents = [...agentsById.values()].sort((a, b) => a.name.localeCompare(b.name))
+  return { schemaVersion: 1, demo: false, generatedAt: new Date(now()).toISOString(), agents, events: events.slice(-MAX_EVENTS), limits: { maxEvents: MAX_EVENTS, maxFiles: MAX_FILES, maxTotalBytes: MAX_TOTAL_BYTES }, warnings }
+}
+
+function demoSnapshot(stamp) {
+  const events = []
+  const agents = ['codex', 'opencode', 'claude'].map((provider, index) => ({ id: `demo-${provider}`, identifier: `demo-${provider}`, slug: ['Alex', 'Robin', 'Sam'][index], name: ['Alex', 'Robin', 'Sam'][index], provider, runId: `demo-run-${provider}`, pid: null, status: 'demo', demo: true, lastSeen: new Date(stamp).toISOString(), lastEventType: 'output.final' }))
+  for (const [index, agent] of agents.entries()) {
+    const cycleId = `${agent.runId}:cycle-1`, common = { cycleId, kind: 'full', lane: 'work', model: ['gpt-5.6-sol', 'openai/gpt-5.6-sol', 'claude-sonnet'][index], workdir: '/demo/workspace/ticket-77', ticket: { projectId: 5, ticketId: 77, slug: 'DEMO-77' }, watcherPid: null }
+    const rows = [
+      ['runtime.started', { status: 'simulated' }],
+      ['cycle.queued', { ...common, status: 'queued' }],
+      ['cycle.started', { ...common, status: 'running', queueMs: 24 }],
+      ['process.started', { ...common, runtime: 'ACP', runtimePid: null, status: 'connecting' }],
+      ['plan.updated', { ...common, entries: [{ content: 'Inspect the failing build', status: 'completed', priority: 'high' }, { content: 'Fix the module import and run tests', status: 'completed', priority: 'high' }, { content: 'Publish the verified result', status: 'completed', priority: 'normal' }] }],
+      ['tool.started', { ...common, toolCallId: 'demo-read', name: 'read_file', title: 'Read package.json', status: 'running', kind: 'read', locations: [{ path: 'package.json' }] }],
+      ['tool.finished', { ...common, toolCallId: 'demo-read', name: 'read_file', title: 'Read package.json', status: 'completed', kind: 'read', locations: [{ path: 'package.json' }] }],
+      ['output.progress', { ...common, text: 'I found the import that prevented the build from completing.' }],
+      ['tool.started', { ...common, toolCallId: 'demo-test', name: 'execute', title: 'Run the build and tests', status: 'running', kind: 'execute' }],
+      ['tool.finished', { ...common, toolCallId: 'demo-test', name: 'execute', title: 'Run the build and tests', status: 'completed', kind: 'execute' }],
+      ['output.final', { ...common, text: 'The module import is fixed. The build and 18 tests pass. This is simulated demonstration data.' }],
+      ['cycle.finished', { ...common, status: 'completed', durationMs: 24_000 }],
+      ['process.ready', { ...common, runtime: 'ACP', runtimePid: null, status: 'idle' }],
+    ]
+    for (const [offset, [type, data]] of rows.entries()) events.push({ schemaVersion: 1, id: `${agent.runId}:${offset + 1}`, sequence: offset + 1, runId: agent.runId, timestamp: new Date(stamp - 30_000 + index * 1000 + offset * 1500).toISOString(), type, agent: { identifier: agent.identifier, slug: agent.slug, provider: agent.provider }, pid: null, demo: true, data })
+  }
+  return { schemaVersion: 1, demo: true, generatedAt: new Date(stamp).toISOString(), agents, events: events.sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp)), limits: { maxEvents: MAX_EVENTS }, warnings: ['Demo mode contains simulated agent activity. No model or task is running.'] }
+}
+
+export async function startStudioServer({ stateDir, host = '127.0.0.1', port = 4317, assetsDir = DEFAULT_ASSETS, demo = false }) {
+  if (!['127.0.0.1', '::1', 'localhost'].includes(host)) throw new Error('Agent Studio can bind only to a loopback address')
+  if (!Number.isInteger(port) || port < 0 || port > 65535) throw new Error('Agent Studio port must be an integer from 0 to 65535')
+  if (!stateDir) throw new Error('Agent Studio requires a local state directory')
+  const bindHost = host === 'localhost' ? '127.0.0.1' : host
+  const root = await realpath(assetsDir)
+  const clients = new Set()
+  const demoState = demo ? demoSnapshot(Date.now()) : null
+  let current, pending, stopped = false, interval
+  const delivered = new WeakMap()
+  const fingerprint = (value) => createHash('sha256').update(JSON.stringify({ agents: value.agents, events: value.events, warnings: value.warnings })).digest('hex')
+  const snapshot = async () => {
+    if (pending) return pending
+    pending = (async () => {
+      current = demoState || await readStudioSnapshot({ stateDir })
+      return current
+    })().finally(() => { pending = null })
+    return pending
+  }
+  const headers = {
+    'cache-control': 'no-store', 'x-content-type-options': 'nosniff', 'referrer-policy': 'no-referrer',
+    'content-security-policy': "default-src 'self'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'self' data:; object-src 'none'; base-uri 'none'; frame-ancestors 'none'",
+    'x-frame-options': 'DENY', 'cross-origin-resource-policy': 'same-origin',
+  }
+  const sendSnapshot = (res, value) => {
+    if (res.writableNeedDrain) return
+    res.write(`event: snapshot\ndata: ${JSON.stringify(value)}\n\n`)
+    delivered.set(res, fingerprint(value))
+    if (res.writableLength > 8 * 1024 * 1024) { clients.delete(res); res.end() }
+  }
+  const server = createServer(async (req, res) => {
+    for (const [key, value] of Object.entries(headers)) res.setHeader(key, value)
+    try {
+      const boundPort = server.address().port
+      const allowedAuthorities = new Set([`127.0.0.1:${boundPort}`, `localhost:${boundPort}`, `[::1]:${boundPort}`])
+      if (!allowedAuthorities.has(String(req.headers.host || '').toLowerCase())) { res.writeHead(403); res.end('Invalid local host'); return }
+      if (req.headers.origin && ![...allowedAuthorities].some((authority) => req.headers.origin === `http://${authority}`)) { res.writeHead(403); res.end('Cross-origin access denied'); return }
+      if (req.headers['sec-fetch-site'] === 'cross-site') { res.writeHead(403); res.end('Cross-site access denied'); return }
+      if (!['GET', 'HEAD'].includes(req.method)) { res.writeHead(405, { allow: 'GET, HEAD' }); res.end('Read-only viewer'); return }
+      const path = new URL(req.url, `http://${req.headers.host}`).pathname
+      if (path === '/api/snapshot') { res.setHeader('content-type', 'application/json; charset=utf-8'); res.end(req.method === 'HEAD' ? undefined : JSON.stringify(await snapshot())); return }
+      if (path === '/api/events' && req.method === 'GET') {
+        if (clients.size >= 32) { res.writeHead(503); res.end('Too many local viewer connections'); return }
+        res.writeHead(200, { 'content-type': 'text/event-stream; charset=utf-8', connection: 'keep-alive' })
+        clients.add(res); req.on('close', () => clients.delete(res))
+        sendSnapshot(res, await snapshot())
+        return
+      }
+      const file = ({ '/': 'index.html', '/index.html': 'index.html', '/guide': 'guide.html', '/guide.html': 'guide.html', '/style.css': 'style.css', '/app.mjs': 'app.mjs' })[path]
+      if (!file) { res.writeHead(404); res.end('Not found'); return }
+      const target = await realpath(resolve(root, file))
+      const rel = relative(root, target)
+      if (rel.startsWith('..') || resolve(dirname(target)) !== root) { res.writeHead(403); res.end('Invalid asset'); return }
+      const body = await readFile(target)
+      res.setHeader('content-type', file.endsWith('.css') ? 'text/css; charset=utf-8' : file.endsWith('.mjs') ? 'text/javascript; charset=utf-8' : 'text/html; charset=utf-8')
+      res.end(req.method === 'HEAD' ? undefined : body)
+    } catch (error) {
+      if (!res.headersSent) res.writeHead(error.code === 'ENOENT' ? 404 : 500)
+      res.end('Local viewer request unavailable')
+    }
+  })
+  await new Promise((resolve, reject) => { server.once('error', reject); server.listen(port, bindHost, resolve) }).catch((error) => {
+    if (error.code === 'EADDRINUSE') throw Object.assign(new Error(`Agent Studio port ${port} is already in use. Choose another port with --port.`), { code: error.code })
+    throw error
+  })
+  let ticks = 0
+  interval = setInterval(async () => {
+    if (stopped || !clients.size) return
+    try {
+      const value = await snapshot()
+      const next = fingerprint(value)
+      for (const res of clients) if (delivered.get(res) !== next) sendSnapshot(res, value)
+      if (++ticks % 30 === 0) for (const res of clients) if (!res.writableNeedDrain) res.write(': heartbeat\n\n')
+    } catch { /* keep serving the next readable snapshot */ }
+  }, 500)
+  interval.unref?.()
+  let closing
+  const close = () => {
+    if (closing) return closing
+    stopped = true; clearInterval(interval)
+    for (const res of clients) res.end()
+    clients.clear(); server.closeAllConnections()
+    closing = new Promise((resolve) => server.close(resolve))
+    return closing
+  }
+  return { url: `http://${bindHost === '::1' ? '[::1]' : bindHost}:${server.address().port}`, close }
+}

package/src/task-types.mjs

@@ -1,4 +1,5 @@
 export function createTaskTypeLookup({ load, now = Date.now, ttlMs = 60_000 }) {
+  if (!Number.isFinite(ttlMs) || ttlMs < 0) throw new Error('Invalid task column cache lifetime')
   const cache = new Map(), pending = new Map()
   return async (projectId) => {
     const key = String(projectId)
@@ -6,9 +7,9 @@ export function createTaskTypeLookup({ load, now = Date.now, ttlMs = 60_000 }) {
     if (hit && hit.expiresAt > now()) return hit.value
     if (pending.has(key)) return pending.get(key)
     const request = Promise.resolve().then(() => load(projectId)).then((data) => {
-      const types = data.types ?? data.task_types ?? data.taskTypes
+      const types = data?.types ?? data?.task_types ?? data?.taskTypes
       if (!Array.isArray(types)) throw new Error('Cannot verify task columns')
-      const matching = (pattern) => new Set(types.filter((type) => pattern.test(String(type.name || ''))).map((type) => Number(type.id)))
+      const matching = (pattern) => new Set(types.filter((type) => type && ['number', 'string'].includes(typeof type.id) && Number.isSafeInteger(Number(type.id)) && Number(type.id) > 0 && pattern.test(String(type.name || ''))).map((type) => Number(type.id)))
       const value = {
         done: matching(/\b(?:done|complete|completed|closed|cancelled|canceled|archived|resolved)\b/i),
         review: matching(/\b(?:review|test|testing|qa|quality\s+assurance|verification|approval)\b/i),

package/src/thread-context.mjs

@@ -0,0 +1,62 @@
+import { messageParentId, messageSenderIsAgent, renderedAgentMessages } from './events.mjs'
+
+// An agent's own root post establishes a conversation, even if nobody tagged
+// the agent before replying. Verify the exact root, never mere participation.
+export function ownThreadRoot(thread, rootId, identity) {
+  if (rootId == null || String(rootId).trim() === '') return null
+  return renderedAgentMessages(thread, identity).find((row) => String(row.id) === String(rootId) && row.parentId == null) || null
+}
+
+function verifiedOtherAuthor(row, identity) {
+  const sender = [row.sender, row.user, row.author, row.member].find((value) => value && typeof value === 'object') || {}
+  if (messageSenderIsAgent(row)) {
+    const agent = [row.senderAgent, row.sender_agent, row.agent, sender.agent].find((value) => value && typeof value === 'object') || sender
+    const agentId = agent.id ?? agent.agent_id ?? row.agent_id ?? row.sender_agent_id ?? row.senderAgentId
+    const knownId = (id) => messageParentId({ parent_id: id }) != null
+    if (knownId(identity?.id) && knownId(agentId)) return Number(agentId) !== Number(identity.id)
+    const identifier = agent.identifier ?? agent.slug ?? row.agent_identifier ?? row.sender_identifier
+    return !!identifier && !!identity?.identifier && String(identifier).toLowerCase() !== String(identity.identifier).toLowerCase()
+  }
+  const kind = String(sender.type ?? sender.kind ?? row.sender_type ?? row.author_type ?? '').toLowerCase()
+  return /^(?:human|user|member|person)$/.test(kind) || typeof sender.email === 'string' || messageParentId({ parent_id: row.sender_id ?? row.user_id ?? row.author_id }) != null
+}
+
+function containsRoot(value, rootId, identity, depth = 0) {
+  if (!value || depth > 6) return false
+  if (Array.isArray(value)) return value.some((row) => containsRoot(row, rootId, identity, depth + 1))
+  if (typeof value !== 'object') return false
+  if (String(value.message_id ?? value.messageId ?? value.id) === String(rootId) && messageParentId(value) == null && typeof (value.content ?? value.body ?? value.text) === 'string' && verifiedOtherAuthor(value, identity)) return true
+  return ['messages', 'replies', 'items', 'data', 'result', 'thread', 'message', 'root'].some((key) => containsRoot(value[key], rootId, identity, depth + 1))
+}
+
+export function createThreadContextResolver({ read, save, cancelled, load, identity, now = Date.now }) {
+  const pending = new Map()
+  const otherRoots = new Map()
+  return async (channelId, rootId) => {
+    if (channelId == null || rootId == null || cancelled(channelId, rootId)) return ''
+    const cached = read(channelId, rootId)
+    if (cached) return cached
+    const key = `${channelId}:${rootId}`
+    const currentIdentity = identity()
+    const identityKey = JSON.stringify([currentIdentity?.id, currentIdentity?.identifier, currentIdentity?.slug])
+    const previous = otherRoots.get(key)
+    if (previous?.identityKey === identityKey && previous.until > now()) return ''
+    if (!pending.has(key)) {
+      const request = Promise.resolve().then(() => load(channelId, rootId)).then((thread) => {
+        const root = ownThreadRoot(thread, rootId, identity())
+        // Organization fanout repeats unrelated human threads. Cache only an
+        // observed non-owned root, never an unavailable/incomplete API result.
+        if (!root && containsRoot(thread, rootId, identity())) {
+          otherRoots.delete(key)
+          otherRoots.set(key, { identityKey, until: now() + 60_000 })
+          while (otherRoots.size > 256) otherRoots.delete(otherRoots.keys().next().value)
+        }
+        if (!root || cancelled(channelId, rootId)) return ''
+        save(channelId, rootId, root.content)
+        return root.content
+      }).finally(() => pending.delete(key))
+      pending.set(key, request)
+    }
+    return pending.get(key)
+  }
+}