@zq-silk/yui 0.14.0 → 0.14.2

package/dist/commands/taskRoleRuntimeStatus.js

@@ -335,7 +335,7 @@ function calculateHealth(role, activeTurn, lastTurn, nativeSession, runtimeClean
         : { health: "idle", healthReason: "there is no active work or live tmux pane" };
 }
 function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, taskId, roleName, now) {
-    if (run === null || session?.launchId === undefined)
+    if (run === null || session?.runtimeGenerationId === undefined)
         return null;
     let driverId;
     try {
@@ -350,8 +350,7 @@ function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, tas
         turnId: run.id,
         agentId: run.effective.agentId,
         driverId,
-        launchId: session.launchId,
-        sessionGenerationId: session.launchId,
+        runtimeGenerationId: session.runtimeGenerationId,
         nativeSessionId: session.nativeSessionId,
         nativeTurnId: runtimeNativeTurnId(events, {
             taskId: run.taskId,
@@ -359,7 +358,7 @@ function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, tas
             turnId: run.id,
             agentId: run.effective.agentId,
             driverId,
-            launchId: session.launchId,
+            runtimeGenerationId: session.runtimeGenerationId,
             nativeSessionId: session.nativeSessionId,
             receiptId: store.getTaskRoleSessionSet(taskId, roleName)?.providerBinding?.turn?.attemptId
                 ?? formatTurnReceiptId(run.taskId, run.id)
@@ -369,7 +368,7 @@ function projectTaskRoleRuntime(run, session, tmux, events, _mailbox, store, tas
     };
     let projection = projectRuntimeTaskEvents(fence, run.createdAt, events);
     projection = projectRuntimeObservation(projection, createRuntimeObservation({
-        schemaVersion: 2,
+        schemaVersion: 4,
         eventId: `runtime-host-${run.id}`,
         semanticKey: `runtime-host-${run.id}`,
         kind: "host.observed",
@@ -421,7 +420,7 @@ function runtimeNativeTurnId(events, expected) {
         && observation.fence.turnId === expected.turnId
         && observation.fence.agentId === expected.agentId
         && observation.fence.driverId === expected.driverId
-        && observation.fence.launchId === expected.launchId
+        && observation.fence.runtimeGenerationId === expected.runtimeGenerationId
         && observation.fence.nativeSessionId === expected.nativeSessionId
         && observation.fence.receiptId === expected.receiptId
         && observation.fence.nativeTurnId !== undefined)

package/dist/commands/taskUpstreamCommands.js

@@ -1,136 +1,120 @@
 import { usageError } from "../errors/cliError.js";
-import { createTaskEvent } from "../event/taskEvent.js";
+import { GitIntegrationService } from "../integration/gitIntegrationService.js";
+import { createIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { NodeGitWorkspace } from "../repository/gitWorkspace.js";
-import { acquireProjectMaintenanceLock } from "../repository/projectMaintenanceLock.js";
+import { FileTaskWorkspacePreparer } from "../repository/taskWorkspacePreparer.js";
 import { workspaceProjectEntry } from "../worktree/managedWorkspace.js";
-export async function runTaskUpstreamCommand(args, store, options = {}) {
+import { parseRepeatable } from "./taskIntegrationCommands.js";
+import { taskLocalActor } from "./taskActor.js";
+export async function runTaskUpstreamCommand(args, store, home, options = {}) {
     const [command, ...rest] = args;
-    if (command === "integrate") {
-        return integrateUpstream(rest, store, options);
-    }
+    if (command === "integrate")
+        return integrateUpstream(rest, store, home, options);
     throw usageError(command === undefined
         ? "Task upstream command is required."
         : `Unknown command: task upstream ${command}`);
 }
-async function integrateUpstream(args, store, options) {
-    const usage = "Task upstream integrate usage: yui task upstream integrate <task> [--latest] [--project <project>].";
-    const taskId = args[0];
-    if (taskId === undefined)
-        throw usageError(usage);
-    const flags = new Set(args.slice(1));
-    if (flags.size !== args.length - 1) {
-        throw usageError(usage);
+async function integrateUpstream(args, store, home, options) {
+    const usage = "Task upstream integrate usage: yui task upstream integrate <task> (--latest|--project <project>) [--check <command> ...].";
+    let latest = false;
+    const normalized = [];
+    for (const arg of args) {
+        if (arg === "--latest") {
+            if (latest)
+                throw usageError("Option may only be specified once: --latest.", usage);
+            latest = true;
+            continue;
+        }
+        normalized.push(...(arg.startsWith("--project=")
+            ? ["--project", arg.slice("--project=".length)]
+            : [arg]));
     }
-    const latest = flags.has("--latest");
-    const projectFlag = args.find((arg) => arg.startsWith("--project="));
-    const projectRef = projectFlag?.slice("--project=".length);
+    const parsed = parseRepeatable(normalized, new Set(["--check"]), new Set(["--project"]), usage);
+    if (parsed.positionals.length !== 1)
+        throw usageError(usage);
+    const taskId = parsed.positionals[0];
+    const projectRef = parsed.one.get("--project");
     if (!latest && projectRef === undefined) {
-        throw usageError("Specify --latest to integrate the remote development head, or --project=<project> to target one Project.");
+        throw usageError("Specify --latest for every Task Project, or --project <project>.");
     }
     if (latest && projectRef !== undefined) {
         throw usageError("--latest and --project are mutually exclusive.");
     }
-    for (const flag of flags) {
-        if (flag !== "--latest" && !flag.startsWith("--project=")) {
-            throw usageError(usage);
-        }
-    }
-    const task = store.getTask(taskId);
+    let task = store.getTask(taskId);
     if (task === null)
         throw usageError(`Task not found: ${taskId}.`);
     if (task.status !== "active") {
         throw usageError(`Task must be active to integrate upstream: ${taskId}/${task.status}.`);
     }
-    // RFC Phase 4: integrating upstream rewrites the Task worktree HEAD. Refuse
-    // while the Leader has an active Turn so the merge never lands under a
-    // running Session.
-    const activeLeaderRun = store.getActiveTurn(taskId, "leader");
-    if (activeLeaderRun !== null) {
-        throw usageError(`Task has an active Leader Turn (${activeLeaderRun.id}); stop it before integrating upstream: ${taskId}.`);
-    }
-    const workspace = store.getTaskWorkspace(taskId);
-    if (workspace === null) {
-        throw usageError(`Task has no workspace: ${taskId}. Activate it first.`);
-    }
+    taskLocalActor(store, options.environment, task.id);
     const git = options.git ?? new NodeGitWorkspace();
     const now = options.now ?? (() => new Date());
+    await new FileTaskWorkspacePreparer(home, store, git, now)
+        .prepareTaskWorkspace(task.id);
+    task = store.getTask(task.id);
+    if (task === null || task.status !== "active") {
+        throw usageError(`Task is no longer active: ${taskId}.`);
+    }
+    const workspace = store.getTaskWorkspace(task.id);
+    if (workspace === null || workspace.owner.type !== "task") {
+        throw usageError(`Task has no authoritative main clone: ${task.id}.`);
+    }
+    const service = new GitIntegrationService(store.rootDirectory(), store, git, now);
     const results = [];
     for (const binding of task.projectBindings) {
         if (projectRef !== undefined && binding.projectId !== projectRef)
             continue;
         const project = store.getProject(binding.projectId);
-        if (project === null) {
+        if (project === null)
             throw usageError(`Project not found: ${binding.projectId}.`);
-        }
         if (project.remoteUrl === undefined) {
             throw usageError(`Project has no remote URL: ${project.id}.`);
         }
+        if (binding.baseCommit === undefined || binding.currentCommit === undefined) {
+            throw usageError(`Task Project has no activated commit boundary: ${task.id}/${project.id}.`);
+        }
         const entry = workspaceProjectEntry(workspace, project.id);
         if (entry === undefined) {
             throw usageError(`Task workspace has no entry for Project: ${project.id}.`);
         }
-        // Hold the per-Project maintenance fence while resolving the remote
-        // baseline so a concurrent `project refresh` cannot interleave with the
-        // fetch.
-        const releaseMaintenance = acquireProjectMaintenanceLock(store.rootDirectory(), project.id);
-        let oldHead;
-        let newHead;
-        let upstreamCommit;
-        try {
-            // Resolve the exact upstream commit.
-            const upstream = await git.resolveRemoteBaseline({
-                repositoryPath: project.path,
-                remoteUrl: project.remoteUrl,
-                developmentRef: project.developmentBranch
-            });
-            upstreamCommit = upstream.commit;
-            // Record the current HEAD as a backup before merging.
-            const current = await git.inspect(entry.path, "HEAD");
-            oldHead = current.baseCommit;
-            try {
-                // mergeWorktree always creates a merge commit (--no-ff); record the
-                // actual resulting HEAD rather than assuming a fast-forward.
-                await git.mergeWorktree({
-                    targetPath: entry.path,
-                    sourceRefs: [upstream.commit]
-                });
-            }
-            catch (error) {
-                // Restore the original HEAD on failure.  mergeWorktree already aborts
-                // a conflicted merge, so HEAD is usually already at oldHead; reset
-                // only when the merge left HEAD moved or the tree dirty.
-                let restoreNote;
-                try {
-                    await git.resetWorktree({
-                        targetPath: entry.path,
-                        expectedHead: oldHead,
-                        restoreHead: oldHead
-                    });
-                    restoreNote = ` The workspace has been restored to ${oldHead}.`;
-                }
-                catch {
-                    restoreNote = ` The workspace may be left in a conflicted state; inspect ${entry.path} manually.`;
-                }
-                const message = error instanceof Error ? error.message : String(error);
-                throw new Error(`Upstream integration failed for Project ${project.id}: ${message}.` + restoreNote);
-            }
-            const after = await git.inspect(entry.path, "HEAD");
-            newHead = after.baseCommit;
-        }
-        finally {
-            releaseMaintenance();
+        const head = (await git.inspect(entry.path, entry.branch)).baseCommit;
+        if (head !== binding.currentCommit) {
+            throw usageError(`Task Project current commit diverged from its main clone: ${task.id}/${project.id}.`);
         }
-        // Record the integration event immediately so a later Project's failure
-        // does not lose this Project's audit trail.
-        const result = { projectId: project.id, oldHead, newHead, upstreamCommit };
-        store.transaction((tx) => {
-            tx.saveEvent(task.id, createTaskEvent(tx.nextEventId(task.id), task.id, "task.upstream-integrated", result, now()));
+        const remote = await git.resolveRemoteHead({
+            remoteUrl: project.remoteUrl,
+            branch: binding.baseRef
         });
+        const attempt = store.transaction((tx) => {
+            const created = createIntegrationAttempt({
+                id: tx.nextIntegrationAttemptId(task.id),
+                taskId: task.id,
+                projectId: project.id,
+                targetRef: entry.branch,
+                beforeCommit: binding.currentCommit,
+                source: {
+                    kind: "upstream",
+                    branch: remote.branch,
+                    remoteCommit: remote.commit,
+                    taskBaseCommit: binding.baseCommit,
+                    strategy: "rebase"
+                },
+                checkCommands: parsed.many.get("--check") ?? []
+            }, now());
+            tx.saveIntegrationAttempt(task.id, created);
+            return created;
+        });
+        const result = await service.integrate(task.id, attempt.id);
         results.push(result);
+        if (result.status !== "committed")
+            break;
+    }
+    if (projectRef !== undefined && results.length === 0) {
+        throw usageError(`Task Project not found: ${task.id}/${projectRef}.`);
     }
-    const lines = results.map((r) => `  ${r.projectId}: ${r.oldHead.slice(0, 12)} -> ${r.newHead.slice(0, 12)} (upstream: ${r.upstreamCommit.slice(0, 12)})`);
+    const lines = results.map(({ attempt, status }) => (`  ${attempt.projectId}: ${attempt.beforeCommit.slice(0, 12)} -> ${(attempt.afterCommit ?? attempt.candidateCommit ?? attempt.beforeCommit).slice(0, 12)} (${status})`));
     return {
-        output: `Integrated upstream for Task ${taskId}:\n${lines.join("\n")}\n`,
-        data: { taskId, integrations: results }
+        output: `Upstream Integration results for Task ${task.id}:\n${lines.join("\n")}\n`,
+        data: { taskId: task.id, integrations: results }
     };
 }

package/dist/config/configCatalog.js

@@ -16,7 +16,7 @@ export const CONFIG_DEFINITIONS = Object.freeze([
     { key: "delivery-timeout-seconds", domain: "runtime", property: "deliveryTimeoutSeconds", label: "Delivery timeout", summary: "Total control-plane delivery retry budget, 5-600 seconds (default: 120).", takesEffect: "After the Controller restarts; internal retry cadence remains automatic." },
     { 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 completed Leader turns without durable delivery progress before warning, 1-20 (default: 3).", takesEffect: "The next Leader delivery guard evaluation." },
-    { 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: "review", domain: "workflow", property: "review", label: "Review", summary: "Optional global WorkItem review rule: a configured Role plus always, leader, or final trigger. 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/context/contextSnapshot.js

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { normalizedUniqueText, optionalText, requireIdentity, requirePositiveInteger, requireText, requireTimestamp } from "../domain/validation.js";
+import { MAX_CONTEXT_SOURCE_TURN_BYTES, MAX_CONTEXT_SOURCE_TURNS } from "./sourceTurnContext.js";
 export const CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CONTEXT_SNAPSHOT_MAX_RESOURCES = 256;
 export const CONTEXT_SNAPSHOT_MAX_RESOURCE_BYTES = 4 * 1024 * 1024;
@@ -184,7 +185,16 @@ function validateContextRef(value) {
 function normalizeSnapshotResources(values, refs) {
     if (!Array.isArray(values))
         throw new Error("Context Snapshot resources must be an array.");
-    if (values.length > CONTEXT_SNAPSHOT_MAX_RESOURCES) {
+    const sourceTurnCount = values.filter((resource) => (resource !== null
+        && typeof resource === "object"
+        && !Array.isArray(resource)
+        && resource.ref !== null
+        && typeof resource.ref === "object"
+        && resource.ref.store === "source-turn")).length;
+    if (sourceTurnCount > MAX_CONTEXT_SOURCE_TURNS) {
+        throw new Error(`Context Snapshot exceeds ${MAX_CONTEXT_SOURCE_TURNS} source Turns.`);
+    }
+    if (values.length - sourceTurnCount > CONTEXT_SNAPSHOT_MAX_RESOURCES) {
         throw new Error(`Context Snapshot exceeds ${CONTEXT_SNAPSHOT_MAX_RESOURCES} resources.`);
     }
     const byRef = new Map(refs.map((ref) => [contextRefKey(ref), ref]));
@@ -210,9 +220,14 @@ function normalizeSnapshotResources(values, refs) {
         || new Set(resources.map(({ ref }) => contextRefKey(ref))).size !== refs.length) {
         throw new Error("Context Snapshot resources must cover every ref exactly once.");
     }
-    if (Buffer.byteLength(JSON.stringify(resources), "utf8") > CONTEXT_SNAPSHOT_MAX_BYTES) {
+    const ordinary = resources.filter(({ ref }) => ref.store !== "source-turn");
+    const sourceTurns = resources.filter(({ ref }) => ref.store === "source-turn");
+    if (Buffer.byteLength(JSON.stringify(ordinary), "utf8") > CONTEXT_SNAPSHOT_MAX_BYTES) {
         throw new Error(`Context Snapshot resources exceed ${CONTEXT_SNAPSHOT_MAX_BYTES} bytes.`);
     }
+    if (Buffer.byteLength(JSON.stringify(sourceTurns), "utf8") > MAX_CONTEXT_SOURCE_TURN_BYTES) {
+        throw new Error(`Context Snapshot source Turns exceed ${MAX_CONTEXT_SOURCE_TURN_BYTES} bytes.`);
+    }
     return Object.freeze(resources);
 }
 function contextRefKey(ref) {

package/dist/context/sessionBootstrapManifest.js

@@ -130,7 +130,10 @@ export function materializeSessionBootstrap(input) {
         roleProfileRef: { digest: profileDigest, path: roleProfilePath },
         contextProtocol: input.owner.scope === "global"
             ? {
-                loadCommand: "\"$YUI_SESSION_CLI\" session context \"$YUI_ROLE\" --json"
+                // A Global Session may move between Yui's remote TUI and Desktop.
+                // Carry its read entry in the Thread-visible Manifest instead of
+                // depending on the client process that happened to create it.
+                loadCommand: renderGlobalContextCommand(input.controlPlane, home, input.role.name)
             }
             : {
                 loadCommand: "\"$YUI_SESSION_CLI\" task turn context \"$YUI_TASK_ID/<turn-id>\" --json",
@@ -148,6 +151,20 @@ export function materializeSessionBootstrap(input) {
         descriptorPath
     });
 }
+function renderGlobalContextCommand(controlPlane, home, roleName) {
+    return [
+        `YUI_HOME=${quoteShellWord(home)}`,
+        quoteShellWord(controlPlane.executable),
+        quoteShellWord(controlPlane.cliEntry),
+        "session",
+        "context",
+        quoteShellWord(roleName),
+        "--json"
+    ].join(" ");
+}
+function quoteShellWord(value) {
+    return `'${value.replaceAll("'", "'\"'\"'")}'`;
+}
 /**
  * Retargets known managed wrappers to the current resolved control plane after
  * a compatible update. Only a valid Session Manifest may nominate a wrapper,

package/dist/context/sourceTurnContext.js

@@ -0,0 +1,30 @@
+import { MAX_TURN_RESULT_OUTPUT_BYTES } from "../domain/agentResultTransport.js";
+export const MAX_SYNTHESIS_SOURCE_TURNS = 8;
+export const MAX_CONTEXT_SOURCE_TURNS = MAX_SYNTHESIS_SOURCE_TURNS + 1;
+export const MAX_CONTEXT_SOURCE_TURN_BYTES = MAX_CONTEXT_SOURCE_TURNS * (MAX_TURN_RESULT_OUTPUT_BYTES + 16 * 1024);
+/**
+ * Frozen input for synthesis. The main Agent needs the producer identity and
+ * exact result, not another copy of its prompt history, launch configuration,
+ * or workspace descriptor.
+ */
+export function sourceTurnContextValue(turn) {
+    if (turn.result === undefined) {
+        throw new Error(`Source Turn has no result: ${turn.id}.`);
+    }
+    return Object.freeze({
+        schemaVersion: 1,
+        id: turn.id,
+        taskId: turn.taskId,
+        roleName: turn.roleName,
+        purpose: turn.purpose,
+        ...(turn.workItemId === undefined ? {} : { workItemId: turn.workItemId }),
+        ...(turn.reviewRoundId === undefined ? {} : { reviewRoundId: turn.reviewRoundId }),
+        ...(turn.executionGroupId === undefined
+            ? {}
+            : { executionGroupId: turn.executionGroupId }),
+        ...(turn.executionLaneId === undefined ? {} : { executionLaneId: turn.executionLaneId }),
+        result: turn.result,
+        createdAt: turn.createdAt,
+        updatedAt: turn.updatedAt
+    });
+}

package/dist/context/turnContextPack.js

@@ -1,7 +1,10 @@
 import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
 import { TASK_COMPLETION_PUBLISHED_TREE_AUTHORIZED_EVENT } from "../task/publicationReference.js";
 import { TURN_INPUT_MAX_DELTAS } from "./turnInputContract.js";
+import { assertWorkItemDependenciesCompleted } from "../workItem/dependencyGate.js";
+import { workItemExecutionGroupById } from "../workItem/workItem.js";
 import { contextContentDigest, contextSnapshotRef, createContextSnapshot, validateContextSnapshot } from "./contextSnapshot.js";
+import { sourceTurnContextValue } from "./sourceTurnContext.js";
 export const TURN_CONTEXT_PACK_SCHEMA_VERSION = 1;
 export const TURN_CONTEXT_PACK_MAX_REFS = 256;
 export const TURN_CONTEXT_PACK_MAX_BYTES = 8 * 1024 * 1024;
@@ -20,7 +23,10 @@ export function freezeTurnContextSnapshot(store, run, now, frozenBy = "controlle
             throw new Error(`Turn Context baseline is missing or drifted: ${baselineRef.id}.`);
         }
         validateContextSnapshot(baseline);
-        const overlays = collectTurnContextOverlays(store, run);
+        const overlays = [
+            ...collectTurnContextOverlays(store, run),
+            ...collectSourceTurnContext(store, run)
+        ];
         const resources = [...new Map([...baseline.resources, ...overlays].map((entry) => [
                 contextRefIdentity(entry.ref),
                 entry
@@ -76,11 +82,11 @@ export function freezeTurnContextSnapshot(store, run, now, frozenBy = "controlle
 }
 /**
  * Freeze the shared, role-neutral ContextSnapshot anchored by one WorkItem
- * exploration stage Group. Turn 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.
+ * ExecutionAssignment. Turn snapshots remain role-specific; this record is
+ * the durable Assignment baseline and freezes the current WorkItem facts so
+ * the Group never depends on ambient latest state.
  */
-export function freezeExecutionStageContextSnapshot(store, input, now) {
+export function freezeWorkItemExecutionAssignmentContextSnapshot(store, input, now) {
     const task = store.getTask(input.taskId);
     if (task === null)
         throw new Error(`Task not found: ${input.taskId}.`);
@@ -91,11 +97,11 @@ export function freezeExecutionStageContextSnapshot(store, input, now) {
         materialize("L2", "task", task.id, task),
         materialize("L3", "work-item", workItem.id, workItem)
     ];
+    assertWorkItemDependenciesCompleted(store, 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}.`);
-        }
+        if (dependency === null)
+            throw new Error(`WorkItem dependency disappeared: ${dependencyId}.`);
         materialized.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
     }
     for (const binding of task.projectBindings) {
@@ -112,42 +118,20 @@ export function freezeExecutionStageContextSnapshot(store, input, now) {
             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({
+    const assignmentSnapshot = createContextSnapshot({
         id: store.nextContextSnapshotId(task.id),
         taskId: task.id,
         scope: "stage",
         scopeRef: input.executionGroupId,
-        sequence: workItemSnapshot.sequence + 1,
+        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;
+    store.saveContextSnapshot(assignmentSnapshot);
+    return assignmentSnapshot;
 }
 /**
  * Freeze the role-neutral baseline for one Reviewer ExecutionGroup before
@@ -282,10 +266,35 @@ export function buildTurnContextPack(store, taskId, turnId) {
             returnedBytes: preliminaryBytes,
             truncated: false
         }),
-        digest
+        digest,
+        liveTaskState: readLiveTaskState(store, taskId)
     });
     return pack;
 }
+/** Reads the Task's current in-flight execution, outside the frozen contract. */
+function readLiveTaskState(store, taskId) {
+    const activeTurns = store.listTurns(taskId)
+        .filter((turn) => turn.status === "active")
+        .map((turn) => Object.freeze({
+        turnId: turn.id,
+        roleName: turn.roleName,
+        purpose: turn.purpose,
+        ...(turn.workItemId === undefined ? {} : { workItemId: turn.workItemId }),
+        ...(turn.reviewRoundId === undefined ? {} : { reviewRoundId: turn.reviewRoundId })
+    }));
+    const activeTaskReviews = store.listReviewRounds(taskId)
+        .filter((round) => ((round.scope ?? "work-item") === "task"
+        && (round.status === "pending" || round.status === "running")))
+        .map((round) => Object.freeze({
+        reviewRoundId: round.id,
+        reviewerRoleName: round.reviewerRoleName,
+        status: round.status
+    }));
+    return Object.freeze({
+        activeTurns: Object.freeze(activeTurns),
+        activeTaskReviews: Object.freeze(activeTaskReviews)
+    });
+}
 export function expandTurnContextRef(store, taskId, turnId, refId, refStore) {
     const pack = buildTurnContextPack(store, taskId, turnId);
     const authorized = pack.pointers.filter((ref) => (ref.refId === refId && (refStore === undefined || ref.store === refStore)));
@@ -352,20 +361,18 @@ function collectAuthorizedContext(store, run) {
         result.push(materialize("L2", "task-brief", task.id, brief));
     }
     result.push(...collectTurnContextOverlays(store, run));
+    result.push(...collectSourceTurnContext(store, run));
     if (run.workItemId !== undefined) {
         const item = store.getWorkItem(task.id, run.workItemId);
         if (item === null)
             throw new Error(`Turn WorkItem not found: ${run.workItemId}.`);
         result.push(materialize("L3", "work-item", item.id, item));
         if (view === "worker") {
+            assertWorkItemDependenciesCompleted(store, item);
             for (const dependencyId of item.dependsOn) {
                 const dependency = store.getWorkItem(task.id, dependencyId);
-                if (dependency === null
-                    || (dependency.status !== "completed" && dependency.status !== "retired")) {
-                    throw new Error(`Turn WorkItem dependency is not accepted: ${dependencyId}.`);
-                }
-                if (dependency.status === "retired")
-                    continue;
+                if (dependency === null)
+                    throw new Error(`WorkItem dependency disappeared: ${dependencyId}.`);
                 result.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
             }
         }
@@ -375,10 +382,21 @@ function collectAuthorizedContext(store, run) {
         if (round === null)
             throw new Error(`Turn ReviewRound not found: ${run.reviewRoundId}.`);
         result.push(materialize("L3", "review-round", round.id, round));
-        for (const finding of store.listReviewFindings(task.id).filter((candidate) => (candidate.firstReviewRoundId === round.id
-            || candidate.lastReviewRoundId === round.id
-            || candidate.repair?.workItemId === round.workItemId))) {
-            result.push(materialize("L3", "review-finding", finding.id, finding));
+        if (round.deltaRecheck !== undefined) {
+            const previous = store.getReviewRound(task.id, round.deltaRecheck.previousReviewRoundId);
+            const previousTurn = previous?.reviewerTurnId === undefined
+                ? null
+                : store.getTurn(task.id, previous.reviewerTurnId);
+            if (previous === null
+                || previous === undefined
+                || previous.status !== "completed"
+                || previousTurn === null
+                || previousTurn.status !== "completed"
+                || previousTurn.result === undefined) {
+                throw new Error(`Delta recheck source Review result is unavailable: ${round.deltaRecheck.previousReviewRoundId}.`);
+            }
+            result.push(materialize("L3", "review-round", previous.id, previous));
+            result.push(materialize("L4", "source-turn", previousTurn.id, sourceTurnContextValue(previousTurn)));
         }
     }
     for (const binding of task.projectBindings) {
@@ -405,9 +423,6 @@ function collectAuthorizedContext(store, run) {
         for (const round of store.listReviewRounds(task.id).slice(-16)) {
             result.push(materialize("L3", "review-round", round.id, round));
         }
-        for (const finding of store.listReviewFindings(task.id)) {
-            result.push(materialize("L3", "review-finding", finding.id, finding));
-        }
         for (const turn of operationalTaskRecords(store.listTurns(task.id), events, "turn").slice(-24)) {
             result.push(materialize("L4", "turn", turn.id, turn));
         }
@@ -454,6 +469,50 @@ function collectTurnContextOverlays(store, run) {
             : [])
     ];
 }
+function collectSourceTurnContext(store, run) {
+    if (run.sourceExecutionGroupId === undefined)
+        return [];
+    const group = run.purpose === "execution"
+        ? (() => {
+            if (run.workItemId === undefined) {
+                throw new Error("Execution synthesis source requires a WorkItem.");
+            }
+            const item = store.getWorkItem(run.taskId, run.workItemId);
+            if (item === null)
+                throw new Error(`Turn WorkItem not found: ${run.workItemId}.`);
+            return workItemExecutionGroupById(item, run.sourceExecutionGroupId);
+        })()
+        : (() => {
+            if (run.reviewRoundId === undefined) {
+                throw new Error("Review synthesis source requires a ReviewRound.");
+            }
+            const round = store.getReviewRound(run.taskId, run.reviewRoundId);
+            if (round === null)
+                throw new Error(`Turn ReviewRound not found: ${run.reviewRoundId}.`);
+            return round.executionGroup?.id === run.sourceExecutionGroupId
+                ? round.executionGroup
+                : undefined;
+        })();
+    if (group === undefined) {
+        throw new Error(`Source ExecutionGroup not found: ${run.sourceExecutionGroupId}.`);
+    }
+    return [...group.lanes]
+        .sort((left, right) => left.ordinal - right.ordinal || left.id.localeCompare(right.id))
+        .flatMap((lane) => {
+        if (lane.disposition !== "succeeded" || lane.successfulTurnId === undefined)
+            return [];
+        const source = store.getTurn(run.taskId, lane.successfulTurnId);
+        if (source === null
+            || source.status !== "completed"
+            || source.result === undefined
+            || source.executionGroupId !== group.id
+            || source.executionLaneId !== lane.id
+            || source.roleName !== lane.roleName) {
+            throw new Error(`Successful source Turn is missing or drifted: ${group.id}/${lane.id}.`);
+        }
+        return [materialize("L4", "source-turn", source.id, sourceTurnContextValue(source))];
+    });
+}
 function materialize(layer, store, refId, value) {
     const digest = contextContentDigest(value);
     const record = value;