@zq-silk/yui 0.13.9 → 0.14.0

package/dist/runtime/agentHost.js

@@ -8,7 +8,7 @@ import { callController, controllerCallMayHaveApplied, ControllerClientError } f
 import { readHomeFilesystemId } from "../core/homeFilesystemIdentity.js";
 import { callFileTaskController } from "../controller/clientRuntime.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
-import { publishStructuredProviderAccepted, publishStructuredProviderActivationTerminal, publishStructuredConversationRecoverability, publishStructuredProviderOpened, publishStructuredProviderTerminal } from "../controller/structuredProviderObservation.js";
+import { publishStructuredProviderAccepted, publishStructuredProviderActivationTerminal, publishStructuredProviderGoal, publishStructuredConversationRecoverability, publishStructuredProviderOpened, publishStructuredProviderStarted, publishStructuredProviderTerminal } from "../controller/structuredProviderObservation.js";
 import { validateAgentHostLaunchPayload } from "./launchBroker.js";
 import { ProviderDeliveryUnknownError, ProviderConversationMissingError, ProviderTurnBusyError, ProviderTurnRejectedError, startStructuredProviderSession } from "./structuredProviderHost.js";
 import { sameProviderAuthorityFence, validateProviderAuthorityFence } from "./providerAuthorityFence.js";
@@ -42,6 +42,7 @@ export async function runAgentHost(input) {
     let snapshot = hostSnapshot("idle");
     let dispatchTail = Promise.resolve();
     let promptHuman = () => { };
+    const recentSteerAttempts = new Set();
     await replayExitOutbox(input.home);
     const updateSnapshot = (next) => {
         snapshot = validateSnapshot(next);
@@ -51,6 +52,29 @@ export async function runAgentHost(input) {
         authorityOwner: authority.owner,
         authorityHolderId: authority.holderId
     };
+    const handleStarted = (started, observedPayload = sessionPayload) => {
+        if (started.clientOwned || observedPayload === undefined)
+            return;
+        updateSnapshot(hostSnapshot("busy", {
+            launchId: observedPayload.launchId,
+            adapterId: observedPayload.providerControl?.adapterId,
+            processInstanceId: session?.processInstanceId,
+            nativeSessionId: started.nativeSessionId,
+            conversationId: started.conversationId,
+            nativeTurnId: started.nativeTurnId,
+            ...authorityFields()
+        }));
+        const directActivationId = activationId ?? observedPayload.launchId;
+        void enqueueSerialized(async () => {
+            await publishStructuredProviderStarted({
+                home: input.home,
+                environment: observedPayload.environment,
+                activationId: directActivationId,
+                started
+            });
+            signalRoleMailbox(input.home, observedPayload);
+        }).catch(() => { });
+    };
     const handleTerminal = (terminal) => {
         if (!terminal.clientOwned) {
             const busyPayload = sessionPayload;
@@ -58,19 +82,29 @@ export async function runAgentHost(input) {
                 || session === undefined
                 || terminal.conversationId !== session.conversationId)
                 return;
-            // Another ordinary client completed a Turn. It never enters Yui's Run
-            // observation path; it only removes backpressure from retained work.
-            if (snapshot.state === "busy") {
-                updateSnapshot(hostSnapshot("idle", {
-                    launchId: busyPayload.launchId,
-                    adapterId: session.adapterId,
-                    processInstanceId: session.processInstanceId,
-                    nativeSessionId: session.nativeSessionId,
-                    conversationId: session.conversationId,
-                    ...authorityFields()
-                }));
-            }
-            signalRoleMailbox(input.home, busyPayload);
+            // A direct Provider client shares the Session but still produces a Yui
+            // Turn audit record. It has no WorkItem ownership and no managed input
+            // fence; the runtime observer records only visible input/output.
+            const directActivationId = activationId ?? busyPayload.launchId;
+            void enqueueSerialized(async () => {
+                await publishStructuredProviderTerminal({
+                    home: input.home,
+                    environment: busyPayload.environment,
+                    activationId: directActivationId,
+                    terminal
+                });
+                if (session !== undefined && terminal.conversationId === session.conversationId) {
+                    updateSnapshot(hostSnapshot(session.activeTurnId === undefined ? "idle" : "busy", {
+                        launchId: busyPayload.launchId,
+                        adapterId: session.adapterId,
+                        processInstanceId: session.processInstanceId,
+                        nativeSessionId: session.nativeSessionId,
+                        conversationId: session.conversationId,
+                        ...authorityFields()
+                    }));
+                }
+                signalRoleMailbox(input.home, busyPayload);
+            }).catch(() => { });
             return;
         }
         const terminalPayload = activeTurnPayload;
@@ -130,6 +164,23 @@ export async function runAgentHost(input) {
             }
         }).catch(() => { });
     };
