@zq-silk/yui 0.11.3 → 0.12.1

package/dist/runtime/sessionTokenMetrics.js

@@ -0,0 +1,181 @@
+import { builtinDriverIdForAdapter } from "./builtinAgentDrivers.js";
+import { isRuntimeTokenEvidence, runtimeObservationFromTaskEvent } from "./runtimeObservation.js";
+const UNOBSERVED = Object.freeze({ status: "unobserved" });
+export function resolveSessionTokenIdentity(input) {
+    if (input?.taskId === undefined
+        || input.roleName === undefined
+        || input.agentId === undefined
+        || input.adapterId === undefined
+        || input.launchId === undefined
+        || input.nativeSessionId === undefined)
+        return null;
+    let driverId;
+    try {
+        driverId = builtinDriverIdForAdapter(input.adapterId);
+    }
+    catch {
+        return null;
+    }
+    return Object.freeze({
+        taskId: input.taskId,
+        roleName: input.roleName,
+        agentId: input.agentId,
+        driverId,
+        launchId: input.launchId,
+        nativeSessionId: input.nativeSessionId,
+        sessionGenerationId: input.launchId
+    });
+}
+/**
+ * Read-only projection over canonical runtime observations. Token values never
+ * decide lifecycle, health, scheduling, resource admission, or workflow state.
+ */
+export function projectSessionTokenMetrics(events, identity) {
+    if (identity === null)
+        return unobservedSessionTokenMetrics();
+    const observations = events
+        .map(runtimeObservationFromTaskEvent)
+        .filter((observation) => (observation !== null
+        && isRuntimeTokenEvidence(observation)
+        && matchesSessionGeneration(observation, identity)))
+        .sort(compareObservations);
+    const incompleteBoundaries = observations.filter(({ payload }) => (payload.usage === undefined));
+    const request = observations.filter(({ payload }) => (payload.usage?.semantics === "request-context"));
+    const cumulative = observations.filter(({ payload }) => (payload.usage?.semantics === "cumulative-session"));
+    // A generation cannot switch counter semantics without an explicit fact
+    // explaining how the two streams overlap. Remaining-context is capacity,
+    // not consumption, and is intentionally absent from both metrics.
+    if (request.length > 0 && cumulative.length > 0) {
+        return unobservedSessionTokenMetrics(identity);
+    }
+    if (request.length > 0) {
+        return projectRequestSnapshots(identity, request, incompleteBoundaries.length > 0);
+    }
+    if (cumulative.length > 0) {
+        return projectCumulativeSnapshots(identity, cumulative, incompleteBoundaries.length > 0);
+    }
+    return unobservedSessionTokenMetrics(identity);
+}
+export function unobservedSessionTokenMetrics(identity = null) {
+    return Object.freeze({
+        identity: identity === null ? null : Object.freeze({ ...identity }),
+        cumulativeTotal: UNOBSERVED,
+        maximumRequestInput: UNOBSERVED
+    });
+}
+function projectRequestSnapshots(identity, observations, hasIncompleteBoundary) {
+    if (hasIncompleteBoundary || observations.some(({ payload }) => (payload.observationQuality === "partial"
+        || payload.observationQuality === "unavailable")))
+        return unobservedSessionTokenMetrics(identity);
+    const requests = new Map();
+    for (const observation of observations) {
+        const usage = observation.payload.usage;
+        const requestId = observation.payload.activityId ?? observation.semanticKey;
+        // Structured providers may publish multiple snapshots for one stable
+        // request identity. The latest snapshot supersedes the earlier delivery;
+        // replays with the same identity never become a second request.
+        requests.set(requestId, usage);
+    }
+    const values = [...requests.values()];
+    const inputTokens = safeSum(values.map((usage) => usage.inputTokens));
+    const outputTokens = safeSum(values.map((usage) => usage.outputTokens));
+    if (inputTokens === null || outputTokens === null) {
+        return unobservedSessionTokenMetrics(identity);
+    }
+    const totalTokens = safeAdd(inputTokens, outputTokens);
+    if (totalTokens === null)
+        return unobservedSessionTokenMetrics(identity);
+    const cachedInputTokens = values.every((usage) => usage.cachedInputTokens !== undefined)
+        ? safeSum(values.map((usage) => usage.cachedInputTokens))
+        : null;
+    const reasoningTokens = values.every((usage) => usage.reasoningTokens !== undefined)
+        ? safeSum(values.map((usage) => usage.reasoningTokens))
+        : null;
+    return Object.freeze({
+        identity: Object.freeze({ ...identity }),
+        cumulativeTotal: Object.freeze({
+            status: "observed",
+            totalTokens,
+            inputTokens,
+            outputTokens,
+            ...(cachedInputTokens === null ? {} : { cachedInputTokens }),
+            ...(reasoningTokens === null ? {} : { reasoningTokens })
+        }),
+        maximumRequestInput: Object.freeze({
+            status: "observed",
+            inputTokens: Math.max(...values.map((usage) => usage.inputTokens))
+        })
+    });
+}
+function projectCumulativeSnapshots(identity, observations, hasIncompleteBoundary) {
+    const values = observations.map(({ payload }) => payload.usage);
+    const requestBoundaryIncomplete = hasIncompleteBoundary || observations.some(({ payload }) => (payload.observationQuality === "partial"
+        || payload.observationQuality === "unavailable"));
+    let counterRollback = false;
+    let maximumRequestInput = null;
+    for (let index = 1; index < values.length; index += 1) {
+        const previous = values[index - 1];
+        const current = values[index];
+        if (current.inputTokens < previous.inputTokens
+            || current.outputTokens < previous.outputTokens)
+            counterRollback = true;
+        const requestInput = Math.max(0, current.inputTokens - previous.inputTokens);
+        maximumRequestInput = maximumRequestInput === null
+            ? requestInput
+            : Math.max(maximumRequestInput, requestInput);
+    }
+    const latest = values.at(-1);
+    const totalTokens = safeAdd(latest.inputTokens, latest.outputTokens);
+    const cumulativeTotal = counterRollback || totalTokens === null
+        ? UNOBSERVED
+        : Object.freeze({
+            status: "observed",
+            totalTokens,
+            inputTokens: latest.inputTokens,
+            outputTokens: latest.outputTokens,
+            ...(latest.cachedInputTokens === undefined
+                ? {}
+                : { cachedInputTokens: latest.cachedInputTokens }),
+            ...(latest.reasoningTokens === undefined
+                ? {}
+                : { reasoningTokens: latest.reasoningTokens })
+        });
+    return Object.freeze({
+        identity: Object.freeze({ ...identity }),
+        cumulativeTotal,
+        maximumRequestInput: counterRollback
+            || requestBoundaryIncomplete
+            || maximumRequestInput === null
+            ? UNOBSERVED
+            : Object.freeze({ status: "observed", inputTokens: maximumRequestInput })
+    });
+}
+function matchesSessionGeneration(observation, identity) {
+    const fence = observation.fence;
+    return fence.taskId === identity.taskId
+        && fence.roleName === identity.roleName
+        && fence.agentId === identity.agentId
+        && fence.driverId === identity.driverId
+        && fence.launchId === identity.launchId
+        && fence.nativeSessionId === identity.nativeSessionId
+        && fence.sessionGenerationId === identity.sessionGenerationId;
+}
+function compareObservations(left, right) {
+    return left.receivedAt.localeCompare(right.receivedAt)
+        || (left.sequence ?? -1) - (right.sequence ?? -1)
+        || (left.ordinal ?? -1) - (right.ordinal ?? -1)
+        || left.eventId.localeCompare(right.eventId);
+}
+function safeSum(values) {
+    let total = 0;
+    for (const value of values) {
+        total = safeAdd(total, value) ?? Number.NaN;
+        if (!Number.isSafeInteger(total))
+            return null;
+    }
+    return total;
+}
+function safeAdd(left, right) {
+    const total = left + right;
+    return Number.isSafeInteger(total) && total >= 0 ? total : null;
+}

