@zq-silk/yui 0.13.9 → 0.14.0

package/dist/controller/sessionNotify.js

@@ -2,7 +2,7 @@ import { callController } from "../core/controllerClient.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { setCodexThreadName } from "../execution/codexThreadNaming.js";
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 const NO_FINAL_ASSISTANT_MESSAGE_SUMMARY = "Native Turn completed without a final assistant message.";
 /** Hidden CLI entrypoint used by Codex's structured notify hook. */
 export async function runSessionNotifyCommand(payloadArgument, environment = process.env, call, setThreadName = setCodexThreadName) {
@@ -16,8 +16,8 @@ export async function runSessionNotifyCommand(payloadArgument, environment = pro
         adapterId: params.adapterId,
         launchId: params.launchId,
         nativeSessionId: params.nativeSessionId,
-        turnId: params.turnId,
-        ...(params.runId === undefined ? {} : { runId: params.runId }),
+        nativeTurnId: params.nativeTurnId,
+        ...(params.turnId === undefined ? {} : { turnId: params.turnId }),
         ...(params.title === undefined ? {} : { title: params.title }),
         summary: params.lastAssistantMessage
     });
@@ -47,11 +47,11 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
         throw new Error("Codex notify payload type is invalid.");
     }
     const nativeSessionId = requireText(payload["thread-id"], "Codex thread-id");
-    const turnId = requireText(payload["turn-id"], "Codex turn-id");
+    const nativeTurnId = requireText(payload["turn-id"], "Codex turn-id");
     const lastAssistantMessage = requireAssistantMessage(payload["last-assistant-message"]);
-    const runId = environment.YUI_RUN_ID === undefined
+    const turnId = environment.YUI_TURN_ID === undefined
         ? undefined
-        : requireText(environment.YUI_RUN_ID, "YUI_RUN_ID");
+        : requireText(environment.YUI_TURN_ID, "YUI_TURN_ID");
     const title = environment.YUI_SESSION_TITLE === undefined
         ? undefined
         : requireText(environment.YUI_SESSION_TITLE, "YUI_SESSION_TITLE");
@@ -66,8 +66,8 @@ export function parseCodexSessionNotification(payloadArgument, environment) {
         adapterId: requireCodexAdapter(environment.YUI_ADAPTER_ID),
         launchId: requireText(environment.YUI_LAUNCH_ID, "YUI_LAUNCH_ID"),
         nativeSessionId,
-        turnId,
-        ...(runId === undefined ? {} : { runId }),
+        nativeTurnId,
+        ...(turnId === undefined ? {} : { turnId }),
         ...(title === undefined ? {} : { title }),
         lastAssistantMessage
     };
