perf(agents): release published child payloads and index live work

This commit is contained in:
Brennan Benson
2026-11-08 20:25:30 -08:00
parent d714d577bf
commit 42a3262c2f
5 changed files with 194 additions and 55 deletions
+4 -3
View File
@@ -19,7 +19,7 @@ import type { AcpSubagentUpdate } from '../acp-dialects/acp-dialect'
type KnownSubagent = {
/** Pin replies to the spawning turn. */
placement: ProviderTimelineJoin
reply?: string
replyDigest?: string
/** Preserve the first terminal state; only completed runs can publish replies. */
ended?: NativeChatSubagentState
}
@@ -102,10 +102,11 @@ export class AcpSubagents {
}
private reply(id: string, subagent: KnownSubagent, text: string): ProviderTimelineEvent[] {
if (subagent.reply === text) {
const digest = createHash('sha256').update(text, 'utf16le').digest('hex')
if (subagent.replyDigest === digest) {
return []
}
subagent.reply = text
subagent.replyDigest = digest
return [
{
type: 'item.update',
@@ -35,6 +35,7 @@ export type CodexBackgroundCommandChange =
export class CodexBackgroundCommandTracker {
private readonly commands = new Map<string, Command>()
private readonly byThread = new Map<string, Set<string>>()
private readonly settled = new Set<string>()
constructor(private readonly primaryThreadId: string) {}
@@ -52,13 +53,20 @@ export class CodexBackgroundCommandTracker {
return null
}
this.commands.set(key, command)
const thread = this.byThread.get(command.threadId) ?? new Set<string>()
thread.add(key)
this.byThread.set(command.threadId, thread)
return this.liveChange(command)
}
/** A surviving process becomes background work when the turn that launched it ends. */
endTurn(threadId: string, turnId: string): CodexBackgroundCommandChange[] {
const backgrounded: CodexBackgroundCommandChange[] = []
for (const command of this.commands.values()) {
for (const key of this.byThread.get(threadId) ?? []) {
const command = this.commands.get(key)
if (!command) {
continue
}
if (
command.threadId === threadId &&
(command.turnId === turnId || command.turnId === null) &&
@@ -86,9 +94,7 @@ export class CodexBackgroundCommandTracker {
/** The thread closed: Codex stops its processes first, so none of them can report an exit. */
endThread(threadId: string): CodexBackgroundCommandChange[] {
return [...this.commands]
.filter(([, command]) => command.threadId === threadId)
.flatMap(([key]) => this.end(key) ?? [])
return [...(this.byThread.get(threadId) ?? [])].flatMap((key) => this.end(key) ?? [])
}
/** Its approval went unanswered until its turn ended, so its process never started. */
@@ -129,9 +135,10 @@ export class CodexBackgroundCommandTracker {
/** Live processes, including foreground tools that are absent from the strip. */
threadCommands(threadId: string): CodexBackgroundCommandChange[] {
return [...this.commands.values()]
.filter((command) => command.threadId === threadId)
.map((command) => this.liveChange(command))
return [...(this.byThread.get(threadId) ?? [])].flatMap((key) => {
const command = this.commands.get(key)
return command ? [this.liveChange(command)] : []
})
}
clear(): CodexBackgroundCommandChange[] {
@@ -143,6 +150,7 @@ export class CodexBackgroundCommandTracker {
})
)
this.commands.clear()
this.byThread.clear()
this.settled.clear()
return ended
}
@@ -152,6 +160,11 @@ export class CodexBackgroundCommandTracker {
const existing = this.commands.get(key)
if (existing) {
this.commands.delete(key)
const thread = this.byThread.get(existing.threadId)
thread?.delete(key)
if (thread?.size === 0) {
this.byThread.delete(existing.threadId)
}
}
this.rememberSettled(key)
return existing
@@ -11,11 +11,15 @@ import {
type CodexBackgroundTaskEvent
} from './codex-background-task-frames'
import { CodexSubagentExecutions } from './codex-subagent-executions'
import { CodexBackgroundCommandTracker } from './codex-background-command-tracker'
import {
CodexBackgroundCommandTracker,
type CodexBackgroundCommandChange
} from './codex-background-command-tracker'
import { CodexChildWorkEvidence } from './codex-child-work-evidence'
import type { CodexAbandonedCommand } from '../prompts/codex-prompt-registry'
import type { CodexStructuredSessionAdapterDeps } from '../session-lifecycle/codex-structured-session-state'
import { boundSubagentLabel } from '../../../native-chat/agent-session-journal/item-lifecycle/journal-subagent-item'
import { codexChildCommandDescription } from '../../../../shared/codex-child-command-description'
export type CodexChildWorkSink = {
deliver: (evidence: AgentChildWorkEvidence[]) => void
@@ -40,6 +44,7 @@ export type CodexTerminalStopSupport = 'supported' | 'unsupported' | 'unknown'
export class CodexBackgroundTaskTracker {
private publishedFingerprint = '[]'
private publishedState: AgentSessionBackgroundTaskState | null = null
private readonly projectedTasks = new Map<string, AgentSessionBackgroundTask>()
private readonly commands: CodexBackgroundCommandTracker
private readonly childWork: CodexChildWorkEvidence
private terminalStops: CodexTerminalStopSupport | 'probing' = 'unknown'
@@ -91,11 +96,18 @@ export class CodexBackgroundTaskTracker {
turns: { threadId: string; turnId: string }[]
terminals: { threadId: string; processId: string }[]
} {
const named = new Set(taskIds)
const lineage = this.executions
.workingChildren()
.filter((child) => named.has(child.agentThreadId))
.flatMap((child) => this.executions.lineage(child.agentThreadId))
const named = new Set(
taskIds.filter((id) => {
const child = this.executions.find(id)
return child?.registered && child.execution?.state === 'working'
})
)
const lineage = named.size
? this.executions.lineage(
named,
this.commands.liveCommands().map((command) => command.threadId)
)
: []
const threads = [...new Set(lineage.map((child) => child.agentThreadId))]
return {
turns: threads.flatMap((threadId) => {
@@ -147,16 +159,16 @@ export class CodexBackgroundTaskTracker {
]
observeCodexExecutionFrame(this.executions, frame, this.primaryThreadId)
this.childWork.observe(event, frame, commands)
if (!frame) {
return itemEvent || commands.length > 0 ? this.refresh() : false
}
// Children can outlive the parent turn; republish without settling or sweeping them.
return this.refresh()
// The journal may have dirtied this shared registry before admitting the frame.
return this.updateProjection(this.executions.takeChangedThreads(), commands)
? this.refresh()
: false
}
clear(processExit?: StructuredAgentSessionEndedEvent['processExit']): boolean {
this.childWork.clear(this.commands.clear(), processExit)
this.executions.clear()
this.projectedTasks.clear()
return this.refresh()
}
@@ -188,6 +200,63 @@ export class CodexBackgroundTaskTracker {
]
}
private updateProjection(
threads: readonly string[],
commands: readonly CodexBackgroundCommandChange[]
): boolean {
let changed = false
for (const threadId of threads) {
const child = this.executions.find(threadId)
const task =
child?.registered && child.execution?.state === 'working'
? {
id: `codex-agent:${threadId}`,
kind: 'agent' as const,
...(child.label ? { description: boundSubagentLabel(child.label) } : {})
}
: null
changed = this.projectTask(`codex-agent:${threadId}`, task) || changed
for (const command of this.commands.threadCommands(threadId)) {
changed = this.projectCommand(command) || changed
}
}
for (const command of commands) {
changed = this.projectCommand(command) || changed
}
return changed
}
private projectCommand(command: CodexBackgroundCommandChange): boolean {
if (command.type === 'ended') {
return this.projectTask(command.taskId, null)
}
const child = this.executions.find(command.threadId)
if (!command.backgrounded || (child?.registered && child.execution?.state === 'working')) {
return this.projectTask(command.task.id, null)
}
const label =
command.threadId === this.primaryThreadId ? null : this.executions.label(command.threadId)
const task = label
? {
...command.task,
description: codexChildCommandDescription(label, command.task.description)
}
: command.task
return this.projectTask(task.id, task)
}
private projectTask(id: string, task: AgentSessionBackgroundTask | null): boolean {
if (task === null) {
return this.projectedTasks.delete(id)
}
const previous = this.projectedTasks.get(id)
if (previous?.kind === task.kind && previous.description === task.description) {
return false
}
this.projectedTasks.set(id, task)
return true
}
private refresh(): boolean {
const tasks = this.tasks()
const fingerprint = JSON.stringify(tasks)
@@ -207,14 +207,21 @@ export class CodexChildWorkEvidence {
const lastMessage = ofTurn(facts.lastMessage, turnId)?.text
const { totalTokens } = facts
const outcome = codexChildTurnOutcome(state)
this.publish(facts, JSON.stringify(['ended', turnId, state]), (observedAt) => ({
type: 'ended',
observedAt,
handle: { idKind: 'thread_id', id: threadId, runId: turnId },
outcome,
...(lastMessage ? { lastMessage } : {}),
...(totalTokens !== undefined ? { totalTokens } : {})
}))
const published = this.publish(
facts,
JSON.stringify(['ended', turnId, state]),
(observedAt) => ({
type: 'ended',
observedAt,
handle: { idKind: 'thread_id', id: threadId, runId: turnId },
outcome,
...(lastMessage ? { lastMessage } : {}),
...(totalTokens !== undefined ? { totalTokens } : {})
})
)
if (facts.lastMessage?.turnId === turnId && (published || state !== 'unverifiable')) {
facts.lastMessage = undefined
}
return
}
for (const [itemId, call] of facts.openCalls) {
@@ -267,19 +274,21 @@ export class CodexChildWorkEvidence {
}
}
private publish(facts: ChildFacts, fingerprint: string, edge: CodexPendingChildWork): void {
private publish(facts: ChildFacts, fingerprint: string, edge: CodexPendingChildWork): boolean {
if (facts.published !== fingerprint) {
facts.published = fingerprint
this.pending.push(edge)
return true
}
return false
}
// Reassert ownership for work admitted before its owner's record existed.
private requeueOwnedBy(threadId: string): void {
this.queueCommands(this.liveCommands(threadId))
for (const spawned of this.executions.workingChildren()) {
for (const spawned of this.executions.workingSpawnedBy(threadId)) {
const facts = this.facts.get(spawned.agentThreadId)
if (spawned.spawnerThreadId === threadId && facts?.published !== undefined) {
if (facts?.published !== undefined) {
facts.published = undefined
this.queueChild(spawned.agentThreadId)
}
@@ -15,6 +15,7 @@ export type CodexChildExecution = {
export type CodexExecutionChild = {
agentThreadId: string
observationOrder: number
registered: boolean
label: string | null
/** Spawn announcements arrive on the parent's thread. */
@@ -28,6 +29,9 @@ export type CodexExecutionChild = {
export class CodexSubagentExecutions {
private readonly children = new Map<string, CodexExecutionChild>()
private readonly settledTurns = new Map<string, NativeChatSubagentState>()
private readonly working = new Map<string, CodexExecutionChild>()
private readonly workingBySpawner = new Map<string, Set<CodexExecutionChild>>()
private readonly changed = new Set<string>()
register(
agentThreadId: string,
@@ -35,6 +39,7 @@ export class CodexSubagentExecutions {
spawnerThreadId?: string
): CodexExecutionChild {
const child = this.child(agentThreadId)
const previousLabel = child.label
// Keep the original spawner across duplicate announcement frames.
child.spawnerThreadId ??= spawnerThreadId ?? null
child.registered = true
@@ -44,6 +49,10 @@ export class CodexSubagentExecutions {
?.trim()
.replace(/\s+/g, ' ')
.slice(0, MAX_SUBAGENT_FIELD_CHARS + 1) || null
this.updateWorking(child)
if (previousLabel !== child.label) {
this.changed.add(agentThreadId)
}
return child
}
@@ -83,6 +92,7 @@ export class CodexSubagentExecutions {
}
if (state === 'working' || !child.execution || child.execution.turnId === turnId) {
child.execution = execution
this.updateWorking(child)
}
return { child, execution }
}
@@ -113,42 +123,53 @@ export class CodexSubagentExecutions {
return this.children.get(agentThreadId)
}
lineage(agentThreadId: string): CodexExecutionChild[] {
const spawnedByThread = new Map<string, string[]>()
for (const child of this.children.values()) {
if (child.spawnerThreadId === null) {
continue
}
const siblings = spawnedByThread.get(child.spawnerThreadId) ?? []
siblings.push(child.agentThreadId)
spawnedByThread.set(child.spawnerThreadId, siblings)
}
lineage(roots: ReadonlySet<string>, commandThreads: Iterable<string>): CodexExecutionChild[] {
const lineage: CodexExecutionChild[] = []
const seen = new Set<string>()
const pending = [agentThreadId]
for (let id = pending.pop(); id !== undefined; id = pending.pop()) {
const child = this.children.get(id)
if (!child || seen.has(id)) {
continue
const reachesRoot = new Map<string, boolean>()
const candidates = new Set([...this.working.keys(), ...commandThreads])
for (const threadId of candidates) {
let id = threadId
const path = new Set<string>()
while (!roots.has(id) && !reachesRoot.has(id) && !path.has(id)) {
path.add(id)
const spawner = this.children.get(id)?.spawnerThreadId
if (spawner === null || spawner === undefined) {
break
}
id = spawner
}
seen.add(id)
lineage.push(child)
for (const spawned of spawnedByThread.get(id) ?? []) {
pending.push(spawned)
const included = roots.has(id) || reachesRoot.get(id) === true
for (const ancestor of path) {
reachesRoot.set(ancestor, included)
}
const child = this.children.get(threadId)
if (included && child) {
lineage.push(child)
}
}
return lineage
}
workingChildren(): CodexExecutionChild[] {
return [...this.children.values()].filter(
(child) => child.registered && child.execution?.state === 'working'
)
return [...this.working.values()].sort((a, b) => a.observationOrder - b.observationOrder)
}
workingSpawnedBy(threadId: string): CodexExecutionChild[] {
return [...(this.workingBySpawner.get(threadId) ?? [])]
}
takeChangedThreads(): string[] {
const threads = [...this.changed]
this.changed.clear()
return threads
}
clear(): void {
this.children.clear()
this.settledTurns.clear()
this.working.clear()
this.workingBySpawner.clear()
this.changed.clear()
}
retentionSizes(): { children: number; settledTurns: number } {
@@ -162,6 +183,7 @@ export class CodexSubagentExecutions {
}
const child: CodexExecutionChild = {
agentThreadId,
observationOrder: this.children.size,
registered: false,
label: null,
spawnerThreadId: null,
@@ -173,6 +195,31 @@ export class CodexSubagentExecutions {
return child
}
private updateWorking(child: CodexExecutionChild): void {
const working = child.registered && child.execution?.state === 'working'
if (working !== this.working.has(child.agentThreadId)) {
this.changed.add(child.agentThreadId)
if (working) {
this.working.set(child.agentThreadId, child)
} else {
this.working.delete(child.agentThreadId)
}
}
const spawner = child.spawnerThreadId
if (spawner !== null) {
const children = this.workingBySpawner.get(spawner) ?? new Set<CodexExecutionChild>()
if (working) {
children.add(child)
this.workingBySpawner.set(spawner, children)
} else {
children.delete(child)
if (children.size === 0) {
this.workingBySpawner.delete(spawner)
}
}
}
}
private numberTurn(child: CodexExecutionChild, turnId: string): void {
if (child.turnOrdinals.has(turnId)) {
return