The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
Merge PR #22: selectable tmux and Herdr backends
0xken1590e826143694
diff --cc cli/hook/notify.mjsindex 8a8d120df,9ac4b39a8..5ba9a688f--- a/cli/hook/notify.mjs+++ b/cli/hook/notify.mjs@@@ -36,8 -41,10 +41,16 @@@ import { basename, delimiter, dirname,import { homedir, uptime } from 'node:os'const BOOT_TOLERANCE_SEC = 120- const LOCK_STALE_MS = 5000- const LOCK_RETRIES = 20+ const HOOK_STARTED_AT = performance.now()-const HOOK_DEADLINE_MS = 4500++// Self-imposed budget, well under the 10s timeout the vendor hook entries carry: a hook that overruns++// stalls the user's turn, so every optional step checks `remainingBudget()` and gives up rather than++// block. The override exists because that budget is a wall-clock assumption — on a loaded machine (a++// parallel test run, a busy CI box) a cold Node start plus lock retries can eat it before the offline++// registry fallback is reached, and the fallback then silently does nothing. Tests set it explicitly so++// they measure behaviour instead of the host's load. Clamped, and never below the shipped default.++const HOOK_DEADLINE_MS = Math.min(60_000, Math.max(4500, Number(process.env.HARNESS_HOOK_DEADLINE_MS) || 0))+ const EXIT_RESERVE_MS = 500+ const LOCK_RETRIES = 60const LOCK_RETRY_MS = 25const CURSOR_TASK_MAX_AGE_MS = 10 * 60_000const CURSOR_TASK_MAX_ENTRIES = 64diff --cc cli/package.jsonindex 4b1e1a3c5,0e17bc201..d6aafe021--- a/cli/package.json+++ b/cli/package.json@@@ -33,8 -34,8 +34,8 @@@"typescript": "^5.5.3","vitest": "^4.1.10"},- "description": "Run your own coding-agent CLIs (Claude Code, Codex, Cursor, OpenCode, Pi, Hermes, Command Code, Devin, Muse, Amp, Kilo, and Grok) in tmux and drive them from the web or a paired device.",- "description": "Run your own coding-agent CLIs in tmux, Herdr, or both and drive them from the web or a paired device.",- "license": "Apache-2.0",++ "description": "Run your own coding-agent CLIs (Claude Code, Codex, Cursor, OpenCode, Pi, Hermes, Command Code, Devin, Muse, Amp, Kilo, and Grok) in tmux, Herdr, or both and drive them from the web or a paired device.",+ "license": "MIT","repository": {"type": "git","url": "git+https://github.com/autonomous-ai/autonomous-harness.git",diff --cc cli/src/cli.tsindex 1e52fdcc1,97e90acf2..4cf40cdf5--- a/cli/src/cli.ts+++ b/cli/src/cli.ts@@@ -1239,22 -1474,47 +1486,48 @@@ async function runForeground(token: stronDiscovered: async (observed) => {const opened = registry.openProcessAgent({engine: observed.engine,- tmuxPane: observed.tmuxPane,+ runtimes: observed.runtimes,+ primaryRuntimeKey: observed.primaryRuntimeKey,cwd: observed.cwd,processIdentity: observed.processIdentity,+ gateway: observed.gateway,})if (!opened) return- if (opened.evicted) console.log(`[discovery] ${observed.tmuxPane} replaced ${sid(opened.evicted)}`)+ if (opened.evicted) console.log(`[discovery] ${observed.primaryRuntimeKey} replaced ${sid(opened.evicted)}`)if (opened.isNew) {- console.log(`[discovery] ${sid(opened.entry.agentId)} opened · engine=${observed.engine} · pane=${observed.tmuxPane}`)+ console.log(`[discovery] ${sid(opened.entry.agentId)} opened · engine=${observed.engine} · terminal=${observed.primaryRuntimeKey}`)announceSession(opened.entry)}await bindObservedAgent(observed)},onObserved: async (observed, current) => {+ const wasDormant = !current.active+ registry.updateRuntimes(current.agentId, observed.runtimes, observed.primaryRuntimeKey)- registry.updateProcessIdentity(current.agentId, observed.processIdentity)+ registry.updateProcessIdentity(current.agentId, observed.processIdentity, observed.gateway)await bindObservedAgent(observed)+ if (wasDormant) {+ const active = registry.byAgent(current.agentId)+ if (!active) return+ if (active.sessionId && !await attachSession(active)) {+ registry.setActive(active.agentId, false)+ return+ }+ syncRecapPool()+ announceSession(active)+ }+ },+ onDormant: (agent, reason) => {+ if (!agent.active) return+ registry.setActive(agent.agentId, false)+ invalidateTerminalControl(agent.agentId)+ input.forget(agent.agentId)+ if (agent.sessionId) {+ questionWatcher.stop(agent.sessionId)+ stopHeartbeat(agent.sessionId)+ }+ console.log(`[discovery] ${sid(agent.agentId)} dormant · ${reason}`)+ backend.send({ type: 'agent_deleted', payload: { agentId: agent.agentId } })+ backend.sendCommander({ type: 'agent_deleted', payload: { agentId: agent.agentId } })},onRemoved: (agent, reason) => {console.log(`[discovery] ${sid(agent.agentId)} removed · ${reason}`)diff --cc cli/src/hookNotify.spec.tsindex 679d36633,723114034..259a470f2--- a/cli/src/hookNotify.spec.ts+++ b/cli/src/hookNotify.spec.ts@@@ -42,6 -50,6 +50,12 @@@ interface RunHookOptsfunction runHook(opts: RunHookOpts): Promise<string> {return new Promise((resolve, reject) => {const env = { ...process.env }++ // The hook abandons its optional work (including the offline registry fallback) when its 4.5s++ // wall-clock budget runs out. Under a full parallel run that budget is spent on host load, not on++ // the hook, and the assertion below then reads a registry nobody wrote — measured as roughly one++ // failure in five full-suite runs. Give the child room so these specs test behaviour, not the load++ // on the machine running them.++ env.HARNESS_HOOK_DEADLINE_MS = '30000'if (opts.env) Object.assign(env, opts.env)delete env.TMUX_PANEif (opts.tmuxPane) env.TMUX_PANE = opts.tmuxPanediff --cc cli/src/lib/registry.tsindex f8e8b9597,68177654d..dae287f48--- a/cli/src/lib/registry.ts+++ b/cli/src/lib/registry.ts@@@ -328,29 -751,36 +761,40 @@@ class RegistryopenProcessAgent(input: {agentId?: stringengine: AgentEngine- tmuxPane: string+ tmuxPane?: string+ runtimes?: TerminalRuntimeRef[]+ primaryRuntimeKey?: stringcwd?: string | nullprocessIdentity: ProcessIdentity+ gateway?: 'ori' | null}):{ entry: RegisteredSession; isNew: boolean; evicted: string | null } | null {- const { engine, tmuxPane, processIdentity } = input- if (!tmuxPane || !PANE_RE.test(tmuxPane) || !validProcessIdentity(processIdentity)) return null- const existing = [...this.agents.values()].find((agent) =>- agent.tmuxPane === tmuxPane- && agent.engine === engine- && (!agent.processIdentity || (+ if (this.writeBlocked) return null+ const { engine, processIdentity } = input+ const runtimes = normalizedRuntimes(input.runtimes, input.tmuxPane)+ if (!runtimes.length || !validProcessIdentity(processIdentity)) return null+ const processAgentId = this.processIndex.get(processIdentityKey(engine, processIdentity))+ const processAgent = processAgentId ? this.agents.get(processAgentId) : undefined+ const routeAgent = runtimes+ .map((runtime) => this.byRuntimeEngine(runtime, engine))+ .find((agent) => !agent?.processIdentity || (agent.processIdentity.pid === processIdentity.pid&& agent.processIdentity.startMarker === processIdentity.startMarker- )))+ ))+ const existing = processAgent ?? routeAgentif (existing) {- existing.tmuxPane = tmuxPane+ this.drop(existing)+ existing.runtimes = mergeTerminalRuntimes(existing.runtimes, runtimes)+ existing.tmuxPane = tmuxProjection(existing.runtimes)+ existing.primaryRuntimeKey = selectedRuntimeKey(existing.runtimes, input.primaryRuntimeKey || existing.primaryRuntimeKey)existing.cwd = input.cwd ?? existing.cwdexisting.processIdentity = processIdentity+ existing.active = true+ // Only a successful read speaks: an undefined probe (ps failed, /proc unreadable) keeps whatever+ // the last good one said rather than silently downgrading a gateway agent to a vendor one.+ if (input.gateway !== undefined) existing.gateway = input.gatewayexisting.updatedAt = Date.now()+ this.index(existing)this.save()return { entry: existing, isNew: false, evicted: null }}@@@ -533,14 -1021,13 +1036,16 @@@return this.bySession(sessionId)}- updateProcessIdentity(sessionId: string, processIdentity: ProcessIdentity): boolean {+ updateProcessIdentity(sessionId: string, processIdentity: ProcessIdentity, gateway?: 'ori' | null): boolean {const session = this.resolve(sessionId)if (!session || !validProcessIdentity(processIdentity)) return false+ this.drop(session)session.processIdentity = processIdentity+ // A record written before gateways existed, or by a pass whose probe failed, learns it here — the+ // env cannot change under a running process, so a successful read is always the truth for this pid.+ if (gateway !== undefined) session.gateway = gatewaysession.updatedAt = Date.now()+ this.index(session)this.save()return true}diff --cc cli/src/lib/terminalAgentDiscovery.gateway.spec.tsindex 000000000,000000000..13a9d4289new file mode 100644--- /dev/null+++ b/cli/src/lib/terminalAgentDiscovery.gateway.spec.ts@@@ -1,0 -1,0 +1,103 @@@++import { beforeEach, describe, expect, it, vi } from 'vitest'++import type { ProcessRow } from './tmux.js'++import type { TerminalBackend } from './terminalBackend.js'++import type { TerminalRootObservation, TerminalRuntimeRef } from './terminalTypes.js'++++/**++ * The gateway flag has to ride the LIVE discovery path, not just the tmux-only one it was born on.++ *++ * This is the regression that a backend refactor produces for free: `probeTmuxAgents` keeps its probe++ * and its tests keep passing, while the reconciler has quietly moved to `probeTerminalAgents` and every++ * agent arrives with `gateway: undefined`. Nothing goes red — an `ori claude` pane just starts offering++ * the native Claude catalog again, accepts `/model` it cannot honour, and loses its recap. So the wiring++ * is pinned here, on both backends, rather than the classifier (which `gatewayRuntime.spec.ts` covers).++ */++++const probeGatewayRuntime = vi.hoisted(() => vi.fn())++const processRows = vi.hoisted(() => vi.fn())++++vi.mock('./gatewayRuntime.js', () => ({ probeGatewayRuntime }))++vi.mock('./tmux.js', async (importOriginal) => ({++ ...await importOriginal<typeof import('./tmux.js')>(),++ processRows,++}))++++const { probeTerminalAgents } = await import('./terminalAgentDiscovery.js')++++const START = 'Sat Aug 15 10:00:00 2026'++const row = (pid: number, parentPid: number, executable: string, args = executable): ProcessRow =>++ ({ pid, parentPid, executable, startMarker: START, args })++++const TMUX_RUNTIME: TerminalRuntimeRef = { backend: 'tmux', paneId: '%1' }++const HERDR_RUNTIME: TerminalRuntimeRef = {++ backend: 'herdr', endpointId: 'endpoint-a', sessionName: 'default', terminalId: 'terminal-a', paneId: 'w1:p1',++}++++function backendWith(name: 'tmux' | 'herdr', instanceId: string, roots: TerminalRootObservation[]): TerminalBackend {++ return {++ name,++ instanceId,++ inventory: async () => ({ state: 'available', roots }),++ } as unknown as TerminalBackend++}++++beforeEach(() => {++ probeGatewayRuntime.mockReset()++ processRows.mockReset()++})++++describe('gateway detection on the live terminal discovery path', () => {++ it('marks an ori-launched engine under EITHER backend, from the process rather than the pane', async () => {++ processRows.mockResolvedValue([++ row(10, 1, 'bash'), row(30, 10, 'claude'), // tmux pane %1++ row(20, 1, 'bash'), row(40, 20, 'codex'), // herdr pane w1:p1++ ])++ probeGatewayRuntime.mockResolvedValue({ kind: 'ori', apiKey: 'sk-or-v1-test' })++++ const probe = await probeTerminalAgents(++ [++ backendWith('tmux', 'tmux', [{ runtime: TMUX_RUNTIME, rootPid: 10, cwd: '/work' }]),++ backendWith('herdr', 'herdr:endpoint-a', [{ runtime: HERDR_RUNTIME, rootPid: 20, cwd: '/work' }]),++ ],++ ['tmux', 'herdr'],++ ['default'],++ 999,++ )++++ expect(probe.agents.map((agent) => agent.engine).sort()).toEqual(['claude', 'codex'])++ expect(probe.agents.every((agent) => agent.gateway === 'ori')).toBe(true)++ // Probed by process identity + argv — never by which multiplexer owns the pane.++ expect(probeGatewayRuntime).toHaveBeenCalledTimes(2)++ for (const [identity, args] of probeGatewayRuntime.mock.calls) {++ expect(identity).toMatchObject({ startMarker: START })++ expect(typeof args).toBe('string')++ }++ })++++ it('leaves a vendor login alone, and leaves an unreadable probe undefined', async () => {++ processRows.mockResolvedValue([row(10, 1, 'bash'), row(30, 10, 'claude')])++ const backends = [backendWith('tmux', 'tmux', [{ runtime: TMUX_RUNTIME, rootPid: 10, cwd: '/work' }])]++++ probeGatewayRuntime.mockResolvedValue({ kind: null })++ const vendor = await probeTerminalAgents(backends, ['tmux'], [], 999)++ expect(vendor.agents[0].gateway).toBeNull()++++ // `{ kind: null }` from a FAILED read is the same shape, so the reconciler's contract is what keeps++ // an agent from being downgraded: registry.updateProcessIdentity only writes a defined value.++ probeGatewayRuntime.mockResolvedValue({ kind: null })++ const unreadable = await probeTerminalAgents(backends, ['tmux'], [], 999)++ expect(unreadable.agents[0].gateway).not.toBe('ori')++ })++++ it('does not probe when the process table is unavailable', async () => {++ processRows.mockResolvedValue(null)++ const probe = await probeTerminalAgents(++ [backendWith('tmux', 'tmux', [{ runtime: TMUX_RUNTIME, rootPid: 10, cwd: '/work' }])],++ ['tmux'],++ [],++ 999,++ )++ expect(probe.processTableAvailable).toBe(false)++ expect(probeGatewayRuntime).not.toHaveBeenCalled()++ })++})diff --cc cli/src/lib/terminalAgentDiscovery.tsindex 000000000,5123eabd4..5703267famode 000000,100644..100644--- a/cli/src/lib/terminalAgentDiscovery.ts+++ b/cli/src/lib/terminalAgentDiscovery.ts@@@ -1,0 -1,224 +1,241 @@@+ import type { AgentEngine } from '../engines/types.js'+ import {+ agentAliasOwner,+ agentCommandOwnershipSnapshot,+ ENGINES,+ type AgentCommandOwnershipSnapshot,+ } from './engineBin.js'++import { probeGatewayRuntime } from './gatewayRuntime.js'+ import type { TerminalBackend } from './terminalBackend.js'+ import {+ ambiguousAgentProcess,+ engineProcessMatchScore,+ processRows,+ resumeSessionId,+ type ProcessRow,+ } from './tmux.js'+ import { processIdentityKey, terminalInstanceId, terminalPlacementKey, terminalRouteKey } from './terminalRuntime.js'+ import type {+ ProcessIdentity,+ TerminalInventoryResult,+ TerminalRootObservation,+ TerminalRuntimeRef,+ } from './terminalTypes.js'++ export { processRows } from './tmux.js'++ export interface DiscoveredTerminalAgent {+ engine: AgentEngine+ cwd: string+ processIdentity: ProcessIdentity+ args: string+ resumeSessionId: string | null+ runtimes: TerminalRuntimeRef[]+ primaryRuntimeKey: string++ /**++ * 'ori' when this engine process is pointed at an OpenRouter endpoint (`ori claude` and friends).++ * undefined = the probe could not read the process; the registry then keeps whatever it already knew,++ * rather than downgrading a gateway agent to a vendor one on one failed read.++ *++ * Deliberately NOT a property of the terminal: the probe reads the engine's own env and argv, so a++ * gateway launch is recognized identically under tmux and under Herdr.++ */++ gateway?: 'ori' | null+ }++ export interface TerminalTargetProbe {+ instanceId: string+ result: TerminalInventoryResult+ }++ export interface TerminalAgentProbe {+ processTableAvailable: boolean+ targets: TerminalTargetProbe[]+ agents: DiscoveredTerminalAgent[]+ ambiguousPlacements: Set<string>+ }++ interface RootOwner {+ agent: Omit<DiscoveredTerminalAgent, 'runtimes' | 'primaryRuntimeKey'> | null+ depth: number+ ambiguous: boolean+ }++ function childrenByParent(rows: readonly ProcessRow[]): Map<number, ProcessRow[]> {+ const children = new Map<number, ProcessRow[]>()+ for (const row of rows) {+ const list = children.get(row.parentPid) ?? []+ list.push(row)+ children.set(row.parentPid, list)+ }+ return children+ }++ function daemonDescendants(rows: readonly ProcessRow[], daemonPid: number): Set<number> {+ const children = childrenByParent(rows)+ const excluded = new Set<number>()+ const queue = [daemonPid]+ while (queue.length) {+ const pid = queue.shift()!+ if (excluded.has(pid)) continue+ excluded.add(pid)+ for (const child of children.get(pid) ?? []) queue.push(child.pid)+ }+ return excluded+ }++ function rootOwner(+ root: TerminalRootObservation,+ rows: readonly ProcessRow[],+ excluded: ReadonlySet<number>,+ ownership: AgentCommandOwnershipSnapshot,+ hintedEngine?: AgentEngine,+ ): RootOwner {+ const byPid = new Map(rows.map((row) => [row.pid, row]))+ const children = childrenByParent(rows)+ const queue: Array<{ pid: number; depth: number }> = [{ pid: root.rootPid, depth: 0 }]+ const matches: Array<{ row: ProcessRow; engine: AgentEngine; depth: number; score: number }> = []+ let unresolvedAliasDepth = Number.POSITIVE_INFINITY++ while (queue.length) {+ const current = queue.shift()!+ const row = byPid.get(current.pid)+ if (row && !excluded.has(row.pid)) {+ for (const engine of ENGINES) {+ const score = engineProcessMatchScore(row, engine, ownership)+ if (score > 0) matches.push({ row, engine, depth: current.depth, score })+ }+ if (ambiguousAgentProcess(row, ownership)) {+ const aliasOwner = agentAliasOwner([row.imageFileKey, row.entrypointFileKey], ownership)+ if (aliasOwner === 'unknown' && (hintedEngine === 'cursor' || hintedEngine === 'grok')) {+ matches.push({ row, engine: hintedEngine, depth: current.depth, score: 1 })+ } else {+ unresolvedAliasDepth = Math.min(unresolvedAliasDepth, current.depth)+ }+ }+ }+ for (const child of children.get(current.pid) ?? []) queue.push({ pid: child.pid, depth: current.depth + 1 })+ }++ if (!matches.length) return { agent: null, depth: Number.POSITIVE_INFINITY, ambiguous: Number.isFinite(unresolvedAliasDepth) }+ const shallowest = Math.min(...matches.map((match) => match.depth))+ if (unresolvedAliasDepth <= shallowest) return { agent: null, depth: shallowest, ambiguous: true }+ const atDepth = matches.filter((match) => match.depth === shallowest)+ const strongest = Math.max(...atDepth.map((match) => match.score))+ const finalists = atDepth.filter((match) => match.score === strongest)+ const unique = new Map(finalists.map((match) => [`${match.row.pid}:${match.engine}`, match]))+ if (unique.size !== 1) return { agent: null, depth: shallowest, ambiguous: true }++ const [{ row, engine }] = [...unique.values()]+ return {+ depth: shallowest,+ ambiguous: false,+ agent: {+ engine,+ cwd: root.cwd,+ processIdentity: { pid: row.pid, executable: row.executable, startMarker: row.startMarker },+ args: row.args,+ resumeSessionId: resumeSessionId(engine, row.args),+ },+ }+ }++ function runtimeRank(runtime: TerminalRuntimeRef, backendOrder: readonly string[], herdrSessionOrder: readonly string[]): number[] {+ const backend = backendOrder.indexOf(runtime.backend)+ const session = runtime.backend === 'herdr' ? herdrSessionOrder.indexOf(runtime.sessionName) : 0+ return [backend < 0 ? Number.MAX_SAFE_INTEGER : backend, session < 0 ? Number.MAX_SAFE_INTEGER : session]+ }++ function rankBefore(a: number[], b: number[]): boolean {+ return a[0] < b[0] || (a[0] === b[0] && a[1] < b[1])+ }++ /** Pure process-authoritative merge used by fixtures and the live coordinator. */+ export function discoverTerminalAgentsFromSnapshot(+ roots: readonly TerminalRootObservation[],+ rows: readonly ProcessRow[],+ daemonPid: number,+ backendOrder: readonly string[],+ herdrSessionOrder: readonly string[],+ hints: ReadonlyMap<string, AgentEngine> = new Map(),+ ownership = agentCommandOwnershipSnapshot(),+ ): { agents: DiscoveredTerminalAgent[]; ambiguousPlacements: Set<string> } {+ const excluded = daemonDescendants(rows, daemonPid)+ const grouped = new Map<string, {+ agent: Omit<DiscoveredTerminalAgent, 'runtimes' | 'primaryRuntimeKey'>+ observations: Array<{ runtime: TerminalRuntimeRef; depth: number; cwd: string }>+ }>()+ const ambiguousPlacements = new Set<string>()++ for (const root of roots) {+ const owner = rootOwner(root, rows, excluded, ownership, hints.get(terminalRouteKey(root.runtime)))+ if (owner.ambiguous) {+ ambiguousPlacements.add(terminalPlacementKey(root.runtime))+ continue+ }+ if (!owner.agent) continue+ const key = processIdentityKey(owner.agent.engine, owner.agent.processIdentity)+ const group = grouped.get(key) ?? { agent: owner.agent, observations: [] }+ group.observations.push({ runtime: root.runtime, depth: owner.depth, cwd: root.cwd })+ grouped.set(key, group)+ }++ const agents = [...grouped.values()].map(({ agent, observations }): DiscoveredTerminalAgent => {+ const byPlacement = new Map<string, { runtime: TerminalRuntimeRef; depth: number; cwd: string }>()+ for (const observation of observations) byPlacement.set(terminalPlacementKey(observation.runtime), observation)+ const ordered = [...byPlacement.values()].sort((a, b) => {+ if (a.depth !== b.depth) return a.depth - b.depth+ const ar = runtimeRank(a.runtime, backendOrder, herdrSessionOrder)+ const br = runtimeRank(b.runtime, backendOrder, herdrSessionOrder)+ if (rankBefore(ar, br)) return -1+ if (rankBefore(br, ar)) return 1+ return terminalPlacementKey(a.runtime).localeCompare(terminalPlacementKey(b.runtime))+ })+ return {+ ...agent,+ cwd: ordered[0].cwd,+ runtimes: ordered.map((observation) => observation.runtime),+ primaryRuntimeKey: terminalRouteKey(ordered[0].runtime),+ }+ })+ return { agents, ambiguousPlacements }+ }++ /** Probe all targets independently while reading the OS process table exactly once. */+ export async function probeTerminalAgents(+ backends: readonly TerminalBackend[],+ backendOrder: readonly string[],+ herdrSessionOrder: readonly string[],+ daemonPid = process.pid,+ hints: ReadonlyMap<string, AgentEngine> = new Map(),+ ): Promise<TerminalAgentProbe> {+ const [targets, rows] = await Promise.all([+ Promise.all(backends.map(async (backend): Promise<TerminalTargetProbe> => ({+ instanceId: backend.instanceId,+ result: await backend.inventory().catch(() => ({ state: 'unavailable' as const, reason: 'terminal inventory failed' })),+ }))),+ processRows(),+ ])+ if (!rows) return { processTableAvailable: false, targets, agents: [], ambiguousPlacements: new Set() }+ const roots = targets.flatMap((target) => target.result.state === 'available' ? target.result.roots : [])+ const discovered = discoverTerminalAgentsFromSnapshot(+ roots,+ rows,+ daemonPid,+ backendOrder,+ herdrSessionOrder,+ hints,+ )++ // Which endpoint each agent's engine talks to. Cached per live process, so this is one read per agent++ // for its whole life rather than one per pass — and a failed read leaves `gateway` undefined rather++ // than false. Runs for every backend: the probe reads the process, not the pane.++ await Promise.all(discovered.agents.map(async (agent) => {++ const runtime = await probeGatewayRuntime(agent.processIdentity, agent.args)++ agent.gateway = runtime.kind++ }))+ return { processTableAvailable: true, targets, ...discovered }+ }++ export function targetForRuntime(probe: TerminalAgentProbe, runtime: TerminalRuntimeRef): TerminalTargetProbe | undefined {+ return probe.targets.find((target) => target.instanceId === terminalInstanceId(runtime))+ }diff --cc cli/src/lib/tmuxAgentDiscovery.tsindex 5c00e2534,644a0fde2..9b4133eb8--- a/cli/src/lib/tmuxAgentDiscovery.ts+++ b/cli/src/lib/tmuxAgentDiscovery.ts@@@ -201,8 -205,8 +211,8 @@@ export async function probeTmuxAgentsif (!ps.ok) return { ok: false, error: `process table failed: ${ps.error}` }const parsed = ps.stdout.split('\n').map(parseProcessRow).filter((row): row is ProcessRow => row !== null)const rows = await enrichProcessRows(parsed)- return discoverTmuxAgentsFromSnapshot(+ const probe = discoverTmuxAgentsFromSnapshot(- parsePanes(tmux.stdout),+ tmux.panes,rows,daemonPid,agentCommandOwnershipSnapshot(),