@zq-silk/yui 0.15.7 → 0.15.9

package/dist/context/{turnContextPack.js → runContextPack.js}

@@ -1,15 +1,17 @@
 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 { RUN_INPUT_MAX_DELTAS } from "./runInputContract.js";
 import { assertWorkItemDependenciesCompleted } from "../workItem/dependencyGate.js";
-import { workItemExecutionGroupById } from "../workItem/workItem.js";
+import { governingWorkItemCandidate, workItemExecutionGroupById } from "../workItem/workItem.js";
+import { formatGitArtifactRef, validateGitArtifactRef } from "../artifacts/gitArtifactRef.js";
+import { managedWorkspaceKey } from "../worktree/managedWorkspace.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;
-export const TURN_CONTEXT_EXPAND_MAX_BYTES = 4 * 1024 * 1024;
-export function freezeTurnContextSnapshot(store, run, now, frozenBy = "controller", baselineRef) {
+import { MAX_SYNTHESIS_SOURCE_RUNS, sourceRunContextValue } from "./sourceRunContext.js";
+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", baselineRef, sourceRunIds) {
     if (baselineRef !== undefined) {
         const baseline = store.getContextSnapshot(run.taskId, baselineRef.id);
         if (baseline === null
@@ -20,12 +22,12 @@ export function freezeTurnContextSnapshot(store, run, now, frozenBy = "controlle
             || baseline.scope !== "stage"
             || baselineRef.scope !== baseline.scope
             || baseline.scopeRef !== baselineRef.scopeRef) {
-            throw new Error(`Turn Context baseline is missing or drifted: ${baselineRef.id}.`);
+            throw new Error(`AgentRun Context baseline is missing or drifted: ${baselineRef.id}.`);
         }
         validateContextSnapshot(baseline);
         const overlays = [
-            ...collectTurnContextOverlays(store, run),
-            ...collectSourceTurnContext(store, run)
+            ...collectRunContextOverlays(store, run),
+            ...collectSourceRunContext(store, run, sourceRunIds)
         ];
         const resources = [...new Map([...baseline.resources, ...overlays].map((entry) => [
                 contextRefIdentity(entry.ref),
@@ -82,7 +84,7 @@ export function freezeTurnContextSnapshot(store, run, now, frozenBy = "controlle
 }
 /**
  * Freeze the shared, role-neutral ContextSnapshot anchored by one WorkItem
- * ExecutionAssignment. Turn snapshots remain role-specific; this record is
+ * ExecutionAssignment. AgentRun 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.
  */
@@ -97,17 +99,19 @@ export function freezeWorkItemExecutionAssignmentContextSnapshot(store, input, n
         materialize("L2", "task", task.id, task),
         materialize("L3", "work-item", workItem.id, workItem)
     ];
+    materialized.push(...candidateArtifacts(task.id, workItem.candidates));
     assertWorkItemDependenciesCompleted(store, workItem);
     for (const dependencyId of workItem.dependsOn) {
         const dependency = store.getWorkItem(task.id, dependencyId);
         if (dependency === null)
             throw new Error(`WorkItem dependency disappeared: ${dependencyId}.`);
         materialized.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
+        materialized.push(...candidateArtifacts(task.id, dependency.candidates));
     }
     for (const binding of task.projectBindings) {
         const project = store.getProject(binding.projectId);
         if (project === null)
-            throw new Error(`Turn Project not found: ${binding.projectId}.`);
+            throw new Error(`AgentRun 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")) {
@@ -200,10 +204,10 @@ export function contextSnapshotDeltaRefIds(store, snapshot) {
             || before.store !== ref.store
             || before.layer !== ref.layer;
     }).map(({ refId }) => refId);
-    return Object.freeze([...new Set(changed)].sort().slice(0, TURN_INPUT_MAX_DELTAS));
+    return Object.freeze([...new Set(changed)].sort().slice(0, RUN_INPUT_MAX_DELTAS));
 }
-export function buildTurnContextPack(store, taskId, turnId) {
-    const run = requireExactTurn(store, taskId, turnId);
+export function buildRunContextPack(store, taskId, runId) {
+    const run = requireExactRun(store, taskId, runId);
     const current = collectAuthorizedContext(store, run);
     let pointers = current.map(({ ref }) => ref);
     let snapshotRef;
@@ -211,16 +215,16 @@ export function buildTurnContextPack(store, taskId, turnId) {
         const expected = run.inputs[0].input.contextSnapshotRef;
         const snapshot = store.getContextSnapshot(taskId, expected.id);
         if (snapshot === null)
-            throw new Error(`Turn Context Snapshot is missing: ${expected.id}.`);
+            throw new Error(`AgentRun Context Snapshot is missing: ${expected.id}.`);
         validateContextSnapshot(snapshot);
         if (snapshot.digest !== expected.digest || snapshot.taskId !== taskId) {
-            throw new Error(`Turn Context Snapshot identity drifted: ${expected.id}.`);
+            throw new Error(`AgentRun Context Snapshot identity drifted: ${expected.id}.`);
         }
         pointers = snapshot.refs;
         snapshotRef = contextSnapshotRef(snapshot);
     }
-    if (pointers.length > TURN_CONTEXT_PACK_MAX_REFS) {
-        throw new Error(`Turn Context exceeds ${TURN_CONTEXT_PACK_MAX_REFS} authorized refs.`);
+    if (pointers.length > RUN_CONTEXT_PACK_MAX_REFS) {
+        throw new Error(`AgentRun Context exceeds ${RUN_CONTEXT_PACK_MAX_REFS} authorized refs.`);
     }
     const view = contextView(run);
     const writableProjectIds = writableProjects(store, run, view);
@@ -231,10 +235,10 @@ export function buildTurnContextPack(store, taskId, turnId) {
         digest: ref.digest
     }));
     const body = {
-        schemaVersion: TURN_CONTEXT_PACK_SCHEMA_VERSION,
+        schemaVersion: RUN_CONTEXT_PACK_SCHEMA_VERSION,
         identity: Object.freeze({
             taskId,
-            turnId: turnId,
+            runId: runId,
             roleName: run.roleName,
             purpose: run.purpose,
             agentId: run.effective.agentId,
@@ -248,21 +252,21 @@ export function buildTurnContextPack(store, taskId, turnId) {
         summaries,
         deltas: pointers.filter((ref) => run.inputs[0].input.deltaRefIds.includes(ref.refId)),
         completion: Object.freeze({
-            allowedActions: completionActions(view),
-            exactTurnRef: `${taskId}/${turnId}`
+            allowedActions: completionActions(view, run.effective.executionAuthority),
+            exactRunRef: `${taskId}/${runId}`
         })
     };
     const digest = contextContentDigest(body);
     const preliminaryBytes = Buffer.byteLength(JSON.stringify({ ...body, digest }), "utf8");
-    if (preliminaryBytes > TURN_CONTEXT_PACK_MAX_BYTES) {
-        throw new Error(`Turn Context Pack exceeds ${TURN_CONTEXT_PACK_MAX_BYTES} bytes.`);
+    if (preliminaryBytes > RUN_CONTEXT_PACK_MAX_BYTES) {
+        throw new Error(`AgentRun Context Pack exceeds ${RUN_CONTEXT_PACK_MAX_BYTES} bytes.`);
     }
     const pack = Object.freeze({
         ...body,
         budget: Object.freeze({
-            maxRefs: TURN_CONTEXT_PACK_MAX_REFS,
+            maxRefs: RUN_CONTEXT_PACK_MAX_REFS,
             returnedRefs: pointers.length,
-            maxBytes: TURN_CONTEXT_PACK_MAX_BYTES,
+            maxBytes: RUN_CONTEXT_PACK_MAX_BYTES,
             returnedBytes: preliminaryBytes,
             truncated: false
         }),
@@ -273,14 +277,14 @@ export function buildTurnContextPack(store, taskId, turnId) {
 }
 /** 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 activeRuns = store.listRuns(taskId)
+        .filter((run) => run.status === "active")
+        .map((run) => Object.freeze({
+        runId: run.id,
+        roleName: run.roleName,
+        purpose: run.purpose,
+        ...(run.workItemId === undefined ? {} : { workItemId: run.workItemId }),
+        ...(run.reviewRoundId === undefined ? {} : { reviewRoundId: run.reviewRoundId })
     }));
     const activeTaskReviews = store.listReviewRounds(taskId)
         .filter((round) => ((round.scope ?? "work-item") === "task"
@@ -291,28 +295,28 @@ function readLiveTaskState(store, taskId) {
         status: round.status
     }));
     return Object.freeze({
-        activeTurns: Object.freeze(activeTurns),
+        activeRuns: Object.freeze(activeRuns),
         activeTaskReviews: Object.freeze(activeTaskReviews)
     });
 }
-export function expandTurnContextRef(store, taskId, turnId, refId, refStore) {
-    const pack = buildTurnContextPack(store, taskId, turnId);
+export function expandRunContextRef(store, taskId, runId, refId, refStore) {
+    const pack = buildRunContextPack(store, taskId, runId);
     const authorized = pack.pointers.filter((ref) => (ref.refId === refId && (refStore === undefined || ref.store === refStore)));
     const selector = refStore === undefined ? refId : `${refStore}/${refId}`;
     if (authorized.length !== 1) {
-        throw new Error(`Turn Context ref is not uniquely authorized: ${selector}.`);
+        throw new Error(`AgentRun Context ref is not uniquely authorized: ${selector}.`);
     }
-    const run = requireExactTurn(store, taskId, turnId);
+    const run = requireExactRun(store, taskId, runId);
     const snapshotRef = run.inputs[0].input.contextSnapshotRef;
     const materialized = snapshotRef === undefined
         ? collectAuthorizedContext(store, run).find(({ ref }) => (contextRefIdentity(ref) === contextRefIdentity(authorized[0])))
         : store.getContextSnapshot(taskId, snapshotRef.id)?.resources.find(({ ref }) => (contextRefIdentity(ref) === contextRefIdentity(authorized[0])));
     if (materialized === undefined || materialized.ref.digest !== authorized[0].digest) {
-        throw new Error(`Turn Context ref is unavailable or drifted: ${selector}.`);
+        throw new Error(`AgentRun Context ref is unavailable or drifted: ${selector}.`);
     }
     const bytes = Buffer.byteLength(JSON.stringify(materialized.value), "utf8");
-    if (bytes > TURN_CONTEXT_EXPAND_MAX_BYTES) {
-        throw new Error(`Turn Context expansion exceeds ${TURN_CONTEXT_EXPAND_MAX_BYTES} bytes.`);
+    if (bytes > RUN_CONTEXT_EXPAND_MAX_BYTES) {
+        throw new Error(`AgentRun Context expansion exceeds ${RUN_CONTEXT_EXPAND_MAX_BYTES} bytes.`);
     }
     return Object.freeze({
         ref: materialized.ref,
@@ -320,13 +324,13 @@ export function expandTurnContextRef(store, taskId, turnId, refId, refStore) {
         digest: contextContentDigest({ ref: materialized.ref, value: materialized.value })
     });
 }
-/** Fail-closed delta cursor resolution for one immutable Turn lineage. */
-export function buildTurnContextDelta(store, taskId, turnId, after) {
-    const pack = buildTurnContextPack(store, taskId, turnId);
+/** Fail-closed delta cursor resolution for one immutable AgentRun lineage. */
+export function buildRunContextDelta(store, taskId, runId, after) {
+    const pack = buildRunContextPack(store, taskId, runId);
     if (after === pack.digest || after === pack.snapshot?.digest) {
         return Object.freeze({ schemaVersion: 1, after, cursor: pack.digest, refs: [] });
     }
-    const run = requireExactTurn(store, taskId, turnId);
+    const run = requireExactRun(store, taskId, runId);
     const snapshotRef = run.inputs[0].input.contextSnapshotRef;
     const snapshot = snapshotRef === undefined
         ? null
@@ -334,7 +338,7 @@ export function buildTurnContextDelta(store, taskId, turnId, after) {
     const parentDigest = snapshot?.parentRef?.digest;
     if (!((parentDigest !== undefined && after === parentDigest)
         || (parentDigest === undefined && after === "none"))) {
-        throw new Error("Turn Context delta cursor is outside the frozen Snapshot lineage.");
+        throw new Error("AgentRun Context delta cursor is outside the frozen Snapshot lineage.");
     }
     return Object.freeze({
         schemaVersion: 1,
@@ -343,10 +347,10 @@ export function buildTurnContextDelta(store, taskId, turnId, after) {
         refs: pack.deltas
     });
 }
-function requireExactTurn(store, taskId, turnId) {
-    const run = store.getTurn(taskId, turnId);
-    if (run === null || run.taskId !== taskId || run.id !== turnId) {
-        throw new Error(`Turn not found: ${taskId}/${turnId}.`);
+function requireExactRun(store, taskId, runId) {
+    const run = store.getRun(taskId, runId);
+    if (run === null || run.taskId !== taskId || run.id !== runId) {
+        throw new Error(`AgentRun not found: ${taskId}/${runId}.`);
     }
     return run;
 }
@@ -360,13 +364,14 @@ function collectAuthorizedContext(store, run) {
     if (brief !== null && view === "leader") {
         result.push(materialize("L2", "task-brief", task.id, brief));
     }
-    result.push(...collectTurnContextOverlays(store, run));
-    result.push(...collectSourceTurnContext(store, run));
+    result.push(...collectRunContextOverlays(store, run));
+    result.push(...collectSourceRunContext(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}.`);
+            throw new Error(`AgentRun WorkItem not found: ${run.workItemId}.`);
         result.push(materialize("L3", "work-item", item.id, item));
+        result.push(...candidateArtifacts(task.id, item.candidates));
         if (view === "worker") {
             assertWorkItemDependenciesCompleted(store, item);
             for (const dependencyId of item.dependsOn) {
@@ -374,35 +379,45 @@ function collectAuthorizedContext(store, run) {
                 if (dependency === null)
                     throw new Error(`WorkItem dependency disappeared: ${dependencyId}.`);
                 result.push(materialize("L3", "accepted-work-item", dependency.id, dependency));
+                result.push(...candidateArtifacts(task.id, dependency.candidates));
             }
         }
     }
     if (run.reviewRoundId !== undefined) {
         const round = store.getReviewRound(task.id, run.reviewRoundId);
         if (round === null)
-            throw new Error(`Turn ReviewRound not found: ${run.reviewRoundId}.`);
+            throw new Error(`AgentRun ReviewRound not found: ${run.reviewRoundId}.`);
         result.push(materialize("L3", "review-round", round.id, round));
+        if (round.scope === "task") {
+            for (const item of store.listWorkItems(task.id).filter(({ status }) => status !== "retired")) {
+                const candidate = governingWorkItemCandidate(item);
+                if (candidate === undefined)
+                    continue;
+                result.push(materialize("L3", "candidate", `${item.id}/${candidate.id}`, candidate));
+                result.push(...candidateArtifacts(task.id, [candidate]));
+            }
+        }
         if (round.deltaRecheck !== undefined) {
             const previous = store.getReviewRound(task.id, round.deltaRecheck.previousReviewRoundId);
-            const previousTurn = previous?.reviewerTurnId === undefined
+            const previousRun = previous?.reviewerRunId === undefined
                 ? null
-                : store.getTurn(task.id, previous.reviewerTurnId);
+                : store.getRun(task.id, previous.reviewerRunId);
             if (previous === null
                 || previous === undefined
                 || previous.status !== "completed"
-                || previousTurn === null
-                || previousTurn.status !== "completed"
-                || previousTurn.result === undefined) {
+                || previousRun === null
+                || previousRun.status !== "completed"
+                || previousRun.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)));
+            result.push(materialize("L4", "source-run", previousRun.id, sourceRunContextValue(previousRun)));
         }
     }
     for (const binding of task.projectBindings) {
         const project = store.getProject(binding.projectId);
         if (project === null)
-            throw new Error(`Turn Project not found: ${binding.projectId}.`);
+            throw new Error(`AgentRun Project not found: ${binding.projectId}.`);
         const { knowledge, ...projectPolicy } = project;
         result.push(materialize("L1", "project-policy", project.id, projectPolicy));
         for (const entry of knowledge.filter(({ status }) => status === "active")) {
@@ -410,6 +425,21 @@ function collectAuthorizedContext(store, run) {
         }
     }
     if (view === "leader") {
+        // File artifacts are NOT enumerated into the synchronous context pack: the
+        // core cursor does not cover file edits, and an ambient directory listing
+        // here would be exactly the forbidden update-time mirror (§3.7). The Leader
+        // reads current artifacts on demand via the async `artifact.list` /
+        // `artifact.read` capabilities; frozen Candidate artifacts still enter the
+        // pack as commit-pinned pointers through candidateArtifacts().
+        for (const preparation of store.listEnvironmentPreparations(task.id)) {
+            result.push(materialize("L3", "environment-preparation", preparation.id, preparation));
+        }
+        for (const workspace of store.listManagedWorkspaces(task.id)) {
+            result.push(materialize("L3", "managed-workspace", managedWorkspaceKey(workspace.owner), workspace));
+        }
+        for (const changeSet of store.listChangeSets(task.id)) {
+            result.push(materialize("L3", "change-set", changeSet.id, changeSet));
+        }
         const events = store.listEvents(task.id);
         for (const item of store.listWorkItems(task.id).filter(({ status }) => status !== "retired")) {
             result.push(materialize("L3", "work-item", item.id, item));
@@ -423,8 +453,8 @@ 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 turn of operationalTaskRecords(store.listTurns(task.id), events, "turn").slice(-24)) {
-            result.push(materialize("L4", "turn", turn.id, turn));
+        for (const run of operationalTaskRecords(store.listRuns(task.id), events, "run").slice(-24)) {
+            result.push(materialize("L4", "run", run.id, run));
         }
         for (const message of operationalTaskRecords(store.listMessages(task.id), events, "message").slice(-16)) {
             result.push(materialize("L4", "task-message", message.id, message));
@@ -448,11 +478,33 @@ 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))));
 }
+/** Only artifacts attached to already-authorized candidates enter a bounded
+ * Worker/Reviewer snapshot. Each is a commit-pinned pointer: the commit
+ * self-certifies the frozen bytes, so the pointer is carried as pure data with
+ * NO build-time Git read. The bytes are resolved lazily on the async expand
+ * path (`artifact.read` at the pinned commit); the pointer survives cleanup of
+ * the producing workspace and Session. */
+function candidateArtifacts(taskId, candidates) {
+    return candidates.flatMap((candidate) => (candidate.artifactRefs ?? []).map((ref) => {
+        const pinned = validateGitArtifactRef(ref);
+        if (pinned.taskId !== taskId) {
+            throw new Error(`Candidate Artifact belongs to another Task: ${pinned.taskId}.`);
+        }
+        // The refId is the self-certifying string form; the value is the pure
+        // pointer, never the bytes. inspectValue reconstructs the same pointer.
+        return materialize("L3", "artifact", formatGitArtifactRef(pinned), {
+            taskId: pinned.taskId,
+            commit: pinned.commit,
+            relativePath: pinned.relativePath,
+            ...(pinned.digest === undefined ? {} : { digest: pinned.digest })
+        });
+    }));
+}
 /** Lane-specific context that may be layered over an immutable stage base. */
-function collectTurnContextOverlays(store, run) {
+function collectRunContextOverlays(store, run) {
     const role = store.getRole(run.taskId, run.roleName);
     if (role === null)
-        throw new Error(`Turn Role not found: ${run.taskId}/${run.roleName}.`);
+        throw new Error(`AgentRun Role not found: ${run.taskId}/${run.roleName}.`);
     return [
         materialize("L1", "role-profile", role.name, {
             name: role.name,
@@ -469,9 +521,14 @@ function collectTurnContextOverlays(store, run) {
             : [])
     ];
 }
-function collectSourceTurnContext(store, run) {
+function collectSourceRunContext(store, run, sourceRunIds) {
     if (run.sourceExecutionGroupId === undefined)
         return [];
+    if (sourceRunIds === undefined || sourceRunIds.length === 0
+        || sourceRunIds.length > MAX_SYNTHESIS_SOURCE_RUNS
+        || new Set(sourceRunIds).size !== sourceRunIds.length) {
+        throw new Error("Synthesis requires explicit, distinct source AgentRun references.");
+    }
     const group = run.purpose === "execution"
         ? (() => {
             if (run.workItemId === undefined) {
@@ -479,7 +536,7 @@ function collectSourceTurnContext(store, run) {
             }
             const item = store.getWorkItem(run.taskId, run.workItemId);
             if (item === null)
-                throw new Error(`Turn WorkItem not found: ${run.workItemId}.`);
+                throw new Error(`AgentRun WorkItem not found: ${run.workItemId}.`);
             return workItemExecutionGroupById(item, run.sourceExecutionGroupId);
         })()
         : (() => {
@@ -488,7 +545,7 @@ function collectSourceTurnContext(store, run) {
             }
             const round = store.getReviewRound(run.taskId, run.reviewRoundId);
             if (round === null)
-                throw new Error(`Turn ReviewRound not found: ${run.reviewRoundId}.`);
+                throw new Error(`AgentRun ReviewRound not found: ${run.reviewRoundId}.`);
             return round.executionGroup?.id === run.sourceExecutionGroupId
                 ? round.executionGroup
                 : undefined;
@@ -496,23 +553,39 @@ function collectSourceTurnContext(store, run) {
     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);
+    return sourceRunIds.map((runId) => {
+        const source = store.getRun(run.taskId, runId);
+        const lane = group.lanes.find(({ id }) => id === source?.executionLaneId);
         if (source === null
-            || source.status !== "completed"
+            || lane === undefined
+            || !["completed", "failed"].includes(source.status)
             || source.result === undefined
+            || source.purpose !== run.purpose
+            || source.workItemId !== run.workItemId
+            || source.reviewRoundId !== run.reviewRoundId
             || 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}.`);
+            throw new Error(`Selected source AgentRun is missing or drifted: ${group.id}/${runId}.`);
         }
-        return [materialize("L4", "source-turn", source.id, sourceTurnContextValue(source))];
+        return materialize("L4", "source-run", source.id, sourceRunContextValue(source));
     });
 }
+/** The frozen refs, not the Group's changing lane state, define provenance. */
+export function synthesisSourceRunIds(store, run) {
+    const ref = run.inputs[0].input.contextSnapshotRef;
+    if (ref === undefined)
+        throw new Error(`Synthesis AgentRun has no Context Snapshot: ${run.id}.`);
+    const snapshot = store.getContextSnapshot(run.taskId, ref.id);
+    if (snapshot === null || snapshot.digest !== ref.digest
+        || snapshot.sequence !== ref.sequence || snapshot.scope !== ref.scope
+        || snapshot.scopeRef !== ref.scopeRef || snapshot.taskId !== run.taskId) {
+        throw new Error(`Synthesis Context Snapshot is missing or drifted: ${ref.id}.`);
+    }
+    validateContextSnapshot(snapshot);
+    return snapshot.resources.filter(({ ref: entry, value }) => (entry.store === "source-run"
+        && value.executionGroupId === run.sourceExecutionGroupId)).map(({ ref: entry }) => entry.refId);
+}
 function materialize(layer, store, refId, value) {
     const digest = contextContentDigest(value);
     const record = value;
@@ -547,6 +620,8 @@ function contextView(run) {
     return "worker";
 }
 function writableProjects(store, run, view) {
+    if (run.effective.executionAuthority === "planning")
+        return Object.freeze([]);
     if (view === "leader")
         return Object.freeze(store.getTask(run.taskId)?.projectBindings.map(({ projectId }) => projectId) ?? []);
     if (view === "reviewer") {
@@ -556,7 +631,9 @@ function writableProjects(store, run, view) {
         return Object.freeze([]);
     return Object.freeze(store.getWorkItem(run.taskId, run.workItemId)?.writeProjectIds ?? []);
 }
-function completionActions(view) {
+function completionActions(view, authority) {
+    if (authority === "planning")
+        return Object.freeze(["finish-turn", "request-input", "request-activation"]);
     if (view === "leader")
         return Object.freeze(["finish-turn", "complete-task", "request-input"]);
     if (view === "reviewer")