@zq-silk/yui 0.10.0 → 0.11.0

package/dist/context/runContextPack.js

@@ -6,7 +6,47 @@ export const RUN_CONTEXT_PACK_SCHEMA_VERSION = 1;
 export const RUN_CONTEXT_PACK_MAX_REFS = 256;
 export const RUN_CONTEXT_PACK_MAX_BYTES = 8 * 1024 * 1024;
 export const RUN_CONTEXT_EXPAND_MAX_BYTES = 4 * 1024 * 1024;
-export function freezeRunContextSnapshot(store, run, now, frozenBy = "controller") {
+export function freezeRunContextSnapshot(store, run, now, frozenBy = "controller", baselineRef) {
+    if (baselineRef !== undefined) {
+        const baseline = store.getContextSnapshot(run.taskId, baselineRef.id);
+        if (baseline === null
+            || baseline.taskId !== run.taskId
+            || baselineRef.taskId !== run.taskId
+            || baseline.digest !== baselineRef.digest
+            || baseline.sequence !== baselineRef.sequence
+            || baseline.scope !== "stage"
+            || baselineRef.scope !== baseline.scope
+            || baseline.scopeRef !== baselineRef.scopeRef) {
+            throw new Error(`Run Context baseline is missing or drifted: ${baselineRef.id}.`);
+        }
+        validateContextSnapshot(baseline);
+        const overlays = collectRunContextOverlays(store, run);
+        const resources = [...new Map([...baseline.resources, ...overlays].map((entry) => [
+                contextRefIdentity(entry.ref),
+                entry
+            ])).values()].sort((left, right) => (contextRefIdentity(left.ref).localeCompare(contextRefIdentity(right.ref))));
+        const previous = store.listContextSnapshots(run.taskId)
+            .filter((candidate) => candidate.scope === baseline.scope
+            && candidate.scopeRef === baseline.scopeRef)
+            .sort((left, right) => left.sequence - right.sequence)
+            .at(-1);
+        const snapshot = createContextSnapshot({
+            id: store.nextContextSnapshotId(run.taskId),
+            taskId: run.taskId,
+            scope: baseline.scope,
+            scopeRef: baseline.scopeRef,
+            sequence: (previous?.sequence ?? baseline.sequence) + 1,
+            refs: resources.map(({ ref }) => ref),
+            resources,
+            ...(baseline.repoCommit === undefined ? {} : { repoCommit: baseline.repoCommit }),
+            acceptRefs: baseline.acceptRefs,
+            parentRef: contextSnapshotRef(baseline),
+            frozenAt: now,
+            frozenBy
+        });
+        store.saveContextSnapshot(snapshot);
+        return snapshot;
+    }
     const scope = run.reviewRoundId !== undefined
         ? "stage"
         : run.workItemId !== undefined
@@ -34,6 +74,127 @@ export function freezeRunContextSnapshot(store, run, now, frozenBy = "controller
     store.saveContextSnapshot(snapshot);
     return snapshot;
 }
+/**
+ * Freeze the shared, role-neutral ContextSnapshot anchored by one WorkItem
+ * exploration stage Group. AgentRun snapshots remain role-specific; this
+ * record is the durable stage baseline and derives from a fresh WorkItem
+ * snapshot so the Group never depends on ambient latest state.
+ */
+export function freezeExecutionStageContextSnapshot(store, input, now) {
+    const task = store.getTask(input.taskId);
+    if (task === null)
+        throw new Error(`Task not found: ${input.taskId}.`);
+    const workItem = store.getWorkItem(input.taskId, input.workItemId);
+    if (workItem === null)
+        throw new Error(`WorkItem not found: ${input.workItemId}.`);
+    const materialized = [
+        materialize("L2", "task", task.id, task),
+        materialize("L3", "work-item", workItem.id, workItem)
+    ];
+    for (const dependencyId of workItem.dependsOn) {
+        const dependency = store.getWorkItem(task.id, dependencyId);
+        if (dependency === null || dependency.status !== "completed") {
+            throw new Error(`Exploration stage dependency is not accepted: ${dependencyId}.`);
+        }
+        materialized.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
+    }
+    for (const binding of task.projectBindings) {
+        const project = store.getProject(binding.projectId);
+        if (project === null)
+            throw new Error(`Run Project not found: ${binding.projectId}.`);
+        const { knowledge, ...projectPolicy } = project;
+        materialized.push(materialize("L1", "project-policy", project.id, projectPolicy));
+        for (const entry of knowledge.filter(({ status }) => status === "active")) {
+            materialized.push(materialize("L1", "project-knowledge", `${project.id}:${entry.id}`, { projectId: project.id, ...entry }));
+        }
+    }
+    const resources = [...new Map(materialized.map((entry) => [
+            contextRefIdentity(entry.ref),
+            entry
+        ])).values()].sort((left, right) => (contextRefIdentity(left.ref).localeCompare(contextRefIdentity(right.ref))));
+    const previousWorkItem = store.listContextSnapshots(task.id)
+        .filter((candidate) => candidate.scope === "workitem"
+        && candidate.scopeRef === workItem.id)
+        .sort((left, right) => left.sequence - right.sequence)
+        .at(-1);
+    const workItemSnapshot = createContextSnapshot({
+        id: store.nextContextSnapshotId(task.id),
+        taskId: task.id,
+        scope: "workitem",
+        scopeRef: workItem.id,
+        sequence: (previousWorkItem?.sequence ?? 0) + 1,
+        refs: resources.map(({ ref }) => ref),
+        resources,
+        acceptRefs: [`work-item:${workItem.id}:acceptance`],
+        ...(previousWorkItem === undefined
+            ? {}
+            : { parentRef: contextSnapshotRef(previousWorkItem) }),
+        frozenAt: now,
+        frozenBy: "controller"
+    });
+    store.saveContextSnapshot(workItemSnapshot);
+    const stageSnapshot = createContextSnapshot({
+        id: store.nextContextSnapshotId(task.id),
+        taskId: task.id,
+        scope: "stage",
+        scopeRef: input.executionGroupId,
+        sequence: workItemSnapshot.sequence + 1,
+        refs: resources.map(({ ref }) => ref),
+        resources,
+        acceptRefs: [`work-item:${workItem.id}:acceptance`],
+        parentRef: contextSnapshotRef(workItemSnapshot),
+        frozenAt: now,
+        frozenBy: "controller"
+    });
+    store.saveContextSnapshot(stageSnapshot);
+    return stageSnapshot;
+}
+/**
+ * Freeze the role-neutral baseline for one Reviewer ExecutionGroup before
+ * admission. Delayed or retried sibling Lanes reuse the same immutable
+ * ReviewRound/Task/Project values and add only their Role overlay.
+ */
+export function freezeReviewStageContextSnapshot(store, input, now) {
+    const existing = store.listContextSnapshots(input.taskId)
+        .filter((candidate) => candidate.scope === "stage"
+        && candidate.scopeRef === input.executionGroupId
+        && candidate.parentRef === undefined)
+        .sort((left, right) => left.sequence - right.sequence)
+        .at(0);
+    if (existing !== undefined)
+        return validateContextSnapshot(existing);
+    const round = store.getReviewRound(input.taskId, input.reviewRoundId);
+    if (round === null)
+        throw new Error(`ReviewRound not found: ${input.reviewRoundId}.`);
+    const materialized = collectAuthorizedContext(store, {
+        taskId: input.taskId,
+        roleName: round.reviewerRoleName,
+        purpose: "review",
+        ...(round.workItemId === undefined ? {} : { workItemId: round.workItemId }),
+        reviewRoundId: round.id
+    }).filter(({ ref }) => (ref.store !== "role-profile" && ref.store !== "managed-workspace"));
+    if (!materialized.some(({ ref }) => (ref.store === "review-round" && ref.refId === round.id))) {
+        throw new Error(`ReviewRound Context baseline is unavailable: ${round.id}.`);
+    }
+    const resources = [...new Map(materialized.map((entry) => [
+            contextRefIdentity(entry.ref),
+            entry
+        ])).values()].sort((left, right) => (contextRefIdentity(left.ref).localeCompare(contextRefIdentity(right.ref))));
+    const snapshot = createContextSnapshot({
+        id: store.nextContextSnapshotId(input.taskId),
+        taskId: input.taskId,
+        scope: "stage",
+        scopeRef: input.executionGroupId,
+        sequence: 1,
+        refs: resources.map(({ ref }) => ref),
+        resources,
+        acceptRefs: round.workItemId === undefined ? [] : [`work-item:${round.workItemId}:acceptance`],
+        frozenAt: now,
+        frozenBy: "controller"
+    });
+    store.saveContextSnapshot(snapshot);
+    return snapshot;
+}
 /** Bounded changed-ref hint between one frozen Snapshot and its exact parent. */
 export function contextSnapshotDeltaRefIds(store, snapshot) {
     validateContextSnapshot(snapshot);
@@ -190,22 +351,7 @@ function collectAuthorizedContext(store, run) {
     if (brief !== null && view === "leader") {
         result.push(materialize("L2", "task-brief", task.id, brief));
     }
-    const role = store.getRole(task.id, run.roleName);
-    if (role === null)
-        throw new Error(`Run Role not found: ${task.id}/${run.roleName}.`);
-    result.push(materialize("L1", "role-profile", role.name, {
-        name: role.name,
-        defaultAccess: role.defaultAccess,
-        description: role.description,
-        responsibilities: role.responsibilities ?? [],
-        constraints: role.constraints ?? [],
-        expectedOutput: role.expectedOutput,
-        skills: role.skills ?? [],
-        launchRevision: role.launchRevision
-    }));
-    if ("workspace" in run && run.workspace !== undefined) {
-        result.push(materialize("L3", "managed-workspace", `${run.taskId}/${run.roleName}`, run.workspace));
-    }
+    result.push(...collectRunContextOverlays(store, run));
     if (run.workItemId !== undefined) {
         const item = store.getWorkItem(task.id, run.workItemId);
         if (item === null)
@@ -287,6 +433,27 @@ function collectAuthorizedContext(store, run) {
     const unique = new Map(result.map((entry) => [contextRefIdentity(entry.ref), entry]));
     return [...unique.values()].sort((left, right) => (contextRefIdentity(left.ref).localeCompare(contextRefIdentity(right.ref))));
 }
+/** Lane-specific context that may be layered over an immutable stage base. */
+function collectRunContextOverlays(store, run) {
+    const role = store.getRole(run.taskId, run.roleName);
+    if (role === null)
+        throw new Error(`Run Role not found: ${run.taskId}/${run.roleName}.`);
+    return [
+        materialize("L1", "role-profile", role.name, {
+            name: role.name,
+            defaultAccess: role.defaultAccess,
+            description: role.description,
+            responsibilities: role.responsibilities ?? [],
+            constraints: role.constraints ?? [],
+            expectedOutput: role.expectedOutput,
+            skills: role.skills ?? [],
+            launchRevision: role.launchRevision
+        }),
+        ...("workspace" in run && run.workspace !== undefined
+            ? [materialize("L3", "managed-workspace", `${run.taskId}/${run.roleName}`, run.workspace)]
+            : [])
+    ];
+}
 function materialize(layer, store, refId, value) {
     const digest = contextContentDigest(value);
     const record = value;

package/dist/controller/agentRuntimeObserver.js

@@ -59,26 +59,37 @@ 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 && freshSession && state.usage === undefined) {
-                const zero = Object.freeze({
-                    semantics: "cumulative-session",
-                    inputTokens: 0,
-                    outputTokens: 0
-                });
-                this.inbox.enqueueObservation(createRuntimeObservation({
-                    schemaVersion: 2,
-                    eventId: observationId("baseline", fence, source.sourceId, "zero"),
-                    semanticKey: observationId("baseline", fence, source.sourceId, "zero"),
-                    kind: "activity.observed",
-                    authority: "controller",
-                    receivedAt: at,
-                    sequence,
-                    ordinal: 1,
-                    fence,
-                    payload: { activity: "model", usage: zero }
-                }));
-                state.usage = zero;
-                dirty.add(`role:${fence.taskId}/${fence.roleName}`);
+            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);
+                    this.inbox.enqueueObservation(createRuntimeObservation({
+                        schemaVersion: 2,
+                        eventId: observationId("baseline", fence, source.sourceId, baselineKey),
+                        semanticKey: observationId("baseline", fence, source.sourceId, baselineKey),
+                        kind: "activity.observed",
+                        authority: freshSession ? "controller" : "driver-inferred",
+                        receivedAt: at,
+                        sequence,
+                        ordinal: 1,
+                        fence,
+                        payload: { activity: "model", usage: baseline }
+                    }));
+                    state.usage = baseline;
+                    dirty.add(`role:${fence.taskId}/${fence.roleName}`);
+                }
             }
             const health = JSON.stringify([sample.status, sample.detail ?? null]);
             if (state.health !== health) {

package/dist/controller/fileSchedulerStoreAdapter.js

@@ -30,7 +30,7 @@ import { wakeReason } from "../scheduler/wakeReason.js";
 import { foldRunProgressFacts, latestRunDurableProgressAt, latestRunEventTime, latestStallEvidenceKey, clearMatchingLeaderStallAttention, RUN_PROGRESS_EVENT, RUN_RECOVERED_EVENT, RUN_STALLED_EVENT } from "../scheduler/roleRunStall.js";
 import { projectProviderContinuations } from "../runtime/runtimeContinuationProjection.js";
 import { providerContinuationKey } from "../runtime/providerContinuation.js";
-import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus } from "../workItem/workItem.js";
+import { currentWorkItemExecutionGroup, updateWorkItemExecutionGroup, updateWorkItemStatus, workItemOwnsUnresolvedExecutionLane } from "../workItem/workItem.js";
 import { recordExecutionLaneResult } from "../execution/executionGroup.js";
 import { formatAgentRunReceiptId, formatTaskRecordReference } from "../task/taskRecordReference.js";
 import { bindExecution, claimPending, claimInputDelivery as claimMailboxInputDelivery, completeInputDelivery as completeMailboxInputDelivery, completeProcessing, mailboxHasPending, mailboxHasWork, pendingLane, markInputDeliveryPushed as markMailboxInputDeliveryPushed, markInputDeliveryUnknown as markMailboxInputDeliveryUnknown, releaseInputDelivery as releaseMailboxInputDelivery, resolveInputDeliveryNotAccepted as resolveMailboxInputDeliveryNotAccepted, releaseProcessing } from "../coordination/workMailbox.js";
@@ -1547,11 +1547,7 @@ export class FileSchedulerStoreAdapter {
                 if (item !== null && ![
                     "completed", "failed", "retired"
                 ].includes(item.status)) {
-                    const group = currentWorkItemExecutionGroup(item);
-                    const groupedPanel = group !== undefined
-                        && (group.lanes.length > 1 || group.strategy.mode === "adaptive")
-                        && group.resolution === undefined;
-                    if (!groupedPanel) {
+                    if (!workItemOwnsUnresolvedExecutionLane(item, terminal.executionGroupId, terminal.executionLaneId)) {
                         store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", input.now, summary));
                     }
                 }
@@ -1705,11 +1701,7 @@ export class FileSchedulerStoreAdapter {
                         store.saveWorkItem(task.id, updateWorkItemExecutionGroup(workItem, recordExecutionLaneResult(group, currentRun.executionLaneId, { summary: input.summary }, "failed", input.now), input.now));
                     }
                     const laneUpdated = store.getWorkItem(task.id, currentRun.workItemId);
-                    const laneGroup = currentWorkItemExecutionGroup(laneUpdated);
-                    const groupedPanel = laneGroup !== undefined
-                        && (laneGroup.lanes.length > 1 || laneGroup.strategy.mode === "adaptive")
-                        && laneGroup.resolution === undefined;
-                    if (!groupedPanel) {
+                    if (!workItemOwnsUnresolvedExecutionLane(laneUpdated, currentRun.executionGroupId, currentRun.executionLaneId)) {
                         store.saveWorkItem(task.id, updateWorkItemStatus(laneUpdated, "failed", input.now, input.summary));
                     }
                 }
@@ -2109,7 +2101,7 @@ export class FileSchedulerStoreAdapter {
                 const item = store.getWorkItem(input.taskId, before.workItemId);
                 if (item !== null && ![
                     "completed", "failed", "retired"
-                ].includes(item.status)) {
+                ].includes(item.status) && !workItemOwnsUnresolvedExecutionLane(item, before.executionGroupId, before.executionLaneId)) {
                     store.saveWorkItem(input.taskId, updateWorkItemStatus(item, "failed", now, summary));
                 }
             }
@@ -3388,7 +3380,9 @@ function finalizeProviderRetryDeadline(store, run, summary, reason, now) {
     }, now));
     if (terminal.purpose === "execution" && terminal.workItemId !== undefined) {
         const item = store.getWorkItem(run.taskId, terminal.workItemId);
-        if (item !== null && !["completed", "failed", "retired"].includes(item.status)) {
+        if (item !== null
+            && !["completed", "failed", "retired"].includes(item.status)
+            && !workItemOwnsUnresolvedExecutionLane(item, terminal.executionGroupId, terminal.executionLaneId)) {
             store.saveWorkItem(run.taskId, updateWorkItemStatus(item, "failed", now, summary));
         }
     }