@meistrari/agent-core 0.1.11 → 0.1.13

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@meistrari/agent-core",
     "type": "module",
-    "version": "0.1.11",
+    "version": "0.1.13",
     "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/model-rebinding-run.ts

@@ -19,6 +19,7 @@ export class ModelRebindingRun implements AgentRun {
     private workspacePrepared = false
     private workspaceChanging = false
     private readonly lifetime = new AbortController()
+    private readonly controls = new Set<Promise<unknown>>()
 
     constructor(run: AgentRun, private readonly reopen: (model: string, signal: AbortSignal) => Promise<AgentRun>, private readonly rootAdded?: (root: string) => void) {
         this.run = run
@@ -41,11 +42,11 @@ export class ModelRebindingRun implements AgentRun {
         })
     }
 
-    respondUserInput: AgentRun['respondUserInput'] = async (command, options) => await this.run.respondUserInput(command, options)
-    interrupt: AgentRun['interrupt'] = async (command, options) => await this.run.interrupt(command, options)
+    respondUserInput: AgentRun['respondUserInput'] = async (command, options) => await this.withControl(signal => this.run.respondUserInput(command, { ...options, signal }), options)
+    interrupt: AgentRun['interrupt'] = async (command, options) => await this.withControl(signal => this.run.interrupt(command, { ...options, signal }), options)
 
     async sendPrompt(command: SendPromptCommand, options: AgentOperationOptions = {}): Promise<AgentPromptAcceptance> {
-        if (this.dispatching || this.workspaceChanging)
+        if (this.dispatching || this.workspaceChanging || this.controls.size)
             throw new AgentPromptDeferredError({ message: 'A prompt admission is already in progress.' })
         const task = this.dispatchPrompt(command, options)
         this.dispatching = task
@@ -112,6 +113,7 @@ export class ModelRebindingRun implements AgentRun {
             throw new AgentRunStateError({ message: 'Stop does not target the bound run.' })
         this.stopped = true
         this.lifetime.abort()
+        await Promise.allSettled([...this.controls])
         await this.run.stop(command, options)
         await this.dispatching?.catch(() => undefined)
         await this.pump
@@ -122,6 +124,23 @@ export class ModelRebindingRun implements AgentRun {
         return { provider: this.metadata.provider, sessionId: this.metadata.sessionId, providerSessionId: this.metadata.providerSessionId }
     }
 
+    private async withControl<T>(operation: (signal: AbortSignal) => Promise<T>, options: AgentOperationOptions = {}): Promise<T> {
+        if (this.stopped)
+            throw new AgentRunStateError({ message: 'The run stopped.' })
+        if (this.changing || this.needsRebind)
+            throw new AgentPromptDeferredError({ message: 'The provider model is being rebound.' })
+        const signal = AbortSignal.any([this.lifetime.signal, ...(options.signal ? [options.signal] : [])])
+        const task = Promise.resolve().then(async () => {
+            signal.throwIfAborted()
+            return await operation(signal)
+        })
+        this.controls.add(task)
+        try {
+            return await task
+        }
+        finally { this.controls.delete(task) }
+    }
+
     private async withWorkspaceChange(operation: () => Promise<void>): Promise<void> {
         if (this.stopped)
             throw new AgentRunStateError({ message: 'The run stopped.' })

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.1.11",
-    sha: "8a060e09b239547c1fb7731ab7e73d2439619a38",
-    buildTime: "2026-09-14T17:32:26.510Z",
+    version: "0.1.13",
+    sha: "4f60fec6595bb447bfb1d307118a4a60264045a6",
+    buildTime: "2026-09-14T20:08:24.556Z",
 } as const

package/src/supervisor/ephemeral-frame-buffer.ts

@@ -0,0 +1,39 @@
+import { Buffer } from 'node:buffer'
+
+/** Connection-local best effort only; never persisted or acknowledged as durable. */
+export class EphemeralFrameBuffer {
+    private readonly frames: { value: string, bytes: number, barrier: number, expires: number }[] = []
+    private bytes = 0
+
+    constructor(private readonly options = { maxFrames: 2048, maxBytes: 1024 * 1024, ttlMs: 10_000, now: Date.now }) {}
+
+    enqueue(value: string, barrier: number): void {
+        this.expire()
+        const bytes = Buffer.byteLength(value)
+        if (this.frames.length >= this.options.maxFrames || this.bytes + bytes > this.options.maxBytes)
+            return
+        this.frames.push({ value, bytes, barrier, expires: this.options.now() + this.options.ttlMs })
+        this.bytes += bytes
+    }
+
+    flush(ackFloor: number, send: (value: string) => number): void {
+        this.expire()
+        while (this.frames.length > 0) {
+            const frame = this.frames[0]!
+            if (frame.barrier > ackFloor || send(frame.value) < 0)
+                return
+            this.bytes -= frame.bytes
+            this.frames.shift()
+        }
+    }
+
+    clear(): void {
+        this.frames.length = 0
+        this.bytes = 0
+    }
+
+    private expire(): void {
+        while (this.frames[0] && this.frames[0].expires <= this.options.now())
+            this.bytes -= this.frames.shift()!.bytes
+    }
+}

package/src/supervisor/runtime-handler.ts

@@ -11,6 +11,7 @@ import { durabilityOf } from '../supervisor-protocol/durability'
 import { wireEventBodySchema } from '../supervisor-protocol/event-body'
 import { maxDurableEventBytes, maxEphemeralDeltaBytes } from '../supervisor-protocol/payload-overflow'
 import { decodeControlPlaneFrame, encodeWireFrame } from '../supervisor-protocol/wire-codec'
+import { EphemeralFrameBuffer } from './ephemeral-frame-buffer'
 import { SupervisorRpcClient } from './rpc-client'
 
 export interface ResidentSupervisorSocket {
@@ -36,6 +37,7 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
     private eventAckFloor = 0
     private stopped = false
     private readonly retainedFrames: string[] = []
+    private readonly ephemeralFrames = new EphemeralFrameBuffer()
     private readonly heartbeatTimer: ReturnType<typeof setInterval>
 
     constructor(private readonly dependencies: {
@@ -67,6 +69,7 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
         this.socket = input.socket
         this.eventAckFloor = input.eventAckFloor
         this.retainedFrames.length = 0
+        this.ephemeralFrames.clear()
         if (previous && previous !== input.socket)
             previous.close(1008, 'Connection generation was superseded.')
         this.rpc.attach(frame => this.sendRetained(frame))
@@ -107,6 +110,7 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
                 return
             }
             this.eventAckFloor = Math.max(this.eventAckFloor, frame.highWaterMark)
+            this.flushEphemeral()
             return
         }
         if (frame.kind === 'rpc.response') {
@@ -121,6 +125,7 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
             return
         this.socket = undefined
         this.retainedFrames.length = 0
+        this.ephemeralFrames.clear()
         this.rpc.detach()
     }
 
@@ -128,6 +133,7 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
         if (this.socket !== socket)
             return
         this.flushRetained()
+        this.flushEphemeral()
     }
 
     async refreshSecrets(input: {
@@ -154,6 +160,7 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
         this.rpc.stop()
         this.socket?.close(1001, 'Supervisor runtime stopped.')
         this.socket = undefined
+        this.ephemeralFrames.clear()
         await this.processing.catch(() => undefined)
     }
 
@@ -269,14 +276,20 @@ export class SupervisorRuntimeHandler implements RuntimeConnectionHandler {
     private sendEvent(event: EventEnvelope): void {
         const frame = encodeWireFrame(event)
         if (event.delivery_semantics === 'ephemeral') {
-            if (this.dependencies.store.localEventMax() > this.eventAckFloor || this.retainedFrames.length > 0)
+            if (!this.socket)
                 return
-            this.socket?.send(frame)
+            this.ephemeralFrames.enqueue(frame, this.dependencies.store.localEventMax())
+            this.flushEphemeral()
             return
         }
         this.sendRetained(frame)
     }
 
+    private flushEphemeral(): void {
+        if (this.socket && this.retainedFrames.length === 0)
+            this.ephemeralFrames.flush(this.eventAckFloor, frame => this.socket!.send(frame))
+    }
+
     private sendRetained(frame: string): void {
         const socket = this.socket
         if (!socket)