package/dist/runtime/structuredProviderHost.js

@@ -391,7 +391,13 @@ class ClaudeStructuredProviderSession {
                 waiter.reject(new ProviderDeliveryUnknownError("Claude replayed input for a different native Session.", waiter.attemptId));
                 return;
             }
-            const nativeTurnId = `claude-input:${waiter.attemptId}`;
+            const nativeTurnId = optionalId(message.uuid);
+            if (nativeTurnId === undefined) {
+                clearTimeout(waiter.timer);
+                this.#waiter = undefined;
+                waiter.reject(new ProviderDeliveryUnknownError("Claude replayed input without a native message identity.", waiter.attemptId));
+                return;
+            }
             this.#activeTurnId = nativeTurnId;
             clearTimeout(waiter.timer);
             this.#waiter = undefined;

package/dist/runtime/tmuxAdapters.js

@@ -408,7 +408,10 @@ export class TmuxSessionHost {
             throw error;
         }
         if (providerDispatchObserved
-            && hostCreated
+            // A fresh Host always starts a Provider process. mode=new also starts
+            // one inside a reused Host by replacing (or creating) the native
+            // Conversation. Same-Conversation resume must retain its inherited key.
+            && (hostCreated || request.mode === "new")
             && request.owner.scope === "task"
             && planned.launch.env.YUI_JOB_CALLER_KEY !== undefined
             && this.planner.commitTaskCallerKey !== undefined) {

package/dist/scheduler/activeRoleRunDelivery.js

@@ -1,20 +1,14 @@
 import { selectedSchedulerRoles, selectedActiveSchedulerTasks } from "./ports.js";
 import { isSchedulerTaskWorkspaceReady } from "./ports.js";
 import { formatAgentRunReceiptId } from "../task/taskRecordReference.js";
-import { prefixYuiTitleInput } from "../run/runIdentity.js";
-import { resolveTaskRoleSessionTitle } from "../runtime/sessionTitle.js";
 import { agentRunDeliveryReceiptId } from "../run/agentRun.js";
-import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskMain } from "../executor/effectiveLaunch.js";
+import { effectiveLaunchSnapshotsCompatible, effectiveLaunchSnapshotsCompatibleForTaskSession } from "../executor/effectiveLaunch.js";
 import { RuntimeLaunchError } from "../runtime/ports.js";
 import { RuntimeLaunchFailure } from "../runtime/launchDiagnostics.js";
