@zq-silk/yui 0.14.0 → 0.14.2

package/dist/runtime/runtimeObservation.js

@@ -86,8 +86,8 @@ const PROVIDER_STATE = new Set([
     "operation.failed"
 ]);
 export function createRuntimeObservation(input) {
-    if (input.schemaVersion !== 2)
-        throw new Error("Runtime observation schemaVersion must be 2.");
+    if (input.schemaVersion !== 4)
+        throw new Error("Runtime observation schemaVersion must be 4.");
     if (!KINDS.includes(input.kind))
         throw new Error("Runtime observation kind is invalid.");
     if (!AUTHORITIES.includes(input.authority))
@@ -133,7 +133,7 @@ export function createRuntimeObservation(input) {
         throw new Error("Runtime observation ordinal must be a non-negative safe integer.");
     }
     return Object.freeze({
-        schemaVersion: 2,
+        schemaVersion: 4,
         eventId: requireIdentity(input.eventId, "Runtime observation event id"),
         semanticKey: requireIdentity(input.semanticKey, "Runtime observation semantic key"),
         kind: input.kind,
@@ -155,8 +155,7 @@ export function runtimeObservationFenceMatches(expected, actual) {
         "turnId",
         "agentId",
         "driverId",
-        "launchId",
-        "sessionGenerationId",
+        "runtimeGenerationId",
         "conversationId",
         "activationId",
         "continuationId",
@@ -172,7 +171,7 @@ export function runtimeObservationFenceMatches(expected, actual) {
     return true;
 }
 /**
- * Matches observations that belong to one durable Turn/Session generation.
+ * Matches observations that belong to one durable Turn/Runtime generation.
  * A provider may advance its native Turn while background subagents from an
  * earlier Turn are still active and later mailbox activations use their own
  * exactly-once receipt, so nativeTurnId and receiptId are intentionally
@@ -185,8 +184,7 @@ export function runtimeObservationTurnFenceMatches(expected, actual) {
         "turnId",
         "agentId",
         "driverId",
-        "launchId",
-        "sessionGenerationId",
+        "runtimeGenerationId",
         "nativeSessionId"
     ]) {
         if (expected[field] !== actual[field])
@@ -203,7 +201,7 @@ export function runtimeObservationTaskEventPayload(input) {
         roleName: observation.fence.roleName,
         agentId: observation.fence.agentId,
         driverId: observation.fence.driverId,
-        launchId: observation.fence.launchId,
+        runtimeGenerationId: observation.fence.runtimeGenerationId,
         ...(observation.fence.taskId === undefined ? {} : { taskId: observation.fence.taskId }),
         ...(observation.fence.turnId === undefined ? {} : { turnId: observation.fence.turnId }),
         ...(observation.fence.nativeSessionId === undefined
@@ -247,8 +245,7 @@ function normalizeFence(input) {
         ...(input.turnId === undefined ? {} : { turnId: requireIdentity(input.turnId, "Turn id") }),
         agentId: requireIdentity(input.agentId, "Agent id"),
         driverId: requireDriverId(input.driverId),
-        launchId: requireIdentity(input.launchId, "Launch id"),
-        sessionGenerationId: requireIdentity(input.sessionGenerationId, "Session generation id"),
+        runtimeGenerationId: requireIdentity(input.runtimeGenerationId, "Runtime generation id"),
         ...(input.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireIdentity(input.nativeSessionId, "Native Session id") }),
@@ -323,6 +320,12 @@ function normalizePayload(kind, input) {
     if (kind === "turn.failed" && input.failure === undefined) {
         throw new Error("turn.failed requires normalized failure evidence.");
     }
+    if (input.resultTransportDiagnostic !== undefined && kind !== "turn.completed") {
+        throw new Error("Only turn.completed may carry a result transport diagnostic.");
+    }
+    if (input.output !== undefined && input.resultTransportDiagnostic !== undefined) {
+        throw new Error("A runtime observation cannot carry Agent output and a result diagnostic.");
+    }
     if (kind === "conversation.observed"
         && !["unknown", "recoverable", "unrecoverable"].includes(input.recoverability ?? "")) {
         throw new Error("conversation.observed requires recoverability.");
@@ -404,6 +407,14 @@ function normalizePayload(kind, input) {
             : { observerDetail: requireText(input.observerDetail, "Runtime observer detail") }),
         ...(failure === undefined ? {} : { failure }),
         ...(input.input === undefined ? {} : { input: requireText(input.input, "Provider-visible input") }),
+        ...(input.output === undefined
+            ? {}
+            : { output: requireResultText(input.output, "Runtime Turn output") }),
+        ...(input.resultTransportDiagnostic === undefined
+            ? {}
+            : {
+                resultTransportDiagnostic: requireText(input.resultTransportDiagnostic, "Runtime Turn result diagnostic")
+            }),
         ...(input.summary === undefined ? {} : { summary: requireText(input.summary, "Runtime summary") }),
         ...(input.execution === undefined ? {} : { execution: input.execution }),
         ...(input.outcome === undefined ? {} : { outcome: input.outcome }),
@@ -449,8 +460,8 @@ export function runtimeObservationSemanticKey(input) {
     const continuationIdentity = [
         fence.driverId,
         fence.agentId,
-        fence.conversationId ?? fence.nativeSessionId ?? fence.launchId,
-        fence.activationId ?? fence.launchId,
+        fence.conversationId ?? fence.nativeSessionId ?? fence.runtimeGenerationId,
+        fence.activationId ?? fence.runtimeGenerationId,
         fence.continuationId ?? "none",
         fence.continuationGeneration ?? "none"
     ];
@@ -475,7 +486,7 @@ export function runtimeObservationSemanticKey(input) {
         return [
             "goal-state",
             fence.driverId,
-            fence.conversationId ?? fence.nativeSessionId ?? fence.launchId,
+            fence.conversationId ?? fence.nativeSessionId ?? fence.runtimeGenerationId,
             input.payload?.goalStatus ?? "unknown",
             input.payload?.goalUpdatedAt ?? "unknown"
         ].join(":");
@@ -504,8 +515,8 @@ export function runtimeObservationSemanticKey(input) {
         return [
             "provider-sequence",
             fence.driverId,
-            fence.conversationId ?? fence.nativeSessionId ?? fence.launchId,
-            fence.activationId ?? fence.launchId,
+            fence.conversationId ?? fence.nativeSessionId ?? fence.runtimeGenerationId,
+            fence.activationId ?? fence.runtimeGenerationId,
             fence.continuationId ?? fence.nativeTurnId ?? "none",
             fence.continuationGeneration ?? "none",
             input.sequence,
@@ -589,3 +600,9 @@ function requireText(value, label) {
     }
     return normalized;
 }
+function requireResultText(value, label) {
+    if (typeof value !== "string" || value.includes("\0") || value.trim().length === 0) {
+        throw new Error(`${label} is invalid.`);
+    }
+    return value;
+}

package/dist/runtime/runtimeSessionCandidate.js

@@ -15,9 +15,9 @@ export function projectRuntimeSessionCandidate(sessions) {
         agentId: active.agentId,
         adapterId: active.adapterId,
         nativeSessionId: active.nativeSessionId,
-        ...(active.launchId === undefined ? {} : { launchId: active.launchId }),
+        ...(active.runtimeGenerationId === undefined ? {} : { runtimeGenerationId: active.runtimeGenerationId }),
         sessionUpdatedAt: active.updatedAt,
-        cleanupRequired: active.launchId !== undefined
+        cleanupRequired: active.runtimeGenerationId !== undefined
     };
 }
 /** Deterministic owner order shared by all storage backends. */

package/dist/runtime/runtimeStopReceipt.js

@@ -1,16 +1,16 @@
 import { createHash } from "node:crypto";
 import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-export function writeRuntimeStopReceipt(home, launchId, requestedAt) {
+export function writeRuntimeStopReceipt(home, runtimeGenerationId, requestedAt) {
     const receipt = Object.freeze({
         schemaVersion: 1,
         receiptId: `runtime-stop-${createHash("sha256")
-            .update(`${launchId}\0${requestedAt.toISOString()}`)
+            .update(`${runtimeGenerationId}\0${requestedAt.toISOString()}`)
             .digest("hex")}`,
-        launchId,
+        runtimeGenerationId,
         requestedAt: requestedAt.toISOString()
     });
-    const path = stopReceiptPath(home, launchId);
+    const path = stopReceiptPath(home, runtimeGenerationId);
     mkdirSync(resolve(join(home, "runtime", "stop-receipts")), { recursive: true, mode: 0o700 });
     const temporary = `${path}.tmp-${process.pid}`;
     writeFileSync(temporary, `${JSON.stringify(receipt)}\n`, { mode: 0o600 });
@@ -18,10 +18,10 @@ export function writeRuntimeStopReceipt(home, launchId, requestedAt) {
     chmodSync(path, 0o600);
     return receipt;
 }
-export function readRuntimeStopReceipt(home, launchId) {
+export function readRuntimeStopReceipt(home, runtimeGenerationId) {
     try {
-        const value = JSON.parse(readFileSync(stopReceiptPath(home, launchId), "utf8"));
-        if (value.schemaVersion !== 1 || value.launchId !== launchId
+        const value = JSON.parse(readFileSync(stopReceiptPath(home, runtimeGenerationId), "utf8"));
+        if (value.schemaVersion !== 1 || value.runtimeGenerationId !== runtimeGenerationId
             || typeof value.receiptId !== "string" || !Number.isFinite(Date.parse(value.requestedAt))) {
             throw new Error("Runtime stop receipt is invalid.");
         }
@@ -33,10 +33,10 @@ export function readRuntimeStopReceipt(home, launchId) {
         throw error;
     }
 }
-export function removeRuntimeStopReceipt(home, launchId) {
-    rmSync(stopReceiptPath(home, launchId), { force: true });
+export function removeRuntimeStopReceipt(home, runtimeGenerationId) {
+    rmSync(stopReceiptPath(home, runtimeGenerationId), { force: true });
 }
-function stopReceiptPath(home, launchId) {
-    const name = createHash("sha256").update(launchId).digest("hex");
+function stopReceiptPath(home, runtimeGenerationId) {
+    const name = createHash("sha256").update(runtimeGenerationId).digest("hex");
     return resolve(join(home, "runtime", "stop-receipts", `${name}.json`));
 }

package/dist/runtime/sessionLaunchRequest.js

@@ -18,11 +18,11 @@ export function createSessionLaunchRequest(input) {
     if (runtimeIsolation !== undefined && (input.owner.scope !== "task"
         || runtimeIsolation.taskId !== input.owner.taskId
         || runtimeIsolation.workspace.root !== workspace
-        || runtimeIsolation.generation.launchId !== input.launchId)) {
+        || runtimeIsolation.generation.runtimeGenerationId !== input.runtimeGenerationId)) {
         throw new TypeError("Session launch request does not match its Task runtime isolation descriptor.");
     }
     const common = {
-        launchId: requireSafeIdentity(input.launchId, "Launch id"),
+        runtimeGenerationId: requireSafeIdentity(input.runtimeGenerationId, "Runtime generation id"),
         owner: normalizeRuntimeOwner(input.owner),
         agentId,
         adapterId,

package/dist/runtime/sessionOwnerIdentity.js

@@ -29,7 +29,7 @@ export function createSessionOwnerIdentity(input) {
     }
     const tmux = input.tmux;
     return Object.freeze({
-        schemaVersion: 1,
+        schemaVersion: 2,
         kind: "yui-session-owner",
         owner: Object.freeze({
             scope: owner.scope,
@@ -38,7 +38,7 @@ export function createSessionOwnerIdentity(input) {
         }),
         agentId: requireSafeIdentity(input.agentId, "Agent id"),
         adapterId: requireText(input.adapterId, "Adapter id"),
-        launchId: requireSafeIdentity(input.launchId, "Launch id"),
+        runtimeGenerationId: requireSafeIdentity(input.runtimeGenerationId, "Runtime generation id"),
         ...(input.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: requireText(input.nativeSessionId, "Native session id") }),
@@ -134,12 +134,12 @@ export function isLinuxProcessLive(pid, startIdentity) {
     return current.startIdentity === startIdentity;
 }
 /**
- * Discovers the Provider root for one launch by the exact YUI_LAUNCH_ID
+ * Discovers the Provider root for one launch by the exact YUI_RUNTIME_GENERATION_ID
  * environment fence. Returns undefined when no same-user process carries the
  * fence — the caller must not guess from a process name or cwd.
  */
-export function discoverProviderRootByLaunchEnv(launchId) {
-    const matches = listLaunchFencedProcesses(launchId);
+export function discoverProviderRootByLaunchEnv(runtimeGenerationId) {
+    const matches = listLaunchFencedProcesses(runtimeGenerationId);
     for (const pid of matches) {
         const identity = readLinuxProcessIdentity(pid);
         if (identity !== undefined)
@@ -149,13 +149,13 @@ export function discoverProviderRootByLaunchEnv(launchId) {
 }
 /**
  * Lists every live process whose initial environment carries the exact
- * `YUI_LAUNCH_ID=<launchId>` fence. The fence is inherited by Provider
+ * `YUI_RUNTIME_GENERATION_ID=<runtimeGenerationId>` fence. The fence is inherited by Provider
  * children, so this is the exact, PID-reuse-safe attribution for a surviving
  * child after its root has exited: a recycled PID never carries the fence.
  * Processes without the fence are unattributed and must never be signaled.
  */
-export function listLaunchFencedProcesses(launchId) {
-    if (!Number.isSafeInteger(launchId) && !/^[A-Za-z0-9_.:-]+$/u.test(launchId)) {
+export function listLaunchFencedProcesses(runtimeGenerationId) {
+    if (!Number.isSafeInteger(runtimeGenerationId) && !/^[A-Za-z0-9_.:-]+$/u.test(runtimeGenerationId)) {
         return [];
     }
     let entries;
@@ -165,7 +165,7 @@ export function listLaunchFencedProcesses(launchId) {
     catch {
         return [];
     }
-    const needle = `YUI_LAUNCH_ID=${launchId}`;
+    const needle = `YUI_RUNTIME_GENERATION_ID=${runtimeGenerationId}`;
     const matches = [];
     for (const entry of entries) {
         if (!/^[0-9]+$/u.test(entry))

package/dist/runtime/sessionOwnerRegistry.js

@@ -4,7 +4,7 @@ import { createSessionOwnerIdentity } from "./sessionOwnerIdentity.js";
 /**
  * Durable, enumerable physical owner records for runtime generations.
  *
- * One JSON file per launch id under `<home>/runtime/session-owners/`. The
+ * One JSON file per runtime generation id under `<home>/runtime/session-owners/`. The
  * directory is runtime state (like the tmux socket), not aggregate domain
  * state, so it needs no schema migration; it survives a Controller restart and
  * stays enumerable after the durable Session map or history is cleared, which
@@ -22,16 +22,16 @@ export class FileSessionOwnerRegistry {
     /** Atomically records (or replaces) one generation's owner identity. */
     record(identity) {
         mkdirSync(this.#directory, { recursive: true, mode: 0o700 });
-        const target = this.#path(identity.launchId);
+        const target = this.#path(identity.runtimeGenerationId);
         const temporary = `${target}.tmp-${process.pid}`;
         writeFileSync(temporary, JSON.stringify(identity, null, 2) + "\n", { mode: 0o600 });
         renameSync(temporary, target);
     }
-    get(launchId) {
-        if (!isSafeLaunchId(launchId))
+    get(runtimeGenerationId) {
+        if (!isSafeRuntimeGenerationId(runtimeGenerationId))
             return null;
         try {
-            return parseOwnerRecord(readFileSync(this.#path(launchId), "utf8"));
+            return parseOwnerRecord(readFileSync(this.#path(runtimeGenerationId), "utf8"));
         }
         catch {
             return null;
@@ -66,11 +66,11 @@ export class FileSessionOwnerRegistry {
             && record.owner.roleName === owner.roleName));
     }
     /** Removes a record whose physical resources were proven absent. */
-    remove(launchId) {
-        if (!isSafeLaunchId(launchId))
+    remove(runtimeGenerationId) {
+        if (!isSafeRuntimeGenerationId(runtimeGenerationId))
             return;
         try {
-            rmSync(this.#path(launchId), { force: true });
+            rmSync(this.#path(runtimeGenerationId), { force: true });
         }
         catch {
             // A stale record is harmless: reconciliation re-verifies physical
@@ -80,12 +80,12 @@ export class FileSessionOwnerRegistry {
     exists() {
         return existsSync(this.#directory);
     }
-    #path(launchId) {
-        return join(this.#directory, `${launchId}.json`);
+    #path(runtimeGenerationId) {
+        return join(this.#directory, `${runtimeGenerationId}.json`);
     }
 }
-function isSafeLaunchId(launchId) {
-    return /^[A-Za-z0-9_.:-]+$/u.test(launchId);
+function isSafeRuntimeGenerationId(runtimeGenerationId) {
+    return /^[A-Za-z0-9_.:-]+$/u.test(runtimeGenerationId);
 }
 function parseOwnerRecord(raw) {
     const parsed = JSON.parse(raw);
@@ -104,7 +104,7 @@ function parseOwnerRecord(raw) {
         },
         agentId: String(record.agentId),
         adapterId: String(record.adapterId),
-        launchId: String(record.launchId),
+        runtimeGenerationId: String(record.runtimeGenerationId),
         ...(record.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: String(record.nativeSessionId) }),

package/dist/runtime/sessionReconciliation.js

@@ -1,5 +1,5 @@
 /**
- * Bidirectional durable <-> physical reconciliation for Session generations.
+ * Bidirectional durable <-> physical reconciliation for Runtime generations.
  *
  * Durable -> physical: every owner record's Provider root must be absent once
  * its durable Session is terminal; a live root with a terminal durable state
@@ -34,7 +34,7 @@ function reconcileOne(record, input) {
         ? input.taskStatus(owner.taskId)
         : undefined;
     const tmuxPane = input.inspectPane(owner.taskId, owner.roleName);
-    const lastStopOutcome = input.lastStopOutcome(owner.taskId, owner.roleName, record.launchId);
+    const lastStopOutcome = input.lastStopOutcome(owner.taskId, owner.roleName, record.runtimeGenerationId);
     let mismatch;
     let verificationGap;
     if (physical?.identityConflict === true) {
@@ -64,7 +64,7 @@ function reconcileOne(record, input) {
         },
         agentId: record.agentId,
         adapterId: record.adapterId,
-        launchId: record.launchId,
+        runtimeGenerationId: record.runtimeGenerationId,
         ...(record.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: record.nativeSessionId }),
@@ -83,7 +83,7 @@ function matchDurable(record, durable) {
         && fact.roleName === record.owner.roleName
         && (record.owner.scope === "global" || fact.taskId === record.owner.taskId)
         && fact.agentId === record.agentId));
-    const byLaunch = candidates.find((fact) => fact.launchId !== undefined && fact.launchId === record.launchId);
+    const byLaunch = candidates.find((fact) => fact.runtimeGenerationId !== undefined && fact.runtimeGenerationId === record.runtimeGenerationId);
     if (byLaunch !== undefined)
         return byLaunch;
     const byNative = candidates.find((fact) => fact.nativeSessionId !== undefined

package/dist/runtime/sessionTerminationGuard.js

@@ -26,7 +26,7 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
         ports.emit({
             stage: "stop-requested",
             owner,
-            launchId: record.launchId,
+            runtimeGenerationId: record.runtimeGenerationId,
             ...(record.nativeSessionId === undefined
                 ? {}
                 : { nativeSessionId: record.nativeSessionId }),
@@ -37,7 +37,7 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
     // inventory: /proc entries can disappear between the directory and
     // environment reads. Retain every exact child identity observed during the
     // stop so one later scan miss cannot be mistaken for physical zero.
-    const trackedChildren = new Map(records.map((record) => [record.launchId, new Map()]));
+    const trackedChildren = new Map(records.map((record) => [record.runtimeGenerationId, new Map()]));
     for (const record of records) {
         refreshTrackedFencedChildren(record, ports, trackedChildren);
     }
@@ -102,7 +102,7 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
             continue;
         }
         if (verdict.kind === "gap") {
-            verificationGap = `/proc unreadable for launch ${record.launchId}`;
+            verificationGap = `/proc unreadable for launch ${record.runtimeGenerationId}`;
             remaining.push({ record, detail: verificationGap });
             continue;
         }
@@ -111,7 +111,7 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
             record,
             detail: root.kind === "live"
                 ? `provider root pid ${record.providerRoot.pid} still live`
-                : `provider children still live for launch ${record.launchId}`
+                : `provider children still live for launch ${record.runtimeGenerationId}`
         });
     }
     const outcome = remaining.length === 0 ? "stop-confirmed" : "stop-blocked";
@@ -121,7 +121,7 @@ export async function terminateSessionOwners(owner, records, ports, options = {}
         ...(outcome === "stop-blocked"
             ? {
                 detail: remaining
-                    .map(({ record, detail }) => `${record.launchId}: ${detail}`)
+                    .map(({ record, detail }) => `${record.runtimeGenerationId}: ${detail}`)
                     .join("; ")
             }
             : {}),
@@ -169,11 +169,11 @@ function treeVerdict(record, ports, trackedChildren) {
     return { kind: "absent" };
 }
 function refreshTrackedFencedChildren(record, ports, trackedChildren) {
-    const tracked = trackedChildren.get(record.launchId);
+    const tracked = trackedChildren.get(record.runtimeGenerationId);
     if (tracked === undefined)
         return true;
     let verificationGap = false;
-    for (const pid of ports.listLaunchFencedProcesses(record.launchId)) {
+    for (const pid of ports.listLaunchFencedProcesses(record.runtimeGenerationId)) {
         if (pid === record.providerRoot.pid)
             continue;
         const identity = ports.processIdentity(pid);
@@ -189,7 +189,7 @@ function refreshTrackedFencedChildren(record, ports, trackedChildren) {
     return verificationGap;
 }
 function trackedChildrenVerdict(record, ports, trackedChildren) {
-    const tracked = trackedChildren.get(record.launchId);
+    const tracked = trackedChildren.get(record.runtimeGenerationId);
     if (tracked === undefined)
         return { kind: "gap" };
     let verificationGap = false;
@@ -242,7 +242,7 @@ function escalateRecord(record, ports, trackedChildren, signal) {
     if (root.kind !== "absent")
         return;
     refreshTrackedFencedChildren(record, ports, trackedChildren);
-    const tracked = trackedChildren.get(record.launchId);
+    const tracked = trackedChildren.get(record.runtimeGenerationId);
     if (tracked === undefined)
         return;
     for (const [pid, startIdentity] of tracked) {

package/dist/runtime/sessionTokenMetrics.js

@@ -6,7 +6,7 @@ export function resolveSessionTokenIdentity(input) {
         || input.roleName === undefined
         || input.agentId === undefined
         || input.adapterId === undefined
-        || input.launchId === undefined
+        || input.runtimeGenerationId === undefined
         || input.nativeSessionId === undefined)
         return null;
     let driverId;
@@ -21,9 +21,8 @@ export function resolveSessionTokenIdentity(input) {
         roleName: input.roleName,
         agentId: input.agentId,
         driverId,
-        launchId: input.launchId,
-        nativeSessionId: input.nativeSessionId,
-        sessionGenerationId: input.launchId
+        runtimeGenerationId: input.runtimeGenerationId,
+        nativeSessionId: input.nativeSessionId
     });
 }
 /**
@@ -156,9 +155,8 @@ function matchesSessionGeneration(observation, identity) {
         && fence.roleName === identity.roleName
         && fence.agentId === identity.agentId
         && fence.driverId === identity.driverId
-        && fence.launchId === identity.launchId
-        && fence.nativeSessionId === identity.nativeSessionId
-        && fence.sessionGenerationId === identity.sessionGenerationId;
+        && fence.runtimeGenerationId === identity.runtimeGenerationId
+        && fence.nativeSessionId === identity.nativeSessionId;
 }
 function compareObservations(left, right) {
     return left.receivedAt.localeCompare(right.receivedAt)

package/dist/runtime/structuredProviderHost.js

@@ -2,7 +2,7 @@ import { spawn } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { Duplex } from "node:stream";
 import WebSocket from "ws";
-import { CodexAppServerRequestError, CodexAppServerRuntime, codexGoalNotification, codexAppServerErrorIsMissing, codexTurnInput, codexTurnSummary } from "./codexAppServerRuntime.js";
+import { CodexAppServerRequestError, CodexAppServerRuntime, codexGoalNotification, codexAppServerErrorIsMissing, codexTurnInput, codexTurnOutput } from "./codexAppServerRuntime.js";
 import { serializeAgentErrorRaw } from "./agentError.js";
 import { PROVIDER_ACCEPT_TIMEOUT_MS } from "./runtimeDeadlines.js";
 import { YUI_VERSION } from "../version.js";
@@ -433,7 +433,7 @@ class CodexStructuredProviderSession {
                         ? "failed"
                         : recovered.status === "interrupted" ? "cancelled" : "completed",
                     observedAt: new Date().toISOString(),
-                    ...(recovered.summary === undefined ? {} : { summary: recovered.summary }),
+                    ...(recovered.output === undefined ? {} : { output: recovered.output }),
                     ...(recovered.status !== "failed"
                         ? {}
                         : {
@@ -497,7 +497,7 @@ class CodexStructuredProviderSession {
         const failure = status === "failed"
             ? providerErrorEvidence(turn.error)
             : undefined;
-        const summary = codexTurnSummary(turn);
+        const output = codexTurnOutput(turn);
         const input = codexTurnInput(turn);
         const terminal = {
             conversationId: this.conversationId,
@@ -506,7 +506,7 @@ class CodexStructuredProviderSession {
             status,
             observedAt: new Date().toISOString(),
             ...(input === undefined ? {} : { input }),
-            ...(summary === undefined ? {} : { summary }),
+            ...(output === undefined ? {} : { output }),
             ...(failure === undefined ? {} : failure)
         };
         if (this.#submissionPending && emit) {
@@ -744,7 +744,7 @@ class ClaudeStructuredProviderSession {
             ...(failed
                 ? { error: result, rawError: providerErrorEvidence(message).rawError }
                 : typeof message.result === "string" && message.result.length > 0
-                    ? { summary: message.result }
+                    ? { output: message.result }
                     : {})
         });
     }