@meistrari/agent-core 0.2.0-experimental.9 → 0.3.1-experimental.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@meistrari/agent-core",
     "type": "module",
-    "version": "0.2.0-experimental.9",
+    "version": "0.3.1-experimental.0",
     "packageManager": "bun@1.3.12",
     "description": "Shared contracts and runtime modules for Tela coding-agent sandboxes: agent protocol, supervisor wire protocol, resident supervisor, worker runtime client, and Claude/Codex harness adapters.",
     "license": "UNLICENSED",

package/src/agents/codex/codex-event-mapper.ts

@@ -57,6 +57,9 @@ export interface CodexEventMapperState {
     readonly endedSubagentIds: Set<string>
     readonly subagentByThreadId: Map<string, CodexSubagentRef>
     readonly subagentById: Map<string, CodexSubagentRef>
+    readonly ownerTurnIdBySubagentId: Map<string, string>
+    readonly draftsAwaitingOwnerByActorId: Map<string, AgentEventDraft[]>
+    readonly unreportedEndedSubagentsByParent: Map<string, Map<string, string>>
     readonly subagentNameByThreadId: Map<string, string>
     readonly pendingDraftsByThreadId: Map<string, CodexUnownedTurnEventDraft[]>
     readonly turnErrorsById: Map<string, AgentError>
@@ -80,6 +83,9 @@ export function createCodexEventMapperState(): CodexEventMapperState {
         endedSubagentIds: new Set(),
         subagentByThreadId: new Map(),
         subagentById: new Map(),
+        ownerTurnIdBySubagentId: new Map(),
+        draftsAwaitingOwnerByActorId: new Map(),
+        unreportedEndedSubagentsByParent: new Map(),
         subagentNameByThreadId: new Map(),
         pendingDraftsByThreadId: new Map(),
         turnErrorsById: new Map(),
@@ -106,6 +112,52 @@ export function cacheCodexThreadMetadata(thread: CodexThreadMetadata, state: Cod
 }
 
 export function mapCodexNotification(notification: CodexNotification, state: CodexEventMapperState): AgentEventDraft[] {
+    return attributeSubagentDraftsToOwnerTurn(mapNotificationDrafts(notification, state), state)
+}
+
+function attributeSubagentDraftsToOwnerTurn(drafts: AgentEventDraft[], state: CodexEventMapperState): AgentEventDraft[] {
+    return drafts.flatMap(draft => attributeSubagentDraft(draft, state))
+}
+
+function attributeSubagentDraft(draft: AgentEventDraft, state: CodexEventMapperState): AgentEventDraft[] {
+    if (!('actor' in draft) || draft.actor.type !== 'subagent')
+        return [draft]
+    const { subagentId, parentActorId } = draft.actor
+    if (draft.type === 'turn.started' || draft.type === 'turn.ended')
+        return []
+    let ownerTurnId = state.ownerTurnIdBySubagentId.get(subagentId)
+    if (!ownerTurnId && draft.type === 'subagent.started') {
+        ownerTurnId = parentActorId === mainActor.actorId ? draft.turnId : state.ownerTurnIdBySubagentId.get(parentActorId)
+        if (ownerTurnId)
+            state.ownerTurnIdBySubagentId.set(subagentId, ownerTurnId)
+        else
+            return awaitOwner(parentActorId, draft, state)
+    }
+    if (!ownerTurnId && parentActorId === mainActor.actorId)
+        ownerTurnId = state.currentMainTurn.status === 'open' ? state.currentMainTurn.turnId : draft.turnId
+    if (!ownerTurnId)
+        return awaitOwner(subagentId, draft, state)
+    if (draft.type === 'subagent.ended') {
+        const pending = state.unreportedEndedSubagentsByParent.get(parentActorId) ?? new Map<string, string>()
+        pending.set(subagentId, draft.payload.status)
+        state.unreportedEndedSubagentsByParent.set(parentActorId, pending)
+    }
+    const attributed: AgentEventDraft = { ...draft, turnId: ownerTurnId }
+    if (draft.type !== 'subagent.started')
+        return [attributed]
+    const awaiting = state.draftsAwaitingOwnerByActorId.get(subagentId) ?? []
+    state.draftsAwaitingOwnerByActorId.delete(subagentId)
+    return [attributed, ...attributeSubagentDraftsToOwnerTurn(awaiting, state)]
+}
+
+function awaitOwner(actorId: string, draft: AgentEventDraft, state: CodexEventMapperState): AgentEventDraft[] {
+    const awaiting = state.draftsAwaitingOwnerByActorId.get(actorId) ?? []
+    awaiting.push(draft)
+    state.draftsAwaitingOwnerByActorId.set(actorId, awaiting)
+    return []
+}
+
+function mapNotificationDrafts(notification: CodexNotification, state: CodexEventMapperState): AgentEventDraft[] {
     // Codex has many app-server notifications; the runtime maps the subset that has a provider-neutral AgentEvent.
 
     switch (notification.method) {
@@ -265,11 +317,11 @@ function toolCallStart(item: CodexStartedItem): { toolName: string, input: JsonV
         return undefined
 
     if (item.type === 'commandExecution')
-        return { toolName, input: toJsonObject({ command: Array.isArray(item.command) ? item.command.join(' ') : String(item.command ?? ''), cwd: item.cwd }) }
+        return { toolName, input: toJsonObject({ command: unwrapShellCommand(Array.isArray(item.command) ? item.command.join(' ') : String(item.command ?? '')), cwd: item.cwd }) }
     if (item.type === 'webSearch')
         return { toolName, input: toJsonObject({ query: optionalNonEmpty(item.query) }) }
     if (item.type === 'fileChange')
-        return { toolName, input: jsonInput({ files: item.changes.map(change => removeUndefined({ path: change.path, kind: change.kind?.type })) }) }
+        return { toolName, input: jsonInput({ file_path: item.changes.map(change => change.path).join(', '), files: item.changes.map(change => removeUndefined({ path: change.path, kind: change.kind?.type })) }) }
     if (item.type === 'imageView')
         return { toolName, input: toJsonObject({ path: item.path }) }
     if (item.type === 'imageGeneration')
@@ -283,6 +335,17 @@ function toolCallStart(item: CodexStartedItem): { toolName: string, input: JsonV
     return undefined
 }
 
+const SHELL_WRAPPER = /^(?:\/(?:usr\/)?bin\/)?(?:ba|z)?sh -l?c (?:'((?:[^']|'\\'')*)'|"((?:[^"\\]|\\.)*)")$/s
+
+export function unwrapShellCommand(command: string): string {
+    const match = SHELL_WRAPPER.exec(command.trim())
+    if (!match)
+        return command
+    if (match[1] !== undefined)
+        return match[1].replaceAll(`'\\''`, `'`)
+    return match[2]!.replace(/\\([\\"$`])/g, '$1')
+}
+
 function toolNameForItem(item: CodexStartedItem | CodexCompletedItem): string | undefined {
     if (item.type === 'commandExecution')
         return CANONICAL_TOOL.bash
@@ -586,6 +649,7 @@ function mapCollabAgentToolCompleted({ turnId, threadId, item, mapperState }: {
                 toolCallId: item.id,
                 toolName: item.tool,
                 status: item.status === 'failed' ? 'failed' as const : 'completed' as const,
+                output: item.status === 'failed' ? undefined : collabToolOutput(collabToolSummary(item, mapperState)),
                 error: item.status === 'failed' ? { message: `Codex ${item.tool} failed.` } : undefined,
             }),
         },
@@ -666,7 +730,7 @@ function mapSubAgentActivityCompleted(input: { turnId: string, threadId: string,
         state.subagentById.set(item.agentThreadId, actor)
         return [
             ...emitOrBufferByThread({ draft: { type: 'tool.call.started', turnId, payload: { toolCallId: item.id, toolName: 'spawnAgent' } }, threadId, state }),
-            ...emitOrBufferByThread({ draft: { type: 'tool.call.completed', turnId, payload: { toolCallId: item.id, toolName: 'spawnAgent', status: 'completed' } }, threadId, state }),
+            ...emitOrBufferByThread({ draft: { type: 'tool.call.completed', turnId, payload: { toolCallId: item.id, toolName: 'spawnAgent', status: 'completed', output: collabToolOutput(item.agentPath) } }, threadId, state }),
             {
                 type: 'subagent.started',
                 turnId,
@@ -680,7 +744,7 @@ function mapSubAgentActivityCompleted(input: { turnId: string, threadId: string,
     if (item.kind === 'interacted') {
         return [
             ...emitOrBufferByThread({ draft: { type: 'tool.call.started', turnId, payload: { toolCallId: item.id, toolName: 'sendInput' } }, threadId, state }),
-            ...emitOrBufferByThread({ draft: { type: 'tool.call.completed', turnId, payload: { toolCallId: item.id, toolName: 'sendInput', status: 'completed' } }, threadId, state }),
+            ...emitOrBufferByThread({ draft: { type: 'tool.call.completed', turnId, payload: { toolCallId: item.id, toolName: 'sendInput', status: 'completed', output: collabToolOutput(item.agentPath) } }, threadId, state }),
         ]
     }
 
@@ -703,6 +767,26 @@ function mapSubAgentActivityCompleted(input: { turnId: string, threadId: string,
     }]
 }
 
+function collabToolSummary(item: CodexCollabAgentToolCompletedItem, state: CodexEventMapperState): string {
+    const name = (threadId: string) => state.subagentByThreadId.get(threadId)?.name ?? state.subagentNameByThreadId.get(threadId) ?? threadId
+    const parentActorId = item.senderThreadId === state.mainThreadId ? mainActor.actorId : item.senderThreadId
+    const unreported = state.unreportedEndedSubagentsByParent.get(parentActorId)
+    const states = Object.entries(item.agentsStates).map(([threadId, agentState]) => {
+        unreported?.delete(threadId)
+        return `${name(threadId)}: ${agentState.status}`
+    })
+    if (states.length)
+        return states.join('\n')
+    if (item.receiverThreadIds.length)
+        return item.receiverThreadIds.map(name).join('\n')
+    state.unreportedEndedSubagentsByParent.delete(parentActorId)
+    return [...unreported ?? []].map(([threadId, status]) => `${name(threadId)}: ${status}`).join('\n') || item.tool
+}
+
+function collabToolOutput(text: string): AgentToolResult {
+    return { success: true, content: [{ type: 'text', text }] }
+}
+
 function mapChildTurnCompleted(input: {
     threadId: string
     turnId: string
@@ -853,10 +937,9 @@ function subagentPayloadRef(actor: CodexSubagentRef): Pick<CodexSubagentRef, 'ac
 
 function collabToolInput(item: CodexCollabAgentToolStartedItem): JsonObject {
     return toJsonObject({
-        senderThreadId: item.senderThreadId,
-        receiverThreadIds: item.receiverThreadIds.join(','),
-        prompt: item.prompt,
-        model: item.model,
+        prompt: optionalNonEmpty(item.prompt),
+        receiverThreadIds: optionalNonEmpty(item.receiverThreadIds.join(',')),
+        model: optionalNonEmpty(item.model),
         reasoningEffort: typeof item.reasoningEffort === 'string' ? item.reasoningEffort : undefined,
     })
 }

package/src/provenance.gen.ts

@@ -1,6 +1,6 @@
 // Generated by scripts/write-provenance.ts. Do not edit by hand.
 export const generatedProvenance = {
-    version: "0.2.0-experimental.9",
-    sha: "8cc96eb90e17628946dfd6f7cc0bac298722a4c1",
-    buildTime: "2026-10-20T14:42:52.340Z",
+    version: "0.3.1-experimental.0",
+    sha: "0fe0d37e1a4d2965fb8da08b3160ac676f1229e1",
+    buildTime: "2026-10-26T12:38:01.769Z",
 } as const

package/src/steps/projector.ts

@@ -152,14 +152,16 @@ export class DurableStepProjector {
                 : event.type.startsWith('reasoning.') ? 'reasoning' : undefined
         if (!kind || !('turnId' in event)) {
             const frames: WireEventBody[] = []
-            if (event.type === 'turn.ended' || event.type === 'session.ended') {
+            if (event.type === 'turn.ended' || event.type === 'session.ended' || event.type === 'subagent.ended') {
                 for (const row of this.db.query<{ body: string, last_event_id: string | null }, []>('select body, last_event_id from steps').all()) {
                     const step = JSON.parse(row.body) as StepDetailV1
                     if (step.sessionId !== event.sessionId || step.providerSessionId !== event.providerSessionId)
                         continue
                     if ((step.status !== 'running' && row.last_event_id !== event.eventId) || (event.type === 'turn.ended' && (step.turnId !== event.turnId || step.actor.actorId !== event.actor.actorId)))
                         continue
-                    step.status = event.type === 'turn.ended' && event.payload.status === 'failed' ? 'failed' : 'interrupted'
+                    if (event.type === 'subagent.ended' && step.actor.actorId !== event.actor.actorId)
+                        continue
+                    step.status = event.type !== 'session.ended' && event.payload.status === 'failed' ? 'failed' : 'interrupted'
                     step.incomplete = true
                     step.endedAt = event.timestamp
                     frames.push(...await this.finish(step))

package/src/supervisor/resident.ts

@@ -75,9 +75,10 @@ export async function createResidentSupervisor(input: {
                 credentials: activation.envelope.credentials,
                 gitToken: activation.envelope.gitToken,
                 logger: input.logger,
-                onFatal: error => requestShutdown(
-                    error instanceof SupervisorConfigurationError ? TERMINAL_ERROR_CODE : RECOVERABLE_ERROR_CODE,
-                ),
+                onFatal: (error) => {
+                    input.logger.error({ err: error }, 'Supervisor agent runtime failed')
+                    requestShutdown(error instanceof SupervisorConfigurationError ? TERMINAL_ERROR_CODE : RECOVERABLE_ERROR_CODE)
+                },
             })
         }
         else {