@zq-silk/yui 0.13.9 → 0.14.0

package/dist/runtime/runtimeObservation.js

@@ -25,6 +25,8 @@ const KINDS = [
     "activation.started",
     "activation.ended",
     "activation.failed",
+    "goal.updated",
+    "goal.cleared",
     "turn.accepted",
     "turn.waiting",
     "turn.completed",
@@ -50,7 +52,9 @@ const AUTHORITIES = [
     "host",
     "diagnostic"
 ];
-const RUN_SCOPED = new Set([
+/** Provider Turn facts always carry native Turn identity. `turnId` is only an
+ * optional correlation when that Turn was started for a Yui Turn. */
+const TURN_SCOPED = new Set([
     "turn.accepted",
     "turn.waiting",
     "turn.completed",
@@ -97,13 +101,10 @@ export function createRuntimeObservation(input) {
         throw new Error(`${input.kind} requires provider-structured or controller authority.`);
     }
     const fence = normalizeFence(input.fence);
-    if (RUN_SCOPED.has(input.kind) && fence.runId === undefined) {
-        throw new Error(`${input.kind} requires runId.`);
-    }
-    if (RUN_SCOPED.has(input.kind) && fence.nativeSessionId === undefined) {
+    if (TURN_SCOPED.has(input.kind) && fence.nativeSessionId === undefined) {
         throw new Error(`${input.kind} requires nativeSessionId.`);
     }
-    if (RUN_SCOPED.has(input.kind) && fence.nativeTurnId === undefined) {
+    if (TURN_SCOPED.has(input.kind) && fence.nativeTurnId === undefined) {
         throw new Error(`${input.kind} requires nativeTurnId.`);
     }
     if ((input.kind.startsWith("activation.") || CONTINUATION_SCOPED.has(input.kind)
@@ -151,7 +152,7 @@ export function runtimeObservationFenceMatches(expected, actual) {
     for (const field of [
         "taskId",
         "roleName",
-        "runId",
+        "turnId",
         "agentId",
         "driverId",
         "launchId",
@@ -171,17 +172,17 @@ export function runtimeObservationFenceMatches(expected, actual) {
     return true;
 }
 /**
- * Matches observations that belong to one durable Run/session generation.
+ * Matches observations that belong to one durable Turn/Session 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
  * excluded. Exact acceptance still validates both fields before persistence.
  */
-export function runtimeObservationRunFenceMatches(expected, actual) {
+export function runtimeObservationTurnFenceMatches(expected, actual) {
     for (const field of [
         "taskId",
         "roleName",
-        "runId",
+        "turnId",
         "agentId",
         "driverId",
         "launchId",
@@ -204,7 +205,7 @@ export function runtimeObservationTaskEventPayload(input) {
         driverId: observation.fence.driverId,
         launchId: observation.fence.launchId,
         ...(observation.fence.taskId === undefined ? {} : { taskId: observation.fence.taskId }),
-        ...(observation.fence.runId === undefined ? {} : { runId: observation.fence.runId }),
+        ...(observation.fence.turnId === undefined ? {} : { turnId: observation.fence.turnId }),
         ...(observation.fence.nativeSessionId === undefined
             ? {}
             : { nativeSessionId: observation.fence.nativeSessionId }),
@@ -227,15 +228,15 @@ export function runtimeObservationFromTaskEvent(event) {
 /**
  * Runtime observation events are compacted by operation identity: a terminal
  * operation replaces its matching start. Any retained exact start therefore
- * represents Provider-owned work that is still active for this Run.
+ * represents Provider-owned work that is still active for this Turn.
  */
-export function runHasActiveRuntimeOperations(events, owner) {
+export function turnHasActiveRuntimeOperations(events, owner) {
     return events.some((event) => {
         const observation = runtimeObservationFromTaskEvent(event);
         return observation?.kind === "operation.started"
             && observation.fence.taskId === owner.taskId
             && observation.fence.roleName === owner.roleName
-            && observation.fence.runId === owner.runId
+            && observation.fence.turnId === owner.turnId
             && observation.fence.agentId === owner.agentId;
     });
 }
@@ -243,7 +244,7 @@ function normalizeFence(input) {
     return Object.freeze({
         ...(input.taskId === undefined ? {} : { taskId: requireIdentity(input.taskId, "Task id") }),
         roleName: requireIdentity(input.roleName, "Role name"),
-        ...(input.runId === undefined ? {} : { runId: requireIdentity(input.runId, "Run id") }),
+        ...(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"),
@@ -326,6 +327,21 @@ function normalizePayload(kind, input) {
         && !["unknown", "recoverable", "unrecoverable"].includes(input.recoverability ?? "")) {
         throw new Error("conversation.observed requires recoverability.");
     }
+    if (kind === "goal.updated") {
+        if (!["active", "paused", "blocked", "usage-limited", "budget-limited", "complete"]
+            .includes(input.goalStatus ?? "")) {
+            throw new Error("goal.updated requires a supported status.");
+        }
+        if (input.goalObjective === undefined || input.goalUpdatedAt === undefined) {
+            throw new Error("goal.updated requires objective and updatedAt.");
+        }
+        requireText(input.goalObjective, "Provider Goal objective");
+        requireTimestamp(input.goalUpdatedAt, "Provider Goal updatedAt");
+        if (input.goalTokenBudget !== undefined
+            && (!Number.isSafeInteger(input.goalTokenBudget) || input.goalTokenBudget < 1)) {
+            throw new Error("Provider Goal token budget is invalid.");
+        }
+    }
     if (kind === "native-work.snapshot") {
         if (typeof input.snapshotComplete !== "boolean"
             || !["exact", "partial", "unavailable"].includes(input.observationQuality ?? "")) {
@@ -387,6 +403,7 @@ 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.summary === undefined ? {} : { summary: requireText(input.summary, "Runtime summary") }),
         ...(input.execution === undefined ? {} : { execution: input.execution }),
         ...(input.outcome === undefined ? {} : { outcome: input.outcome }),
@@ -413,7 +430,18 @@ function normalizePayload(kind, input) {
             : { snapshotComplete: input.snapshotComplete }),
         ...(input.recoverability === undefined
             ? {}
-            : { recoverability: input.recoverability })
+            : { recoverability: input.recoverability }),
+        ...(input.goalStatus === undefined ? {} : { goalStatus: input.goalStatus }),
+        ...(input.goalObjective === undefined
+            ? {}
+            : { goalObjective: requireText(input.goalObjective, "Provider Goal objective") }),
+        ...(input.goalUpdatedAt === undefined
+            ? {}
+            : { goalUpdatedAt: requireTimestamp(input.goalUpdatedAt, "Provider Goal updatedAt") }),
+        ...(input.goalNativeTurnId === undefined
+            ? {}
+            : { goalNativeTurnId: requireIdentity(input.goalNativeTurnId, "Provider Goal native Turn id") }),
+        ...(input.goalTokenBudget === undefined ? {} : { goalTokenBudget: input.goalTokenBudget })
     });
 }
 export function runtimeObservationSemanticKey(input) {
@@ -430,7 +458,7 @@ export function runtimeObservationSemanticKey(input) {
     // fresh transport sequence after reconnect, so terminal identity must win
     // over occurrence ordering or one SessionEnd storm becomes many facts.
     if (["session.ended", "session.failed", "activation.ended", "activation.failed",
-        "turn.completed", "turn.failed", "turn.cancelled", "continuation.settled"].includes(input.kind)) {
+        "goal.cleared", "turn.completed", "turn.failed", "turn.cancelled", "continuation.settled"].includes(input.kind)) {
         return [
             "terminal",
             ...continuationIdentity,
@@ -438,11 +466,20 @@ export function runtimeObservationSemanticKey(input) {
             input.kind,
             input.payload?.outcome ?? input.payload?.failure?.error.code ?? "terminal",
             input.kind === "continuation.settled" ? input.payload?.resultRef ?? "none" : "none",
-            input.kind === "turn.failed" && input.payload?.failure?.runTerminal === true
-                ? "run-terminal"
+            input.kind === "turn.failed" && input.payload?.failure?.turnTerminal === true
+                ? "turn-terminal-failure"
                 : "turn-terminal"
         ].join(":");
     }
+    if (input.kind === "goal.updated") {
+        return [
+            "goal-state",
+            fence.driverId,
+            fence.conversationId ?? fence.nativeSessionId ?? fence.launchId,
+            input.payload?.goalStatus ?? "unknown",
+            input.payload?.goalUpdatedAt ?? "unknown"
+        ].join(":");
+    }
     if (input.kind === "continuation.reported") {
         const summary = input.payload?.summary?.trim();
         const resultIdentity = summary === undefined || summary.length === 0
@@ -503,9 +540,9 @@ function normalizeFailure(input) {
         ...(input.lastOutput === undefined
             ? {}
             : { lastOutput: requireText(input.lastOutput, "Runtime failure last output") }),
-        ...(input.runTerminal === undefined
+        ...(input.turnTerminal === undefined
             ? {}
-            : { runTerminal: requireBoolean(input.runTerminal, "Runtime failure runTerminal") })
+            : { turnTerminal: requireBoolean(input.turnTerminal, "Runtime failure turnTerminal") })
     });
 }
 function requireBoolean(value, label) {

package/dist/runtime/runtimeProjection.js

@@ -1,4 +1,4 @@
-import { createRuntimeObservation, runtimeObservationFromTaskEvent, runtimeObservationRunFenceMatches } from "./runtimeObservation.js";
+import { createRuntimeObservation, runtimeObservationFromTaskEvent, runtimeObservationTurnFenceMatches } from "./runtimeObservation.js";
 import { DEFAULT_RUNTIME_HEALTH_POLICY } from "./runtimeHealthPolicy.js";
 export function createRuntimeProjection(fence, createdAt) {
     const timestamp = requireTimestamp(createdAt);
@@ -9,8 +9,8 @@ export function createRuntimeProjection(fence, createdAt) {
         turn: "none",
         conversation: "unknown",
         activation: "none",
+        goal: "none",
         continuations: Object.freeze({}),
-        inputDelivery: "none",
         runActivity: "starting",
         health: "reconciling",
         waitingOn: Object.freeze([]),
@@ -29,7 +29,7 @@ export function createRuntimeProjection(fence, createdAt) {
 export function projectRuntimeTaskEvents(fence, createdAt, events) {
     const observations = events
         .map(runtimeObservationFromTaskEvent)
-        .filter((event) => (event !== null && runtimeObservationRunFenceMatches(fence, event.fence)))
+        .filter((event) => (event !== null && runtimeObservationTurnFenceMatches(fence, event.fence)))
         .sort((left, right) => (left.receivedAt.localeCompare(right.receivedAt)
         || (left.sequence ?? -1) - (right.sequence ?? -1)
         || (left.ordinal ?? -1) - (right.ordinal ?? -1)
@@ -38,7 +38,7 @@ export function projectRuntimeTaskEvents(fence, createdAt, events) {
 }
 export function projectRuntimeObservation(current, raw) {
     const event = createRuntimeObservation(raw);
-    if (!runtimeObservationRunFenceMatches(current.fence, event.fence)) {
+    if (!runtimeObservationTurnFenceMatches(current.fence, event.fence)) {
         throw new Error("Runtime observation fence does not match the projection.");
     }
     const at = event.receivedAt;
@@ -63,9 +63,9 @@ export function projectRuntimeObservation(current, raw) {
                 activation: "ended",
                 turn: terminalTurn(current.turn),
                 // A parent provider Session ending is independent from native child
-                // operations already observed under the Run. Keep those children
+                // operations already observed under the Turn. Keep those children
                 // visible until their own terminal facts arrive; host/session loss is
-                // health evidence, not proof that child work or the Yui Run ended.
+                // health evidence, not proof that child work or the Yui Turn ended.
                 operations: activeSubagentOperations(current.operations),
                 stateSince: at
             });
@@ -102,7 +102,7 @@ export function projectRuntimeObservation(current, raw) {
                 waitId: undefined,
                 // Tool operations belong to the completed native Turn. Provider-owned
                 // background subagents may legitimately outlive it and wake later
-                // native Turns inside the same durable Yui Run.
+                // native Provider activity inside the same durable Yui Turn.
                 operations: activeSubagentOperations(current.operations),
                 stateSince: at
             }), "provider", at);
@@ -198,6 +198,10 @@ export function projectRuntimeObservation(current, raw) {
             return next(current, { activation: "ended", stateSince: at });
         case "activation.failed":
             return next(current, { activation: "failed", stateSince: at });
+        case "goal.updated":
+            return next(current, { goal: event.payload.goalStatus, stateSince: at });
+        case "goal.cleared":
+            return next(current, { goal: "none", stateSince: at });
         case "continuation.started":
         case "continuation.reported":
         case "continuation.settled": {
@@ -259,7 +263,7 @@ export function projectRuntimeObservation(current, raw) {
             });
         }
         case "input.delivery-unknown":
-            return next(current, { inputDelivery: "delivery-unknown", stateSince: at });
+            return next(current, { turn: "delivery-unknown", stateSince: at });
         case "native-work.snapshot":
             return next(current, {});
         default:
@@ -284,16 +288,6 @@ export function completeRuntimeWorkflow(current, completedAt) {
         })
     });
 }
-export function projectRuntimeMailbox(current, mailbox) {
-    if (mailbox?.inputDelivery === undefined || mailbox.inputDelivery === null) {
-        return next(current, { inputDelivery: "none" });
-    }
-    return next(current, {
-        inputDelivery: mailbox.inputDelivery.status === "delivery-unknown"
-            ? "delivery-unknown"
-            : "dispatching"
-    });
-}
 export function runtimeDisplayStatus(current) {
     if (current.session === "failed")
         return "broken";
@@ -324,7 +318,7 @@ export function runtimeDisplayStatus(current) {
 /**
  * Classify one RuntimeProjection into the layered health state shared by CLI,
  * Web, and scheduler. The semantic progress timestamp is the same durable
- * fence the scheduler stall pass consumes (deliveredAt plus Work/Review/
+ * fence the scheduler stall pass consumes (Turn creation plus Work/Review/
  * Integration checkpoints), so token/tool/CPU activity can never masquerade
  * as business progress.
  *
@@ -410,7 +404,7 @@ function runtimeHealthReason(layer, current) {
         case "broken":
             return "the Agent Driver runtime is broken";
         case "stopped":
-            return "the Provider Activation ended while the Yui Run remains active";
+            return "the Provider Activation ended while the Yui Turn remains active";
         case "subagent-active":
         case "tool-active":
         case "model-active":
@@ -429,9 +423,9 @@ function runtimeHealthReason(layer, current) {
         case "waiting-external":
             return `the Agent Driver is ${layer.replaceAll("-", " ")}`;
         case "ready":
-            return "the Agent turn ended while the workflow Run is still active";
+            return "the Provider turn ended while the Yui Turn is still active";
         case "awaiting-provider-acceptance":
-            return "the pushed active Run is awaiting provider acceptance";
+            return "the submitted active Turn is awaiting Provider acceptance";
         case "runtime-unobservable":
             return "the host is present but the Agent Driver exposes no current runtime state";
         case "starting":
@@ -460,7 +454,7 @@ function next(current, patch) {
         ...activeNativeOperations.map(([id]) => `native-operation:${id}`)
     ];
     const attention = [
-        ...(copy.inputDelivery === "delivery-unknown" ? ["delivery-unknown"] : []),
+        ...(copy.turn === "delivery-unknown" ? ["delivery-unknown"] : []),
         ...continuations.flatMap(([id, continuation]) => (continuation.identityConflict ? [`identity-conflict:${id}`]
             : continuation.observation === "unavailable" ? [`continuation-unresolved:${id}`]
                 : [])),
@@ -475,12 +469,10 @@ function next(current, patch) {
         || copy.session === "ended"
         || copy.session === "failed"
         ? "unobservable"
-        : copy.inputDelivery === "dispatching"
-            || (copy.activation !== "active" && waitingNative.length > 0)
+        : (copy.activation !== "active" && waitingNative.length > 0)
             ? "reconciling"
             : "healthy";
-    const runActivity = copy.inputDelivery === "dispatching"
-        || copy.turn === "accepted"
+    const runActivity = copy.turn === "accepted"
         || copy.session === "active"
         ? "running"
         : waitingNative.length > 0 || activeNativeOperations.length > 0 ? "waiting"

package/dist/runtime/sessionLaunchRequest.js

@@ -29,9 +29,9 @@ export function createSessionLaunchRequest(input) {
         effective,
         workspace,
         ...(runtimeIsolation === undefined ? {} : { runtimeIsolation }),
-        ...(input.runId === undefined
+        ...(input.turnId === undefined
             ? {}
-            : { runId: requireSafeIdentity(input.runId, "Run id") }),
+            : { turnId: requireSafeIdentity(input.turnId, "Turn id") }),
         ...(input.environment === undefined
             ? {}
             : { environment: copyEnvironment(input.environment) })