@plurnk/plurnk-agui 3.1.0 → 4.0.0

package/dist/Translator.js

@@ -1,14 +1,15 @@
-import { TurnDisposition } from "@plurnk/plurnk-contracts";
 // The projection — plurnk's log-shaped wire onto AG-UI's event vocabulary. PURE: one daemon
 // notification in, zero-or-more AG-UI events out, with per-worker turn tracking as the only state.
 // The mapping ({§agui-projection}):
 //   log/entry response (model) → optional standard reasoning lifecycle, then TEXT_MESSAGE triple
-//                                 (assistant speech; the signal rides plurnk.send)
-//   log/entry rejected emission → forensic row only, no conversational event
+//                                 (assistant speech, a reply or a WAIT's body)
+//   log/entry rejected emission → CUSTOM plurnk.ambient, no message event
 //   log/entry other    (model)  → TOOL_CALL_START/ARGS/END + TOOL_CALL_RESULT (an op row IS a
-//                                 tool call: tx is the args, rx the result, coordinate the id)
-//   log/entry          (plurnk) → CUSTOM plurnk.ambient (foists, deltas, narrations — the
-//                                 environment speaking; generic UIs skip, rich UIs render)
+//                                 tool call: tx is the args, rx the result, coordinate the id; a bodiless WAIT too)
+//   log/entry arrival  (plurnk) → TEXT_MESSAGE triple, role user, named by its source (another client's
+//                                 prompt, a worker's message), except the Run's own submission
+//   log/entry          (plurnk) → CUSTOM plurnk.ambient (deltas, narrations — the environment
+//                                 speaking; generic UIs skip, rich UIs render)
 //   outside/event               → CUSTOM plurnk.outside (the thread's worker only: text the model
 //                                 emitted outside every operation, never assistant speech)
 //   turn_id advances            → STEP_FINISHED/STEP_STARTED
@@ -17,11 +18,13 @@ import { TurnDisposition } from "@plurnk/plurnk-contracts";
 // Numbers are passed through verbatim, never recomputed — the daemon's gauge is the gauge
 // ({§agui-numbers-passthrough}).
 import { EventType, } from "./types.js";
