@meistrari/agent-core 0.2.0-experimental.2 → 0.2.0-experimental.4

package/README.md

@@ -139,5 +139,5 @@ process lifecycle spec reads `/proc`, so it fails on macOS. Claude Code rejects
 bypass-permissions mode as root, so run them as a regular user.
 
 Regenerate the experimental Codex wire types with `bun run generate:codex-protocol`.
-The generator pins Codex 0.153.4 and verifies any `CODEX_EXECUTABLE` override before
+The generator pins Codex 0.156.1 and verifies any `CODEX_EXECUTABLE` override before
 using it. Commit generated files with generator changes; CI checks reproducibility.

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@meistrari/agent-core",
     "type": "module",
-    "version": "0.2.0-experimental.2",
+    "version": "0.2.0-experimental.4",
     "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/claude/claude-event-mapper.ts

@@ -400,6 +400,10 @@ function correlateConsumedPrompts({ message, turnId, drafts, state }: {
         ? message.user_message_uuids.filter((id): id is string => typeof id === 'string')
         : message.user_message_uuid ? [message.user_message_uuid] : []
     for (const inputId of inputIds) {
+        // Main-response UUIDs prove consumption even if the started receipt was omitted. This
+        // also applies to supervisor inputs, which intentionally have no human-prompt correlation.
+        if (state.queuedSteerIds.delete(inputId))
+            state.heldTurnEnd = undefined
         const commandId = state.promptCommandByInputId.get(inputId)
         if (!commandId)
             continue

package/src/agents/claude/claude-provider.ts

@@ -512,6 +512,17 @@ function createInputQueue(): AsyncIterable<SDKUserMessage> & { push: (message: S
     }
 }
 
+// Claude Code 2.1.280 sanitizePath: replace each non-ASCII-alphanumeric UTF-16 unit,
+// then cap the slug at 200 units and suffix a base-36 signed-32-bit hash of the ORIGINAL
+// cwd. The non-Unicode regex is deliberate: an astral character becomes two hyphens.
+// This is needed before input; SessionStart's transcript_path arrives too late for the
+// session-local stores and resume-context lookup. Real-CLI tests pin open and resume.
 function encodeClaudeProjectPath(cwd: string): string {
-    return cwd.replaceAll('/', '-')
+    const encoded = cwd.replace(/[^a-z0-9]/gi, '-')
+    if (encoded.length <= 200)
+        return encoded
+    let hash = 0
+    for (let index = 0; index < cwd.length; index++)
+        hash = ((hash << 5) - hash + cwd.charCodeAt(index)) | 0
+    return `${encoded.slice(0, 200)}-${Math.abs(hash).toString(36)}`
 }

package/src/agents/claude/claude-run.ts

@@ -79,7 +79,7 @@ function isClaudePreInitHookMessage(message: SDKMessage | ClaudeCommandLifecycle
 // run in this session". Any other shape or state deviation is provider protocol drift and fails
 // the run closed. Only `queued`/`started`/`completed` are positive. `cancelled` (steered-over,
 // aborted, or user-cancelled) and `discarded` (session ended with the command still queued) are
-// observed non-positive states whose real outcome the run's close settles; `refused` is a definite
+// non-positive states that reject an unsettled waiter as delivery-unknown; `refused` is a definite
 // terminal non-acceptance while the session keeps running, so it settles the waiter itself.
 const commandLifecycleFrameSchema = z.strictObject({
     type: z.literal('command_lifecycle'),
@@ -393,10 +393,11 @@ export class ClaudeRun implements AgentRun {
             // Register before the push: the CLI's queued receipt can outrun the local push resolution,
             // and a receipt with no registered waiter would be lost.
             const receipt = this.registerAcceptanceWaiter(clientMessageId)
-            if (command.origin === 'user')
+            if (command.origin === 'user') {
                 this.eventMapperState.promptCommandByInputId.set(clientMessageId, command.commandId)
+                this.pendingMessages.set(command.commandId, { messageId: clientMessageId, mode: command.mode, turnId: command.turnId, started: false })
+            }
             this.commandByClientMessageId.set(clientMessageId, command.commandId)
-            this.pendingMessages.set(command.commandId, { messageId: clientMessageId, mode: command.mode, turnId: command.turnId, started: false })
             if (command.mode === 'steer')
                 this.steerInputIds.add(clientMessageId)
             try {
@@ -740,7 +741,25 @@ export class ClaudeRun implements AgentRun {
         // Deliver first: on a prebound resume this is the run's first input, and the resolved
         // event must not precede the lifecycle events the init barrier emits.
         await this.applyProviderSettings(this.current)
-        await this.deliverInput(toClaudeUserMessage({ prompt: resolved.prompt, mode: 'next', commandId: command.commandId }))
+        // The answer opens its turn as the user's input, correlated like a prompt: the turn it
+        // starts carries this command, and the answer is accepted as that turn's user message.
+        const clientMessageId = deriveMessageId(command.commandId)
+        const receipt = this.registerAcceptanceWaiter(clientMessageId)
+        this.eventMapperState.promptCommandByInputId.set(clientMessageId, command.commandId)
+        this.pendingMessages.set(command.commandId, { messageId: clientMessageId, mode: 'next', turnId: undefined, started: false })
+        this.commandByClientMessageId.set(clientMessageId, command.commandId)
+        try {
+            await this.deliverInput(toClaudeUserMessage({ prompt: resolved.prompt, mode: 'next', commandId: command.commandId }))
+            await receipt.promise
+        }
+        catch (error) {
+            if (error instanceof AgentNotAcceptedError)
+                this.eventMapperState.promptCommandByInputId.delete(clientMessageId)
+            throw error
+        }
+        finally {
+            this.acceptanceWaiters.delete(clientMessageId)
+        }
         if (resolved.event)
             this.pushEvent(resolved.event)
         this.userInputRequests.markDelivered(command.requestId)
@@ -945,9 +964,9 @@ export class ClaudeRun implements AgentRun {
 
     // Strict pinned-runtime boundary for the undocumented receipt frame: shape/state deviation and
     // session identity mismatch are provider protocol drift and fail the run closed. `cancelled`
-    // and `discarded` are valid non-positive states that are validated and no-op even when a
-    // waiter is pending: the pending prompt's real outcome is settled by run close/error as
-    // delivery-unknown. `refused` is the pinned runtime's definite pre-queue rejection: the input
+    // and `discarded` reject an unsettled waiter as delivery-unknown; a prior positive acceptance
+    // cannot be revoked, and later consumed UUIDs remain valid evidence. `refused` is the pinned
+    // runtime's definite pre-queue rejection: the input
     // will never run in this session, and the session stays open, so the pending waiter is
     // rejected as a terminal not-accepted outcome instead of waiting for a close that may not
     // come. Valid positive frames without a pending waiter are internal lifecycle for
@@ -1198,6 +1217,10 @@ export class ClaudeRun implements AgentRun {
             if (!this.initialized) {
                 throw new AgentProviderProtocolError({ message: 'Claude SDK ended before emitting system init.' })
             }
+            // A queued steer was accepted but never consumed or explicitly dropped. Its preceding
+            // ask's held result cannot stand in for that owed input's completion.
+            if (this.eventMapperState.queuedSteerIds.size > 0)
+                throw new AgentProviderProtocolError({ message: 'Claude SDK ended before queued steering input started.' })
             // A superseded ask's held end is final once the stream can deliver no steer to continue it.
             await this.emitDrafts(flushHeldTurnEnd(this.eventMapperState), this.eventMapperState.interrupt)
             // The SDK reports non-zero exits and signals as errors, but a clean exit mid-turn ends the stream

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

@@ -397,10 +397,16 @@ function toolCallCompletion(item: CodexCompletedItem): { toolName: string, statu
     if (item.type === 'imageGeneration')
         return { toolName, status: item.status === 'failed' ? 'failed' : 'completed', output: imageGenerationResult(item) }
     if (item.type === 'commandExecution') {
-        const status = item.exitCode === undefined || item.exitCode === null || item.exitCode === 0 ? 'completed' : 'failed'
+        const status = item.status === 'declined'
+            ? 'cancelled'
+            : item.status !== 'completed' || (item.exitCode != null && item.exitCode !== 0) ? 'failed' : 'completed'
         const error = 'error' in item && typeof item.error === 'string'
             ? { message: item.error }
-            : status === 'failed' ? { message: `Command exited with code ${item.exitCode}.` } : undefined
+            : status === 'failed'
+                ? { message: item.exitCode != null && item.exitCode !== 0
+                        ? `Command exited with code ${item.exitCode}.`
+                        : item.status === 'inProgress' ? 'Command completion status was inconsistent.' : 'Command execution failed.' }
+                : undefined
         return { toolName, status, output: commandExecutionResult(item, status), error }
     }
     if (item.type === 'dynamicToolCall')
@@ -503,7 +509,7 @@ function hookPromptText(item: CodexHookPromptItem): string | undefined {
     return optionalNonEmpty(item.fragments.map(fragment => fragment.text).join('\n'))
 }
 
-function commandExecutionResult(item: Extract<CodexCompletedItem, { type: 'commandExecution' }>, status: 'completed' | 'failed'): AgentToolResult | undefined {
+function commandExecutionResult(item: Extract<CodexCompletedItem, { type: 'commandExecution' }>, status: AgentToolCallStatus): AgentToolResult | undefined {
     // Stdout is content, not a label: whitespace and an explicitly empty
     // successful output must survive normalization into the complete step.
     // Native build_command_execution_end_item encodes empty captured output as

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.2",
-    sha: "b808a0e0d307bcaa2cd0d47d2fd1e4112f70290c",
-    buildTime: "2026-09-25T17:58:45.916Z",
+    version: "0.2.0-experimental.4",
+    sha: "432a69b2d7243b7d5c6651229bf2f005e94afad7",
+    buildTime: "2026-09-29T14:26:10.056Z",
 } as const

package/src/supervisor/agent-provider-factory.ts

@@ -1,6 +1,6 @@
 import type { AgentProvider, AgentRun } from '../agents'
 import type { AgentInputAttachmentPreparation } from '../agents/materialized-input-attachment'
-import type { AgentEvent, AgentProviderId } from '../protocol'
+import type { AgentEvent, AgentPrompt, AgentProviderId } from '../protocol'
 import type { EphemeralCredentials, SessionBootstrapBody, SessionBootstrapGitToken } from '../supervisor-protocol/bootstrap'
 import type { WireSendPromptCommand } from '../supervisor-protocol/command-body'
 import type { WireEventBody } from '../supervisor-protocol/event-body'
@@ -62,11 +62,16 @@ export interface AgentSupervisorProviderFactoryOptions {
         rpc: SupervisorRpcClient
     }) => AgentProvider<'claude'> | AgentProvider<'codex'>
     bindingStore: AgentProviderBindingStore
+    /**
+     * Prepares a send-prompt's attachments before the provider sees it. It may also return the
+     * prompt the provider receives instead of the command's, for text the command could only
+     * reference (a message too long for a wire frame, fetched by the supervisor).
+     */
     prepareInputAttachments?: (input: {
         commandId: string
         command: WireSendPromptCommand
         signal: AbortSignal
-    }) => Promise<AgentInputAttachmentPreparation | undefined>
+    }) => Promise<(AgentInputAttachmentPreparation & { prompt?: AgentPrompt }) | undefined>
     onSecretsRefreshed?: (input: {
         credentials?: EphemeralCredentials
         gitToken?: SessionBootstrapGitToken
@@ -194,7 +199,7 @@ class AgentSupervisorRuntime implements SupervisorAgentRuntime {
                 model: input.body.model,
                 reasoningEffort: input.body.reasoningEffort,
                 origin: 'user',
-                prompt: input.body.prompt,
+                prompt: inputAttachmentPreparation?.prompt ?? input.body.prompt,
                 author: input.body.user
                     ? {
                             name: input.body.user.name,