-import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
 import { mailboxHasWork, nextPendingBatch } from "../coordination/workMailbox.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { hasRuntimeLifecycleWork, RuntimeLifecycleBusyError, runtimeLifecycleTarget } from "../runtime/lifecycleReservation.js";
-import { serializeRunBootstrapEnvelope } from "../context/runContextContract.js";
-import { serializeProviderRetryEnvelope } from "../run/providerRetry.js";
-import { serializeWorkflowOutcomeRequestEnvelope } from "../run/runControlRequest.js";
 /**
  * Delivers durable Work AgentRuns before liveness reconciliation. Task command
  * handlers only record intent; this Controller path is the sole automated
@@ -109,9 +103,14 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
             let preparedSession = existingSession;
             let preStartFencePersisted = false;
             let deliveryAttempted = false;
-            let providerSubmissionBegun = false;
             try {
-                const nativeSessionId = run.mode === "resume"
+                // Workflow-outcome control is always another Turn on the already-bound
+                // Conversation. Provider retry alone may carry an exact missing-
+                // Conversation decision and therefore retains its explicit new mode.
+                const launchMode = run.controlRequest?.state === "dispatching"
+                    ? "resume"
+                    : run.mode;
+                const nativeSessionId = launchMode === "resume"
                     ? requireResumeSession(role, run.effective, existingSession)
                     : undefined;
                 prepared = await delivery.prepareRoleSession({
@@ -124,12 +123,12 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     ...(run.workspace === undefined
                         ? {}
                         : { managedWorkspace: run.workspace }),
-                    mode: run.mode,
+                    mode: launchMode,
                     runId: run.id,
                     ...(nativeSessionId === undefined ? {} : { nativeSessionId }),
                     beforeHostStart: (preflight) => {
                         persistPreStartFence(store, task, role, run, existingSession, preflight, now);
-                        preparedSession = preflightSession(role, run.effective, existingSession, run.mode, preflight);
+                        preparedSession = preflightSession(role, run.effective, existingSession, launchMode, preflight);
                         preStartFencePersisted = true;
                     }
                 });
@@ -177,20 +176,32 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     now
                 });
                 if (ready.prepared.turnRejectedDuringLaunch === true) {
-                    delivery.forgetPrepared?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        ...(ready.prepared.launchId === undefined
-                            ? {}
-                            : { launchId: ready.prepared.launchId })
+                    const persisted = store.saveRoleRunDeliveryFailure({
+                        ...roleRunDeliveryFailure(run, processing.batchId, session, ready.prepared.launchId),
+                        summary: `Provider conclusively rejected the exact initial Run input: ${run.id}.`,
+                        cleanupRequired: false,
+                        now
                     });
+                    if (persisted === "failed") {
+                        delivery.forgetPrepared?.({
+                            taskId: task.id,
+                            roleName: role.name,
+                            runId: run.id,
+                            ...(ready.prepared.launchId === undefined
+                                ? {}
+                                : { launchId: ready.prepared.launchId })
+                        });
+                    }
                     results.push({
                         taskId: task.id,
                         roleName: role.name,
                         runId: run.id,
-                        status: "skipped",
-                        reason: "not-ready"
+                        status: persisted === "failed" ? "failed" : "skipped",
+                        reason: "provider-rejected",
+                        terminalized: persisted === "failed",
+                        ...(persisted === "failed"
+                            ? {}
+                            : { error: "Run state changed while recording exact Provider rejection." })
                     });
                     continue;
                 }
@@ -252,171 +263,10 @@ export async function processActiveRoleRunDeliveries(store, delivery, now, selec
                     });
                     continue;
                 }
-                // Pre-input readiness gate. For an adapter whose capability proves a
-                // native event fires before the first prompt (e.g. Claude SessionStart),
-                // a freshly-started host must not be pushed until that provider-ready
-                // fact has been folded. Unsupported adapters (e.g. Codex) have no
-                // pre-input event, so their push proceeds and acceptance is confirmed
-                // only by the later exact provider-accepted fold. The gate reads the
-                // adapter capability and the durable ready projection — never a sleep,
-                // screen scrape, or pane/PID inference — and fails closed for a
-                // supported adapter whose readiness cannot be confirmed.
-                if (ready.prepared.sessionStarted
-                    && builtinAgentDriverRegistry().requireByAdapterId(run.effective.adapterId)
-                        .capabilities.observation.preInputReadiness === "exact"
-                    && !providerReadyForPush(store, {
-                        taskId: task.id,
-                        roleName: role.name,
-                        agentId: run.effective.agentId,
-                        ...(ready.prepared.launchId === undefined ? {} : { launchId: ready.prepared.launchId }),
-                        ...(session?.nativeSessionId === undefined
-                            ? {}
-                            : { nativeSessionId: session.nativeSessionId })
-                    })) {
-                    results.push({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: "not-ready"
-                    });
-                    continue;
-                }
-                if (session === null || session.launchId === undefined
-                    || !hasText(session.nativeSessionId)
-                    || store.beginRoleRunProviderTurn?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        agentId: run.effective.agentId,
-                        launchId: session.launchId,
-                        nativeSessionId: session.nativeSessionId,
-                        attemptId: receiptId,
-                        now
-                    }) !== true) {
-                    throw new Error("Provider Turn intent could not be durably fenced before delivery.");
-                }
-                providerSubmissionBegun = true;
-                deliveryAttempted = true;
-                const launchText = run.controlRequest?.state === "dispatching"
-                    ? serializeWorkflowOutcomeRequestEnvelope({
-                        taskId: task.id,
-                        runId: run.id,
-                        roleName: role.name,
-                        request: run.controlRequest
-                    })
-                    : run.providerRetry?.state === "dispatching"
-                        ? serializeProviderRetryEnvelope({
-                            taskId: task.id,
-                            runId: run.id,
-                            roleName: role.name,
-                            retry: run.providerRetry
-                        })
-                        : serializeRunBootstrapEnvelope(run.bootstrapEnvelope);
-                const outcome = await delivery.sendOnce({
-                    delivery: ready,
-                    receiptId,
-                    text: prefixYuiTitleInput(launchText, resolveTaskRoleSessionTitle(session.title, task, role.name))
-                });
-                if (outcome === "busy" || outcome === "unavailable") {
-                    store.resolveRoleRunProviderSubmission?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        attemptId: receiptId,
-                        status: "rejected",
-                        reason: outcome === "busy"
-                            ? "Agent Host was busy before Provider mutation."
-                            : "Agent Host was unavailable before Provider mutation.",
-                        now
-                    });
-                    providerSubmissionBegun = false;
-                    results.push({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: outcome === "busy" ? "not-ready" : "runtime-unavailable",
-                        terminalFailure: roleRunDeliveryFailure(run, processing.batchId, session, ready.prepared.launchId)
-                    });
-                    continue;
-                }
-                if (outcome === "rejected") {
-                    store.resolveRoleRunProviderSubmission?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        attemptId: receiptId,
-                        status: "rejected",
-                        reason: "Provider returned an exact negative acknowledgement.",
-                        now
-                    });
-                    providerSubmissionBegun = false;
-                    results.push({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: "not-ready"
-                    });
-                    continue;
-                }
-                if (outcome === "delivery-unknown") {
-                    store.resolveRoleRunProviderSubmission?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        attemptId: receiptId,
-                        status: "delivery-unknown",
-                        reason: "Provider Turn delivery is ambiguous; automatic retry is fenced.",
-                        now
-                    });
-                    providerSubmissionBegun = false;
-                    store.saveRoleRunDelivery({
-                        task,
-                        role,
-                        run,
-                        session,
-                        ...(ready.prepared.launchId === undefined
-                            ? {}
-                            : { launchId: ready.prepared.launchId }),
-                        now
-                    });
-                    results.push({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        status: "skipped",
-                        reason: "delivery-uncertain"
-                    });
-                    continue;
-                }
-                const status = outcome === "sent" ? "delivered" : "already-delivered";
-                store.saveRoleRunDelivery({
-                    task,
-                    role,
-                    run,
-                    session,
-                    ...(ready.prepared.launchId === undefined
-                        ? {}
-                        : { launchId: ready.prepared.launchId }),
-                    now
-                });
-                results.push({ taskId: task.id, roleName: role.name, runId: run.id, status });
+                throw new Error("Managed Provider launch completed without an initial Turn outcome.");
             }
             catch (error) {
                 const message = error instanceof Error ? error.message : String(error);
-                if (providerSubmissionBegun) {
-                    store.resolveRoleRunProviderSubmission?.({
-                        taskId: task.id,
-                        roleName: role.name,
-                        runId: run.id,
-                        attemptId: receiptId,
-                        status: "delivery-unknown",
-                        reason: message,
-                        now
-                    });
-                }
                 // Scheduler single-flight backpressure: the Role runtime lifecycle
                 // lane was busy when the launch was reserved. The Run stays
                 // active-unpushed and its mailbox claim is retained; the next pass
@@ -881,7 +731,7 @@ function requireResumeSession(role, effective, session) {
     if (session === null || !hasText(session.nativeSessionId)) {
         throw new Error(`Role resume has no fixed native session: ${role.taskId}/${role.name}.`);
     }
-    if (!effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, effective, role.managedWorkspace)) {
+    if (!effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, effective)) {
         throw new Error(`Role resume effective snapshot drifted: ${role.taskId}/${role.name}.`);
     }
     return session.nativeSessionId;
@@ -948,16 +798,11 @@ function validateRoleSession(role, effective, existing, mode, session) {
         throw new Error(`Ready Role session identity changed: ${role.taskId}/${role.name}.`);
     }
     const compatible = mode === "resume"
-        ? effectiveLaunchSnapshotsCompatibleForTaskMain(session.effective, effective, role.managedWorkspace)
+        ? effectiveLaunchSnapshotsCompatibleForTaskSession(session.effective, effective)
         : effectiveLaunchSnapshotsCompatible(session.effective, effective);
     if (!compatible) {
         throw new Error(`Ready Role session effective snapshot changed: ${role.taskId}/${role.name}.`);
     }
-    if (existing?.nativeSessionId !== undefined
-        && effectiveLaunchSnapshotsCompatibleForTaskMain(existing.effective, effective, role.managedWorkspace)
-        && session.nativeSessionId !== existing.nativeSessionId) {
-        throw new Error(`Ready Role session changed the fixed native session id: ${role.taskId}/${role.name}.`);
-    }
     if (mode === "resume" && session.nativeSessionId !== existing?.nativeSessionId) {
         throw new Error(`Role resume changed the fixed native session id: ${role.taskId}/${role.name}.`);
     }
@@ -972,13 +817,3 @@ function validateRoleSession(role, effective, existing, mode, session) {
 function hasText(value) {
     return typeof value === "string" && value.trim().length > 0;
 }
-/**
- * Fail-closed readiness check for a supported-readiness adapter's first push.
- * When the store cannot answer (no implementation), the push is held rather than
- * proceeding blind — a supported adapter must have a proven provider-ready fold.
- */
-function providerReadyForPush(store, input) {
-    if (store.isRoleGenerationProviderReady === undefined)
-        return false;
-    return store.isRoleGenerationProviderReady(input);
-}