+import { aggregateTokenUsage, tokenUsageFromAiSdkUsage } from "@ag-ui/core";
 import { derivationActivity } from "./AguiPlus.js";
 import MessageAddress from "./MessageAddress.js";
 import { Validator, lifecycleOfLoopStatus } from "@plurnk/plurnk-contracts";
 export default class Translator {
     #threadId;
+    #replyThreads;
     #runId; // AG-UI's Run id (echoed from RunAgentInput.runId) — the standard face
     #currentTurn = null;
     #stepOpen = false;
@@ -29,12 +32,23 @@ export default class Translator {
     #workspaceId;
     #activeReasoning = new Map();
     #completedReasoning = new Map();
+    // {§agui-snapshot} The messages this Run submitted: its client already holds them.
+    #submitted = new Set();
+    // {§agui-call-result} The calls this Run's client holds without their result: a gate's call it presented, or a
+    // pending one its snapshot held. A later delivery of that row only answers it.
+    #held = new Set();
+    // {§agui-subagents} A delegation this Run observes: the subagent run its events are attributed to, and the worker
+    // whose rows' identities it namespaces; null for the Run's own worker.
+    #subagent;
     constructor(args) {
+        this.#subagent = args.subagent ?? null;
         this.#threadId = args.threadId;
+        this.#replyThreads = args.replyThreads ?? [args.threadId];
         this.#runId = args.runId;
         this.#currentTurn = args.continuation?.currentTurn ?? null;
         this.#modelWorkerId = args.continuation?.modelWorkerId ?? args.modelWorkerId ?? null;
         this.#completedReasoning = new Map(args.continuation?.completedReasoning.map(([turnId, values]) => [turnId, [...values]]) ?? []);
+        this.#held = args.held ?? new Set(args.continuation?.held ?? []);
         this.#workspaceId = args.workspaceId ?? null;
     }
     #continuation() {
@@ -45,6 +59,7 @@ export default class Translator {
             currentTurn: this.#currentTurn,
             modelWorkerId: this.#modelWorkerId,
             completedReasoning: [...this.#completedReasoning].map(([turnId, values]) => [turnId, [...values]]),
+            held: [...this.#held],
         };
     }
     runStarted(state) {
@@ -62,6 +77,10 @@ export default class Translator {
         }
         return events;
     }
+    // A message this Run submits arrives in its worker's log like any other; its own client already holds it.
+    submitted(messageId) {
+        this.#submitted.add(messageId);
+    }
     // {§agui-gate-deferral} — a stopped-world cannot split this lifecycle; the Portal holds it until the end.
     get reasoningOpen() { return this.#activeReasoning.size > 0; }
     interrupt() {
@@ -86,79 +105,136 @@ export default class Translator {
         this.#currentTurn = null;
         this.#stepOpen = false;
         this.#completedReasoning.clear();
-        return events;
+        return this.#attributed(events);
+    }
+    // {§agui-readable-reasoning} A Run ended before its request is (revoked, stopped, failed) still
+    // balances what it opened; the request itself streams on to the Runs still observing it.
+    fail() {
+        const events = [];
+        for (const { messageId } of this.#activeReasoning.values()) {
+            events.push({ type: EventType.REASONING_MESSAGE_END, messageId }, { type: EventType.REASONING_END, messageId });
+        }
+        this.#activeReasoning.clear();
+        return [...events, ...this.finish()];
     }
     logEntry(n) {
+        return this.#attributed(this.#project(n));
+    }
+    // {§agui-subagents} The translator of a subagent run this Run presents: its own namespace, this Run's client.
+    subagentTranslator(args) {
+        return new Translator({ threadId: this.#threadId, runId: this.#runId, modelWorkerId: args.modelWorkerId, workspaceId: this.#workspaceId,
+            subagent: args.subagent, held: this.#held, replyThreads: this.#replyThreads });
+    }
+    // {§agui-proposal-resolve} A gate's call: the operation awaiting its decision, built as its row builds it and so
+    // unanswered. Its client then holds it, and the settled row updates and answers it ({§agui-call-result}).
+    gateCall(entry) {
+        if (this.#held.has(this.#id(entry)))
+            return [];
+        const events = this.#project({ entry });
+        this.#held.add(this.#id(entry));
+        return this.#attributed(events);
+    }
+    #project(n) {
         const e = n.entry;
         const events = [];
-        const clientEntry = e;
         // {§agui-topology-scope} — the workspace broadcast carries EVERY worker's rows (workers, the
         // plurnk worker, siblings); only the THREAD's model worker projects onto the core vocabulary.
-        // Everything else rides plurnk.row/plurnk.ambient — visible to rich clients as topology,
-        // never interleaved into the conversation a generic frontend renders.
+        // Another worker's row is workspace activity, never interleaved into the messages a generic frontend renders.
         const workerId = e.worker_id;
-        // Lazy binding: workspace.create returns the CLIENT worker's id — the model worker is born at
-        // loop worker's drain, so a fresh thread adopts its first model-origin row's worker as the
-        // model worker (workers spawn FROM it later; reattach seeds it from workspace.workers instead).
+        // Lazy binding: a Run that binds no model worker adopts its first model-origin row's worker as the
+        // model worker (workers spawn FROM it later).
         if (this.#modelWorkerId === null && e.origin === "model" && typeof workerId === "number")
             this.#modelWorkerId = workerId;
         const foreign = this.#modelWorkerId !== null && typeof workerId === "number" && workerId !== this.#modelWorkerId;
-        // {§agui-row-channel} — the complete client-facing row rides plurnk.row alongside the core projection:
-        // curation metadata, durable tags, coordinates — everything clients render that
-        // the core vocabulary can't hold. Rich clients render the original operations.
-        const row = { type: EventType.CUSTOM, name: "plurnk.row", value: clientEntry };
-        if (foreign) {
-            events.push(row);
-            events.push({ type: EventType.CUSTOM, name: "plurnk.ambient", value: clientEntry });
-            return events;
-        }
-        // A family client renders the SEND from plurnk.row rather than duplicating
-        // TEXT_MESSAGE. Delay that one mirror until after the standard reasoning
-        // lifecycle so both generic and family clients observe reasoning before speech.
-        const response = Translator.isResponse(e, this.#threadId);
-        const lifecycle = typeof e.op === "string" && TurnDisposition.isOp(e.op);
-        const reasoningRow = response || lifecycle || e.op === "NOTE";
-        const delayedSendRow = e.origin === "model" && reasoningRow;
-        if (!delayedSendRow)
-            events.push(row);
+        // {§agui-ambient} A row that builds nothing in the conversation rides whole.
+        const ambient = { type: EventType.CUSTOM, name: "plurnk.ambient", value: e };
+        if (foreign)
+            return [ambient];
         if (typeof e.turn_id === "number")
             events.push(...this.#enterTurn(e.turn_id));
-        if (e.origin !== "model" && !response) {
-            events.push({ type: EventType.CUSTOM, name: "plurnk.ambient", value: clientEntry });
+        const arrival = this.#arrival(e);
+        if (arrival !== null) {
+            // {§agui-plurnk-metadata} The Run that submitted a message already holds it: it receives only the row's facts,
+            // which the reducer folds onto that message.
+            if (this.#submitted.has(arrival.id)) {
+                events.push({ type: EventType.TEXT_MESSAGE_START, messageId: arrival.id, role: "user", metadata: Translator.#rowMetadata(e) });
+                events.push({ type: EventType.TEXT_MESSAGE_END, messageId: arrival.id });
+                return events;
+            }
+            events.push({ type: EventType.TEXT_MESSAGE_START, messageId: arrival.id, role: "user", ...(arrival.name === undefined ? {} : { name: arrival.name }), metadata: Translator.#rowMetadata(e) });
+            events.push({ type: EventType.TEXT_MESSAGE_CONTENT, messageId: arrival.id, delta: arrival.content });
+            events.push({ type: EventType.TEXT_MESSAGE_END, messageId: arrival.id });
             return events;
         }
-        const id = e.coordinate ?? String(e.id);
-        if (reasoningRow) {
-            const text = Translator.#txBody(e.tx);
-            events.push(...Translator.#readableReasoningEvents(id, Translator.#claimReasoning(this.#completedReasoning, e.turn_id, e.reasoning)));
-            if (delayedSendRow)
-                events.push(row);
-            // {§agui-projection} — a reply SEND speaks; so does a WAIT that carries a body (#1003): the card
-            // teaches both as the worker's words to the user. A bodiless WAIT is lifecycle alone.
-            const waitSpeech = e.op === "WAIT" && e.origin === "model" && text.trim().length > 0;
-            if (response || waitSpeech) {
-                events.push({ type: EventType.TEXT_MESSAGE_START, messageId: id, role: "assistant" });
-                events.push({ type: EventType.TEXT_MESSAGE_CONTENT, messageId: id, delta: text });
+        const response = Translator.isResponse(e, this.#replyThreads);
+        if (e.origin !== "model" && !response) {
+            const answered = this.#answered(e);
+            if (answered !== null) {
+                events.push({ type: EventType.TOOL_CALL_RESULT, toolCallId: answered, messageId: this.#id(e), content: Translator.#delivered(e), metadata: Translator.#rowMetadata(e) });
+                return events;
+            }
+            // {§agui-progress-reply} Progress on a message this worker sent is a message from the one who reported it.
+            if (typeof e.answering === "string") {
+                const id = this.#id(e);
+                const text = Translator.#txBody(e.tx);
+                events.push({ type: EventType.TEXT_MESSAGE_START, messageId: id, role: "user", ...(typeof e.source === "string" ? { name: e.source } : {}), metadata: Translator.#rowMetadata(e) });
+                if (text.length > 0)
+                    events.push({ type: EventType.TEXT_MESSAGE_CONTENT, messageId: id, delta: text });
                 events.push({ type: EventType.TEXT_MESSAGE_END, messageId: id });
+                return events;
             }
-            if (response || lifecycle) {
-                events.push({ type: EventType.CUSTOM, name: "plurnk.send", value: { signal: e.signal, status: e.status_rx, coordinate: e.coordinate } });
+            events.push(ambient);
+            return events;
+        }
+        const id = this.#id(e);
+        // {§agui-proposal-resolve} The client holds this gated call: its settlement is a repeated START and END, which the
+        // reducer folds onto the call it holds, its arguments untouched, then its answer unless something later answers it
+        // ({§agui-call-result}).
+        if (this.#held.has(id)) {
+            if (e.state === "proposed")
                 return events;
+            this.#held.delete(id);
+            const metadata = Translator.#rowMetadata(e);
+            events.push({ type: EventType.TOOL_CALL_START, toolCallId: id, toolCallName: Translator.#callOf(e).name, metadata });
+            events.push({ type: EventType.TOOL_CALL_END, toolCallId: id });
+            if (!Translator.#answeredLater(e)) {
+                events.push({ type: EventType.TOOL_CALL_RESULT, toolCallId: id, messageId: `${id}/result`, content: Translator.#asText(e.rx), metadata });
             }
+            return events;
+        }
+        if (e.op !== null) {
+            events.push(...Translator.#readableReasoningEvents(Translator.#reasoningId(e, id), Translator.#claimReasoning(this.#completedReasoning, e.turn_id, e.reasoning)));
+        }
+        // {§agui-projection} — a reply SEND speaks; so does a WAIT that carries a body (#1003): the card
+        // teaches both as the worker's words to the user. A bodiless WAIT is an operation like any other.
+        const text = Translator.#txBody(e.tx);
+        if (response || Translator.#waitSpeech(e, text)) {
+            events.push({ type: EventType.TEXT_MESSAGE_START, messageId: id, role: "assistant", metadata: Translator.#speechMetadata(e) });
+            events.push({ type: EventType.TEXT_MESSAGE_CONTENT, messageId: id, delta: text });
+            events.push({ type: EventType.TEXT_MESSAGE_END, messageId: id });
+            return events;
         }
         if (e.op === null) {
-            const kind = Translator.#modelArtifactKind(e.attrs);
-            if (kind === null) {
+            // {§rejected-emission-entry} An emission the daemon rejected builds no part.
+            if (Translator.#modelArtifactKind(e.attrs) === null) {
                 throw new TypeError("An actionless model-origin row must carry attrs.kind=emissionAttempt.");
             }
+            events.push(ambient);
             return events;
         }
-        events.push({ type: EventType.TOOL_CALL_START, toolCallId: id, toolCallName: e.op });
-        events.push({ type: EventType.TOOL_CALL_ARGS, toolCallId: id, delta: Translator.#argsFor(e) });
+        // {§agui-parse-refusal} A refusal is the call the worker attempted; one that names no attempt builds no part.
+        const call = Translator.#callOf(e);
+        if (call === null) {
+            events.push(ambient);
+            return events;
+        }
+        const metadata = Translator.#rowMetadata(e);
+        events.push({ type: EventType.TOOL_CALL_START, toolCallId: id, toolCallName: call.name, metadata });
+        events.push({ type: EventType.TOOL_CALL_ARGS, toolCallId: id, delta: call.args });
         events.push({ type: EventType.TOOL_CALL_END, toolCallId: id });
-        const rxText = Translator.#asText(e.rx);
-        if (rxText.length > 0) {
-            events.push({ type: EventType.TOOL_CALL_RESULT, toolCallId: id, messageId: `${id}/result`, content: rxText });
+        // {§agui-call-result} A call is answered by its receipt, unless something later answers it.
+        if (!Translator.#answeredLater(e)) {
+            events.push({ type: EventType.TOOL_CALL_RESULT, toolCallId: id, messageId: `${id}/result`, content: Translator.#asText(e.rx), metadata });
         }
         return events;
     }
@@ -167,7 +243,7 @@ export default class Translator {
             this.#modelWorkerId = event.workerId;
         if (event.workerId !== this.#modelWorkerId)
             return [];
-        const messageId = `model-call-${event.modelCallId}/request-${event.requestSequence}/reasoning`;
+        const messageId = Translator.#requestReasoningId(event.modelCallId, event.requestSequence);
         if (event.phase === "start") {
             if (this.#activeReasoning.has(event.modelCallId)) {
                 throw new TypeError(`Reasoning model call ${event.modelCallId} already started a physical request.`);
@@ -184,7 +260,10 @@ export default class Translator {
             return events;
         }
         const active = this.#activeReasoning.get(event.modelCallId);
-        if (active === undefined || active.requestSequence !== event.requestSequence) {
+        // {§agui-readable-reasoning} A Run that joined after this request began presents none of it.
+        if (active === undefined)
+            return [];
+        if (active.requestSequence !== event.requestSequence) {
             throw new TypeError(`Reasoning model call ${event.modelCallId} request ${event.requestSequence} emitted ${event.phase} without a start.`);
         }
         if (active.turnId !== event.turnId || active.loopId !== event.loopId) {
@@ -226,9 +305,10 @@ export default class Translator {
         events.push({
             type: EventType.STATE_DELTA,
             delta: [
-                { op: "replace", path: "/plurnk/status/lifecycle", value: result.status === 200 ? "completed" : "failed" },
+                // {§loop-lifecycle-vocabulary} — a loop that concluded with any result below 400 completed.
+                { op: "replace", path: "/plurnk/status/lifecycle", value: result.status < 400 ? "completed" : "failed" },
                 { op: "replace", path: "/plurnk/status/loopId", value: n.loopId },
-                { op: "replace", path: "/plurnk/status/activity", value: null },
+                { op: "replace", path: "/plurnk/status/terminatedAt", value: n.terminatedAt },
                 { op: "replace", path: "/plurnk/status/waitUntil", value: null },
                 { op: "replace", path: "/budget/curationWeight", value: n.usage.curationWeight },
                 { op: "replace", path: "/budget/curationBudget", value: n.usage.curationBudget },
@@ -236,13 +316,6 @@ export default class Translator {
                 { op: "replace", path: "/budget/contextCapacity", value: n.usage.contextCapacity },
             ],
         });
-        // Family channel — the full terminal truth the core STATE_DELTA can't hold
-        // (loopId, turnIds, physical-request accounting, usage meta, attribution) PLUS the daemon workspaceId, so a
-        // plurnk client rebuilds its json record from the stream with ONE schema
-        // and no second round-trip. Numbers verbatim
-        // ({§agui-numbers-passthrough}). Generic frontends ignore it; the RUN_FINISHED/
-        // RUN_ERROR below is their terminal signal.
-        events.push({ type: EventType.CUSTOM, name: "plurnk.terminated", value: { ...n, workspaceId: this.#workspaceId } });
         // The standard RAW channel (§475): the provider's NATIVE completion frame rides
         // usage.meta (finish_reason, model, timings, id, …) — AG-UI's RAW is exactly this,
         // a passthrough of an external system's own event with a source tag. Generic
@@ -250,77 +323,130 @@ export default class Translator {
         if (n.usage.meta !== undefined && n.usage.meta !== null && Object.keys(n.usage.meta).length > 0) {
             events.push({ type: EventType.RAW, event: n.usage.meta, source: "provider" });
         }
-        if (result.status === 200) {
-            events.push({ type: EventType.RUN_FINISHED, threadId: this.#threadId, runId: this.#runId, outcome: { type: "success" } });
+        // {§agui-run-outcome} A loop that completed finishes the Run with its result; one stopped without failing (499)
+        // finishes it cancelled; any other failure is the Run's error. Usage is each physical request's own counts, and
+        // the end's metadata is the loop's complete terminal record with the daemon's workspaceId, numbers verbatim, so
+        // a plurnk client rebuilds its record from the stream alone ({§agui-plurnk-metadata}, {§agui-numbers-passthrough}).
+        const usage = Translator.#tokenUsage(n.usage.accounting);
+        const metadata = { plurnk: { terminal: { ...n, workspaceId: this.#workspaceId } } };
+        if (result.status < 400) {
+            events.push({ type: EventType.RUN_FINISHED, threadId: this.#threadId, runId: this.#runId, outcome: { type: "success" }, result, ...usage, metadata });
+        }
+        else if (result.status === 499) {
+            events.push({ type: EventType.RUN_FINISHED, threadId: this.#threadId, runId: this.#runId, outcome: { type: "cancelled" }, ...usage, metadata });
         }
         else {
             events.push({
                 type: EventType.RUN_ERROR,
                 message: result.problem.detail,
                 code: result.problem.type,
+                ...usage,
+                metadata,
             });
         }
         return events;
     }
-    // {§agui-replay} — delivered model responses become assistant messages. Everything else
-    // stays reachable through live plurnk.row rendering. Wire rows arrive as the
-    // log.read projection (tx parsed).
+    // {§agui-run-outcome} AG-UI's token usage of the loop's physical requests, by the standard's own AI SDK mapping and
+    // per-model aggregation: the daemon's counts, never its gauge ({§agui-numbers-passthrough}). Unreported counts stay absent.
+    static #tokenUsage(accounting) {
+        const usage = aggregateTokenUsage(accounting.requests.flatMap(({ provider, model, usage: counts }) => tokenUsageFromAiSdkUsage(counts, { provider, model }) ?? []));
+        return usage.length === 0 ? {} : { usage };
+    }
+    // {§agui-replay} {§agui-snapshot} — the messages as the live projection built them: arrivals, each turn's
+    // reasoning, speech, and every other model operation as its tool call and result, under the
+    // live identities. Wire rows arrive as the log.read projection (tx parsed).
     replay(entries, currentUser) {
+        return Translator.replayAll([{ translator: this, entries }], currentUser);
+    }
+    // {§agui-snapshot} {§agui-subagents} One conversation from several logs: every row in the order the workspace
+    // committed it, each projected by its own worker's translator into one message list.
+    static replayAll(parts, currentUser) {
         const messages = [];
-        const deliveredReasoning = new Map();
-        const chronological = entries.toSorted((left, right) => {
-            const leftId = typeof left.id === "number" ? left.id : Number.MAX_SAFE_INTEGER;
-            const rightId = typeof right.id === "number" ? right.id : Number.MAX_SAFE_INTEGER;
-            return leftId - rightId;
-        });
-        for (const e of chronological) {
-            const id = String(e.coordinate ?? e.id);
-            // {§message-arrival} — an arrival replays as a user message; another actor's arrival
-            // carries its source as the message name ({§message-causal-source}).
-            if (e.origin === "_plurnk" && e.op === "SEND" && Translator.#attrKind(e.attrs) === "message") {
-                messages.push({ id: MessageAddress.messageId(e.source, this.#threadId) ?? id,
-                    role: "user", content: Translator.#txBody(e.tx), ...(typeof e.source === "string" ? { name: e.source } : {}) });
-                continue;
-            }
-            const response = Translator.isResponse(e, this.#threadId);
-            if (e.origin !== "model" && !response)
-                continue;
-            const text = Translator.#txBody(e.tx);
-            if (response || e.op === "SEND" || e.op === "NOTE" || typeof e.op === "string" && TurnDisposition.isOp(e.op)) {
-                const reasoning = Translator.#claimReasoning(deliveredReasoning, e.turn_id, e.reasoning);
-                if (reasoning.length > 0)
-                    messages.push({ id: `${id}/reasoning`, role: "reasoning", content: reasoning });
-            }
-            if (response) {
-                const message = { id, role: "assistant", content: text };
-                messages.push(message);
-            }
-            if (e.op === null) {
-                if (Translator.#modelArtifactKind(e.attrs) === null) {
-                    throw new TypeError("An actionless model-origin replay row must carry attrs.kind=emissionAttempt.");
-                }
-            }
+        const order = (e) => typeof e.id === "number" ? e.id : Number.MAX_SAFE_INTEGER;
+        const rows = parts.flatMap(({ translator, entries }) => entries.map((e) => ({ translator, e })))
+            .toSorted((left, right) => order(left.e) - order(right.e));
+        const delivered = new Map();
+        for (const { translator, e } of rows) {
+            const reasoning = delivered.get(translator) ?? new Map();
+            delivered.set(translator, reasoning);
+            translator.#replayRow(e, messages, reasoning);
         }
         if (currentUser !== undefined && !messages.some(({ id }) => id === currentUser.id)) {
             messages.push(currentUser);
         }
         return [{ type: EventType.MESSAGES_SNAPSHOT, messages }];
     }
-    notice(notice) {
+    #replayRow(e, messages, deliveredReasoning) {
+        const attributed = (message) => this.#subagent === null ? message : { ...message, subagentRunId: this.#subagent.runId };
+        const id = this.#id(e);
+        const metadata = Translator.#rowMetadata(e);
+        const arrival = this.#arrival(e);
+        if (arrival !== null) {
+            messages.push(attributed({ id: arrival.id, role: "user", content: arrival.content, ...(arrival.name === undefined ? {} : { name: arrival.name }), metadata }));
+            return;
+        }
+        const response = Translator.isResponse(e, this.#replyThreads);
+        if (e.origin !== "model" && !response) {
+            const answered = this.#answered(e);
+            if (answered !== null)
+                Translator.#placeResult(messages, attributed({ id, role: "tool", toolCallId: answered, content: Translator.#delivered(e), metadata }));
+            // {§agui-progress-reply}
+            else if (typeof e.answering === "string") {
+                messages.push(attributed({ id, role: "user", content: Translator.#txBody(e.tx), ...(typeof e.source === "string" ? { name: e.source } : {}), metadata }));
+            }
+            return;
+        }
+        if (typeof e.op !== "string") {
+            if (Translator.#modelArtifactKind(e.attrs) === null) {
+                throw new TypeError("An actionless model-origin replay row must carry attrs.kind=emissionAttempt.");
+            }
+            return;
+        }
+        const reasoning = Translator.#claimReasoning(deliveredReasoning, e.turn_id, e.reasoning);
+        if (reasoning.length > 0)
+            messages.push(attributed({ id: Translator.#reasoningId(e, id), role: "reasoning", content: reasoning }));
+        const text = Translator.#txBody(e.tx);
+        if (response || Translator.#waitSpeech(e, text)) {
+            messages.push(attributed({ id, role: "assistant", content: text, metadata: Translator.#speechMetadata(e) }));
+            return;
+        }
+        const call = Translator.#callOf(e);
+        if (call === null)
+            return;
+        messages.push(attributed({ id, role: "assistant", toolCalls: [{ id, type: "function", function: { name: call.name, arguments: call.args }, metadata }] }));
+        if (e.state === "proposed")
+            this.#held.add(id);
+        if (Translator.#answeredLater(e))
+            return;
+        Translator.#placeResult(messages, attributed({ id: `${id}/result`, role: "tool", toolCallId: id, content: Translator.#asText(e.rx), metadata }));
+    }
+    notice(notice, loopId = null) {
         const diagnostic = { type: EventType.CUSTOM, name: "plurnk.notice", value: notice };
         const value = notice;
-        // {§loop-status-notice} — lifecycle and its durable deadline, never a diagnostic or chat message.
+        // {§loop-status-notice} {§agui-status-timing} — the loop's lifecycle with its identity, packet count,
+        // stamps and deadline in one delta, never a diagnostic or chat message.
         if (value.source === "engine:lifecycle" && value.kind === "loop_status") {
             if (value.status !== 100 && value.status !== 102 && value.status !== 202)
                 throw new TypeError("A loop_status notice carries 100, 102 or 202.");
             if (value.waitUntil !== null && (typeof value.waitUntil !== "number" || !Number.isFinite(value.waitUntil) || value.waitUntil < 0)) {
                 throw new TypeError("A loop_status notice carries a nullable Unix-millisecond waitUntil.");
             }
+            if (!Number.isSafeInteger(value.packetCount) || value.packetCount < 0)
+                throw new TypeError("A loop_status notice carries its loop's packet count.");
+            if (value.claimedAt !== null && (!Number.isSafeInteger(value.claimedAt) || value.claimedAt <= 0)) {
+                throw new TypeError("A loop_status notice carries a nullable Unix-millisecond claimedAt.");
+            }
+            if (loopId === null || loopId <= 0)
+                throw new TypeError("A loop_status notice names its loop.");
             return [{
                     type: EventType.STATE_DELTA,
                     delta: [
                         { op: "replace", path: "/plurnk/status/lifecycle", value: lifecycleOfLoopStatus(value.status) },
+                        { op: "replace", path: "/plurnk/status/loopId", value: loopId },
+                        { op: "replace", path: "/plurnk/status/packetCount", value: value.packetCount },
                         { op: "replace", path: "/plurnk/status/waitUntil", value: value.status === 202 ? value.waitUntil : null },
+                        { op: "replace", path: "/plurnk/status/claimedAt", value: value.claimedAt },
+                        { op: "replace", path: "/plurnk/status/terminatedAt", value: null },
                     ],
                 }];
         }
@@ -328,7 +454,7 @@ export default class Translator {
             return [diagnostic];
         const events = [{
                 type: EventType.STATE_DELTA,
-                delta: [{ op: "replace", path: "/plurnk/status/activity", value: derivationActivity(notice) }],
+                delta: [{ op: "replace", path: "/plurnk/workspace/activity", value: derivationActivity(notice) }],
             }];
         if (value.level === "error" || value.level === "warn")
             events.push(diagnostic);
@@ -384,10 +510,9 @@ export default class Translator {
     }
     // {§agui-readable-reasoning} Durable reasoning precedes the turn's first
     // speech or note projection when live delivery has not already supplied it.
-    static #readableReasoningEvents(sendId, value) {
+    static #readableReasoningEvents(messageId, value) {
         if (typeof value !== "string" || value.length === 0)
             return [];
-        const messageId = `${sendId}/reasoning`;
         return [
             { type: EventType.REASONING_START, messageId },
             { type: EventType.REASONING_MESSAGE_START, messageId, role: "reasoning" },
@@ -411,7 +536,7 @@ export default class Translator {
         return kind === "emissionAttempt" ? kind : null;
     }
     // {§loop-response-messages}: share admission with reattach orientation.
-    static isResponse(entry, threadId) {
+    static isResponse(entry, replyThreads) {
         if (entry.op !== "SEND" && entry.op !== "KILL")
             return false;
         const deliveredReply = Translator.#attrKind(entry.attrs) === "reply";
@@ -430,7 +555,7 @@ export default class Translator {
         const answers = rx.answers;
         if (!Array.isArray(answers))
             return false;
-        return answers.some((address) => MessageAddress.messageId(address, threadId) !== null);
+        return answers.some((address) => replyThreads.some((threadId) => MessageAddress.messageId(address, threadId) !== null));
     }
     // The model-facing textual statement body out of the tx. The real
     // wire ships tx PARSED (an object); a string is tolerated and parsed for robustness.
@@ -459,6 +584,9 @@ export default class Translator {
             return body.raw;
         return "";
     }
+    static #waitSpeech(e, text) {
+        return e.op === "WAIT" && e.origin === "model" && text.trim().length > 0;
+    }
     // A wire value (object or string) as display text.
     static #asText(v) {
         if (typeof v === "string")
@@ -467,14 +595,159 @@ export default class Translator {
             return "";
         return JSON.stringify(v);
     }
-    // Tool-call args: the op's addressing + body as one JSON string (AG-UI streams args as deltas;
-    // a dispatched plurnk op is atomic, so the whole args object arrives as one delta).
+    // {§agui-snapshot} A row's message identity is its log coordinate L/T/S ({§methods-log-coordinate}).
+    static idOf(e) {
+        const { loop_seq: loop, turn_seq: turn, sequence } = e;
+        if (!Number.isSafeInteger(loop) || !Number.isSafeInteger(turn) || !Number.isSafeInteger(sequence)) {
+            throw new TypeError("A log row carries its loop, turn and sequence ordinals.");
+        }
+        return `${loop}/${turn}/${sequence}`;
+    }
+    // {§agui-readable-reasoning} Reasoning is the request that streamed it, live and on replay alike; reasoning a
+    // FORK inherited was streamed by no request of this worker and is its row's.
+    static #requestReasoningId(modelCallId, requestSequence) {
+        return `model-call-${modelCallId}/request-${requestSequence}/reasoning`;
+    }
+    static #reasoningId(e, id) {
+        const { reasoning_model_call_id: call, reasoning_request_sequence: request } = e;
+        return typeof call === "number" && typeof request === "number" ? Translator.#requestReasoningId(call, request) : `${id}/reasoning`;
+    }
+    // {§message-arrival} An arrival is a user message, live and on replay alike. One a client on this thread sent is that
+    // client's own, under its message id and as it sent it; any other is identified by its coordinate and named by its
+    // source ({§message-causal-source}).
+    #arrival(e) {
+        if (e.origin !== "_plurnk" || e.op !== "SEND" || Translator.#attrKind(e.attrs) !== "message")
+            return null;
+        const messageId = MessageAddress.messageId(e.source, this.#threadId);
+        if (messageId !== null)
+            return { id: messageId, content: Translator.#txBody(e.tx) };
+        return {
+            id: this.#id(e),
+            content: Translator.#txBody(e.tx),
+            ...(typeof e.source === "string" ? { name: e.source } : {}),
+        };
+    }
+    // {§agui-call-result} A call its receipt does not answer: a gated one awaits its own settlement ({§proposal-202-pauses}),
+    // and one that opened an obligation the delivery that discharges it.
+    static #answeredLater(e) {
+        return e.state === "proposed" || Translator.#opensObligation(e);
+    }
+    // {§agui-call-result} A call that opened an obligation is answered by the delivery that discharges it, never by its
+    // receipt, which rides the row: an execution its stream, a message the reply or conclusion ({§worker-obligations}).
+    static #opensObligation(e) {
+        const attrs = typeof e.attrs === "string" ? JSON.parse(e.attrs) : e.attrs;
+        const opened = attrs !== null && typeof attrs === "object" ? attrs : {};
+        return (typeof opened.stream === "string" || typeof opened.message === "string") && typeof e.status_rx === "number" && e.status_rx < 400;
+    }
+    // {§agui-call-result} What the worker received for its call: a reply's words, as an arrival's ({§agui-snapshot}),
+    // or an observation's result.
+    static #delivered(e) {
+        return e.op === "SEND" ? Translator.#txBody(e.tx) : Translator.#asText(e.rx);
+    }
+    // {§agui-call-result} The call a discharging row answers: the operation it names ({§methods-invocation}), in the
+    // namespace of the worker whose log holds both.
+    #answered(e) {
+        if (e.invocation === undefined)
+            return null;
+        const coordinate = Translator.callOf(e.invocation);
+        return this.#subagent === null ? coordinate : `${Translator.subagentIds(this.#subagent.worker)}#${coordinate}`;
+    }
+    // {§agui-plurnk-metadata} What the row that builds a message, tool call or result holds beyond the standard fields: its
+    // durable id, log coordinate, worker, origin, operation, source, address, signal, status, attrs and state, the same live
+    // and on snapshot.
+    static #rowMetadata(e) {
+        return { plurnk: { id: e.id, coordinate: Translator.idOf(e), worker: e.worker_id, origin: e.origin, op: e.op, source: e.source,
+                address: Translator.addressOf(e), signal: e.signal, status: e.status_rx, attrs: e.attrs, state: e.state } };
+    }
+    // {§agui-plurnk-metadata} The address a row recorded: `scheme://host[:port]path[?query][#fragment]`, or the bare path a
+    // file target records, with its channel; null when the row named none.
+    static addressOf(e) {
+        const text = (value) => typeof value === "string" ? value : null;
+        const pathname = text(e.pathname);
+        if (pathname === null)
+            return null;
+        const fragment = text(e.fragment) === null ? "" : `#${text(e.fragment)}`;
+        const scheme = text(e.scheme);
+        if (scheme === null)
+            return `${pathname}${fragment}`;
+        const port = typeof e.port === "number" ? `:${e.port}` : "";
+        const query = text(e.query) === null ? "" : `?${text(e.query)}`;
+        return `${scheme}://${text(e.hostname) ?? ""}${port}${pathname}${query}${fragment}`;
+    }
+    // {§agui-plurnk-metadata} Speech holds the body; its heading's aside and its receipt have no field in a text message.
+    static #speechMetadata(e) {
+        const statement = Translator.#parsed(e.tx);
+        const aside = statement !== null && typeof statement === "object" ? statement.aside ?? null : null;
+        return { plurnk: { ...Translator.#rowMetadata(e).plurnk, aside, receipt: Translator.#parsed(e.rx) } };
+    }
+    // A wire field as its value: the live wire ships it parsed, a replayed one may carry its JSON text.
+    static #parsed(value) {
+        if (value === undefined || value === "")
+            return null;
+        if (typeof value !== "string")
+            return value;
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return value;
+        }
+    }
+    // {§methods-invocation} The coordinate of the operation a log address names in its own worker's log.
+    static callOf(invocation) {
+        const match = typeof invocation === "string" ? /^log:\/\/\/(\d+)\/(\d+)\/(\d+)\/[^/]+$/u.exec(invocation) : null;
+        if (match === null)
+            throw new TypeError(`An invocation is an operation's log address: ${String(invocation)}`);
+        return `${match[1]}/${match[2]}/${match[3]}`;
+    }
+    // {§agui-subagents} A delegated worker's rows are identified within its own namespace, so two logs never collide.
+    static subagentIds(worker) {
+        return `worker://${worker}`;
+    }
+    #id(e) {
+        const coordinate = Translator.idOf(e);
+        return this.#subagent === null ? coordinate : `${Translator.subagentIds(this.#subagent.worker)}#${coordinate}`;
+    }
+    // {§agui-subagents} Everything a delegation's conversation produces is attributed to its subagent run, its metadata
+    // included; only the events that describe a Run itself belong to no subagent.
+    #attributed(events) {
+        const subagent = this.#subagent;
+        if (subagent === null)
+            return events;
+        return events.map((event) => Translator.#runScoped.has(event.type) ? event : { ...event, subagentRunId: subagent.runId });
+    }
+    static #runScoped = new Set([EventType.RUN_STARTED, EventType.RUN_FINISHED, EventType.RUN_ERROR, EventType.MESSAGES_SNAPSHOT]);
+    // {§agui-snapshot} A result sits where the official reducer puts one that arrives live: after its call and the results
+    // already beside it, or last when the call is not in view.
+    static #placeResult(messages, result) {
+        const call = messages.findIndex((message) => message.role === "assistant" && message.toolCalls?.some(({ id }) => id === result.toolCallId) === true);
+        if (call === -1) {
+            messages.push(result);
+            return;
+        }
+        let at = call + 1;
+        while (at < messages.length && messages[at].role === "tool")
+            at++;
+        messages.splice(at, 0, result);
+    }
+    // {§agui-parse-refusal} The call a model operation row is: its operation and its statement, or for a parse refusal the
+    // statement the worker attempted, its verb and its text as written; null for a refusal that names no attempt.
+    static #callOf(e) {
+        if (e.op !== "error")
+            return { name: e.op, args: Translator.#argsFor(e) };
+        const attempt = Translator.#parsed(e.attrs)?.attempt;
+        return typeof attempt?.verb === "string" && typeof attempt.text === "string"
+            ? { name: attempt.verb, args: JSON.stringify({ text: attempt.text }) } : null;
+    }
+    // {§agui-projection} A tool call's arguments are the operation as authored: its durable statement, every operand
+    // exactly as parsed ({§log-sensitive-request-evidence}), without the verb that is the tool's name or the position it
+    // was written at. AG-UI streams arguments as deltas; a dispatched operation is atomic, so they arrive as one.
     static #argsFor(e) {
-        return JSON.stringify({
-            target: e.scheme !== null && e.scheme !== undefined ? `${e.scheme}://${e.pathname ?? ""}` : e.pathname ?? null,
-            body: Translator.#txBody(e.tx) || undefined,
-            signal: e.signal ?? undefined,
-        });
+        const statement = typeof e.tx === "string" && e.tx.length > 0 ? JSON.parse(e.tx) : e.tx;
+        if (statement === null || typeof statement !== "object" || Array.isArray(statement))
+            return JSON.stringify({});
+        const { op: _op, position: _position, ...operands } = statement;
+        return JSON.stringify(operands);
     }
 }
 //# sourceMappingURL=Translator.js.map