+    const handleGoal = (goal) => {
+        const currentPayload = activeTurnPayload ?? sessionPayload;
+        const currentSession = session;
+        if (currentPayload === undefined || currentSession === undefined)
+            return;
+        const currentActivationId = activationId ?? currentPayload.launchId;
+        void enqueueSerialized(async () => {
+            await publishStructuredProviderGoal({
+                home: input.home,
+                environment: currentPayload.environment,
+                activationId: currentActivationId,
+                conversationId: currentSession.conversationId,
+                goal
+            });
+            signalRoleMailbox(input.home, currentPayload);
+        }).catch(() => { });
+    };
     const reconnectCodexClient = async (disconnectedSession, currentPayload) => {
         const previousControl = currentPayload.providerControl;
         if (previousControl?.adapterId !== "codex" || authority === undefined) {
@@ -169,7 +220,9 @@ export async function runAgentHost(input) {
                 return;
             try {
                 const started = await startStructuredProviderSession(reconnectPayload, {
-                    onTerminal: handleTerminal
+                    onStarted: (turn) => handleStarted(turn, currentPayload),
+                    onTerminal: handleTerminal,
+                    onGoal: handleGoal
                 });
                 session = started.session;
                 sessionPayload = currentPayload;
@@ -197,6 +250,17 @@ export async function runAgentHost(input) {
                 if (started.recoveredTerminal !== undefined) {
                     handleTerminal(started.recoveredTerminal);
                 }
+                if (ownedTurn === undefined && started.session.activeTurnId !== undefined) {
+                    handleStarted({
+                        conversationId: started.session.conversationId,
+                        nativeSessionId: started.session.nativeSessionId,
+                        nativeTurnId: started.session.activeTurnId,
+                        clientOwned: false,
+                        observedAt: new Date().toISOString()
+                    }, currentPayload);
+                }
+                if (started.goal !== undefined)
+                    handleGoal(started.goal);
                 return;
             }
             catch (error) {
@@ -298,9 +362,9 @@ export async function runAgentHost(input) {
                         ? {}
                         : { taskId: currentPayload.environment.YUI_TASK_ID }),
                     roleName: currentPayload.environment.YUI_ROLE ?? "unknown-role",
-                    ...(currentPayload.environment.YUI_RUN_ID === undefined
+                    ...(currentPayload.environment.YUI_TURN_ID === undefined
                         ? {}
-                        : { runId: currentPayload.environment.YUI_RUN_ID }),
+                        : { turnId: currentPayload.environment.YUI_TURN_ID }),
                     launchId: currentPayload.launchId,
                     ...(providerSession.nativeSessionId.length === 0
                         ? {}
@@ -372,6 +436,7 @@ export async function runAgentHost(input) {
             }),
             ...authorityFields()
         }));
+        let recoveredGoal;
         try {
             if (session !== undefined) {
                 if (session.adapterId !== providerControl.adapterId
@@ -391,9 +456,14 @@ export async function runAgentHost(input) {
                     activeTurnAttemptId = providerControl.ownedTurn.attemptId;
                     activeNativeTurnId = providerControl.ownedTurn.turnId;
                 }
-                const started = await startStructuredProviderSession(next, { onTerminal: handleTerminal });
+                const started = await startStructuredProviderSession(next, {
+                    onStarted: (turn) => handleStarted(turn, next),
+                    onTerminal: handleTerminal,
+                    onGoal: handleGoal
+                });
                 session = started.session;
                 sessionPayload = next;
+                recoveredGoal = started.goal;
                 if (started.session.adapterId === "codex") {
                     codexClientAttachedAt = Date.now();
                     consecutiveCodexDisconnects = 0;
@@ -402,6 +472,16 @@ export async function runAgentHost(input) {
                 if (started.recoveredTerminal !== undefined) {
                     handleTerminal(started.recoveredTerminal);
                 }
+                if ((providerControl.kind !== "restore" || providerControl.ownedTurn === undefined)
+                    && started.session.activeTurnId !== undefined) {
+                    handleStarted({
+                        conversationId: started.session.conversationId,
+                        nativeSessionId: started.session.nativeSessionId,
+                        nativeTurnId: started.session.activeTurnId,
+                        clientOwned: false,
+                        observedAt: new Date().toISOString()
+                    }, next);
+                }
             }
             await publishStructuredProviderOpened({
                 home: input.home,
@@ -412,6 +492,15 @@ export async function runAgentHost(input) {
                 recoverability: conversationRecoverability,
                 observedAt: new Date().toISOString()
             });
+            if (recoveredGoal !== undefined) {
+                await publishStructuredProviderGoal({
+                    home: input.home,
+                    environment: next.environment,
+                    activationId: activationId ?? next.launchId,
+                    conversationId: session.conversationId,
+                    goal: recoveredGoal
+                });
+            }
             const restoredOwnedTurn = providerControl.kind === "restore"
                 ? providerControl.ownedTurn
                 : undefined;
@@ -488,11 +577,12 @@ export async function runAgentHost(input) {
         if (activeTurnPayload !== undefined || snapshot.state === "settling") {
             throw new ProviderTurnBusyError("Agent Host still owns an unsettled Provider Turn.", request.turn.attemptId, activeNativeTurnId);
         }
+        const { YUI_TURN_ID: _launchTurnId, ...baseEnvironment } = sessionPayload.environment;
         activeTurnPayload = {
             ...sessionPayload,
             environment: {
-                ...sessionPayload.environment,
-                YUI_RUN_ID: request.runId
+                ...baseEnvironment,
+                ...(request.turnId === undefined ? {} : { YUI_TURN_ID: request.turnId })
             }
         };
         activeTurnAttemptId = request.turn.attemptId;
@@ -506,7 +596,7 @@ export async function runAgentHost(input) {
             attemptId: request.turn.attemptId,
             ...authorityFields()
         }));
-        const durableTurn = hostTurnControlParams(sessionPayload, session.nativeSessionId, request.authority, request.turn.attemptId, request.runId);
+        const durableTurn = hostTurnControlParams(sessionPayload, session.nativeSessionId, request.authority, request.turn.attemptId, request.turnId);
         await beginDurableProviderTurn(input.home, durableTurn);
         let providerAccepted = false;
         try {
@@ -516,7 +606,7 @@ export async function runAgentHost(input) {
             try {
                 await publishStructuredProviderAccepted({
                     home: input.home,
-                    environment: sessionPayload.environment,
+                    environment: activeTurnPayload.environment,
                     activationId: activationId ?? sessionPayload.launchId,
                     receipt
                 });
@@ -569,6 +659,29 @@ export async function runAgentHost(input) {
             throw error;
         }
     };
+    const steerTurn = async (request) => {
+        if (session === undefined || sessionPayload === undefined || activeTurnPayload === undefined) {
+            throw new ProviderTurnRejectedError("Agent Host has no active Provider Turn to steer.", request.turn.attemptId);
+        }
+        if (request.nativeSessionId !== session.nativeSessionId
+            || request.nativeTurnId !== activeNativeTurnId) {
+            throw new ProviderTurnRejectedError("Agent Host steer targets a different Provider Turn.", request.turn.attemptId);
+        }
+        if (authority === undefined || !sameProviderAuthorityFence(authority, request.authority)) {
+            throw new Error("Agent Host rejected a stale Provider writer fence.");
+        }
+        if (recentSteerAttempts.has(request.turn.attemptId))
+            return snapshot;
+        const receipt = await session.steerTurn(request.turn);
+        if (receipt.nativeTurnId !== request.nativeTurnId) {
+            throw new ProviderDeliveryUnknownError("Provider accepted steer against an unexpected native Turn.", request.turn.attemptId);
+        }
+        recentSteerAttempts.add(request.turn.attemptId);
+        if (recentSteerAttempts.size > 256) {
+            recentSteerAttempts.delete(recentSteerAttempts.values().next().value);
+        }
+        return snapshot;
+    };
     const setAuthority = (request) => {
         if (session === undefined || request.nativeSessionId !== session.nativeSessionId) {
             throw new Error("Agent Host authority targets a different Provider Conversation.");
@@ -605,6 +718,10 @@ export async function runAgentHost(input) {
             const accepted = await enqueueSerialized(() => submitTurn(request));
             return controlResult("accepted", accepted);
         }
+        if (request.type === "steer-turn") {
+            const accepted = await enqueueSerialized(() => steerTurn(request));
+            return controlResult("accepted", accepted);
+        }
         if (request.type === "set-authority") {
             const accepted = await enqueueSerialized(async () => setAuthority(request));
             return controlResult("accepted", accepted);
@@ -652,22 +769,13 @@ export async function runAgentHost(input) {
                 type: "submit-turn",
                 launchId: currentPayload.launchId,
                 nativeSessionId: currentSession.nativeSessionId,
-                runId: requiredEnvironment(currentPayload.environment.YUI_RUN_ID, "Run id"),
                 authority: currentAuthority,
                 turn: {
                     attemptId,
                     boundedText
                 }
             };
-            const durableTurn = hostTurnControlParams(currentPayload, currentSession.nativeSessionId, currentAuthority, attemptId);
-            await beginDurableProviderTurn(input.home, durableTurn);
-            try {
-                await submitTurn(turnControl);
-            }
-            catch (error) {
-                await resolveProviderTurnSubmission(input.home, durableTurn, error);
-                throw error;
-            }
+            await submitTurn(turnControl);
             process.stdout.write("Provider accepted the human Turn; waiting for its terminal boundary.\n");
         }).catch((error) => {
             process.stderr.write(`Provider input failed: ${errorText(error)}\n`);
@@ -736,6 +844,9 @@ export async function sendAgentHostLaunchControl(input) {
 export async function sendAgentHostTurnControl(input) {
     return await sendAgentHostControl(input);
 }
+export async function sendAgentHostSteerControl(input) {
+    return await sendAgentHostControl(input);
+}
 export async function sendAgentHostAuthorityControl(input) {
     return await sendAgentHostControl(input);
 }
@@ -919,10 +1030,14 @@ function validateControl(control) {
     }
     if (control.type === "status")
         return Object.freeze({ ...control });
-    if (control.type === "submit-turn") {
+    if (control.type === "submit-turn" || control.type === "steer-turn") {
         validateLaunchId(control.launchId);
         validateIdentity(control.nativeSessionId, "native Session id");
-        validateIdentity(control.runId, "Run id");
+        if (control.type === "submit-turn" && control.turnId !== undefined) {
+            validateIdentity(control.turnId, "Turn id");
+        }
+        if (control.type === "steer-turn")
+            validateIdentity(control.nativeTurnId, "native Turn id");
         validateProviderAuthorityFence(control.authority);
         validateIdentity(control.turn.attemptId, "Provider input attempt id");
         if (typeof control.turn.boundedText !== "string"
@@ -1028,12 +1143,12 @@ async function delay(milliseconds) {
         timer.unref();
     });
 }
-function hostTurnControlParams(payload, nativeSessionId, authority, attemptId, runId = requiredEnvironment(payload.environment.YUI_RUN_ID, "Run id")) {
+function hostTurnControlParams(payload, nativeSessionId, authority, attemptId, turnId) {
     const environment = payload.environment;
     return Object.freeze({
         taskId: requiredEnvironment(environment.YUI_TASK_ID, "Task id"),
         roleName: requiredEnvironment(environment.YUI_ROLE, "Role name"),
-        runId: requiredEnvironment(runId, "Run id"),
+        ...(turnId === undefined ? {} : { turnId: requiredEnvironment(turnId, "Turn id") }),
         agentId: requiredEnvironment(environment.YUI_AGENT_ID, "Agent id"),
         launchId: payload.launchId,
         nativeSessionId: requiredEnvironment(nativeSessionId, "native Session id"),

package/dist/runtime/builtinAgentDrivers.js

@@ -35,7 +35,7 @@ const STRUCTURED_CLI_CAPABILITIES = Object.freeze({
     }),
     input: Object.freeze({
         startTurn: true,
-        steer: "unavailable",
+        steer: "fenced",
         inject: "unavailable",
         acceptance: "exact",
         idempotency: "unavailable"
@@ -52,6 +52,7 @@ const STRUCTURED_CLI_CAPABILITIES = Object.freeze({
         preInputReadiness: "unavailable",
         promptAcceptance: "exact",
         turnLifecycle: "exact",
+        goalLifecycle: "partial",
         // Transcript sources may emit an explicit activity identity separately
         // from usage snapshots. Numeric token values never decide runtime health.
         operations: Object.freeze(["tool", "subagent"]),
@@ -129,6 +130,7 @@ export const BUILTIN_AGENT_DRIVERS = Object.freeze([
                 // to manufacture tool/wait/usage observations.
                 operations: Object.freeze([]),
                 waiting: Object.freeze([]),
+                goalLifecycle: "exact",
                 usage: "unavailable"
             })
         }),
@@ -161,6 +163,16 @@ export function builtinAgentDriverRegistry() {
     return registry;
 }
 function mapClaudeHook(name, payload, occurrenceId) {
+    const lifecycle = mapClaudeLifecycleHook(name, payload, occurrenceId);
+    const goal = claudeGoalObservation(payload, occurrenceId);
+    if (goal === undefined)
+        return lifecycle;
+    return Object.freeze([
+        ...(Array.isArray(lifecycle) ? lifecycle : [lifecycle]),
+        goal
+    ]);
+}
+function mapClaudeLifecycleHook(name, payload, occurrenceId) {
     switch (name) {
         case "SessionStart":
             return [
@@ -248,6 +260,71 @@ function mapClaudeHook(name, payload, occurrenceId) {
             throw new Error(`Claude Code Driver does not support Hook event: ${name}.`);
     }
 }
+function claudeGoalObservation(payload, occurrenceId) {
+    if (!Object.hasOwn(payload, "active_goal"))
+        return undefined;
+    if (payload.active_goal === null)
+        return mapped("goal.cleared");
+    const goal = objectValue(payload.active_goal);
+    if (goal === undefined)
+        return undefined;
+    const objective = textValue(goal.objective);
+    const status = normalizedGoalStatus(goal.status);
+    const updatedAt = timestampValue(goal.updated_at ?? goal.updatedAt)
+        ?? timestampValue(payload.timestamp)
+        ?? occurrenceTimestamp(occurrenceId);
+    if (objective === undefined || status === undefined || updatedAt === undefined)
+        return undefined;
+    const tokenBudget = positiveIntegerValue(goal.token_budget ?? goal.tokenBudget);
+    return mapped("goal.updated", {
+        goalStatus: status,
+        goalObjective: objective,
+        goalUpdatedAt: updatedAt,
+        ...(optionalIdentityFrom(goal, ["turn_id", "turnId"]) === undefined
+            ? {}
+            : { goalNativeTurnId: optionalIdentityFrom(goal, ["turn_id", "turnId"]) }),
+        ...(tokenBudget === undefined ? {} : { goalTokenBudget: tokenBudget })
+    });
+}
+function normalizedGoalStatus(value) {
+    if (value === "active" || value === "paused" || value === "blocked" || value === "complete") {
+        return value;
+    }
+    if (value === "usageLimited" || value === "usage_limited" || value === "usage-limited") {
+        return "usage-limited";
+    }
+    if (value === "budgetLimited" || value === "budget_limited" || value === "budget-limited") {
+        return "budget-limited";
+    }
+    return undefined;
+}
+function objectValue(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function textValue(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function positiveIntegerValue(value) {
+    return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function timestampValue(value) {
+    if (typeof value === "string" && Number.isFinite(Date.parse(value))) {
+        return new Date(value).toISOString();
+    }
+    if (Number.isSafeInteger(value) && value >= 0) {
+        const epoch = value;
+        return new Date(epoch < 1_000_000_000_000 ? epoch * 1_000 : epoch).toISOString();
+    }
+    return undefined;
+}
+function occurrenceTimestamp(value) {
+    const prefix = value?.slice(0, 24);
+    return prefix !== undefined && Number.isFinite(Date.parse(prefix))
+        ? new Date(prefix).toISOString()
+        : undefined;
+}
 function mapCodexHook(name, payload, occurrenceId) {
     switch (name) {
         case "SessionStart":
@@ -402,7 +479,7 @@ function claudeFailure(payload) {
             }),
             ...(lastOutput === undefined ? {} : { lastOutput }),
             ...(payload.run_terminal === true || payload.unrecoverable === true
-                ? { runTerminal: true }
+                ? { turnTerminal: true }
                 : {})
         },
         summary: [

package/dist/runtime/codexAppServerRuntime.js

@@ -49,6 +49,12 @@ export class CodexAppServerRuntime {
         });
         return parseThreadSnapshot(result, id, "unknown");
     }
+    async readGoal(conversationId) {
+        const id = text(conversationId, "Codex thread id");
+        const result = await this.transport.request("thread/goal/get", { threadId: id });
+        const goal = objectMember(result, "goal");
+        return goal === null ? null : codexThreadGoal(goal, id);
+    }
     async inspectConversation(conversationId) {
         const id = text(conversationId, "Codex thread id");
         try {
@@ -235,12 +241,29 @@ export function codexNotificationBoundary(input) {
         ?? optionalId(objectMember(input.params, "turn")?.id);
     if (input.method === "thread/closed")
         return { kind: "activation-ended", conversationId };
+    if (input.method === "thread/goal/updated")
+        return { kind: "goal-updated", conversationId, turnId };
+    if (input.method === "thread/goal/cleared")
+        return { kind: "goal-cleared", conversationId };
     if (input.method === "turn/started")
         return { kind: "turn-started", conversationId, turnId };
     if (input.method === "turn/completed")
         return { kind: "turn-completed", conversationId, turnId };
     return { kind: "other", conversationId, turnId };
 }
+export function codexGoalNotification(input) {
+    const conversationId = optionalId(input.params.threadId);
+    if (conversationId === undefined)
+        return undefined;
+    if (input.method === "thread/goal/cleared")
+        return null;
+    if (input.method !== "thread/goal/updated")
+        return undefined;
+    const goal = objectMember(input.params, "goal");
+    if (goal === null)
+        return undefined;
+    return codexThreadGoal(goal, conversationId);
+}
 function parseThreadSnapshot(result, expectedThreadId, loaded) {
     const thread = objectMember(result, "thread") ?? result;
     const id = optionalId(thread.id) ?? expectedThreadId;
@@ -254,10 +277,12 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
         if (turnId === undefined)
             return [];
         const status = optionalTurnStatus(turn.status);
+        const summary = codexTurnSummary(turn);
         const error = providerError(turn.error);
         return [{
                 turnId,
                 ...(status === undefined ? {} : { status }),
+                ...(summary === undefined ? {} : { summary }),
                 ...(error === undefined ? {} : { error })
             }];
     });
@@ -275,6 +300,62 @@ function parseThreadSnapshot(result, expectedThreadId, loaded) {
         raw: result
     };
 }
+/** Extract the last assistant message from one native Codex Turn. */
+export function codexTurnSummary(turn) {
+    for (const value of [...arrayMember(turn, "items")].reverse()) {
+        const item = object(value);
+        if (item === null)
+            continue;
+        const type = item.type;
+        const message = object(item.message);
+        const agentMessage = type === "agentMessage"
+            || type === "agent_message"
+            || (type === "message" && (item.role === "assistant" || message?.role === "assistant"));
+        if (!agentMessage)
+            continue;
+        const text = messageText(item) ?? (message === null ? undefined : messageText(message));
+        if (text !== undefined)
+            return text;
+    }
+    return undefined;
+}
+/** Extract the provider-visible human input without copying tool or reasoning items. */
+export function codexTurnInput(turn) {
+    for (const value of arrayMember(turn, "items")) {
+        const item = object(value);
+        if (item === null)
+            continue;
+        const type = item.type;
+        const message = object(item.message);
+        const userMessage = type === "userMessage"
+            || type === "user_message"
+            || (type === "message" && (item.role === "user" || message?.role === "user"));
+        if (!userMessage)
+            continue;
+        const text = messageText(item) ?? (message === null ? undefined : messageText(message));
+        if (text !== undefined)
+            return text;
+    }
+    return undefined;
+}
+function messageText(message) {
+    for (const value of [message.text, message.content]) {
+        if (typeof value === "string" && value.trim().length > 0)
+            return value.trim();
+        if (!Array.isArray(value))
+            continue;
+        const parts = value.flatMap((part) => {
+            if (typeof part === "string" && part.trim().length > 0)
+                return [part];
+            const record = object(part);
+            const text = record?.text ?? record?.content;
+            return typeof text === "string" && text.trim().length > 0 ? [text] : [];
+        });
+        if (parts.length > 0)
+            return parts.join("\n").trim();
+    }
+    return undefined;
+}
 function providerError(value) {
     if (typeof value === "string" && value.trim().length > 0)
         return value.trim();
@@ -286,6 +367,47 @@ function providerError(value) {
     }
     return JSON.stringify(record);
 }
+function codexThreadGoal(goal, expectedThreadId) {
+    const conversationId = text(goal.threadId, "Codex Goal thread id");
+    if (conversationId !== expectedThreadId) {
+        throw new Error("Codex Goal belongs to a different thread.");
+    }
+    const status = codexGoalStatus(goal.status);
+    const tokenBudget = goal.tokenBudget;
+    return Object.freeze({
+        conversationId,
+        status,
+        objective: text(goal.objective, "Codex Goal objective"),
+        updatedAt: codexEpochTimestamp(goal.updatedAt),
+        ...(tokenBudget === null || tokenBudget === undefined
+            ? {}
+            : { tokenBudget: positiveInteger(tokenBudget, "Codex Goal token budget") })
+    });
+}
+function codexGoalStatus(value) {
+    switch (value) {
+        case "active":
+        case "paused":
+        case "blocked":
+        case "complete":
+            return value;
+        case "usageLimited": return "usage-limited";
+        case "budgetLimited": return "budget-limited";
+        default: throw new Error("Codex Goal status is invalid.");
+    }
+}
+function codexEpochTimestamp(value) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+        throw new Error("Codex Goal updatedAt is invalid.");
+    }
+    const epoch = value;
+    return new Date(epoch < 1_000_000_000_000 ? epoch * 1_000 : epoch).toISOString();
+}
+function positiveInteger(value, label) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new Error(`${label} is invalid.`);
+    return value;
+}
 function codexContinuationState(snapshot) {
     if (snapshot.status === "active" || snapshot.latestTurnStatus === "inProgress") {
         return {

package/dist/runtime/continuationManager.js

@@ -11,7 +11,7 @@ export function foldContinuationObservation(existing, raw) {
     const base = existing ?? createProviderContinuation({
         taskId: observation.fence.taskId,
         roleName: observation.fence.roleName,
-        runId: observation.fence.runId,
+        turnId: observation.fence.turnId,
         identity,
         ...(observation.fence.parentContinuationId === undefined
             ? {}
@@ -107,9 +107,7 @@ export function applyContinuationObservationAtomically(store, raw, factRef) {
                     refs: [factRef],
                     occurredAt: observation.observedAt ?? observation.receivedAt,
                     source: "continuation-manager",
-                    dedupeKey: observation.semanticKey,
-                    deliveryMode: "followup",
-                    lane: "normal"
+                    dedupeKey: observation.semanticKey
                 }
             });
         }
@@ -118,7 +116,7 @@ export function applyContinuationObservationAtomically(store, raw, factRef) {
 }
 function continuationIdentity(observation) {
     const fence = observation.fence;
-    if (fence.taskId === undefined || fence.runId === undefined
+    if (fence.taskId === undefined || fence.turnId === undefined
         || fence.conversationId === undefined || fence.activationId === undefined
         || fence.continuationId === undefined) {
         throw new Error("Continuation observation fence is incomplete.");