@@ -121,11 +121,11 @@ function requireAssistantMessage(value) {
 function shouldSetThreadName(home, params) {
     if (params.scope !== "task"
         || params.title === undefined
-        || params.runId === undefined)
+        || params.turnId === undefined)
         return false;
     try {
-        const store = openCompatibleFileTaskStore(home);
-        return store.getAgentRun(params.taskId, params.runId)?.mode === "new";
+        const store = openCurrentTaskStore(home);
+        return store.getTurn(params.taskId, params.turnId)?.mode === "new";
     }
     catch {
         return false;

package/dist/controller/structuredProviderObservation.js

@@ -6,21 +6,54 @@ import { createRuntimeObservation, runtimeObservationSemanticKey } from "../runt
 import { runtimeLifecycleSignalKey } from "../runtime/lifecycleReservation.js";
 import { isForeignHandoverLockHeld } from "../release/runtimeRelease.js";
 import { FileRuntimeEventInbox } from "./runtimeEventInbox.js";
-import { resolveRuntimeHookRunFence } from "./runtimeHookRunFence.js";
+import { resolveRuntimeHookTurnFence } from "./runtimeHookTurnFence.js";
 let structuredSequence = 0;
+export async function publishStructuredProviderStarted(input) {
+    if (input.started.clientOwned)
+        return;
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.started.nativeSessionId, {
+        nativeTurnId: input.started.nativeTurnId,
+        sessionOnly: true
+    });
+    const receiptId = `direct:${input.started.nativeTurnId}`;
+    const startedObservation = observation({
+        kind: "turn.accepted",
+        observedAt: input.started.observedAt,
+        sequence: nextStructuredSequence(),
+        ordinal: 0,
+        fence: {
+            taskId: fence.taskId,
+            roleName: fence.roleName,
+            agentId: fence.agentId,
+            driverId: driver.id,
+            launchId: fence.launchId,
+            sessionGenerationId: fence.launchId,
+            conversationId: input.started.conversationId,
+            activationId: requireIdentity(input.activationId, "Provider Activation id"),
+            nativeSessionId: input.started.nativeSessionId,
+            nativeTurnId: input.started.nativeTurnId,
+            receiptId
+        },
+        payload: input.started.input === undefined ? {} : { input: input.started.input }
+    });
+    await persistAndApply(input.home, [startedObservation], fence.taskId, fence.roleName);
+}
 export async function publishStructuredProviderAccepted(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
     const startupSession = driver.capabilities.observation.sessionBootstrap;
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.receipt.nativeSessionId, {
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.receipt.nativeSessionId, {
         startupSession,
-        nativeTurnId: input.receipt.nativeTurnId
+        nativeTurnId: input.receipt.nativeTurnId,
+        attemptId: input.receipt.attemptId
     });
     const observedAt = input.receipt.acceptedAt;
     const commonFence = {
         taskId: fence.taskId,
         roleName: fence.roleName,
-        runId: fence.runId,
+        ...(fence.turnId === undefined ? {} : { turnId: fence.turnId }),
         agentId: fence.agentId,
         driverId: driver.id,
         launchId: fence.launchId,
@@ -30,7 +63,7 @@ export async function publishStructuredProviderAccepted(input) {
         nativeSessionId: input.receipt.nativeSessionId,
         nativeTurnId: input.receipt.nativeTurnId,
         // The structured Host owns the exact input attempt identity. Runtime
-        // descriptor receipts name the Run bootstrap and must not overwrite a
+        // descriptor receipts name the Turn bootstrap and must not overwrite a
         // continuation or human-takeover Turn.
         receiptId: input.receipt.attemptId
     };
@@ -67,11 +100,11 @@ export async function publishStructuredProviderOpened(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
     const startupSession = driver.capabilities.observation.sessionBootstrap;
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId, { startupSession });
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.nativeSessionId, { startupSession });
     const commonFence = {
         taskId: fence.taskId,
         roleName: fence.roleName,
-        runId: fence.runId,
+        ...(fence.turnId === undefined ? {} : { turnId: fence.turnId }),
         agentId: fence.agentId,
         driverId: driver.id,
         launchId: fence.launchId,
@@ -104,15 +137,47 @@ export async function publishStructuredProviderOpened(input) {
         })];
     await persistAndApply(input.home, observations, fence.taskId, fence.roleName);
 }
