@zq-silk/yui 0.11.2 → 0.12.0

package/dist/config/configCatalog.js

@@ -22,8 +22,8 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "provider-retry-max-window-seconds", domain: "runtime", property: "providerRetryMaxWindowSeconds", label: "Provider retry max window", summary: "Positive-integer total retry budget per Run lineage in seconds (default: 600).", takesEffect: "The next retry episode; an active episode keeps its existing deadline." },
     { key: "leader-next-action", domain: "workflow", property: "leaderNextActionMode", label: "Leader next-action mode", summary: "Leader next-action mode: display, warn, or enforce (default: display).", takesEffect: "The next Leader next-action projection or gate." },
     { key: "leader-semantic-budget-turns", domain: "workflow", property: "leaderSemanticBudgetTurns", label: "Leader semantic budget", summary: "Consecutive yielded Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
-    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Context budget", summary: `Per-Session context token budget; soft and hard are ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}, with soft below hard (defaults: 100000/120000).`, takesEffect: "The next context-budget evaluation; retained conversation content is unchanged." },
-    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger; optional finding-ledger and delta-recheck controls. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
+    { key: "context-budget", domain: "workflow", property: "contextBudget", label: "Legacy context budget (inactive)", summary: `Compatibility-only soft and hard values in ${MIN_CONTEXT_BUDGET_TOKENS}-${MAX_CONTEXT_BUDGET_TOKENS}; they are parsed but never control Session or workflow behavior.`, takesEffect: "No runtime effect; Session Token metrics are read-only observations." },
+    { key: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger and optional finding-ledger behavior. Setup leaves it disabled so the Leader may review directly or delegate selectively.", takesEffect: "The next Candidate snapshot; in-flight Candidates and ReviewRounds keep their policy." },
     { key: "resources-gc-mode", domain: "resources", property: "resourcesGcMode", label: "Resources GC mode", summary: "Resource GC mode: report or quarantine (default: report).", takesEffect: "The next resource GC operation." },
     { key: "resources-gc-auto-quarantine", domain: "resources", property: "resourcesGcAutoQuarantine", label: "Resources GC auto-quarantine", summary: "Automatically quarantine eligible terminal Task resources (default: false).", takesEffect: "The next eligible automatic resource GC operation." },
     { key: "resources-quarantine-ttl-hours", domain: "resources", property: "resourcesQuarantineTtlHours", label: "Resource quarantine TTL", summary: "Default observation window before purge, 1-720 hours (default: 24).", takesEffect: "The next resource GC command without an explicit TTL override." },

package/dist/config/yuiConfig.js

@@ -227,13 +227,9 @@ export function resolveTmuxHistoryLimit(value) {
     return resolveBoundedPositiveInteger(value, DEFAULT_TMUX_HISTORY_LIMIT, 1_000, 1_000_000, "tmuxHistoryLimit");
 }
 /**
- * Issue 04 (context token budget): thresholds for one native Session
- * generation's observed per-request input peak, measured in tokens. When the
- * peak crosses the soft threshold the Leader wake carries a checkpoint
- * advisory; when it crosses the hard threshold the scheduler retires the
- * generation and starts a fresh one instead of waiting for provider-side
- * auto-compaction. The fields are additive and optional — Homes without them
- * keep these defaults, so no config migration is required.
+ * Compatibility parser for the retired context-budget setting. Existing
+ * Homes may retain these values, but no runtime, scheduler, or lifecycle path
+ * consumes them. Session Token metrics are an independent read-only view.
  */
 export const DEFAULT_CONTEXT_SOFT_TOKENS = 100_000;
 export const DEFAULT_CONTEXT_HARD_TOKENS = 120_000;

package/dist/context/wakeNotification.js

@@ -4,17 +4,18 @@ import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
  * Issue 04 (context token budget) — long-term design:
  *
  * A Leader wake is a NOTIFICATION, not a context dump. The wake envelope
- * carries only what the Agent cannot reconstruct from durable records:
- * the wake id, the aggregated reason tags, and the delta window. The Agent
- * reads the delta content on demand with `yui task wake show <wake-id>` and
- * the full projection with `yui task context <task>`.
+ * carries only what the Agent needs for immediate orientation: the wake id,
+ * aggregated reason tags, delta window, and a bounded list of active frozen
+ * Task Reviews. The Agent reads delta content on demand with
+ * `yui task wake show <wake-id>` and the full projection with
+ * `yui task context <task>`.
  *
  * The envelope is mode-agnostic: fresh generations and resumed generations
  * receive the same minimal text. The native Session is a disposable cache of
  * working context; Yui's durable Task records (including the wake ledger) are
  * the checkpoint.
  */
-/** Structural guardrail: the envelope must stay an order of magnitude below any context budget. */
+/** Structural guardrail: the envelope stays far below a normal model context window. */
 export const WAKE_ENVELOPE_HARD_BYTES = 2_000;
 /** Maximum reason tags rendered before elision to a count. */
 const REASON_DISPLAY_LIMIT = 6;
@@ -35,11 +36,25 @@ export function buildTaskWakeEnvelope(reader, request) {
         runs: operationalTaskRecords(reader.listAgentRuns(request.taskId), events, "agent-run")
             .filter((record) => Date.parse(record.createdAt) > fromTime).length
     };
+    const activeReviews = reader.listReviewRounds(request.taskId).filter((round) => ((round.scope ?? "work-item") === "task"
+        && (round.status === "pending" || round.status === "running")));
+    const reviewOrientation = activeReviews.slice(0, 3).map((round) => {
+        const projects = round.taskCandidate?.projects ?? [];
+        const heads = projects.slice(0, 2).map(({ projectId, commit }) => (`${projectId}@${commit.slice(0, 12)}`)).join("+");
+        return `${round.id}/${round.reviewerRoleName}`
+            + `/${round.deltaRecheck === undefined ? "full" : "delta"}`
+            + `[${round.status}]`
+            + `@${heads || round.reviewBaseCommit.slice(0, 12)}`
+            + `${projects.length > 2 ? `+${projects.length - 2}` : ""}`;
+    }).join(", ");
     const lines = [
         `Wake: ${request.wakeId} — delta since ${request.fromCursor}`,
         `  Reasons: ${renderReasons(request.reasons)}`,
         `  Changed: ${counts.events} events, ${counts.messages} messages, ${counts.runs} runs`
             + ` → yui task wake show ${request.taskId} ${request.wakeId}`,
+        `  Active Task Reviews: ${activeReviews.length === 0
+            ? "none"
+            : `${reviewOrientation}${activeReviews.length > 3 ? `, … (+${activeReviews.length - 3})` : ""}`}`,
         `Full context: yui task context ${request.taskId}`
     ];
     const body = lines.join("\n");

package/dist/controller/agentRuntimeObserver.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { builtinAgentDriverRegistry } from "../runtime/builtinAgentDrivers.js";
-import { createRuntimeObservation, runtimeObservationFenceMatches, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
+import { createRuntimeObservation, runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
 const DEFAULT_MAX_CONCURRENT_SAMPLES = 8;
 const MAX_CONCURRENT_SAMPLES = 64;
 /**
@@ -31,20 +31,30 @@ export class AgentRuntimeObserver {
         const dirty = new Set();
         const sequenceBase = this.#sequence;
         this.#sequence += active.length;
-        await forEachConcurrent(active, this.#maxConcurrentSamples, async ({ key, fence, source, freshSession, persistedState }, index) => {
+        await forEachConcurrent(active, this.#maxConcurrentSamples, async ({ key, fence, source, persistedState }, index) => {
             const existingState = this.#states.get(key);
             // Cursor state is intentionally process-local, but the latest canonical
             // usage/activity baseline is durable. Rehydrate it after Controller
             // restart so rereading the bounded transcript tail cannot manufacture a
             // fresh activity edge from tokens that were already observed.
             const state = existingState ?? { ...persistedState };
+            const restoredUsageEventId = existingState === undefined
+                ? persistedState.usageEventId
+                : undefined;
             const driver = this.drivers.require(fence.driverId);
             const observer = driver.runtime.observer;
             if (observer === undefined)
                 return;
             let sample;
             try {
-                sample = await observer.sample(source, state.cursor);
+                sample = await observer.sample(source, state.cursor, {
+                    ...(state.usageOccurrenceId === undefined
+                        ? {}
+                        : { latestOccurrenceId: state.usageOccurrenceId }),
+                    ...(state.usageOccurrenceCheckpoint === undefined
+                        ? {}
+                        : { latestCheckpoint: state.usageOccurrenceCheckpoint })
+                });
             }
             catch (error) {
                 sample = Object.freeze({
@@ -59,37 +69,70 @@ export class AgentRuntimeObserver {
             // latency can change completion order without changing observation
             // identity or the canonical sequence assigned to a source.
             const sequence = sequenceBase + index;
-            if (existingState === undefined && state.usage === undefined) {
-                // A fresh native Session begins at zero. A resumed Session instead
-                // freezes its first cumulative sample as this Run's lower-bound
-                // baseline so later samples can prove spend without charging usage
-                // that belongs to an earlier Run in the same native conversation.
-                const baseline = freshSession
-                    ? Object.freeze({
-                        semantics: "cumulative-session",
-                        inputTokens: 0,
-                        outputTokens: 0
-                    })
-                    : sample.usage?.semantics === "cumulative-session"
-                        ? sample.usage
-                        : undefined;
-                if (baseline !== undefined) {
-                    const baselineKey = freshSession ? "zero" : JSON.stringify(baseline);
+            let usages = sample.usages ?? [];
+            if (state.usage === undefined) {
+                // Cumulative counters need a lower bound. An exact initial sample
+                // proves the complete Session-generation history even when the
+                // current Run resumed that Session, so preserve every occurrence and
+                // anchor it at zero. A partial sample cannot prove the omitted request
+                // boundaries; retain its latest total as a partial baseline, plus the
+                // smallest ordered witness if the visible counter already rolled back.
+                // Request snapshots already describe one complete occurrence and must
+                // not be mixed with a synthetic cumulative fact.
+                const usageOccurrences = usages.filter(hasUsageSnapshot);
+                const latestOccurrence = usageOccurrences.at(-1);
+                const completeHistory = latestOccurrence?.usage.semantics === "cumulative-session"
+                    && usages.every(({ observationQuality }) => observationQuality !== "partial");
+                const rollbackWitness = latestOccurrence?.usage.semantics === "cumulative-session"
+                    && !completeHistory
+                    ? cumulativeRollbackWitness(usageOccurrences)
+                    : [];
+                const baseline = latestOccurrence?.usage.semantics !== "cumulative-session"
+                    ? undefined
+                    : completeHistory
+                        ? Object.freeze({
+                            semantics: "cumulative-session",
+                            inputTokens: 0,
+                            outputTokens: 0
+                        })
+                        : latestOccurrence.usage;
+                if (baseline !== undefined && rollbackWitness.length === 0) {
+                    const baselineKey = completeHistory ? "zero" : latestOccurrence.occurrenceId;
+                    const identity = completeHistory
+                        ? tokenObservationIdentity("baseline", fence, source.sourceId, baselineKey)
+                        : usageObservationIdentity(fence, source.sourceId, latestOccurrence);
                     this.inbox.enqueueObservation(createRuntimeObservation({
                         schemaVersion: 2,
-                        eventId: observationId("baseline", fence, source.sourceId, baselineKey),
-                        semanticKey: observationId("baseline", fence, source.sourceId, baselineKey),
+                        eventId: identity.eventId,
+                        semanticKey: identity.semanticKey,
                         kind: "activity.observed",
-                        authority: freshSession ? "controller" : "driver-inferred",
+                        authority: completeHistory ? "controller" : "driver-inferred",
                         receivedAt: at,
                         sequence,
                         ordinal: 1,
                         fence,
-                        payload: { activity: "model", usage: baseline }
+                        payload: {
+                            activity: "model",
+                            sourceId: source.sourceId,
+                            usage: baseline,
+                            ...(completeHistory
+                                ? {}
+                                : { observationQuality: "partial" })
+                        }
                     }));
                     state.usage = baseline;
-                    dirty.add(`role:${fence.taskId}/${fence.roleName}`);
+                    state.usageEventId = identity.eventId;
+                    state.usageOccurrenceId = completeHistory
+                        ? undefined
+                        : latestOccurrence.occurrenceId;
+                    state.usageOccurrenceCheckpoint = completeHistory
+                        ? undefined
+                        : latestOccurrence.resumeCheckpoint;
+                    if (!completeHistory)
+                        usages = [];
                 }
+                if (rollbackWitness.length > 0)
+                    usages = rollbackWitness;
             }
             const health = JSON.stringify([sample.status, sample.detail ?? null]);
             if (state.health !== health) {
@@ -112,32 +155,81 @@ export class AgentRuntimeObserver {
                 state.health = health;
                 dirty.add(`role:${fence.taskId}/${fence.roleName}`);
             }
-            const usageChanged = sample.usage !== undefined
-                && !sameUsage(state.usage, sample.usage);
             const activityChanged = sample.activityId !== undefined
                 && sample.activityId !== state.activityId;
-            if (usageChanged || (activityChanged && state.cursor !== undefined)) {
-                const usage = sample.usage;
+            if (restoredUsageEventId !== undefined) {
+                let persistedIndex = -1;
+                for (let usageIndex = usages.length - 1; usageIndex >= 0; usageIndex -= 1) {
+                    if (usageObservationIdentity(fence, source.sourceId, usages[usageIndex]).eventId
+                        === restoredUsageEventId) {
+                        persistedIndex = usageIndex;
+                        break;
+                    }
+                }
+                if (persistedIndex >= 0) {
+                    usages = usages.slice(persistedIndex + 1);
+                }
+                else if (state.usage?.semantics === "cumulative-session") {
+                    // The durable counter proves the latest cumulative total, but an
+                    // initial bounded read that cannot recover that occurrence may
+                    // have skipped intermediate request boundaries while the
+                    // Controller was stopped. Preserve the total and fail closed only
+                    // for the derived maximum-request metric.
+                    usages = usages.map((occurrence) => (occurrence.usage?.semantics !== "cumulative-session"
+                        ? occurrence
+                        : Object.freeze({ ...occurrence, observationQuality: "partial" })));
+                }
+            }
+            usages.forEach((occurrence, usageIndex) => {
+                const identity = usageObservationIdentity(fence, source.sourceId, occurrence);
                 this.inbox.enqueueObservation(createRuntimeObservation({
                     schemaVersion: 2,
-                    eventId: observationId("activity", fence, source.sourceId, JSON.stringify([usage ?? null, sample.activityId ?? null])),
-                    semanticKey: observationId("activity", fence, source.sourceId, JSON.stringify([usage ?? null, sample.activityId ?? null])),
+                    eventId: identity.eventId,
+                    semanticKey: identity.semanticKey,
                     kind: "activity.observed",
                     authority: "driver-inferred",
                     receivedAt: at,
                     sequence,
-                    ordinal: 2,
+                    ordinal: 2 + usageIndex,
                     fence,
                     payload: {
                         activity: sample.activity ?? "model",
-                        ...(sample.activityId === undefined ? {} : { activityId: sample.activityId }),
-                        ...(usage === undefined ? {} : { usage })
+                        sourceId: source.sourceId,
+                        ...(occurrence.usage === undefined || occurrence.activityId === undefined
+                            ? {}
+                            : { activityId: occurrence.activityId }),
+                        ...(occurrence.observationQuality === undefined
+                            ? {}
+                            : { observationQuality: occurrence.observationQuality }),
+                        ...(occurrence.usage === undefined ? {} : { usage: occurrence.usage })
+                    }
+                }));
+                if (occurrence.usage !== undefined) {
+                    state.usage = occurrence.usage;
+                    state.usageEventId = identity.eventId;
+                    state.usageOccurrenceId = occurrence.occurrenceId;
+                    state.usageOccurrenceCheckpoint = occurrence.resumeCheckpoint;
+                }
+            });
+            if (activityChanged && state.cursor !== undefined) {
+                this.inbox.enqueueObservation(createRuntimeObservation({
+                    schemaVersion: 2,
+                    eventId: observationId("activity", fence, source.sourceId, sample.activityId),
+                    semanticKey: observationId("activity", fence, source.sourceId, sample.activityId),
+                    kind: "activity.observed",
+                    authority: "driver-inferred",
+                    receivedAt: at,
+                    sequence,
+                    ordinal: 2 + usages.length,
+                    fence,
+                    payload: {
+                        activity: sample.activity ?? "model",
+                        sourceId: source.sourceId,
+                        activityId: sample.activityId
                     }
                 }));
                 dirty.add(`role:${fence.taskId}/${fence.roleName}`);
             }
-            if (sample.usage !== undefined)
-                state.usage = sample.usage;
             if (sample.activityId !== undefined)
                 state.activityId = sample.activityId;
             this.#states.set(key, state);
@@ -160,11 +252,13 @@ export class AgentRuntimeObserver {
             // by Run and sort each group once so every active Run can reuse the same
             // ordered slice instead of repeatedly filtering/sorting all E events.
             const observationsByRunId = new Map();
+            const taskObservations = [];
             for (const event of this.store.listEvents(task.id)) {
                 const observation = runtimeObservationFromTaskEvent(event);
                 const runId = observation?.fence.runId;
                 if (observation === null || runId === undefined)
                     continue;
+                taskObservations.push(observation);
                 const grouped = observationsByRunId.get(runId);
                 if (grouped === undefined) {
                     observationsByRunId.set(runId, [observation]);
@@ -176,6 +270,7 @@ export class AgentRuntimeObserver {
             for (const observations of observationsByRunId.values()) {
                 observations.sort(compareObservations);
             }
+            taskObservations.sort(compareObservations);
             for (const run of this.store.listAgentRuns(task.id)) {
                 if (run.status !== "active"
                     || this.store.getActiveAgentRun(task.id, run.roleName)?.id !== run.id)
@@ -200,12 +295,18 @@ export class AgentRuntimeObserver {
                     continue;
                 }
                 const fence = accepted.fence;
-                const exact = observations
-                    .filter((observation) => runtimeObservationFenceMatches(fence, observation.fence));
-                const persistedUsage = exact.filter((observation) => (observation.kind === "activity.observed"
+                const generation = taskObservations.filter((observation) => (sessionGenerationFenceMatches(fence, observation.fence)
+                    && observation.payload.sourceId === source.sourceId));
+                const persistedUsage = generation.filter((observation) => (observation.kind === "activity.observed"
                     && observation.payload.usage !== undefined)).at(-1);
-                const persistedHealth = exact.filter((observation) => (observation.kind === "observer.health"
+                const persistedActivity = generation.filter((observation) => (observation.kind === "activity.observed"
+                    && observation.payload.activityId !== undefined
+                    && observation.payload.usage === undefined)).at(-1);
+                const persistedHealth = generation.filter((observation) => (observation.kind === "observer.health"
                     && observation.payload.sourceId === source.sourceId)).at(-1);
+                const persistedUsageResume = persistedUsage === undefined
+                    ? undefined
+                    : usageObservationResume(persistedUsage.semanticKey);
                 result.push(Object.freeze({
                     key: JSON.stringify([
                         fence.taskId,
@@ -216,20 +317,30 @@ export class AgentRuntimeObserver {
                         fence.launchId,
                         fence.sessionGenerationId,
                         fence.nativeSessionId,
-                        fence.nativeTurnId,
-                        fence.receiptId,
                         source.sourceId
                     ]),
                     fence,
                     source,
-                    freshSession: run.mode === "new",
                     persistedState: Object.freeze({
                         ...(persistedUsage?.payload.usage === undefined
                             ? {}
                             : { usage: persistedUsage.payload.usage }),
-                        ...(persistedUsage?.payload.activityId === undefined
+                        ...(persistedUsage === undefined
                             ? {}
-                            : { activityId: persistedUsage.payload.activityId }),
+                            : {
+                                usageEventId: persistedUsage.eventId,
+                                ...(persistedUsageResume === undefined
+                                    ? {}
+                                    : {
+                                        usageOccurrenceId: persistedUsageResume.occurrenceId,
+                                        ...(persistedUsageResume.checkpoint === undefined
+                                            ? {}
+                                            : { usageOccurrenceCheckpoint: persistedUsageResume.checkpoint })
+                                    })
+                            }),
+                        ...(persistedActivity?.payload.activityId === undefined
+                            ? {}
+                            : { activityId: persistedActivity.payload.activityId }),
                         ...(persistedHealth === undefined
                             ? {}
                             : {
@@ -265,6 +376,28 @@ function sampleConcurrency(value) {
     }
     return resolved;
 }
+function hasUsageSnapshot(occurrence) {
+    return occurrence.usage !== undefined;
+}
+function cumulativeRollbackWitness(occurrences) {
+    const cumulative = occurrences.filter(({ usage }) => (usage.semantics === "cumulative-session"));
+    const latest = cumulative.at(-1);
+    for (let index = 1; index < cumulative.length; index += 1) {
+        const previous = cumulative[index - 1];
+        const current = cumulative[index];
+        if (current.usage.inputTokens >= previous.usage.inputTokens
+            && current.usage.outputTokens >= previous.usage.outputTokens)
+            continue;
+        const witness = latest === current
+            ? [previous, current]
+            : [previous, current, latest];
+        return Object.freeze(witness.map((occurrence) => Object.freeze({
+            ...occurrence,
+            observationQuality: "partial"
+        })));
+    }
+    return Object.freeze([]);
+}
 function numericCompare(left, right) {
     return left.localeCompare(right, undefined, { numeric: true });
 }
@@ -279,11 +412,74 @@ function observationId(kind, fence, sourceId, value) {
         .update(JSON.stringify([kind, fence, sourceId, value]))
         .digest("hex")}`;
 }
-function sameUsage(left, right) {
-    return left !== undefined
-        && left.semantics === right.semantics
-        && left.inputTokens === right.inputTokens
-        && left.outputTokens === right.outputTokens
-        && left.cachedInputTokens === right.cachedInputTokens
-        && left.reasoningTokens === right.reasoningTokens;
+function usageObservationIdentity(fence, sourceId, occurrence) {
+    const eventId = tokenObservationId("usage", fence, sourceId, occurrence.occurrenceId);
+    const encodedOccurrenceId = Buffer.from(occurrence.occurrenceId, "utf8").toString("base64url");
+    return Object.freeze({
+        eventId,
+        semanticKey: `${eventId}:occurrence:${encodedOccurrenceId}${occurrence.resumeCheckpoint === undefined
+            ? ""
+            : `:checkpoint:${Buffer.from(occurrence.resumeCheckpoint, "utf8").toString("base64url")}`}`
+    });
+}
+function usageObservationResume(semanticKey) {
+    const occurrenceMarker = ":occurrence:";
+    const checkpointMarker = ":checkpoint:";
+    const occurrenceIndex = semanticKey.lastIndexOf(occurrenceMarker);
+    if (occurrenceIndex < 0)
+        return undefined;
+    const checkpointIndex = semanticKey.indexOf(checkpointMarker, occurrenceIndex + occurrenceMarker.length);
+    const encodedOccurrence = semanticKey.slice(occurrenceIndex + occurrenceMarker.length, checkpointIndex < 0 ? undefined : checkpointIndex);
+    if (encodedOccurrence.length === 0)
+        return undefined;
+    try {
+        const occurrenceId = Buffer.from(encodedOccurrence, "base64url").toString("utf8");
+        if (occurrenceId.length === 0)
+            return undefined;
+        if (checkpointIndex < 0)
+            return Object.freeze({ occurrenceId });
+        const encodedCheckpoint = semanticKey.slice(checkpointIndex + checkpointMarker.length);
+        if (encodedCheckpoint.length === 0)
+            return undefined;
+        const checkpoint = Buffer.from(encodedCheckpoint, "base64url").toString("utf8");
+        return checkpoint.length === 0
+            ? undefined
+            : Object.freeze({ occurrenceId, checkpoint });
+    }
+    catch {
+        return undefined;
+    }
+}
+function tokenObservationIdentity(kind, fence, sourceId, value) {
+    const eventId = tokenObservationId(kind, fence, sourceId, value);
+    return Object.freeze({ eventId, semanticKey: eventId });
+}
+function tokenObservationId(kind, fence, sourceId, value) {
+    return `runtime-observer-${createHash("sha256").update(JSON.stringify([
+        kind,
+        fence.taskId ?? null,
+        fence.roleName,
+        fence.agentId,
+        fence.driverId,
+        fence.launchId,
+        fence.sessionGenerationId,
+        fence.nativeSessionId ?? null,
+        sourceId,
+        value
+    ])).digest("hex")}`;
+}
+function sessionGenerationFenceMatches(expected, actual) {
+    for (const field of [
+        "taskId",
+        "roleName",
+        "agentId",
+        "driverId",
+        "launchId",
+        "sessionGenerationId",
+        "nativeSessionId"
+    ]) {
+        if (expected[field] !== actual[field])
+            return false;
+    }
+    return true;
 }

package/dist/controller/clientRuntime.js

@@ -582,7 +582,7 @@ export class FileTaskWorkflowRuntime {
     async #prepareAndScan(taskId) {
         const task = this.store.getTask(taskId);
         if (task !== null
-            && (task.status === "draft" || task.status === "active")
+            && task.status === "active"
             && this.workspacePreparer !== undefined) {
             await this.workspacePreparer.prepareTaskWorkspace(taskId);
         }

package/dist/controller/controller.js

@@ -1184,11 +1184,12 @@ export class FileTaskController {
                         this.#clearDeliveryRetry(key);
                         this.#scheduleTaskPassRetry({ taskId, keys: [key] });
                     }
+                    const runtimeAdvanced = (firstRuntimeDrain?.acknowledgedEventIds.length ?? 0) > 0
+                        || (secondRuntimeDrain?.acknowledgedEventIds.length ?? 0) > 0;
                     if (scope.kind === "full"
                         || scope.keys.some((key) => key !== "operator")
-                        || (firstRuntimeDrain?.acknowledgedEventIds.length ?? 0) > 0
-                        || (secondRuntimeDrain?.acknowledgedEventIds.length ?? 0) > 0) {
-                        this.#signalOperatorMailbox();
+                        || runtimeAdvanced) {
+                        this.#signalOperatorMailbox(runtimeAdvanced);
                     }
                 }
                 catch (error) {
@@ -1311,7 +1312,7 @@ export class FileTaskController {
         this.#clearEmptyOperatorRetry();
         this.#scheduleNextInputDeadline();
     }
-    #signalOperatorMailbox() {
+    #signalOperatorMailbox(retryReady = false) {
         if (this.#stopped)
             return;
         const mailbox = this.store.getWorkMailbox({ kind: "operator" });
@@ -1320,7 +1321,8 @@ export class FileTaskController {
             this.#lastOperatorSignalIdentity = undefined;
             return;
         }
-        if (identity !== this.#lastOperatorSignalIdentity) {
+        if (identity !== this.#lastOperatorSignalIdentity
+            || (retryReady && this.store.getOperatorDeliveryTarget() !== null)) {
             this.#operatorSignalScheduler.signal("operator");
             this.#lastOperatorSignalIdentity = identity;
         }
@@ -1516,13 +1518,7 @@ export class FileTaskController {
                 && this.#operatorStartupRetryArmed));
         if (operatorRetries.length > 0) {
             retry.set("operator", {
-                identity: operatorRetries.map((notification) => ("inputRequestId" in notification
-                    ? `input:${notification.inputRequestId}`
-                    : "recoveryTaskId" in notification
-                        ? `recovery:${notification.recoveryTaskId}`
-                        : "stallTaskId" in notification
-                            ? `stall:${notification.stallTaskId}`
-                            : `terminal:${notification.terminalTaskId}`)).join("|")
+                identity: operatorRetries.map((notification) => (`${notification.sourceKind}:${notification.taskId}:${notification.sourceId}`)).join("|")
             });
         }
         else if (result.inputNotifications.some((notification) => notification.status === "sent"