package/dist/scheduler/activeTaskProgress.js

@@ -35,8 +35,7 @@ export function repairOrphanedActiveTasks(store, now, selection) {
             runs: activeRuns,
             pendingWakeup: store.getPendingWakeup(task.id),
             leaderMailbox,
-            leaderFailure: store.getLeaderFailure(task.id),
-            operatorNotification: store.getOperatorNotification(task.id)
+            leaderFailure: store.getLeaderFailure(task.id)
         });
         const queuedAlongsideActiveSibling = hasDispatchableQueuedResourceLane(store, task.id)
             && !activeRuns.some(({ roleName }) => roleName === "leader")
@@ -45,7 +44,6 @@ export function repairOrphanedActiveTasks(store, now, selection) {
         if ((queuedAlongsideActiveSibling ? hasLeaderInFlightTurn : hasInFlightTurn)
             || store.hasOpenInputRequest(task.id)
             || store.getLeaderFailure(task.id) !== null
-            || store.getOperatorNotification(task.id) !== null
             || (projection.status !== "needs-leader-action" && !queuedAlongsideActiveSibling)
             || hasUnclaimedLeaderWork(store, task.id, leaderMailbox)) {
             continue;
@@ -121,8 +119,11 @@ function findLastLeaderRun(store, taskId) {
     };
 }
 function hasUnclaimedLeaderWork(store, taskId, leaderMailbox) {
+    if (store.getPendingWakeup(taskId) !== null)
+        return true;
     if (leaderMailbox === null)
-        return store.getPendingWakeup(taskId) !== null;
-    return leaderMailbox?.processing === null
-        && leaderMailbox.pending !== null;
+        return false;
+    return leaderMailbox.processing === null
+        && (leaderMailbox.pending.normal !== null
+            || leaderMailbox.pending.userCorrection !== null);
 }