+export async function publishStructuredProviderGoal(input) {
+    const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
+    const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.conversationId, { sessionOnly: true });
+    const goal = input.goal;
+    const observedAt = input.observedAt ?? goal?.updatedAt ?? new Date().toISOString();
+    const goalObservation = observation({
+        kind: goal === null ? "goal.cleared" : "goal.updated",
+        observedAt,
+        sequence: nextStructuredSequence(),
+        ordinal: 0,
+        fence: {
+            taskId: fence.taskId,
+            roleName: fence.roleName,
+            agentId: fence.agentId,
+            driverId: driver.id,
+            launchId: fence.launchId,
+            sessionGenerationId: fence.launchId,
+            conversationId: input.conversationId,
+            activationId: requireIdentity(input.activationId, "Provider Activation id"),
+            nativeSessionId: input.conversationId
+        },
+        payload: goal === null ? {} : {
+            goalStatus: goal.status,
+            goalObjective: goal.objective,
+            goalUpdatedAt: goal.updatedAt,
+            ...(goal.nativeTurnId === undefined ? {} : { goalNativeTurnId: goal.nativeTurnId }),
+            ...(goal.tokenBudget === undefined ? {} : { goalTokenBudget: goal.tokenBudget })
+        }
+    });
+    await persistAndApply(input.home, [goalObservation], fence.taskId, fence.roleName);
+}
 export async function publishStructuredConversationRecoverability(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.conversationId);
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.conversationId);
     const sequence = nextStructuredSequence();
     const observationFence = {
         taskId: fence.taskId,
         roleName: fence.roleName,
-        runId: fence.runId,
+        ...(fence.turnId === undefined ? {} : { turnId: fence.turnId }),
         agentId: fence.agentId,
         driverId: driver.id,
         launchId: fence.launchId,
@@ -151,12 +216,19 @@ export async function publishStructuredConversationRecoverability(input) {
 export async function publishStructuredProviderTerminal(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.terminal.nativeSessionId, { terminal: true, nativeTurnId: input.terminal.nativeTurnId });
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.terminal.nativeSessionId, {
+        terminal: true,
+        nativeTurnId: input.terminal.nativeTurnId,
+        ...(input.terminal.clientOwned ? {} : { sessionOnly: true })
+    });
     const kind = input.terminal.status === "completed"
         ? "turn.completed"
         : input.terminal.status === "cancelled" ? "turn.cancelled" : "turn.failed";
     const payload = kind === "turn.completed"
-        ? { ...(input.terminal.summary === undefined ? {} : { summary: input.terminal.summary }) }
+        ? {
+            ...(input.terminal.input === undefined ? {} : { input: input.terminal.input }),
+            ...(input.terminal.summary === undefined ? {} : { summary: input.terminal.summary })
+        }
         : kind === "turn.failed"
             ? {
                 failure: {
@@ -176,7 +248,8 @@ export async function publishStructuredProviderTerminal(input) {
                         inputDisposition: "accepted"
                     })
                 },
-                summary: input.terminal.error ?? "Provider Turn failed."
+                summary: input.terminal.error ?? "Provider Turn failed.",
+                ...(input.terminal.input === undefined ? {} : { input: input.terminal.input })
             }
             : {};
     const terminalObservation = observation({
@@ -187,7 +260,7 @@ export async function publishStructuredProviderTerminal(input) {
         fence: {
             taskId: fence.taskId,
             roleName: fence.roleName,
-            runId: fence.runId,
+            ...(fence.turnId === undefined ? {} : { turnId: fence.turnId }),
             agentId: fence.agentId,
             driverId: driver.id,
             launchId: fence.launchId,
@@ -205,7 +278,7 @@ export async function publishStructuredProviderTerminal(input) {
 export async function publishStructuredProviderActivationTerminal(input) {
     const adapterId = requireIdentity(input.environment.YUI_ADAPTER_ID, "Agent adapter id");
     const driver = builtinAgentDriverRegistry().requireByAdapterId(adapterId);
-    const fence = resolveRuntimeHookRunFence(input.environment, adapterId, input.nativeSessionId);
+    const fence = resolveRuntimeHookTurnFence(input.environment, adapterId, input.nativeSessionId, { sessionOnly: true });
     const terminal = observation({
         kind: input.status === "failed" ? "activation.failed" : "activation.ended",
         observedAt: input.observedAt,
@@ -214,7 +287,7 @@ export async function publishStructuredProviderActivationTerminal(input) {
         fence: {
             taskId: fence.taskId,
             roleName: fence.roleName,
-            runId: fence.runId,
+            ...(fence.turnId === undefined ? {} : { turnId: fence.turnId }),
             agentId: fence.agentId,
             driverId: driver.id,
             launchId: fence.launchId,
@@ -291,7 +364,7 @@ async function persistAndApply(home, observations, taskId, roleName) {
             throw error;
         }
         // A fast Provider can accept the initial Turn before the scheduler call
-        // that launched this Host has returned and committed `run.pushed`. The
+        // that launched this Host has returned and committed `turn.pushed`. The
         // immutable inbox entry already makes that exact fenced fact durable;
         // `deferred` therefore means "retained for replay", not delivery failure.
         // The signal below schedules the replay after the transport transaction.