@zq-silk/yui 0.13.9 → 0.14.0

package/dist/storage/taskStore.js

@@ -1,60 +1,16 @@
-import { existsSync, lstatSync, mkdirSync, readFileSync, realpathSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { lstatSync, mkdirSync, realpathSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, join, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
-import { validateConfiguredAgent } from "../agent/agent.js";
 import { validateCapabilityGrant } from "../grant/capabilityGrant.js";
 import { validateReleaseWorkflow } from "../release/releaseWorkflow.js";
-import { publicationExternalKey, validatePublicationReference } from "../task/publicationReference.js";
-import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveContextBudget, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryRunCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
+import { validatePublicationReference } from "../task/publicationReference.js";
+import { reconciliationIntervalMilliseconds, resolveAgentLaunchInactivityTimeoutSeconds, resolveControllerTaskConcurrency, resolveDeliveryTimeoutSeconds, resolveLeaderNextActionMode, resolveLeaderSemanticBudgetTurns, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode, resolveResourcesQuarantineTtlHours, resolveRuntimeHealth, resolveTelemetryEnabled, resolveTelemetryTurnCap, resolveTelemetryTerminalKeep, resolveTmuxBin, resolveTmuxHistoryLimit } from "../config/yuiConfig.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
-import { mailboxBatches, consumePendingBatch, mailboxHasWork, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
-import { validateContextSnapshot } from "../context/contextSnapshot.js";
-import { TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT } from "../review/taskFinalReviewContractEvent.js";
-import { validateInputRequest } from "../input/inputRequest.js";
-import { validateRoleSessionSet } from "../executor/agentExecutor.js";
-import { validateTaskMessage } from "../message/message.js";
-import { agentRunDeliveryReceiptId, validateAgentRun } from "../run/agentRun.js";
-import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
-import { FileSessionOwnerRegistry } from "../runtime/sessionOwnerRegistry.js";
 import { validateReviewConfig } from "../review/reviewConfig.js";
-import { validateReviewRound } from "../review/reviewRound.js";
-import { reviewFindingLedgerMode } from "../review/reviewFindingLedger.js";
-import { sameTaskFinalReviewContract } from "../review/taskFinalReviewContract.js";
-import { assertProjectCatalog, validateProject } from "../repository/project.js";
-import { generateHomeIdentity, validateHomeIdentity } from "../repository/homeIdentity.js";
-import { validateAgentProfile } from "../profile/agentProfile.js";
-import { validateChangeSet } from "../integration/changeSet.js";
-import { validateIntegrationAttempt } from "../integration/integrationAttempt.js";
-import { validateIntegrationQueueEntry } from "../integration/integrationQueueEntry.js";
-import { CURRENT_DURABLE_JOB_SCHEMA_VERSION, validDurableJobTransition, validateDurableJob } from "../job/durableJob.js";
-import { validateGlobalRole, validateTaskRole } from "../role/role.js";
-import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../scheduler/leaderFailure.js";
-import { CURRENT_TASK_WAKE_SCHEMA_VERSION, validateTaskWake } from "../scheduler/taskWake.js";
-import { validateTask } from "../task/task.js";
-import { operationalTaskRecords } from "../task/taskRecordRetirement.js";
-import { TASK_RECORD_ID_PREFIXES, validateTaskRecordReference } from "../task/taskRecordReference.js";
-import { workItemExecutionGroupById, validateWorkItem } from "../workItem/workItem.js";
-import { isExecutionGroupTransition, validateExecutionGroup } from "../execution/executionGroup.js";
-import { managedWorkspaceKey, validateManagedWorkspace } from "../worktree/managedWorkspace.js";
-import { gateArtifactKey, validateGateArtifact } from "../verification/gateArtifact.js";
-import { writeTextFileAtomically } from "./durableFile.js";
-import { assertHomeWritable } from "./upgradeFence.js";
-import { CURRENT_AGGREGATE_SCHEMA_VERSION, requireCompatibleStorageSchema, requireStorageSchema, writeCurrentStorageManifest } from "./storageSchema.js";
-export const STORAGE_STATE_FILE = "state.json";
-/** The root StorageState schema is the persisted aggregate document version. */
-export const CURRENT_STORAGE_STATE_SCHEMA_VERSION = CURRENT_AGGREGATE_SCHEMA_VERSION;
-export const CURRENT_CONFIG_SCHEMA_VERSION = 4;
-export const CURRENT_HOME_IDENTITY_SCHEMA_VERSION = 1;
-export const CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION = 3;
-/**
- * Persisted StorageState/StoredTask family versions owned by this boundary.
- *
- * Keep these names next to the strict parser/writer so the upgrade record map
- * can classify exactly the bytes this store accepts and emits. Nested session
- * members and the PendingWakeup projection are included as parser boundaries
- * below, but are not independent record-axis families.
- */
+import { validateTaskRecordReference } from "../task/taskRecordReference.js";
+export const CURRENT_CONFIG_SCHEMA_VERSION = 6;
+/** Current SQLite payload-family versions owned by this storage boundary. */
 export const CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION = 2;
 export const CURRENT_PROJECT_SCHEMA_VERSION = 5;
 export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 2;
@@ -65,38 +21,34 @@ export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 4;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
-export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 12;
+export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 13;
 export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 6;
-export const CURRENT_CHANGE_SET_SCHEMA_VERSION = 3;
+export const CURRENT_CHANGE_SET_SCHEMA_VERSION = 4;
 export const CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION = 5;
 export const CURRENT_MESSAGE_SCHEMA_VERSION = 3;
-export const CURRENT_INPUT_REQUEST_SCHEMA_VERSION = 2;
+export const CURRENT_INPUT_REQUEST_SCHEMA_VERSION = 3;
 export const CURRENT_DECISION_SCHEMA_VERSION = 1;
 export const CURRENT_MILESTONE_SCHEMA_VERSION = 2;
 export const CURRENT_EVENT_SCHEMA_VERSION = 2;
-export const CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION = 1;
+export const CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION = 2;
 export const CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION = 1;
-export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 3;
+export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 5;
 export const CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION = 1;
-export const CURRENT_ROLE_AGENT_SESSION_SCHEMA_VERSION = 4;
 export const CURRENT_PENDING_WAKEUP_SCHEMA_VERSION = 1;
-const STORAGE_LOCK_DIRECTORY = ".state.lock";
-const LOCK_TIMEOUT_MS = 5_000;
-const LOCK_RETRY_MS = 10;
 export const COMPLETION_SHELLS = ["bash", "zsh", "fish"];
 /**
- * Lane-scoped active pointers live beside the legacy role pointers.  The
+ * Lane-scoped active pointers live beside Role pointers. The
  * namespace starts with a slash because Role identities reject slashes; this
  * makes the two key spaces disjoint even for legal Role names such as
  * `lane:worker:1`.
  */
-export function executionLaneActiveRunKey(executionGroupId, executionLaneId) {
+export function executionLaneActiveTurnKey(executionGroupId, executionLaneId) {
     return `/execution-lane/${encodeLaneKeyPart(executionGroupId)}:${encodeLaneKeyPart(executionLaneId)}`;
 }
 function encodeLaneKeyPart(value) {
     return encodeURIComponent(value).replace(/:/gu, "%3A");
 }
-export function executionLaneActiveRunKeyParts(key) {
+export function executionLaneActiveTurnKeyParts(key) {
     const match = /^\/execution-lane\/([^:]+):([^:]+)$/u.exec(key);
     if (match === null)
         return null;
@@ -110,1774 +62,12 @@ export function executionLaneActiveRunKeyParts(key) {
         return null;
     }
 }
-/** The schema version of each persisted `state.json#/tasks/*` aggregate. */
-export const CURRENT_STORED_TASK_SCHEMA_VERSION = 18;
-/**
- * Persisted nested-record versions consumed by this store's strict parser.
- * Keep these named at the storage boundary so the upgrade record-axis map can
- * assert it is classifying the same bytes the store reads and writes.
- */
-export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 8;
 /**
- * v7 combines optional Issue 04 retry/receipt fields and Issue 05 Leader
- * actionability fields. All are optional, so the v6→v7 migration is a
- * version-only rewrite.
+ * Nested-record versions consumed by the current SQLite payload validators.
  */
-export const CURRENT_AGENT_RUN_SCHEMA_VERSION = 10;
+export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 11;
+export const CURRENT_TURN_SCHEMA_VERSION = 1;
 export const CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION = 1;
-export class FileTaskStore {
-    rootDir;
-    #transaction = null;
-    #readCache = null;
-    #normalizeState;
-    #sessionOwnerRegistry;
-    constructor(rootDir, options = {}) {
-        this.rootDir = rootDir;
-        this.#normalizeState = options.normalizeState;
-        this.#requireReadableSchema();
-        const snapshot = options.initialStateSnapshot;
-        if (snapshot !== undefined) {
-            // The one-snapshot open already fenced these bytes; run the same strict
-            // parser the lazy path would, then warm the cache under the snapshot's
-            // fingerprint. A later external writer still invalidates it on next read.
-            this.#readCache = {
-                fingerprint: snapshot.fingerprint,
-                state: this.#parseState(snapshot.raw)
-            };
-        }
-    }
-    rootDirectory() { return this.rootDir; }
-    transaction(execute) {
-        if (this.#transaction !== null)
-            return synchronousResult(execute(this));
-        return this.#withWriteLock(() => {
-            const state = this.#readCachedState();
-            this.#transaction = { state, baseRevision: state.revision, dirty: false };
-            try {
-                const result = synchronousResult(execute(this));
-                if (this.#transaction.dirty)
-                    this.#commit(state, this.#transaction.baseRevision);
-                return result;
-            }
-            catch (error) {
-                this.#readCache = null;
-                throw error;
-            }
-            finally {
-                this.#transaction = null;
-            }
-        });
-    }
-    withRuntimeEventTransaction(execute) {
-        return this.transaction(() => execute());
-    }
-    async transactionAsync(execute) {
-        if (this.#transaction !== null)
-            return execute(this);
-        const release = acquireStorageLock(this.rootDir);
-        try {
-            const state = this.#readCachedState();
-            this.#transaction = { state, baseRevision: state.revision, dirty: false };
-            try {
-                const result = await execute(this);
-                if (this.#transaction.dirty)
-                    this.#commit(state, this.#transaction.baseRevision);
-                return result;
-            }
-            catch (error) {
-                this.#readCache = null;
-                throw error;
-            }
-            finally {
-                this.#transaction = null;
-            }
-        }
-        finally {
-            release();
-        }
-    }
-    getConfig() { return clone(this.#state().config); }
-    getHomeIdentity() { return clone(this.#state().homeIdentity); }
-    saveConfig(config) {
-        const stored = versioned(config, CURRENT_CONFIG_SCHEMA_VERSION, "Yui config");
-        validateYuiConfig(stored);
-        this.#mutate((state) => { state.config = stored; });
-    }
-    saveConfiguredAgent(agent) {
-        const stored = identified(agent, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, "id", agent.id, "Configured Agent");
-        validateConfiguredAgent(stored);
-        this.#mutate((state) => { state.configuredAgents[stored.id] = stored; });
-    }
-    createConfiguredAgentIfAbsent(agent) {
-        return this.transaction((store) => {
-            if (store.getConfiguredAgent(agent.id) !== null)
-                return null;
-            store.saveConfiguredAgent(agent);
-            return clone(agent);
-        });
-    }
-    updateConfiguredAgent(id, patch, now) {
-        return this.transaction((store) => {
-            const existing = store.getConfiguredAgent(id);
-            if (existing === null)
-                return null;
-            const candidate = versioned({
-                ...existing,
-                ...clone(patch),
-                updatedAt: now.toISOString()
-            }, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, "Configured Agent");
-            const unchanged = isDeepStrictEqual({ ...existing, updatedAt: candidate.updatedAt }, candidate);
-            if (unchanged)
-                return { status: "unchanged", agent: existing };
-            store.saveConfiguredAgent(candidate);
-            return { status: "updated", agent: candidate };
-        });
-    }
-    listConfiguredAgents() { return values(this.#state().configuredAgents, "id"); }
-    getConfiguredAgent(id) { return optional(this.#state().configuredAgents[id]); }
-    removeConfiguredAgent(id) {
-        return this.#remove((state) => state.configuredAgents, id);
-    }
-    nextProjectId() {
-        return this.#nextGlobalId("project", (state) => Object.keys(state.projects));
-    }
-    saveProject(project) {
-        const stored = identified(project, CURRENT_PROJECT_SCHEMA_VERSION, "id", project.id, "Project");
-        validateProject(stored);
-        this.#mutate((state) => {
-            assertProjectCatalog([
-                ...Object.values(state.projects).filter(({ id }) => id !== stored.id),
-                stored
-            ]);
-            state.projects[stored.id] = stored;
-        });
-    }
-    createProjectIfAbsent(project) {
-        validateProject(project);
-        return this.transaction((store) => {
-            if (store.getProject(project.id) !== null)
-                return null;
-            try {
-                assertProjectCatalog([...store.listProjects(), project]);
-            }
-            catch {
-                return null;
-            }
-            store.saveProject(project);
-            return clone(project);
-        });
-    }
-    listProjects() { return values(this.#state().projects, "id"); }
-    getProject(id) { return optional(this.#state().projects[id]); }
-    removeProject(id) {
-        return this.transaction((store) => {
-            if (store.listTasks().some((task) => task.projectBindings.some((binding) => binding.projectId === id))) {
-                throw new StorageRecordError(`Project is still used by a Task: ${id}`);
-            }
-            return this.#remove((state) => state.projects, id);
-        });
-    }
-    summarizeProjectReferences(projectId) {
-        const boundTasks = this.listTasks().filter((task) => task.projectBindings.some((binding) => binding.projectId === projectId));
-        const activeTasks = boundTasks.filter((task) => task.status === "active");
-        const unresolvedWorkItemRefs = [];
-        const activeRunRefs = [];
-        const unresolvedIntegrationRefs = [];
-        for (const task of activeTasks) {
-            for (const workItem of this.listWorkItems(task.id)) {
-                if (workItem.status !== "completed" && workItem.status !== "retired") {
-                    unresolvedWorkItemRefs.push(`${task.id}/${workItem.id}`);
-                }
-            }
-            for (const run of this.listAgentRuns(task.id)) {
-                if (run.status === "active")
-                    activeRunRefs.push(`${task.id}/${run.id}`);
-            }
-            for (const attempt of this.listIntegrationAttempts(task.id)) {
-                if (attempt.status === "running" || attempt.status === "blocked") {
-                    unresolvedIntegrationRefs.push(`${task.id}/${attempt.id}`);
-                }
-            }
-        }
-        return {
-            projectId,
-            boundTaskIds: boundTasks.map(({ id }) => id),
-            activeTaskIds: activeTasks.map(({ id }) => id),
-            unresolvedWorkItemRefs,
-            activeRunRefs,
-            unresolvedIntegrationRefs
-        };
-    }
-    saveAgentProfile(profile) {
-        const stored = identified(profile, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, "id", profile.id, "Agent Profile");
-        validateAgentProfile(stored);
-        this.#mutate((state) => {
-            const existing = state.agentProfiles[stored.id];
-            if (existing !== undefined) {
-                if (stored.revision < existing.revision) {
-                    throw new StorageRecordError(`Agent Profile revision cannot move backwards: ${stored.id}.`);
-                }
-                if (stored.revision === existing.revision
-                    && !isDeepStrictEqual(stored, existing)) {
-                    throw new StorageRecordError(`Agent Profile revision cannot be overwritten: ${stored.id}/${stored.revision}.`);
-                }
-                if (stored.revision > existing.revision + 1) {
-                    throw new StorageRecordError(`Agent Profile revision must be contiguous: ${stored.id}/${stored.revision}.`);
-                }
-            }
-            else if (stored.revision !== 1) {
-                throw new StorageRecordError(`A new Agent Profile must start at revision 1: ${stored.id}.`);
-            }
-            state.agentProfiles[stored.id] = stored;
-        });
-    }
-    createAgentProfileIfAbsent(profile) {
-        return this.transaction((store) => {
-            if (store.getAgentProfile(profile.id) !== null)
-                return null;
-            store.saveAgentProfile(profile);
-            return clone(profile);
-        });
-    }
-    listAgentProfiles() {
-        return values(this.#state().agentProfiles, "id");
-    }
-    getAgentProfile(id) {
-        return optional(this.#state().agentProfiles[id]);
-    }
-    removeAgentProfile(id) {
-        return this.#remove((state) => state.agentProfiles, id);
-    }
-    saveGlobalRole(role) {
-        const stored = identified(role, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, "name", role.name, "Global Role");
-        validateGlobalRole(stored);
-        const sessions = this.getGlobalRoleSessionSet(stored.name);
-        if (sessions !== null)
-            assertSessionsMatchRole(sessions, stored);
-        this.#mutate((state) => { state.globalRoles[stored.name] = stored; });
-    }
-    saveGlobalRoleWithSessionSet(role, sessions) {
-        const storedRole = identified(role, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, "name", role.name, "Global Role");
-        validateGlobalRole(storedRole);
-        const storedSessions = sessions === null ? null : globalSessions(sessions);
-        if (storedSessions !== null)
-            assertSessionsMatchRole(storedSessions, storedRole);
-        this.transaction(() => {
-            this.#mutate((state) => {
-                state.globalRoles[storedRole.name] = storedRole;
-                if (storedSessions === null)
-                    delete state.globalRoleSessionSets[storedRole.name];
-                else
-                    state.globalRoleSessionSets[storedRole.name] = storedSessions;
-            });
-        });
-    }
-    createGlobalRoleIfAbsent(role) {
-        return this.transaction((store) => {
-            if (store.getGlobalRole(role.name) !== null)
-                return null;
-            store.saveGlobalRole(role);
-            return clone(role);
-        });
-    }
-    listGlobalRoles() { return values(this.#state().globalRoles, "name"); }
-    getGlobalRole(name) { return optional(this.#state().globalRoles[name]); }
-    removeGlobalRole(name) {
-        return this.transaction(() => {
-            const removed = this.#remove((state) => state.globalRoles, name);
-            this.#mutate((state) => { delete state.globalRoleSessionSets[name]; });
-            return removed;
-        });
-    }
-    getGlobalRoleSessionSet(name) {
-        return optional(this.#state().globalRoleSessionSets[name]);
-    }
-    listGlobalRoleSessionSets() {
-        return values(this.#state().globalRoleSessionSets, (set) => set.owner.roleName);
-    }
-    saveGlobalRoleSessionSet(sessions) {
-        const stored = globalSessions(sessions);
-        const role = this.getGlobalRole(stored.owner.roleName);
-        if (role === null)
-            throw new StorageRecordError(`Global Role not found: ${stored.owner.roleName}`);
-        assertSessionsMatchRole(stored, role);
-        this.#mutate((state) => { state.globalRoleSessionSets[stored.owner.roleName] = stored; });
-    }
-    nextTaskId() { return this.#nextGlobalId("task", (state) => Object.keys(state.tasks)); }
-    saveTask(task) {
-        const stored = validateTask(identified(task, CURRENT_TASK_SCHEMA_VERSION, "id", task.id, "Task"));
-        this.#mutate((state) => {
-            for (const binding of stored.projectBindings) {
-                if (state.projects[binding.projectId] === undefined) {
-                    throw new StorageRecordError(`Task Project not found: ${binding.projectId}`);
-                }
-            }
-            const aggregate = state.tasks[stored.id] ?? emptyStoredTask(stored);
-            aggregate.task = stored;
-            state.tasks[stored.id] = aggregate;
-        });
-    }
-    listTasks() {
-        // Clone only the Task headers, not the whole stored aggregate (events,
-        // runs, messages): a scheduler pass lists Tasks per phase, and cloning
-        // each aggregate's full event history turned every phase into a 32 MiB
-        // projection. Callers that need a Task's events read them explicitly.
-        return Object.values(this.#state().tasks)
-            .map((aggregate) => clone(aggregate.task))
-            .sort((left, right) => numericCompare(left.id, right.id));
-    }
-    listActiveTaskIds() {
-        // The file rollback backend has no catalog index, so it filters the loaded
-        // aggregate. Layout-7 Controller hot paths use SQLite's bounded selector.
-        return this.listTasks()
-            .filter((task) => task.status === "active" && task.executionGate.state === "enabled")
-            .map((task) => task.id);
-    }
-    getStateRevision() { return this.#state().revision; }
-    getTask(id) { return optional(this.#state().tasks[id]?.task); }
-    readNextActionFacts(taskId) {
-        const aggregate = this.#state().tasks[taskId];
-        if (aggregate === undefined)
-            return null;
-        const events = values(aggregate.events, "id");
-        const agentRuns = operationalTaskRecords(values(aggregate.agentRuns, "id"), events, "agent-run");
-        return {
-            task: {
-                id: aggregate.task.id,
-                status: aggregate.task.status,
-                executionGate: aggregate.task.executionGate,
-                projectBindings: aggregate.task.projectBindings,
-                type: aggregate.task.type
-            },
-            workItems: values(aggregate.workItems, "id"),
-            changeSets: values(aggregate.changeSets, "id"),
-            integrations: values(aggregate.integrationAttempts, "id"),
-            integrationQueueEntries: values(aggregate.integrationQueue, "id"),
-            reviewRounds: values(aggregate.reviewRounds, "id"),
-            taskFinalReviewContractEvents: events
-                .filter((event) => event.type === TASK_FINAL_REVIEW_CONTRACT_REBOUND_EVENT),
-            reviewConfig: this.getReviewConfig(),
-            openInputRequests: values(aggregate.inputRequests, "id")
-                .filter((request) => request.status === "open"),
-            activeRuns: agentRuns.filter((run) => run.status === "active"),
-            leaderRuns: agentRuns.filter((run) => run.roleName === "leader"),
-            reviewOutcomeEvidence: {
-                agentRuns: agentRuns.filter((run) => run.purpose === "review"),
-                // The rollback file backend has no finding-ledger records.
-                reviewFindings: [],
-                events: events.filter((event) => (event.type === "review.completed"))
-            }
-        };
-    }
-    readCompletionReadinessFacts(taskId) {
-        const base = this.readNextActionFacts(taskId);
-        if (base === null)
-            return null;
-        const aggregate = this.#state().tasks[taskId];
-        const ledgerMode = reviewFindingLedgerMode(this.#state().config);
-        // The file-rollback backend does not persist the finding ledger.  Under
-        // `enforce` the completion gate must fail closed with the same bounded
-        // diagnosis as `listReviewFindings` instead of silently treating
-        // "unsupported" as "no open findings".
-        if (ledgerMode === "enforce") {
-            throw new StorageRecordError(`Review findings require the SQLite backend (yui.db); migrate this Home with \`yui update\` before using the finding ledger on Task ${taskId}.`);
-        }
-        return {
-            ...base,
-            agentRuns: operationalTaskRecords(this.listAgentRuns(taskId), values(aggregate.events, "id"), "agent-run"),
-            managedWorkspaces: values(aggregate.managedWorkspaces, (workspace) => managedWorkspaceKey(workspace.owner)),
-            durableJobs: values(aggregate.durableJobs, "id"),
-            integrationQueueEntries: values(aggregate.integrationQueue, "id"),
-            // The SQLite backend supplies real findings; the file backend never
-            // reaches this point under `enforce` (throw above).
-            reviewFindings: [],
-            reviewFindingLedgerMode: ledgerMode,
-            events: values(aggregate.events, "id")
-        };
-    }
-    getReviewConfig() {
-        return optional(this.#state().config.review);
-    }
-    getTaskBrief(taskId) {
-        return optional(this.#state().tasks[taskId]?.brief ?? undefined);
-    }
-    saveTaskBrief(taskId, brief) {
-        const stored = storedTaskBrief(brief);
-        this.#requireTaskForWrite(taskId);
-        this.#mutate((state) => { state.tasks[taskId].brief = stored; });
-    }
-    clearTaskBrief(taskId) {
-        this.#requireTaskForWrite(taskId);
-        this.#mutate((state) => { state.tasks[taskId].brief = null; });
-    }
-    nextChangeSetId(taskId) {
-        return this.#nextTaskRecordId(taskId, "changeSet");
-    }
-    saveChangeSet(taskId, changeSet) {
-        const stored = identifiedChangeSet(changeSet, changeSet.id);
-        validateChangeSet(stored);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`ChangeSet belongs to another Task: ${stored.taskId}.`);
-        }
-        const aggregate = this.#requireTaskForWrite(taskId);
-        const evidenceRound = Object.values(aggregate.reviewRounds).find(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit && evidenceCommit === stored.headCommit);
-        if (evidenceRound !== undefined) {
-            throw new StorageRecordError(`ReviewRound evidence commit ${evidenceRound.id}/${stored.headCommit} cannot become a ChangeSet.`);
-        }
-        if (!aggregate.task.projectBindings.some(({ projectId }) => projectId === stored.projectId)) {
-            throw new StorageRecordError(`ChangeSet Project does not match Task: ${stored.id}.`);
-        }
-        if (aggregate.workItems[stored.workItemId] === undefined) {
-            throw new StorageRecordError(`ChangeSet Work Item not found: ${stored.workItemId}.`);
-        }
-        const existing = aggregate.changeSets[stored.id];
-        if (existing !== undefined && !isDeepStrictEqual(existing, stored)) {
-            throw new StorageRecordError(`ChangeSet is immutable: ${stored.id}.`);
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            observeTaskRecordId(task, "changeSet", stored.id);
-            task.changeSets[stored.id] = stored;
-        });
-    }
-    listChangeSets(taskId) {
-        return values(this.#requireTask(taskId).changeSets, "id");
-    }
-    getChangeSet(taskId, changeSetId) {
-        return optional(this.#state().tasks[taskId]?.changeSets[changeSetId]);
-    }
-    nextIntegrationAttemptId(taskId) {
-        return this.#nextTaskRecordId(taskId, "integrationAttempt");
-    }
-    saveIntegrationAttempt(taskId, attempt) {
-        const stored = identified(attempt, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, "id", attempt.id, "Integration Attempt");
-        validateIntegrationAttempt(stored);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Integration Attempt belongs to another Task: ${stored.taskId}.`);
-        }
-        const aggregate = this.#requireTaskForWrite(taskId);
-        if (!aggregate.task.projectBindings.some(({ projectId }) => projectId === stored.projectId)) {
-            throw new StorageRecordError(`Integration Project does not match Task: ${stored.id}.`);
-        }
-        for (const changeSetId of stored.changeSetIds) {
-            const changeSet = aggregate.changeSets[changeSetId];
-            if (changeSet === undefined) {
-                throw new StorageRecordError(`Integration ChangeSet not found: ${changeSetId}.`);
-            }
-            if (changeSet.projectId !== stored.projectId) {
-                throw new StorageRecordError(`Integration ChangeSet belongs to another Project: ${changeSetId}.`);
-            }
-            const evidenceRound = Object.values(aggregate.reviewRounds).find(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit && evidenceCommit === changeSet.headCommit);
-            if (evidenceRound !== undefined) {
-                throw new StorageRecordError(`ReviewRound evidence commit ${evidenceRound.id}/${changeSet.headCommit} cannot become an Integration source.`);
-            }
-        }
-        const existing = aggregate.integrationAttempts[stored.id];
-        if (existing !== undefined) {
-            if (Date.parse(stored.updatedAt) < Date.parse(existing.updatedAt)) {
-                throw new StorageRecordError(`Integration Attempt updatedAt cannot move backwards: ${stored.id}.`);
-            }
-            if (!validIntegrationTransition(existing, stored)) {
-                throw new StorageRecordError(`Integration Attempt transition is invalid: ${stored.id}.`);
-            }
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            observeTaskRecordId(task, "integrationAttempt", stored.id);
-            task.integrationAttempts[stored.id] = stored;
-        });
-    }
-    listIntegrationAttempts(taskId) {
-        return values(this.#requireTask(taskId).integrationAttempts, "id");
-    }
-    getIntegrationAttempt(taskId, integrationId) {
-        return optional(this.#state().tasks[taskId]?.integrationAttempts[integrationId]);
-    }
-    nextIntegrationQueueEntryId(taskId) {
-        return this.#nextTaskRecordId(taskId, "integrationQueue");
-    }
-    saveIntegrationQueueEntry(taskId, entry) {
-        const stored = identified(entry, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, "id", entry.id, "Integration queue entry");
-        validateIntegrationQueueEntry(stored);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Integration queue entry belongs to another Task: ${stored.taskId}.`);
-        }
-        const aggregate = this.#requireTaskForWrite(taskId);
-        if (!aggregate.task.projectBindings.some(({ projectId }) => projectId === stored.projectId)) {
-            throw new StorageRecordError(`Integration queue Project does not match Task: ${stored.id}.`);
-        }
-        const changeSet = aggregate.changeSets[stored.changeSetId];
-        if (changeSet === undefined) {
-            throw new StorageRecordError(`Integration queue ChangeSet not found: ${stored.changeSetId}.`);
-        }
-        if (changeSet.projectId !== stored.projectId) {
-            throw new StorageRecordError(`Integration queue ChangeSet belongs to another Project: ${stored.changeSetId}.`);
-        }
-        const existing = aggregate.integrationQueue[stored.id];
-        if (existing !== undefined) {
-            if (Date.parse(stored.updatedAt) < Date.parse(existing.updatedAt)) {
-                throw new StorageRecordError(`Integration queue entry updatedAt cannot move backwards: ${stored.id}.`);
-            }
-            if (!validIntegrationQueueTransition(existing, stored)) {
-                throw new StorageRecordError(`Integration queue entry transition is invalid: ${stored.id}.`);
-            }
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            observeTaskRecordId(task, "integrationQueue", stored.id);
-            task.integrationQueue[stored.id] = stored;
-        });
-    }
-    listIntegrationQueueEntries(taskId) {
-        return values(this.#requireTask(taskId).integrationQueue, "id");
-    }
-    getIntegrationQueueEntry(taskId, entryId) {
-        return optional(this.#state().tasks[taskId]?.integrationQueue[entryId]);
-    }
-    nextDurableJobId(taskId) {
-        return this.#nextTaskRecordId(taskId, "durableJob");
-    }
-    saveDurableJob(taskId, job) {
-        const stored = identified(job, CURRENT_DURABLE_JOB_SCHEMA_VERSION, "id", job.id, "DurableJob");
-        validateDurableJob(stored);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`DurableJob belongs to another Task: ${stored.taskId}.`);
-        }
-        const aggregate = this.#requireTaskForWrite(taskId);
-        if (!aggregate.task.projectBindings.some(({ projectId }) => projectId === stored.projectId)) {
-            throw new StorageRecordError(`DurableJob Project does not match Task: ${stored.id}.`);
-        }
-        const existing = aggregate.durableJobs[stored.id];
-        if (existing !== undefined) {
-            if (Date.parse(stored.updatedAt) < Date.parse(existing.updatedAt)) {
-                throw new StorageRecordError(`DurableJob updatedAt cannot move backwards: ${stored.id}.`);
-            }
-            if (!validDurableJobTransition(existing, stored)) {
-                throw new StorageRecordError(`DurableJob transition is invalid: ${stored.id}.`);
-            }
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            observeTaskRecordId(task, "durableJob", stored.id);
-            task.durableJobs[stored.id] = stored;
-        });
-    }
-    listDurableJobs(taskId) {
-        return values(this.#requireTask(taskId).durableJobs, "id");
-    }
-    getDurableJob(taskId, jobId) {
-        return optional(this.#state().tasks[taskId]?.durableJobs[jobId]);
-    }
-    findDurableJobByIdempotencyKey(taskId, key) {
-        const aggregate = this.#state().tasks[taskId];
-        if (aggregate === undefined)
-            return null;
-        const found = Object.values(aggregate.durableJobs)
-            .find((job) => job.idempotencyKey === key);
-        return optional(found);
-    }
-    listActiveDurableJobs() {
-        // The file rollback backend has no secondary indexes, so it filters its
-        // already-loaded aggregate here. Layout-7 Controller hot paths use the
-        // SQLite implementation below, whose status index avoids this history
-        // scan; the return contract and ordering stay identical across backends.
-        const all = [];
-        for (const aggregate of Object.values(this.#state().tasks)) {
-            for (const job of Object.values(aggregate.durableJobs)) {
-                if (job.status === "queued" || job.status === "running")
-                    all.push(job);
-            }
-        }
-        return all
-            .map((job) => clone(job))
-            .sort((left, right) => numericCompare(`${left.taskId}/${left.id}`, `${right.taskId}/${right.id}`));
-    }
-    hasActiveDurableJobs() {
-        for (const aggregate of Object.values(this.#state().tasks)) {
-            for (const job of Object.values(aggregate.durableJobs)) {
-                if (job.status === "queued" || job.status === "running")
-                    return true;
-            }
-        }
-        return false;
-    }
-    saveRole(taskId, role) {
-        const aggregate = this.#requireTaskForWrite(taskId);
-        const stored = identified(role, CURRENT_TASK_ROLE_SCHEMA_VERSION, "name", role.name, "Task Role");
-        if (stored.taskId !== taskId)
-            throw new StorageRecordError(`Task Role belongs to another Task: ${stored.taskId}`);
-        validateTaskRole(stored);
-        const sessions = this.getRoleSessionSet(taskId, stored.name);
-        if (sessions !== null)
-            assertSessionsMatchRole(sessions, stored);
-        this.#mutate((state) => { state.tasks[aggregate.task.id].roles[stored.name] = stored; });
-    }
-    listRoles(taskId) { return values(this.#requireTask(taskId).roles, "name"); }
-    getRole(taskId, name) { return optional(this.#state().tasks[taskId]?.roles[name]); }
-    saveTaskRoleWithSessionSet(role, sessions) {
-        const storedRole = identified(role, CURRENT_TASK_ROLE_SCHEMA_VERSION, "name", role.name, "Task Role");
-        validateTaskRole(storedRole);
-        const storedSessions = taskSessions(sessions);
-        assertSessionsMatchRole(storedSessions, storedRole);
-        this.transaction(() => {
-            this.#requireTaskForWrite(storedRole.taskId);
-            this.#mutate((state) => {
-                state.tasks[storedRole.taskId].roles[storedRole.name] = storedRole;
-                state.tasks[storedRole.taskId].roleSessionSets[storedRole.name] = storedSessions;
-            });
-        });
-    }
-    removeTaskRole(taskId, name) {
-        return this.transaction(() => {
-            const aggregate = this.#requireTask(taskId);
-            const removed = this.#remove(() => aggregate.roles, name);
-            this.#mutate((state) => {
-                delete aggregate.roleSessionSets[name];
-                delete aggregate.activeRuns[name];
-                delete state.mailboxes[mailboxTargetKey({ kind: "role", taskId, roleName: name })];
-            });
-            return removed;
-        });
-    }
-    saveManagedWorkspace(workspace) {
-        const stored = versioned(workspace, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, "Managed workspace");
-        validateManagedWorkspace(stored);
-        const taskId = stored.owner.taskId;
-        const aggregate = this.#requireTaskForWrite(taskId);
-        if (stored.owner.type === "work-item"
-            && aggregate.workItems[stored.owner.workItemId] === undefined) {
-            throw new StorageRecordError(`Managed workspace WorkItem not found: ${taskId}/${stored.owner.workItemId}.`);
-        }
-        if (stored.owner.type === "review-round"
-            && aggregate.reviewRounds[stored.owner.reviewRoundId] === undefined) {
-            throw new StorageRecordError(`Managed workspace ReviewRound not found: ${taskId}/${stored.owner.reviewRoundId}.`);
-        }
-        if (stored.owner.type === "integration-attempt"
-            && aggregate.integrationAttempts[stored.owner.integrationAttemptId] === undefined) {
-            throw new StorageRecordError(`Managed workspace Integration Attempt not found: ${taskId}/${stored.owner.integrationAttemptId}.`);
-        }
-        if (stored.owner.type === "execution-lane") {
-            const groupOwner = stored.owner;
-            if (groupOwner.purpose === "execution") {
-                const item = groupOwner.workItemId === undefined
-                    ? undefined
-                    : aggregate.workItems[groupOwner.workItemId];
-                if (item === undefined
-                    || workItemExecutionGroupById(item, groupOwner.executionGroupId) === undefined
-                    || !workItemExecutionGroupById(item, groupOwner.executionGroupId).lanes.some(({ id }) => id === groupOwner.executionLaneId)) {
-                    throw new StorageRecordError(`Managed execution Lane WorkItem lineage is invalid: ${taskId}/${groupOwner.executionGroupId}/${groupOwner.executionLaneId}.`);
-                }
-            }
-            else {
-                const round = groupOwner.reviewRoundId === undefined
-                    ? undefined
-                    : aggregate.reviewRounds[groupOwner.reviewRoundId];
-                if (round === undefined || round.executionGroup?.id !== groupOwner.executionGroupId
-                    || !round.executionGroup.lanes.some(({ id }) => id === groupOwner.executionLaneId)) {
-                    throw new StorageRecordError(`Managed review Lane ReviewRound lineage is invalid: ${taskId}/${groupOwner.executionGroupId}/${groupOwner.executionLaneId}.`);
-                }
-            }
-        }
-        assertManagedWorkspaceReferences(aggregate, stored, "Managed workspace");
-        const boundProjects = new Set(aggregate.task.projectBindings.map(({ projectId }) => projectId));
-        if (stored.entries.some(({ projectId }) => !boundProjects.has(projectId))) {
-            throw new StorageRecordError(`Managed workspace Project does not match Task: ${taskId}.`);
-        }
-        this.#mutate((state) => {
-            state.tasks[taskId].managedWorkspaces[managedWorkspaceKey(stored.owner)] = stored;
-        });
-    }
-    listManagedWorkspaces(taskId) {
-        return values(this.#requireTask(taskId).managedWorkspaces, (workspace) => managedWorkspaceKey(workspace.owner));
-    }
-    listManagedWorkspace(taskId) {
-        return this.listManagedWorkspaces(taskId);
-    }
-    getTaskWorkspace(taskId) {
-        return this.getManagedWorkspace({ type: "task", taskId });
-    }
-    getWorkItemWorkspace(taskId, workItemId) {
-        return this.getManagedWorkspace({ type: "work-item", taskId, workItemId });
-    }
-    getReviewRoundWorkspace(taskId, reviewRoundId) {
-        return this.getManagedWorkspace({ type: "review-round", taskId, reviewRoundId });
-    }
-    getIntegrationWorkspace(taskId, integrationAttemptId) {
-        return this.getManagedWorkspace({
-            type: "integration-attempt",
-            taskId,
-            integrationAttemptId
-        });
-    }
-    getManagedWorkspace(owner) {
-        return optional(this.#state().tasks[owner.taskId]?.managedWorkspaces[managedWorkspaceKey(owner)]);
-    }
-    removeManagedWorkspace(owner) {
-        this.#requireTaskForWrite(owner.taskId);
-        return this.#remove((state) => state.tasks[owner.taskId].managedWorkspaces, managedWorkspaceKey(owner));
-    }
-    getRoleSessionSet(taskId, roleName) {
-        return optional(this.#state().tasks[taskId]?.roleSessionSets[roleName]);
-    }
-    getTaskRoleSessionSet(taskId, roleName) {
-        return this.getRoleSessionSet(taskId, roleName);
-    }
-    listRoleSessionSets(taskId) {
-        return values(this.#requireTask(taskId).roleSessionSets, (set) => set.owner.roleName);
-    }
-    listRuntimeSessionCandidates(query = {}) {
-        const state = this.#state();
-        const selectedTaskIds = query.taskIds === undefined
-            ? undefined
-            : [...new Set(query.taskIds)].sort(numericCompare);
-        const taskAggregates = query.scope === "global"
-            ? []
-            : selectedTaskIds === undefined
-                ? Object.values(state.tasks)
-                : selectedTaskIds.flatMap((taskId) => {
-                    const aggregate = state.tasks[taskId];
-                    return aggregate === undefined ? [] : [aggregate];
-                });
-        const candidates = [
-            ...taskAggregates.flatMap((task) => (Object.values(task.roleSessionSets).flatMap((sessions) => {
-                const candidate = projectRuntimeSessionCandidate(sessions);
-                return candidate === null ? [] : [candidate];
-            }))),
-            ...(query.scope === "task" || selectedTaskIds !== undefined
-                ? []
-                : Object.values(state.globalRoleSessionSets).flatMap((sessions) => {
-                    const candidate = projectRuntimeSessionCandidate(sessions);
-                    return candidate === null ? [] : [candidate];
-                }))
-        ];
-        return candidates
-            .filter((candidate) => !query.cleanupRequiredOnly || candidate.cleanupRequired)
-            .sort(compareRuntimeSessionCandidates);
-    }
-    saveRoleSessionSet(sessions) {
-        const stored = taskSessions(sessions);
-        const taskId = stored.owner.taskId;
-        this.#requireTaskForWrite(taskId);
-        const role = this.getRole(taskId, stored.owner.roleName);
-        if (role === null)
-            throw new StorageRecordError(`Task Role not found: ${taskId}/${stored.owner.roleName}`);
-        assertSessionsMatchRole(stored, role);
-        this.#mutate((state) => { state.tasks[taskId].roleSessionSets[stored.owner.roleName] = stored; });
-    }
-    saveTaskRoleSessionSet(sessions) { this.saveRoleSessionSet(sessions); }
-    getRoleSession(taskId, roleName) {
-        const set = this.getRoleSessionSet(taskId, roleName);
-        return set === null ? null : optional(set.sessions[set.activeAgentId]);
-    }
-    getJobCallerKeyHash(taskId, roleName, agentId) {
-        const hashes = this.#state().tasks[taskId]?.jobCallerKeyHashes;
-        if (hashes === undefined)
-            return null;
-        return optional(hashes[jobCallerKeyHashKey(roleName, agentId)]);
-    }
-    setJobCallerKeyHash(taskId, roleName, agentId, hash) {
-        this.#requireTaskForWrite(taskId);
-        if (!/^[a-f0-9]{64}$/u.test(hash)) {
-            throw new StorageRecordError(`Job caller key hash is invalid: ${taskId}/${roleName}.`);
-        }
-        this.#mutate((state) => {
-            state.tasks[taskId].jobCallerKeyHashes[jobCallerKeyHashKey(roleName, agentId)] = hash;
-        });
-    }
-    saveSessionOwner(identity) {
-        this.#sessionOwners().record(identity);
-    }
-    getSessionOwner(launchId) {
-        return this.#sessionOwners().get(launchId);
-    }
-    listSessionOwners() {
-        return this.#sessionOwners().list();
-    }
-    listSessionOwnersForOwner(owner) {
-        return this.#sessionOwners().listForOwner(owner);
-    }
-    removeSessionOwner(launchId) {
-        this.#sessionOwners().remove(launchId);
-    }
-    #sessionOwners() {
-        if (this.#sessionOwnerRegistry === undefined) {
-            this.#sessionOwnerRegistry = new FileSessionOwnerRegistry(this.rootDir);
-        }
-        return this.#sessionOwnerRegistry;
-    }
-    nextWorkItemId(taskId) {
-        return this.#nextTaskRecordId(taskId, "workItem");
-    }
-    getWorkItem(taskId, id) { return optional(this.#state().tasks[taskId]?.workItems[id]); }
-    listWorkItems(taskId) { return values(this.#requireTask(taskId).workItems, "id"); }
-    saveWorkItem(taskId, item) {
-        const stored = identified(item, CURRENT_WORK_ITEM_SCHEMA_VERSION, "id", item.id, "Work item");
-        if (stored.taskId !== taskId)
-            throw new StorageRecordError(`Work item belongs to another Task: ${stored.taskId}`);
-        validateWorkItem(stored);
-        const aggregate = this.#requireTaskForWrite(taskId);
-        const boundProjects = new Set(aggregate.task.projectBindings.map(({ projectId }) => projectId));
-        if (stored.writeProjectIds.some((projectId) => !boundProjects.has(projectId))) {
-            throw new StorageRecordError(`Work Item writable Project does not belong to Task: ${stored.id}.`);
-        }
-        const writableProjects = new Set(stored.writeProjectIds);
-        if (stored.baseRefs?.some(({ projectId }) => !boundProjects.has(projectId))) {
-            throw new StorageRecordError(`Work Item base-ref Project does not belong to Task: ${stored.id}.`);
-        }
-        if (stored.baseRefs?.some(({ projectId }) => !writableProjects.has(projectId))) {
-            throw new StorageRecordError(`Work Item base-ref Project must be writable: ${stored.id}.`);
-        }
-        for (const dependencyId of stored.dependsOn) {
-            const dependency = this.getWorkItem(taskId, dependencyId);
-            if (dependency === null) {
-                throw new StorageRecordError(`Work Item dependency not found: ${dependencyId}.`);
-            }
-        }
-        assertAcyclicWorkItems({
-            ...aggregate.workItems,
-            [stored.id]: stored
-        });
-        for (const candidate of stored.candidates) {
-            assertWorkItemCandidateReferences(aggregate, stored, candidate, "Work Item candidate");
-        }
-        const existing = this.getWorkItem(taskId, stored.id);
-        if (existing !== null && !validWorkItemTransition(existing, stored)) {
-            throw new StorageRecordError(`Work Item transition is invalid: ${stored.id}.`);
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            observeTaskRecordId(task, "workItem", stored.id);
-            task.workItems[stored.id] = stored;
-        });
-    }
-    nextContextSnapshotId(taskId) {
-        return this.#nextTaskRecordId(taskId, "contextSnapshot");
-    }
-    getContextSnapshot(taskId, id) {
-        return optional(this.#state().tasks[taskId]?.contextSnapshots[id]);
-    }
-    listContextSnapshots(taskId) {
-        return values(this.#requireTask(taskId).contextSnapshots, "id");
-    }
-    saveContextSnapshot(snapshot) {
-        const stored = identified(snapshot, CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, "id", snapshot.id, "Context Snapshot");
-        validateContextSnapshot(stored);
-        const aggregate = this.#requireTaskForWrite(stored.taskId);
-        const existing = aggregate.contextSnapshots[stored.id];
-        if (existing !== undefined) {
-            if (!isDeepStrictEqual(existing, stored)) {
-                throw new StorageRecordError(`Context Snapshot is immutable: ${stored.id}.`);
-            }
-            return;
-        }
-        const duplicateSequence = Object.values(aggregate.contextSnapshots).find((candidate) => (candidate.scope === stored.scope
-            && candidate.scopeRef === stored.scopeRef
-            && candidate.sequence === stored.sequence));
-        if (duplicateSequence !== undefined) {
-            throw new StorageRecordError(`Context Snapshot sequence already exists: ${stored.taskId}/${stored.scope}/${stored.sequence}.`);
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[stored.taskId];
-            observeTaskRecordId(task, "contextSnapshot", stored.id);
-            task.contextSnapshots[stored.id] = stored;
-        });
-    }
-    nextAgentRunId(taskId) {
-        return this.#nextTaskRecordId(taskId, "agentRun");
-    }
-    peekNextAgentRunId(taskId) {
-        return this.#peekTaskRecordId(taskId, "agentRun");
-    }
-    getAgentRun(taskId, id) { return optional(this.#state().tasks[taskId]?.agentRuns[id]); }
-    listAgentRuns(taskId) { return values(this.#requireTask(taskId).agentRuns, "id"); }
-    saveAgentRun(run) {
-        const stored = identified(run, CURRENT_AGENT_RUN_SCHEMA_VERSION, "id", run.id, "Agent run");
-        validateAgentRun(stored);
-        const aggregate = this.#requireTaskForWrite(stored.taskId);
-        if (stored.purpose === "review"
-            && aggregate.task.projectBindings.length > 0
-            && stored.workspace === undefined) {
-            throw new StorageRecordError(`A Project-backed review Agent run requires its ReviewRound workspace: ${stored.id}.`);
-        }
-        if (stored.reviewRoundId !== undefined) {
-            const round = aggregate.reviewRounds[stored.reviewRoundId];
-            if (round === undefined) {
-                throw new StorageRecordError(`Agent run ReviewRound not found: ${stored.reviewRoundId}.`);
-            }
-            const roundWorkItemId = round.workItemId ?? round.legacyAnchor?.workItemId;
-            const laneRole = round.executionGroup?.lanes.find(({ id }) => id === stored.executionLaneId)?.roleName;
-            if (roundWorkItemId !== stored.workItemId
-                || (round.reviewerRoleName !== stored.roleName && laneRole !== stored.roleName)) {
-                throw new StorageRecordError(`Agent run does not match ReviewRound: ${stored.id}.`);
-            }
-        }
-        assertAgentRunExecutionReferences(aggregate, stored);
-        this.#mutate((state) => {
-            const task = state.tasks[stored.taskId];
-            observeTaskRecordId(task, "agentRun", stored.id);
-            task.agentRuns[stored.id] = stored;
-        });
-    }
-    nextReviewRoundId(taskId) {
-        return this.#nextTaskRecordId(taskId, "reviewRound");
-    }
-    getReviewRound(taskId, reviewRoundId) {
-        return optional(this.#state().tasks[taskId]?.reviewRounds[reviewRoundId]);
-    }
-    listReviewRounds(taskId) {
-        return values(this.#requireTask(taskId).reviewRounds, "id");
-    }
-    saveReviewRound(taskId, round) {
-        const stored = identified(round, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, "id", round.id, "ReviewRound");
-        validateReviewRound(stored);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`ReviewRound belongs to another Task: ${stored.taskId}.`);
-        }
-        const aggregate = this.#requireTaskForWrite(taskId);
-        if ((stored.scope ?? "work-item") === "work-item") {
-            const item = aggregate.workItems[stored.workItemId];
-            if (item === undefined) {
-                throw new StorageRecordError(`ReviewRound Work Item not found: ${stored.workItemId}.`);
-            }
-            const candidate = item.candidates.find(({ id }) => id === stored.candidateId);
-            if (candidate === undefined) {
-                throw new StorageRecordError(`ReviewRound Candidate not found: ${stored.candidateId}.`);
-            }
-            assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${stored.id}`);
-        }
-        if (stored.reviewerRunId !== undefined) {
-            const reviewerRun = aggregate.agentRuns[stored.reviewerRunId];
-            if (reviewerRun !== undefined
-                && (reviewerRun.reviewRoundId !== stored.id || reviewerRun.purpose !== "review")) {
-                throw new StorageRecordError(`ReviewRound Reviewer Run is invalid: ${stored.reviewerRunId}.`);
-            }
-        }
-        const existing = aggregate.reviewRounds[stored.id];
-        if (existing !== undefined && !validReviewRoundTransition(existing, stored)) {
-            throw new StorageRecordError(`ReviewRound transition is invalid: ${stored.id}.`);
-        }
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            observeTaskRecordId(task, "reviewRound", stored.id);
-            task.reviewRounds[stored.id] = stored;
-        });
-    }
-    nextReviewFindingId(taskId) {
-        throw new StorageRecordError(`Review findings require the SQLite backend (yui.db); migrate this Home with \`yui update\` before using the finding ledger on Task ${taskId}.`);
-    }
-    getReviewFinding(taskId, reviewFindingId) {
-        throw new StorageRecordError(`Review findings require the SQLite backend (yui.db); migrate this Home with \`yui update\` before using the finding ledger on Task ${taskId}.`);
-    }
-    listReviewFindings(taskId) {
-        throw new StorageRecordError(`Review findings require the SQLite backend (yui.db); migrate this Home with \`yui update\` before using the finding ledger on Task ${taskId}.`);
-    }
-    saveReviewFinding(taskId, finding) {
-        throw new StorageRecordError(`Review findings require the SQLite backend (yui.db); migrate this Home with \`yui update\` before using the finding ledger on Task ${taskId}.`);
-    }
-    getActiveAgentRun(taskId, roleName) {
-        const aggregate = this.#state().tasks[taskId];
-        const pointer = aggregate?.activeRuns[roleName];
-        if (aggregate === undefined || pointer === undefined)
-            return null;
-        const run = aggregate.agentRuns[pointer.runId];
-        if (run === undefined)
-            throw new StorageRecordError(`Active Agent run pointer is dangling: ${taskId}/${roleName}`);
-        return clone(run);
-    }
-    saveActiveAgentRun(run) {
-        if (run.executionGroupId !== undefined && run.executionLaneId !== undefined) {
-            this.saveActiveExecutionLaneRun(run);
-            return;
-        }
-        if (run.status !== "active")
-            throw new StorageRecordError(`Active Agent run must have active status: ${run.id}`);
-        this.transaction((store) => {
-            const task = store.getTask(run.taskId);
-            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
-                throw new StorageRecordError(`Task execution is not enabled: ${run.taskId}.`);
-            }
-            const current = store.getActiveAgentRun(run.taskId, run.roleName);
-            if (current !== null && current.id !== run.id) {
-                throw new StorageRecordError(`Role already has an active Agent run: ${run.taskId}/${run.roleName}`);
-            }
-            const sessions = store.getTaskRoleSessionSet(run.taskId, run.roleName);
-            if (sessions !== null && sessions.inFlight !== null && sessions.inFlight.runId !== run.id) {
-                throw new StorageRecordError(`Role still has an in-flight Turn: ${run.taskId}/${run.roleName}/${sessions.inFlight.runId}`);
-            }
-            store.saveAgentRun(run);
-            this.#mutate((state) => {
-                state.tasks[run.taskId].activeRuns[run.roleName] = {
-                    schemaVersion: CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION,
-                    runId: run.id
-                };
-            });
-        });
-    }
-    clearActiveAgentRun(taskId, roleName) {
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            if (task === undefined)
-                return;
-            const rolePointer = task.activeRuns[roleName];
-            delete task.activeRuns[roleName];
-            // Older Controller paths only know the Role key.  When that key points
-            // at a lane-backed Run, remove the matching lane pointer too; preserve
-            // every other lane for the same Role in a multi-lane group.
-            if (rolePointer === undefined)
-                return;
-            for (const [key, pointer] of Object.entries(task.activeRuns)) {
-                if (executionLaneActiveRunKeyParts(key) !== null && pointer.runId === rolePointer.runId) {
-                    delete task.activeRuns[key];
-                }
-            }
-        });
-    }
-    getActiveExecutionLaneRun(taskId, executionGroupId, executionLaneId) {
-        const aggregate = this.#state().tasks[taskId];
-        const key = executionLaneActiveRunKey(executionGroupId, executionLaneId);
-        const pointer = aggregate?.activeRuns[key];
-        if (aggregate === undefined || pointer === undefined)
-            return null;
-        const run = aggregate.agentRuns[pointer.runId];
-        if (run === undefined) {
-            throw new StorageRecordError(`Active Agent run pointer is dangling: ${taskId}/${key}`);
-        }
-        if (run.executionGroupId !== executionGroupId
-            || run.executionLaneId !== executionLaneId
-            || run.status !== "active") {
-            throw new StorageRecordError(`Active Agent run pointer is invalid: ${taskId}/${key}`);
-        }
-        return clone(run);
-    }
-    saveActiveExecutionLaneRun(run) {
-        if (run.status !== "active") {
-            throw new StorageRecordError(`Active Agent run must have active status: ${run.id}`);
-        }
-        if (run.executionGroupId === undefined || run.executionLaneId === undefined) {
-            throw new StorageRecordError(`Lane active Agent run requires execution lineage: ${run.id}`);
-        }
-        this.transaction((store) => {
-            const task = store.getTask(run.taskId);
-            if (task === null || task.status !== "active" || task.executionGate.state !== "enabled") {
-                throw new StorageRecordError(`Task execution is not enabled: ${run.taskId}.`);
-            }
-            const key = executionLaneActiveRunKey(run.executionGroupId, run.executionLaneId);
-            const current = store.getActiveExecutionLaneRun(run.taskId, run.executionGroupId, run.executionLaneId);
-            if (current !== null && current.id !== run.id) {
-                throw new StorageRecordError(`Execution Lane already has an active Agent run: ${run.taskId}/${key}`);
-            }
-            const sessions = store.getTaskRoleSessionSet(run.taskId, run.roleName);
-            if (sessions !== null && sessions.inFlight !== null && sessions.inFlight.runId !== run.id) {
-                throw new StorageRecordError(`Role still has an in-flight Turn: ${run.taskId}/${run.roleName}/${sessions.inFlight.runId}`);
-            }
-            store.saveAgentRun(run);
-            this.#mutate((state) => {
-                const task = state.tasks[run.taskId];
-                task.activeRuns[key] = {
-                    schemaVersion: CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION,
-                    runId: run.id
-                };
-                // Preserve the legacy role pointer for the single-lane delivery path.
-                // A second lane for the same Role keeps the first pointer unchanged;
-                // lane-aware readers use the exact key above.
-                if (task.activeRuns[run.roleName] === undefined) {
-                    task.activeRuns[run.roleName] = {
-                        schemaVersion: CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION,
-                        runId: run.id
-                    };
-                }
-            });
-        });
-    }
-    clearActiveExecutionLaneRun(taskId, executionGroupId, executionLaneId) {
-        this.#mutate((state) => {
-            const task = state.tasks[taskId];
-            if (task === undefined)
-                return;
-            const key = executionLaneActiveRunKey(executionGroupId, executionLaneId);
-            const pointer = task.activeRuns[key];
-            delete task.activeRuns[key];
-            const runId = pointer?.runId;
-            for (const [roleName, rolePointer] of Object.entries(task.activeRuns)) {
-                if (executionLaneActiveRunKeyParts(roleName) !== null)
-                    continue;
-                const roleRun = task.agentRuns[rolePointer.runId];
-                const matches = runId !== undefined
-                    ? rolePointer.runId === runId
-                    : roleRun?.executionGroupId === executionGroupId
-                        && roleRun.executionLaneId === executionLaneId;
-                if (matches) {
-                    delete task.activeRuns[roleName];
-                }
-            }
-        });
-    }
-    nextMessageId(taskId) {
-        return this.#nextTaskRecordId(taskId, "message");
-    }
-    saveMessage(taskId, message) {
-        validateTaskMessage(message);
-        if (message.taskId !== taskId) {
-            throw new StorageRecordError(`Message belongs to another Task: ${message.taskId}`);
-        }
-        this.#saveTaskRecord(taskId, "messages", message, "Message");
-    }
-    listMessages(taskId) { return values(this.#requireTask(taskId).messages, "id"); }
-    nextInputRequestId(taskId) {
-        return this.#nextTaskRecordId(taskId, "inputRequest");
-    }
-    saveInputRequest(taskId, request) {
-        const stored = validateInputRequest(versioned(request, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, "Input request"));
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Input request belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            const existing = aggregate.inputRequests[stored.id];
-            if (existing === undefined && stored.status !== "open") {
-                throw new StorageRecordError(`Input request must start open: ${stored.id}`);
-            }
-            if (existing !== undefined && !isValidInputRequestTransition(existing, stored)) {
-                throw new StorageRecordError(`Input request cannot be overwritten: ${stored.id}`);
-            }
-            observeTaskRecordId(aggregate, "inputRequest", stored.id);
-            aggregate.inputRequests[stored.id] = stored;
-        });
-    }
-    getInputRequest(taskId, requestId) {
-        return optional(this.#state().tasks[taskId]?.inputRequests[requestId]);
-    }
-    listInputRequests(taskId) {
-        return values(this.#requireTask(taskId).inputRequests, "id");
-    }
-    listOpenInputRequests(taskIds) {
-        const state = this.#state();
-        const selected = taskIds === undefined
-            ? Object.values(state.tasks)
-            : [...new Set(taskIds)].sort(numericCompare).flatMap((taskId) => {
-                const aggregate = state.tasks[taskId];
-                return aggregate === undefined ? [] : [aggregate];
-            });
-        return selected
-            .flatMap((aggregate) => Object.values(aggregate.inputRequests))
-            .filter((request) => request.status === "open")
-            .map(clone)
-            .sort((left, right) => (numericCompare(left.taskId, right.taskId)
-            || numericCompare(left.id, right.id)));
-    }
-    listAllInputRequests() {
-        return Object.values(this.#state().tasks)
-            .flatMap((aggregate) => Object.values(aggregate.inputRequests).map(clone))
-            .sort((left, right) => (left.createdAt.localeCompare(right.createdAt)
-            || left.taskId.localeCompare(right.taskId)
-            || numericCompare(left.id, right.id)));
-    }
-    nextDecisionId(taskId) {
-        return this.#nextTaskRecordId(taskId, "decision");
-    }
-    saveDecision(taskId, decision) {
-        const stored = storedDecision(decision);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Decision belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            const existing = aggregate.decisions[stored.id];
-            if (existing === undefined && stored.status !== "active") {
-                throw new StorageRecordError(`Decision must start active: ${stored.id}`);
-            }
-            if (existing !== undefined && !isValidDecisionSupersession(existing, stored)) {
-                throw new StorageRecordError(`Decision cannot be overwritten: ${stored.id}`);
-            }
-            observeTaskRecordId(aggregate, "decision", stored.id);
-            aggregate.decisions[stored.id] = stored;
-        });
-    }
-    listDecisions(taskId) {
-        return values(this.#requireTask(taskId).decisions, "id");
-    }
-    getDecision(taskId, decisionId) {
-        return this.#requireTask(taskId).decisions[decisionId] ?? null;
-    }
-    nextMilestoneId(taskId) {
-        return this.#nextTaskRecordId(taskId, "milestone");
-    }
-    saveMilestone(taskId, milestone) {
-        const stored = storedMilestone(milestone);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Milestone belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            if (aggregate.milestones[stored.id] !== undefined) {
-                throw new StorageRecordError(`Milestone already exists: ${taskId}/${stored.id}`);
-            }
-            observeTaskRecordId(aggregate, "milestone", stored.id);
-            aggregate.milestones[stored.id] = stored;
-        });
-    }
-    listMilestones(taskId) {
-        return values(this.#requireTask(taskId).milestones, "id");
-    }
-    getMilestone(taskId, milestoneId) {
-        return this.#requireTask(taskId).milestones[milestoneId] ?? null;
-    }
-    nextEventId(taskId) {
-        return this.#nextTaskRecordId(taskId, "event");
-    }
-    saveEvent(taskId, event) {
-        const stored = storedTaskEvent(event);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Task event belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            if (aggregate.events[stored.id] !== undefined) {
-                throw new StorageRecordError(`Task event already exists: ${taskId}/${stored.id}`);
-            }
-            observeTaskRecordId(aggregate, "event", stored.id);
-            aggregate.events[stored.id] = stored;
-        });
-    }
-    listEvents(taskId) { return values(this.#requireTask(taskId).events, "id"); }
-    nextTaskWakeId(taskId) {
-        return this.#nextTaskRecordId(taskId, "taskWake");
-    }
-    peekNextTaskWakeId(taskId) {
-        return this.#peekTaskRecordId(taskId, "taskWake");
-    }
-    saveTaskWake(taskId, wake) {
-        if (wake.taskId !== taskId) {
-            throw new StorageRecordError(`Task wake belongs to another Task: ${wake.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            observeTaskRecordId(aggregate, "taskWake", wake.id);
-            aggregate.wakes[wake.id] = wake;
-        });
-    }
-    getTaskWake(taskId, wakeId) {
-        return this.#state().tasks[taskId]?.wakes[wakeId] ?? null;
-    }
-    listTaskWakes(taskId) {
-        return values(this.#requireTask(taskId).wakes, "id");
-    }
-    removeEvents(taskId, eventIds) {
-        if (eventIds.length === 0)
-            return 0;
-        let removed = 0;
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            for (const id of eventIds) {
-                if (aggregate.events[id] !== undefined) {
-                    delete aggregate.events[id];
-                    removed++;
-                }
-            }
-        });
-        return removed;
-    }
-    nextCapabilityGrantId(taskId) {
-        return this.#nextTaskRecordId(taskId, "capabilityGrant");
-    }
-    saveCapabilityGrant(taskId, grant) {
-        const stored = storedCapabilityGrant(grant);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Capability grant belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            const existing = aggregate.capabilityGrants[stored.id];
-            if (existing === undefined) {
-                if (stored.revokedAt !== undefined) {
-                    throw new StorageRecordError(`Capability grant must start unrevoked: ${stored.id}`);
-                }
-                if (stored.usesUsed !== 0) {
-                    throw new StorageRecordError(`Capability grant must start unused: ${stored.id}`);
-                }
-            }
-            else if (!isValidCapabilityGrantTransition(existing, stored)) {
-                throw new StorageRecordError(`Capability grant cannot be overwritten: ${taskId}/${stored.id}`);
-            }
-            observeTaskRecordId(aggregate, "capabilityGrant", stored.id);
-            aggregate.capabilityGrants[stored.id] = stored;
-        });
-    }
-    listCapabilityGrants(taskId) {
-        return values(this.#requireTask(taskId).capabilityGrants, "id");
-    }
-    getCapabilityGrant(taskId, grantId) {
-        return this.#requireTask(taskId).capabilityGrants[grantId] ?? null;
-    }
-    nextReleaseWorkflowId(taskId) {
-        return this.#nextTaskRecordId(taskId, "releaseWorkflow");
-    }
-    saveReleaseWorkflow(taskId, workflow) {
-        const stored = storedReleaseWorkflow(workflow);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Release workflow belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            const existing = aggregate.releaseWorkflows[stored.id];
-            if (existing !== undefined && !isValidReleaseWorkflowTransition(existing, stored)) {
-                throw new StorageRecordError(`Release workflow cannot be overwritten: ${taskId}/${stored.id}`);
-            }
-            observeTaskRecordId(aggregate, "releaseWorkflow", stored.id);
-            aggregate.releaseWorkflows[stored.id] = stored;
-        });
-    }
-    listReleaseWorkflows(taskId) {
-        return values(this.#requireTask(taskId).releaseWorkflows, "id");
-    }
-    getReleaseWorkflow(taskId, workflowId) {
-        return this.#requireTask(taskId).releaseWorkflows[workflowId] ?? null;
-    }
-    nextPublicationReferenceId(taskId) {
-        return this.#nextTaskRecordId(taskId, "publicationReference");
-    }
-    savePublicationReference(taskId, reference) {
-        const stored = storedPublicationReference(reference);
-        if (stored.taskId !== taskId) {
-            throw new StorageRecordError(`Publication reference belongs to another Task: ${stored.taskId}`);
-        }
-        this.#mutate((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            const existing = aggregate.publicationReferences[stored.id];
-            if (existing !== undefined) {
-                if (!isDeepStrictEqual(existing, stored)) {
-                    throw new StorageRecordError(`Publication reference cannot be overwritten: ${taskId}/${stored.id}`);
-                }
-            }
-            else {
-                const key = publicationExternalKey(stored);
-                const sameExternal = [];
-                for (const [otherTaskId, otherAggregate] of Object.entries(state.tasks)) {
-                    for (const candidate of Object.values(otherAggregate.publicationReferences)) {
-                        if (publicationExternalKey(candidate) === key) {
-                            if (otherTaskId !== taskId) {
-                                throw new StorageRecordError(`Publication external identity already belongs to Task ${otherTaskId}: ${key}.`);
-                            }
-                            sameExternal.push(candidate);
-                        }
-                    }
-                }
-                if (sameExternal.length > 0) {
-                    const latest = latestPublicationReference(sameExternal);
-                    if (stored.supersedes !== latest.id) {
-                        throw new StorageRecordError(`Publication external identity conflicts with ${latest.id}; `
-                            + `explicitly supersede that record: ${key}.`);
-                    }
-                }
-                else if (stored.supersedes !== undefined) {
-                    throw new StorageRecordError(`Publication supersedes target has a different external identity: ${stored.supersedes}.`);
-                }
-                observeTaskRecordId(aggregate, "publicationReference", stored.id);
-            }
-            aggregate.publicationReferences[stored.id] = stored;
-        });
-    }
-    listPublicationReferences(taskId) {
-        return values(this.#requireTask(taskId).publicationReferences, "id");
-    }
-    getPublicationReference(taskId, referenceId) {
-        return this.#requireTask(taskId).publicationReferences[referenceId] ?? null;
-    }
-    findPublicationReferenceByExternalKey(externalKey) {
-        const matches = Object.values(this.#state().tasks)
-            .flatMap((aggregate) => Object.values(aggregate.publicationReferences))
-            .filter((reference) => publicationExternalKey(reference) === externalKey);
-        return matches.length === 0 ? null : latestPublicationReference(matches);
-    }
-    // -- Gate artifacts (Issue 08) ---------------------------------------------
-    // FileTaskStore delegates to the file-backed artifact namespace under
-    // `<home>/artifacts/gates/`.  This is the transitional path for Homes that
-    // have not yet migrated to SQLite; the SqliteTaskStore stores the same
-    // records and logs in `gate_artifacts` / `gate_artifact_logs`.
-    #gateArtifactRecordPath(projectId, key) {
-        return join(this.rootDir, "artifacts", "gates", projectId, `${key}.json`);
-    }
-    #gateArtifactLogsRoot(projectId, key) {
-        return join(this.rootDir, "artifacts", "gates", projectId, key);
-    }
-    saveGateArtifact(artifact, logs) {
-        validateGateArtifact(artifact);
-        const recordPath = this.#gateArtifactRecordPath(artifact.projectId, artifact.key);
-        const logsRoot = this.#gateArtifactLogsRoot(artifact.projectId, artifact.key);
-        this.#mutate(() => {
-            writeTextFileAtomically(recordPath, `${JSON.stringify(artifact, null, 2)}\n`);
-            mkdirSync(logsRoot, { recursive: true, mode: 0o700 });
-            for (const [stepName, content] of logs) {
-                const logPath = join(logsRoot, stepName);
-                const tmpPath = `${logPath}.tmp-${process.pid}`;
-                writeFileSync(tmpPath, content, { mode: 0o600 });
-                renameSync(tmpPath, logPath);
-            }
-        });
-    }
-    touchGateArtifact(artifact) {
-        validateGateArtifact(artifact);
-        const recordPath = this.#gateArtifactRecordPath(artifact.projectId, artifact.key);
-        if (!existsSync(recordPath)) {
-            throw new StorageRecordError(`Gate artifact not found for touch: ${artifact.key}`);
-        }
-        writeTextFileAtomically(recordPath, `${JSON.stringify(artifact, null, 2)}\n`);
-    }
-    getGateArtifact(projectId, key) {
-        const path = this.#gateArtifactRecordPath(projectId, key);
-        if (!existsSync(path))
-            return null;
-        const parsed = JSON.parse(readFileSync(path, "utf8"));
-        return validateGateArtifact(parsed);
-    }
-    findGateArtifactByIdentity(identity) {
-        return this.getGateArtifact(identity.projectId, gateArtifactKey(identity));
-    }
-    findL2GateArtifactsForCommit(query) {
-        const root = join(this.rootDir, "artifacts", "gates", query.projectId);
-        if (!existsSync(root))
-            return [];
-        const results = [];
-        for (const entry of readdirSync(root)) {
-            if (!entry.endsWith(".json"))
-                continue;
-            let artifact;
-            try {
-                artifact = this.getGateArtifact(query.projectId, entry.slice(0, -".json".length));
-            }
-            catch {
-                continue;
-            }
-            if (artifact === null
-                || artifact.level !== "L2"
-                || artifact.status !== "complete"
-                || artifact.outcome !== "succeeded"
-                || artifact.commit !== query.commit
-                || artifact.planDigest !== query.planDigest
-                || artifact.toolchainDigest !== query.toolchainDigest
-                || artifact.boundary?.targetRef !== query.targetRef) {
-                continue;
-            }
-            results.push(artifact);
-        }
-        return results;
-    }
-    getGateArtifactLogs(artifactKey) {
-        // The artifact key is content-addressed; we need the projectId to build
-        // the path.  Callers that have the artifact should use
-        // getGateArtifactLogsForArtifact; this fallback scans all projects.
-        const gatesRoot = join(this.rootDir, "artifacts", "gates");
-        if (!existsSync(gatesRoot))
-            return new Map();
-        for (const projectId of readdirSync(gatesRoot)) {
-            const logsRoot = join(gatesRoot, projectId, artifactKey);
-            if (existsSync(logsRoot) && statSync(logsRoot).isDirectory()) {
-                return this.#readGateArtifactLogs(logsRoot);
-            }
-        }
-        return new Map();
-    }
-    #readGateArtifactLogs(logsRoot) {
-        const logs = new Map();
-        if (!existsSync(logsRoot))
-            return logs;
-        for (const entry of readdirSync(logsRoot)) {
-            const fullPath = join(logsRoot, entry);
-            if (statSync(fullPath).isFile()) {
-                logs.set(entry, readFileSync(fullPath));
-            }
-        }
-        return logs;
-    }
-    pruneGateArtifacts(projectId, options) {
-        const root = join(this.rootDir, "artifacts", "gates", projectId);
-        if (!existsSync(root))
-            return Object.freeze({ retained: 0, deleted: 0 });
-        let retained = 0;
-        let deleted = 0;
-        for (const entry of readdirSync(root)) {
-            if (!entry.endsWith(".json"))
-                continue;
-            const key = entry.slice(0, -".json".length);
-            let artifact;
-            try {
-                const loaded = this.getGateArtifact(projectId, key);
-                if (loaded === null)
-                    continue;
-                artifact = loaded;
-            }
-            catch {
-                retained += 1;
-                continue;
-            }
-            const age = options.now.getTime() - Date.parse(artifact.lastUsedAt);
-            if (options.isReferenced(key) || age < options.ttlMs) {
-                retained += 1;
-                continue;
-            }
-            rmSync(this.#gateArtifactRecordPath(projectId, key), { force: true });
-            rmSync(this.#gateArtifactLogsRoot(projectId, key), { recursive: true, force: true });
-            deleted += 1;
-        }
-        return Object.freeze({ retained, deleted });
-    }
-    getWorkMailbox(target) {
-        return optional(this.#state().mailboxes[mailboxTargetKey(target)]);
-    }
-    listWorkMailboxes() {
-        return Object.entries(this.#state().mailboxes)
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([, mailbox]) => clone(mailbox));
-    }
-    listReadyWorkMailboxes() {
-        // The file rollback backend has no secondary indexes. It filters the
-        // in-memory aggregate while preserving the indexed SQLite contract's
-        // target-key order; production layout 7 uses the bounded SQLite query.
-        return Object.entries(this.#state().mailboxes)
-            .filter(([, mailbox]) => mailboxHasWork(mailbox))
-            .sort(([left], [right]) => left.localeCompare(right))
-            .map(([, mailbox]) => clone(mailbox));
-    }
-    saveWorkMailbox(value) {
-        let mailbox;
-        try {
-            mailbox = validateWorkMailbox(versioned(value, CURRENT_WORK_MAILBOX_SCHEMA_VERSION, "WorkMailbox"));
-        }
-        catch (error) {
-            throw new StorageRecordError(error instanceof Error ? error.message : String(error));
-        }
-        this.#mutate((state) => {
-            validateMailboxReferences(state, mailbox);
-            state.mailboxes[mailboxTargetKey(mailbox.target)] = clone(mailbox);
-        });
-    }
-    removeWorkMailbox(target) {
-        return this.#remove((state) => state.mailboxes, mailboxTargetKey(target));
-    }
-    getPendingWakeup(taskId) {
-        return pendingWakeupProjection(this.getWorkMailbox({ kind: "role", taskId, roleName: "leader" }));
-    }
-    listPendingWakeups() {
-        return this.listReadyWorkMailboxes()
-            .flatMap((mailbox) => {
-            const wakeup = pendingWakeupProjection(mailbox);
-            return wakeup === null ? [] : [wakeup];
-        })
-            .sort((a, b) => numericCompare(a.taskId, b.taskId));
-    }
-    savePendingWakeup(value) {
-        const wakeup = identified(value, CURRENT_PENDING_WAKEUP_SCHEMA_VERSION, "taskId", value.taskId, "Pending wakeup");
-        const target = { kind: "role", taskId: wakeup.taskId, roleName: "leader" };
-        this.transaction(() => {
-            const existing = this.getWorkMailbox(target);
-            const existingPending = existing === null ? null : pendingLane(existing, "normal");
-            if (existingPending !== null
-                && wakeup.requestCount <= existingPending.requestCount) {
-                throw new StorageRecordError(`Pending wakeup is stale: ${wakeup.taskId}`);
-            }
-            const fromSequence = existingPending?.fromSequence ?? existing?.nextSequence ?? 1;
-            const toSequence = fromSequence + wakeup.requestCount - 1;
-            this.saveWorkMailbox({
-                schemaVersion: CURRENT_WORK_MAILBOX_SCHEMA_VERSION,
-                target,
-                nextSequence: Math.max(existing?.nextSequence ?? 1, toSequence + 1),
-                processing: existing?.processing ?? null,
-                inputDelivery: existing?.inputDelivery ?? null,
-                pending: {
-                    normal: {
-                        fromSequence,
-                        toSequence,
-                        reasons: [...wakeup.reasons],
-                        refs: existingPending?.refs ?? [],
-                        requestCount: wakeup.requestCount,
-                        firstQueuedAt: wakeup.firstRequestedAt,
-                        lastQueuedAt: wakeup.lastRequestedAt,
-                        sources: existingPending?.sources ?? ["pending-wakeup-projection"],
-                        dedupeKeys: existingPending?.dedupeKeys ?? [
-                            `pending-wakeup:${wakeup.taskId}:${fromSequence}-${toSequence}`
-                        ],
-                        deliveryModes: existingPending?.deliveryModes ?? ["followup"]
-                    },
-                    userCorrection: existing?.pending.userCorrection ?? null,
-                    cursors: existing?.pending.cursors ?? { normal: 0, userCorrection: 0 },
-                    recentDedupeKeys: existing?.pending.recentDedupeKeys ?? []
-                }
-            });
-        });
-    }
-    clearPendingWakeup(taskId) {
-        const target = { kind: "role", taskId, roleName: "leader" };
-        const mailbox = this.getWorkMailbox(target);
-        if (mailbox === null || mailbox.pending.normal === null)
-            return;
-        this.saveWorkMailbox(consumePendingBatch(mailbox, "normal"));
-    }
-    getLeaderFailure(taskId) { return optional(this.#state().tasks[taskId]?.leaderFailure ?? undefined); }
-    saveLeaderFailure(value) {
-        const stored = identified(value, CURRENT_LEADER_FAILURE_SCHEMA_VERSION, "taskId", value.taskId, "Leader failure");
-        this.#requireTaskForWrite(value.taskId);
-        this.#mutate((state) => { state.tasks[value.taskId].leaderFailure = stored; });
-    }
-    clearLeaderFailure(taskId) {
-        this.#mutate((state) => {
-            if (state.tasks[taskId] !== undefined)
-                state.tasks[taskId].leaderFailure = null;
-        });
-    }
-    #saveTaskRecord(taskId, key, value, label) {
-        const record = versioned(value, CURRENT_MESSAGE_SCHEMA_VERSION, label);
-        this.#requireTaskForWrite(taskId);
-        this.#mutate((state) => {
-            if (state.tasks[taskId][key][record.id] !== undefined) {
-                throw new StorageRecordError(`${label} already exists: ${taskId}/${record.id}`);
-            }
-            observeTaskRecordId(state.tasks[taskId], "message", record.id);
-            state.tasks[taskId][key][record.id] = clone(value);
-        });
-    }
-    #requireTask(taskId) {
-        const aggregate = this.#state().tasks[taskId];
-        if (aggregate === undefined)
-            throw new StorageRecordError(`Task not found: ${taskId}`);
-        return aggregate;
-    }
-    #requireTaskForWrite(taskId) { return this.#requireTask(taskId); }
-    #state() { return this.#transaction?.state ?? this.#readCachedState(); }
-    #mutate(execute) { this.#mutateResult((state) => { execute(state); }); }
-    #mutateResult(execute) {
-        if (this.#transaction !== null) {
-            const result = execute(this.#transaction.state);
-            this.#transaction.dirty = true;
-            return result;
-        }
-        return this.#withWriteLock(() => {
-            const state = this.#readCachedState();
-            try {
-                const result = execute(state);
-                this.#commit(state, state.revision);
-                return result;
-            }
-            catch (error) {
-                this.#readCache = null;
-                throw error;
-            }
-        });
-    }
-    #remove(select, id) {
-        return this.#mutateResult((state) => {
-            const records = select(state);
-            if (records[id] === undefined)
-                return false;
-            delete records[id];
-            return true;
-        });
-    }
-    #nextGlobalId(prefix, collect) {
-        const pattern = new RegExp(`^${prefix}-(\\d+)$`);
-        const maximum = collect(this.#state()).reduce((max, id) => {
-            const match = pattern.exec(id);
-            return match === null ? max : Math.max(max, Number.parseInt(match[1], 10));
-        }, 0);
-        return `${prefix}-${maximum + 1}`;
-    }
-    #nextTaskRecordId(taskId, kind) {
-        return this.#mutateResult((state) => {
-            const aggregate = requireTaskFromState(state, taskId);
-            const next = nextTaskRecordSequence(aggregate, taskId, kind);
-            aggregate.idHighWaterMarks[kind] = next;
-            return `${TASK_RECORD_ID_PREFIXES[kind]}-${next}`;
-        });
-    }
-    #peekTaskRecordId(taskId, kind) {
-        const aggregate = this.#requireTask(taskId);
-        return `${TASK_RECORD_ID_PREFIXES[kind]}-${nextTaskRecordSequence(aggregate, taskId, kind)}`;
-    }
-    #readState() {
-        this.#requireReadableSchema();
-        const path = join(this.rootDir, STORAGE_STATE_FILE);
-        if (!existsSync(path))
-            return emptyState();
-        return this.#parseState(readFileSync(path, "utf8"));
-    }
-    #readCachedState() {
-        this.#requireReadableSchema();
-        const path = join(this.rootDir, STORAGE_STATE_FILE);
-        if (!existsSync(path)) {
-            if (this.#readCache?.fingerprint === "missing")
-                return this.#readCache.state;
-            const state = emptyState();
-            this.#readCache = { fingerprint: "missing", state };
-            return state;
-        }
-        const fingerprint = stateFileFingerprint(path);
-        if (this.#readCache?.fingerprint === fingerprint)
-            return this.#readCache.state;
-        const state = this.#parseState(readFileSync(path, "utf8"));
-        this.#readCache = { fingerprint, state };
-        return state;
-    }
-    #commit(state, expectedRevision) {
-        // The upgrade admission fence is honored at the single write moment, so both
-        // baseline CLI writers and the Controller (which mutate through this same
-        // store) refuse to persist while an upgrade owns the Home. Reads and
-        // read-only transactions never reach here, and the fencing process itself is
-        // exempt so it can re-pin the revision under the lock.
-        assertHomeWritable(this.rootDir);
-        const current = this.#readState();
-        if (current.revision !== expectedRevision) {
-            throw new StorageConflictError(`Storage changed concurrently (expected revision ${expectedRevision}, found ${current.revision}).`);
-        }
-        state.revision = expectedRevision + 1;
-        const content = `${JSON.stringify(state, null, 2)}\n`;
-        parseState(content);
-        writeTextFileAtomically(join(this.rootDir, STORAGE_STATE_FILE), content);
-        if (this.#normalizeState !== undefined) {
-            // A compatible read never rewrites the Home. Its first actual mutation
-            // emits current-only state, then advances the durable manifest to the
-            // same current family versions under the existing storage write lock.
-            // A crash between the two atomic files is detected as manifest/state
-            // inconsistency on the next open; it is never silently accepted.
-            writeCurrentStorageManifest(this.rootDir);
-            this.#normalizeState = undefined;
-        }
-        // Keep the state we just wrote as the warm read cache. The atomic write
-        // produced a new fingerprint, so a concurrent external writer is still
-        // detected on the next read; our own mutations no longer re-parse the
-        // whole Home to observe state they already held under the write lock.
-        this.#readCache = {
-            fingerprint: stateFileFingerprint(join(this.rootDir, STORAGE_STATE_FILE)),
-            state
-        };
-    }
-    #parseState(raw) {
-        return parseState(this.#normalizeState?.(raw) ?? raw);
-    }
-    #withWriteLock(execute) {
-        const release = acquireStorageLock(this.rootDir);
-        try {
-            return execute();
-        }
-        finally {
-            release();
-        }
-    }
-    #requireReadableSchema() {
-        if (this.#normalizeState === undefined)
-            requireStorageSchema(this.rootDir);
-        else
-            requireCompatibleStorageSchema(this.rootDir);
-    }
-}
-/**
- * The on-disk identity of a `state.json` the store's read cache is keyed on.
- * The one-snapshot current-Home open fences its single read with the same
- * fingerprint, so a writer that changes the file between the fence and the
- * store's next read is detected exactly like a normal cache invalidation.
- */
-export function stateFileFingerprint(path) {
-    const stat = statSync(path, { bigint: true });
-    return [stat.dev, stat.ino, stat.size, stat.mtimeNs, stat.ctimeNs].join(":");
-}
 export class StorageRecordError extends Error {
     constructor(message) { super(message); this.name = "StorageRecordError"; }
 }
@@ -1929,539 +119,51 @@ function canonicalizeYuiHome(value) {
                 }
                 const parent = dirname(current);
                 if (parent === current)
-                    return absolute;
-                trailing.unshift(basename(current));
-                current = parent;
-                continue;
-            }
-            throw unstableYuiHome(absolute, realpathError);
-        }
-    }
-}
-function unstableYuiHome(path, cause) {
-    return new Error(`YUI_HOME cannot be resolved to a stable physical path: ${path}.`, { cause });
-}
-function isErrno(error, code) {
-    return error instanceof Error && "code" in error && error.code === code;
-}
-function emptyState() {
-    return {
-        schemaVersion: CURRENT_STORAGE_STATE_SCHEMA_VERSION,
-        revision: 0,
-        homeIdentity: generateHomeIdentity(new Date()),
-        config: { schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION },
-        configuredAgents: {},
-        projects: {},
-        agentProfiles: {},
-        globalRoles: {},
-        globalRoleSessionSets: {},
-        tasks: {},
-        mailboxes: {}
-    };
-}
-/** rr13: Durable map key for a Session's job caller key hash. */
-function jobCallerKeyHashKey(roleName, agentId) {
-    return `${roleName}\0${agentId}`;
-}
-function emptyStoredTask(task) {
-    return {
-        schemaVersion: CURRENT_STORED_TASK_SCHEMA_VERSION,
-        task,
-        idHighWaterMarks: emptyTaskIdHighWaterMarks(),
-        brief: null,
-        changeSets: {},
-        integrationAttempts: {},
-        integrationQueue: {},
-        durableJobs: {},
-        roles: {},
-        managedWorkspaces: {},
-        roleSessionSets: {},
-        jobCallerKeyHashes: {},
-        workItems: {},
-        contextSnapshots: {},
-        agentRuns: {},
-        reviewRounds: {},
-        activeRuns: {},
-        messages: {},
-        inputRequests: {},
-        decisions: {},
-        milestones: {},
-        events: {},
-        wakes: {},
-        capabilityGrants: {},
-        releaseWorkflows: {},
-        publicationReferences: {},
-        leaderFailure: null
-    };
-}
-function emptyTaskIdHighWaterMarks() {
-    return {
-        workItem: 0,
-        contextSnapshot: 0,
-        agentRun: 0,
-        reviewRound: 0,
-        reviewFinding: 0,
-        changeSet: 0,
-        integrationAttempt: 0,
-        integrationQueue: 0,
-        durableJob: 0,
-        message: 0,
-        inputRequest: 0,
-        decision: 0,
-        milestone: 0,
-        event: 0,
-        taskWake: 0,
-        capabilityGrant: 0,
-        releaseWorkflow: 0,
-        publicationReference: 0
-    };
-}
-function nextTaskRecordSequence(aggregate, taskId, kind) {
-    const next = aggregate.idHighWaterMarks[kind] + 1;
-    if (!Number.isSafeInteger(next)) {
-        throw new StorageRecordError(`Task ${kind} id space is exhausted: ${taskId}.`);
-    }
-    return next;
-}
-function validateTaskIdHighWaterMarks(value, taskId) {
-    const marks = object(value, `Task id high-water marks ${taskId}`);
-    const kinds = Object.keys(TASK_RECORD_ID_PREFIXES);
-    exact(marks, kinds, `Task id high-water marks ${taskId}`);
-    for (const kind of kinds) {
-        if (!Number.isSafeInteger(marks[kind]) || marks[kind] < 0) {
-            throw new StorageRecordError(`Task id high-water mark is invalid: ${taskId}/${kind}.`);
-        }
-    }
-}
-function parseState(raw) {
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new StorageRecordError(`Invalid ${STORAGE_STATE_FILE}: ${error instanceof Error ? error.message : String(error)}`);
-    }
-    const state = object(parsed, "Storage state");
-    exact(state, [
-        "schemaVersion",
-        "revision",
-        "homeIdentity",
-        "config",
-        "configuredAgents",
-        "projects",
-        "agentProfiles",
-        "globalRoles",
-        "globalRoleSessionSets",
-        "tasks",
-        "mailboxes"
-    ], "Storage state");
-    if (state.schemaVersion !== CURRENT_STORAGE_STATE_SCHEMA_VERSION || !Number.isInteger(state.revision) || state.revision < 0)
-        throw new StorageRecordError("Storage state schemaVersion/revision is invalid.");
-    const result = clone(state);
-    try {
-        result.homeIdentity = validateHomeIdentity(versioned(result.homeIdentity, CURRENT_HOME_IDENTITY_SCHEMA_VERSION, "Home identity"));
-    }
-    catch (error) {
-        throw new StorageRecordError(error instanceof Error ? error.message : String(error));
-    }
-    result.config = versioned(result.config, CURRENT_CONFIG_SCHEMA_VERSION, "Yui config");
-    validateYuiConfig(result.config);
-    parseMap(result.configuredAgents, (value, key) => {
-        const agent = identified(value, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, "id", key, "Configured Agent");
-        validateConfiguredAgent(agent);
-        return agent;
-    }, "configuredAgents");
-    parseMap(result.projects, (value, key) => {
-        const project = identified(value, CURRENT_PROJECT_SCHEMA_VERSION, "id", key, "Project");
-        validateProject(project);
-        return project;
-    }, "projects");
-    try {
-        assertProjectCatalog(Object.values(result.projects));
-    }
-    catch (error) {
-        throw new StorageRecordError(error instanceof Error ? error.message : String(error));
-    }
-    parseMap(result.agentProfiles, (value, key) => {
-        const profile = identified(value, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, "id", key, "Agent Profile");
-        validateAgentProfile(profile);
-        return profile;
-    }, "agentProfiles");
-    parseMap(result.globalRoles, (value, key) => {
-        const role = identified(value, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, "name", key, "Global Role");
-        validateGlobalRole(role);
-        return role;
-    }, "globalRoles");
-    parseMap(result.globalRoleSessionSets, (value, key) => { const set = globalSessions(value); if (set.owner.roleName !== key)
-        throw new StorageRecordError(`Global Role session set identity is inconsistent: ${key}`); return set; }, "globalRoleSessionSets");
-    parseMap(result.tasks, (value, key) => parseStoredTask(value, key), "tasks");
-    parseMap(result.mailboxes, (value, key) => {
-        let mailbox;
-        try {
-            mailbox = validateWorkMailbox(versioned(value, CURRENT_WORK_MAILBOX_SCHEMA_VERSION, "WorkMailbox"));
-        }
-        catch (error) {
-            throw new StorageRecordError(error instanceof Error ? error.message : String(error));
-        }
-        if (mailboxTargetKey(mailbox.target) !== key) {
-            throw new StorageRecordError(`WorkMailbox identity is inconsistent: ${key}`);
-        }
-        return mailbox;
-    }, "mailboxes");
-    for (const [name, role] of Object.entries(result.globalRoles)) {
-        const sessions = result.globalRoleSessionSets[name];
-        if (sessions !== undefined)
-            assertSessionsMatchRole(sessions, role);
-    }
-    for (const name of Object.keys(result.globalRoleSessionSets)) {
-        if (result.globalRoles[name] === undefined) {
-            throw new StorageRecordError(`Global Role session set has no Role: ${name}`);
-        }
-    }
-    for (const aggregate of Object.values(result.tasks)) {
-        for (const binding of aggregate.task.projectBindings) {
-            if (result.projects[binding.projectId] === undefined) {
-                throw new StorageRecordError(`Task Project not found: ${aggregate.task.id}/${binding.projectId}`);
-            }
-        }
-        for (const [name, role] of Object.entries(aggregate.roles)) {
-            const sessions = aggregate.roleSessionSets[name];
-            if (sessions !== undefined)
-                assertSessionsMatchRole(sessions, role);
-        }
-        for (const name of Object.keys(aggregate.roleSessionSets)) {
-            if (aggregate.roles[name] === undefined) {
-                throw new StorageRecordError(`Task Role session set has no Role: ${aggregate.task.id}/${name}`);
-            }
-        }
-        for (const [key, workspace] of Object.entries(aggregate.managedWorkspaces)) {
-            if (workspace.owner.taskId !== aggregate.task.id) {
-                throw new StorageRecordError(`Managed workspace belongs to another Task: ${key}`);
-            }
-            const boundProjects = new Set(aggregate.task.projectBindings.map(({ projectId }) => projectId));
-            if (workspace.entries.some(({ projectId }) => !boundProjects.has(projectId))) {
-                throw new StorageRecordError(`Managed workspace Project does not match Task: ${aggregate.task.id}/${key}`);
-            }
-            if (workspace.owner.type === "work-item"
-                && aggregate.workItems[workspace.owner.workItemId] === undefined) {
-                throw new StorageRecordError(`Managed workspace WorkItem not found: ${aggregate.task.id}/${workspace.owner.workItemId}`);
-            }
-            if (workspace.owner.type === "review-round"
-                && aggregate.reviewRounds[workspace.owner.reviewRoundId] === undefined) {
-                throw new StorageRecordError(`Managed workspace ReviewRound not found: ${aggregate.task.id}/${workspace.owner.reviewRoundId}`);
-            }
-            if (workspace.owner.type === "integration-attempt"
-                && aggregate.integrationAttempts[workspace.owner.integrationAttemptId] === undefined) {
-                throw new StorageRecordError(`Managed workspace Integration Attempt not found: ${aggregate.task.id}/${workspace.owner.integrationAttemptId}`);
-            }
-            if (workspace.owner.type === "execution-lane") {
-                const laneOwner = workspace.owner;
-                const laneItem = laneOwner.purpose === "execution"
-                    ? aggregate.workItems[laneOwner.workItemId ?? ""]
-                    : undefined;
-                const group = laneOwner.purpose === "execution"
-                    ? (laneItem === undefined
-                        ? undefined
-                        : workItemExecutionGroupById(laneItem, laneOwner.executionGroupId))
-                    : aggregate.reviewRounds[laneOwner.reviewRoundId ?? ""]?.executionGroup;
-                if (group?.id !== laneOwner.executionGroupId
-                    || !group.lanes.some(({ id }) => id === laneOwner.executionLaneId)) {
-                    throw new StorageRecordError(`Managed workspace Execution Lane not found: ${aggregate.task.id}/${key}`);
-                }
-            }
-        }
-        validateCanonicalTaskReferences(result, aggregate);
-    }
-    for (const mailbox of Object.values(result.mailboxes))
-        validateMailboxReferences(result, mailbox);
-    return result;
-}
-/** Strict current-model gate used by the compatible loader before any writer opens. */
-export function validateCurrentStorageStateSnapshot(value) {
-    parseState(`${JSON.stringify(value)}\n`);
-}
-function parseStoredTask(value, taskId) {
-    const aggregate = object(value, `Task aggregate ${taskId}`);
-    exact(aggregate, [
-        "schemaVersion",
-        "task",
-        "idHighWaterMarks",
-        "brief",
-        "changeSets",
-        "integrationAttempts",
-        "integrationQueue",
-        "durableJobs",
-        "roles",
-        "managedWorkspaces",
-        "roleSessionSets",
-        "jobCallerKeyHashes",
-        "workItems",
-        "contextSnapshots",
-        "agentRuns",
-        "reviewRounds",
-        "activeRuns",
-        "messages",
-        "inputRequests",
-        "decisions",
-        "milestones",
-        "events",
-        "wakes",
-        "capabilityGrants",
-        "releaseWorkflows",
-        "publicationReferences",
-        "leaderFailure"
-    ], `Task aggregate ${taskId}`);
-    parseMap(aggregate.changeSets, (record, key) => {
-        const changeSet = identifiedChangeSet(record, key);
-        if (changeSet.taskId !== taskId) {
-            throw new StorageRecordError(`ChangeSet belongs to another Task: ${changeSet.taskId}.`);
-        }
-        validateChangeSet(changeSet);
-        return changeSet;
-    }, "changeSets");
-    parseMap(aggregate.integrationAttempts, (record, key) => {
-        const attempt = identified(record, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, "id", key, "Integration Attempt");
-        if (attempt.taskId !== taskId) {
-            throw new StorageRecordError(`Integration Attempt belongs to another Task: ${attempt.taskId}.`);
-        }
-        validateIntegrationAttempt(attempt);
-        return attempt;
-    }, "integrationAttempts");
-    parseMap(aggregate.integrationQueue, (record, key) => {
-        const entry = identified(record, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, "id", key, "Integration queue entry");
-        if (entry.taskId !== taskId) {
-            throw new StorageRecordError(`Integration queue entry belongs to another Task: ${entry.taskId}.`);
-        }
-        if (aggregate.changeSets[entry.changeSetId] === undefined) {
-            throw new StorageRecordError(`Integration queue entry ChangeSet not found: ${entry.changeSetId}.`);
-        }
-        validateIntegrationQueueEntry(entry);
-        return entry;
-    }, "integrationQueue");
-    parseMap(aggregate.durableJobs, (record, key) => {
-        const job = identified(record, CURRENT_DURABLE_JOB_SCHEMA_VERSION, "id", key, "DurableJob");
-        if (job.taskId !== taskId) {
-            throw new StorageRecordError(`DurableJob belongs to another Task: ${job.taskId}.`);
-        }
-        validateDurableJob(job);
-        return job;
-    }, "durableJobs");
-    versioned(aggregate, CURRENT_STORED_TASK_SCHEMA_VERSION, `Task aggregate ${taskId}`);
-    validateTaskIdHighWaterMarks(aggregate.idHighWaterMarks, taskId);
-    validateTask(identified(aggregate.task, CURRENT_TASK_SCHEMA_VERSION, "id", taskId, "Task"));
-    if (aggregate.brief !== null)
-        storedTaskBrief(aggregate.brief);
-    parseMap(aggregate.roles, (record, key) => {
-        const role = identified(record, CURRENT_TASK_ROLE_SCHEMA_VERSION, "name", key, "Task Role");
-        if (role.taskId !== taskId)
-            throw new StorageRecordError(`Task Role belongs to another Task: ${role.taskId}`);
-        validateTaskRole(role);
-        return role;
-    }, "roles");
-    parseMap(aggregate.managedWorkspaces, (record, key) => {
-        const workspace = versioned(record, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, "Managed workspace");
-        validateManagedWorkspace(workspace);
-        if (workspace.owner.taskId !== taskId) {
-            throw new StorageRecordError(`Managed workspace belongs to another Task: ${workspace.owner.taskId}`);
-        }
-        if (managedWorkspaceKey(workspace.owner) !== key) {
-            throw new StorageRecordError(`Managed workspace identity is inconsistent: ${taskId}/${key}`);
-        }
-        return workspace;
-    }, "managedWorkspaces");
-    parseMap(aggregate.roleSessionSets, (record, key) => { const set = taskSessions(record); if (set.owner.taskId !== taskId || set.owner.roleName !== key)
-        throw new StorageRecordError(`Task Role session set identity is inconsistent: ${taskId}/${key}`); return set; }, "roleSessionSets");
-    parseMap(aggregate.jobCallerKeyHashes, (hash, key) => {
-        if (typeof hash !== "string" || !/^[a-f0-9]{64}$/u.test(hash)) {
-            throw new StorageRecordError(`Job caller key hash is invalid: ${taskId}/${key}.`);
-        }
-        return hash;
-    }, "jobCallerKeyHashes");
-    parseMap(aggregate.workItems, (record, key) => {
-        const item = identified(record, CURRENT_WORK_ITEM_SCHEMA_VERSION, "id", key, "Work item");
-        if (item.taskId !== taskId) {
-            throw new StorageRecordError(`Work item belongs to another Task: ${item.taskId}`);
-        }
-        validateWorkItem(item);
-        return item;
-    }, "workItems");
-    parseMap(aggregate.contextSnapshots, (record, key) => {
-        const snapshot = identified(record, CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, "id", key, "Context Snapshot");
-        if (snapshot.taskId !== taskId) {
-            throw new StorageRecordError(`Context Snapshot belongs to another Task: ${snapshot.taskId}.`);
-        }
-        validateContextSnapshot(snapshot);
-        return snapshot;
-    }, "contextSnapshots");
-    parseMap(aggregate.agentRuns, (record, key) => {
-        const run = identified(record, CURRENT_AGENT_RUN_SCHEMA_VERSION, "id", key, "Agent run");
-        if (run.taskId !== taskId) {
-            throw new StorageRecordError(`Agent run belongs to another Task: ${run.taskId}`);
-        }
-        validateAgentRun(run);
-        return run;
-    }, "agentRuns");
-    parseMap(aggregate.reviewRounds, (record, key) => {
-        const round = identified(record, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, "id", key, "ReviewRound");
-        if (round.taskId !== taskId) {
-            throw new StorageRecordError(`ReviewRound belongs to another Task: ${round.taskId}.`);
-        }
-        validateReviewRound(round);
-        return round;
-    }, "reviewRounds");
-    parseMap(aggregate.activeRuns, (record, key) => {
-        const pointer = versioned(record, CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION, `Active run ${key}`);
-        const run = typeof pointer.runId === "string" ? aggregate.agentRuns[pointer.runId] : undefined;
-        const laneMatch = executionLaneActiveRunKeyParts(key);
-        const validLanePointer = laneMatch !== null
-            && run !== undefined
-            && run.executionGroupId === laneMatch.executionGroupId
-            && run.executionLaneId === laneMatch.executionLaneId;
-        const validRolePointer = laneMatch === null
-            && run !== undefined
-            && run.roleName === key;
-        if (run === undefined || run.status !== "active"
-            || (!validLanePointer && !validRolePointer)) {
-            throw new StorageRecordError(`Active run pointer is invalid: ${taskId}/${key}`);
-        }
-        return pointer;
-    }, "activeRuns");
-    parseMap(aggregate.messages, (record, key) => {
-        const message = identified(record, CURRENT_MESSAGE_SCHEMA_VERSION, "id", key, "Message");
-        if (message.taskId !== taskId) {
-            throw new StorageRecordError(`Message belongs to another Task: ${message.taskId}`);
-        }
-        validateTaskMessage(message);
-        return message;
-    }, "messages");
-    parseMap(aggregate.inputRequests, (record, key) => {
-        const request = validateInputRequest(versioned(record, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, "Input request"));
-        if (request.id !== key) {
-            throw new StorageRecordError(`Input request identity is inconsistent: ${key}.`);
-        }
-        if (request.taskId !== taskId) {
-            throw new StorageRecordError(`Input request belongs to another Task: ${request.taskId}`);
-        }
-        return request;
-    }, "inputRequests");
-    parseMap(aggregate.decisions, (record, key) => {
-        const decision = storedDecision(record);
-        if (decision.id !== key)
-            throw new StorageRecordError(`Decision identity is inconsistent: ${key}.`);
-        if (decision.taskId !== taskId) {
-            throw new StorageRecordError(`Decision belongs to another Task: ${decision.taskId}`);
-        }
-        return decision;
-    }, "decisions");
-    parseMap(aggregate.milestones, (record, key) => {
-        const milestone = storedMilestone(record);
-        if (milestone.id !== key)
-            throw new StorageRecordError(`Milestone identity is inconsistent: ${key}.`);
-        if (milestone.taskId !== taskId) {
-            throw new StorageRecordError(`Milestone belongs to another Task: ${milestone.taskId}`);
-        }
-        return milestone;
-    }, "milestones");
-    parseMap(aggregate.events, (record, key) => {
-        const event = storedTaskEvent(record);
-        if (event.id !== key)
-            throw new StorageRecordError(`Task event identity is inconsistent: ${key}.`);
-        if (event.taskId !== taskId) {
-            throw new StorageRecordError(`Task event belongs to another Task: ${event.taskId}`);
-        }
-        return event;
-    }, "events");
-    parseMap(aggregate.wakes, (record, key) => {
-        const wake = identified(record, CURRENT_TASK_WAKE_SCHEMA_VERSION, "id", key, "Task wake");
-        if (wake.taskId !== taskId) {
-            throw new StorageRecordError(`Task wake belongs to another Task: ${wake.taskId}`);
-        }
-        validateTaskWake(wake);
-        return wake;
-    }, "wakes");
-    parseMap(aggregate.capabilityGrants, (record, key) => {
-        const grant = storedCapabilityGrant(record);
-        if (grant.id !== key) {
-            throw new StorageRecordError(`Capability grant identity is inconsistent: ${key}.`);
-        }
-        if (grant.taskId !== taskId) {
-            throw new StorageRecordError(`Capability grant belongs to another Task: ${grant.taskId}`);
-        }
-        return grant;
-    }, "capabilityGrants");
-    parseMap(aggregate.releaseWorkflows, (record, key) => {
-        const workflow = storedReleaseWorkflow(record);
-        if (workflow.id !== key) {
-            throw new StorageRecordError(`Release workflow identity is inconsistent: ${key}.`);
-        }
-        if (workflow.taskId !== taskId) {
-            throw new StorageRecordError(`Release workflow belongs to another Task: ${workflow.taskId}`);
-        }
-        return workflow;
-    }, "releaseWorkflows");
-    parseMap(aggregate.publicationReferences, (record, key) => {
-        const reference = storedPublicationReference(record);
-        if (reference.id !== key) {
-            throw new StorageRecordError(`Publication reference identity is inconsistent: ${key}.`);
-        }
-        if (reference.taskId !== taskId) {
-            throw new StorageRecordError(`Publication reference belongs to another Task: ${reference.taskId}`);
-        }
-        return reference;
-    }, "publicationReferences");
-    if (aggregate.leaderFailure !== null) {
-        identified(aggregate.leaderFailure, CURRENT_LEADER_FAILURE_SCHEMA_VERSION, "taskId", taskId, "Leader failure");
-    }
-    validateTaskIdHighWaterCoverage(aggregate, taskId);
-    return aggregate;
-}
-function validateTaskIdHighWaterCoverage(aggregate, taskId) {
-    const records = {
-        workItem: aggregate.workItems,
-        contextSnapshot: aggregate.contextSnapshots,
-        agentRun: aggregate.agentRuns,
-        reviewRound: aggregate.reviewRounds,
-        // Issue 06 dbonly: review findings are SQLite-native; the file aggregate
-        // never carries them, so coverage is trivially empty.
-        reviewFinding: {},
-        changeSet: aggregate.changeSets,
-        integrationAttempt: aggregate.integrationAttempts,
-        integrationQueue: aggregate.integrationQueue,
-        durableJob: aggregate.durableJobs,
-        message: aggregate.messages,
-        inputRequest: aggregate.inputRequests,
-        decision: aggregate.decisions,
-        milestone: aggregate.milestones,
-        event: aggregate.events,
-        taskWake: aggregate.wakes,
-        capabilityGrant: aggregate.capabilityGrants,
-        releaseWorkflow: aggregate.releaseWorkflows,
-        publicationReference: aggregate.publicationReferences
-    };
-    for (const kind of Object.keys(TASK_RECORD_ID_PREFIXES)) {
-        const pattern = new RegExp(`^${TASK_RECORD_ID_PREFIXES[kind]}-(\\d+)$`);
-        for (const id of Object.keys(records[kind])) {
-            const match = pattern.exec(id);
-            if (match === null) {
-                throw new StorageRecordError(`Task-local ${kind} id is invalid: ${taskId}/${id}.`);
-            }
-            const sequence = Number.parseInt(match[1], 10);
-            if (sequence > aggregate.idHighWaterMarks[kind]) {
-                throw new StorageRecordError(`Task id high-water mark is behind ${taskId}/${kind}: ${id}.`);
+                    return absolute;
+                trailing.unshift(basename(current));
+                current = parent;
+                continue;
             }
+            throw unstableYuiHome(absolute, realpathError);
         }
     }
 }
-function observeTaskRecordId(aggregate, kind, id) {
-    validateTaskRecordReference({ taskId: aggregate.task.id, localId: id }, kind);
-    const match = new RegExp(`^${TASK_RECORD_ID_PREFIXES[kind]}-(\\d+)$`).exec(id);
-    if (match === null)
-        throw new StorageRecordError(`Task-local ${kind} id is invalid: ${id}.`);
-    const sequence = Number.parseInt(match[1], 10);
-    aggregate.idHighWaterMarks[kind] = Math.max(aggregate.idHighWaterMarks[kind], sequence);
+function unstableYuiHome(path, cause) {
+    return new Error(`YUI_HOME cannot be resolved to a stable physical path: ${path}.`, { cause });
+}
+function isErrno(error, code) {
+    return error instanceof Error && "code" in error && error.code === code;
 }
 export function validateYuiConfig(config) {
     try {
+        const optionalFields = [
+            "defaultAgent",
+            "defaultWorkspace",
+            "timeZone",
+            "currentTaskId",
+            "lastTaskId",
+            "reconciliationIntervalSeconds",
+            "resourcesGcMode",
+            "resourcesGcAutoQuarantine",
+            "review",
+            "leaderNextActionMode",
+            "runtimeHealth",
+            "controllerTaskConcurrency",
+            "agentLaunchInactivityTimeoutSeconds",
+            "deliveryTimeoutSeconds",
+            "leaderSemanticBudgetTurns",
+            "resourcesQuarantineTtlHours",
+            "tmuxBin",
+            "tmuxHistoryLimit",
+            "telemetryEnabled",
+            "telemetryTerminalKeep",
+            "telemetryTurnCap",
+            "completionInstallations"
+        ];
+        exact(config, [
+            "schemaVersion",
+            ...optionalFields.filter((field) => config[field] !== undefined)
+        ], "Yui config");
         if (config.schemaVersion !== CURRENT_CONFIG_SCHEMA_VERSION) {
             throw new TypeError(`Yui config must use schemaVersion ${CURRENT_CONFIG_SCHEMA_VERSION}.`);
         }
@@ -2470,7 +172,6 @@ export function validateYuiConfig(config) {
         if (config.review !== undefined)
             validateReviewConfig(config.review);
         resolveLeaderNextActionMode(config.leaderNextActionMode);
-        resolveContextBudget(config.contextBudget);
         resolveResourcesGcMode(config.resourcesGcMode);
         resolveResourcesGcAutoQuarantine(config.resourcesGcAutoQuarantine);
         resolveResourcesQuarantineTtlHours(config.resourcesQuarantineTtlHours);
@@ -2483,161 +184,23 @@ export function validateYuiConfig(config) {
         resolveTmuxHistoryLimit(config.tmuxHistoryLimit);
         resolveTelemetryEnabled(config.telemetryEnabled);
         resolveTelemetryTerminalKeep(config.telemetryTerminalKeep);
-        resolveTelemetryRunCap(config.telemetryRunCap);
+        resolveTelemetryTurnCap(config.telemetryTurnCap);
     }
     catch (error) {
         throw new StorageRecordError(error instanceof Error ? error.message : "Yui reconciliation interval is invalid.");
     }
 }
-function globalSessions(value) {
-    const set = versioned(value, CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION, "Global Role session set");
-    if (set.owner?.scope !== "global" || typeof set.owner.roleName !== "string")
-        throw new StorageRecordError("Global Role session owner is invalid.");
-    validateSessions(set.sessions);
-    validateRoleSessionSet(set);
-    return set;
-}
-function taskSessions(value) {
-    const set = versioned(value, CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, "Task Role session set");
-    if (set.owner?.scope !== "task" || typeof set.owner.taskId !== "string" || typeof set.owner.roleName !== "string")
-        throw new StorageRecordError("Task Role session owner is invalid.");
-    validateSessions(set.sessions);
-    validateRoleSessionSet(set);
-    return set;
-}
-function validateSessions(sessions) {
-    parseMap(sessions, (record, key) => identified(record, CURRENT_ROLE_AGENT_SESSION_SCHEMA_VERSION, "agentId", key, "Role Agent session"), "sessions");
-}
-function assertSessionsMatchRole(sessions, role) {
-    validateRoleSessionSet(sessions);
-    if (sessions.owner.roleName !== role.name) {
-        throw new StorageRecordError(`Role session set does not match Role: ${role.name}`);
-    }
-    if ("taskId" in role && (sessions.owner.scope !== "task" || sessions.owner.taskId !== role.taskId)) {
-        throw new StorageRecordError(`Task Role session owner is inconsistent: ${role.taskId}/${role.name}`);
-    }
-    if (!("taskId" in role) && sessions.owner.scope !== "global") {
-        throw new StorageRecordError(`Global Role session owner is inconsistent: ${role.name}`);
-    }
-    const ownedSessions = [
-        ...Object.entries(sessions.sessions),
-        ...(sessions.owner.scope === "global"
-            ? Object.entries(sessions.history ?? {})
-            : [
-                ...(sessions.history ?? []).map((session, index) => [`history-${index}`, session])
-            ])
-    ];
-    for (const [, session] of ownedSessions) {
-        const agentId = session.agentId;
-        const binding = role.agentBindings[agentId];
-        if (binding === undefined || binding.adapterId !== session.adapterId) {
-            throw new StorageRecordError(`Role Agent session has no matching binding: ${role.name}/${agentId}`);
-        }
-    }
-}
-function storedTaskBrief(value) {
-    const brief = versioned(value, CURRENT_TASK_BRIEF_SCHEMA_VERSION, "Task Brief");
-    exact(brief, [
-        "schemaVersion",
-        "objective",
-        "boundaries",
-        "technicalApproach",
-        "currentFocus",
-        "leaderSummary",
-        "updatedAt",
-        "updatedBy"
-    ], "Task Brief");
-    requireNormalizedText(brief.objective, "Task Brief objective");
-    requireOptionalNormalizedText(brief.technicalApproach, "Task Brief technical approach");
-    requireNormalizedText(brief.currentFocus, "Task Brief current focus");
-    requireNormalizedText(brief.leaderSummary, "Task Brief leader summary");
-    requireNormalizedText(brief.updatedBy, "Task Brief updatedBy");
-    if (!Array.isArray(brief.boundaries)) {
-        throw new StorageRecordError("Task Brief boundaries must be an array.");
-    }
-    const boundaries = brief.boundaries.map((boundary) => (requireNormalizedText(boundary, "Task Brief boundary")));
-    if (new Set(boundaries).size !== boundaries.length) {
-        throw new StorageRecordError("Task Brief boundaries must be unique.");
-    }
-    requireTimestamp(brief.updatedAt, "Task Brief updatedAt");
-    return brief;
-}
-function storedDecision(value) {
-    const decision = versioned(value, CURRENT_DECISION_SCHEMA_VERSION, "Decision");
-    const baseFields = [
-        "schemaVersion", "id", "taskId", "title", "rationale", "status", "createdAt", "updatedAt"
-    ];
-    if (decision.status === "active") {
-        exact(decision, baseFields, "Decision");
-    }
-    else if (decision.status === "superseded") {
-        exact(decision, [...baseFields, "supersededReason", "supersededAt"], "Decision");
-        requireNormalizedText(decision.supersededReason, "Decision supersededReason");
-        requireTimestamp(decision.supersededAt, "Decision supersededAt");
-        if (decision.supersededAt !== decision.updatedAt) {
-            throw new StorageRecordError("Decision supersededAt must match updatedAt.");
-        }
-    }
-    else {
-        throw new StorageRecordError(`Decision status is invalid: ${String(decision.status)}.`);
-    }
-    requireRecordIdentity(decision.id, "Decision id");
-    requireRecordIdentity(decision.taskId, "Decision Task id");
-    validateTaskRecordReference({ taskId: decision.taskId, localId: decision.id }, "decision");
-    requireNormalizedText(decision.title, "Decision title");
-    requireNormalizedText(decision.rationale, "Decision rationale");
-    requireTimestamp(decision.createdAt, "Decision createdAt");
-    requireTimestamp(decision.updatedAt, "Decision updatedAt");
-    if (Date.parse(decision.updatedAt) < Date.parse(decision.createdAt)) {
-        throw new StorageRecordError("Decision updatedAt cannot precede createdAt.");
-    }
-    return decision;
-}
-function storedMilestone(value) {
-    const milestone = versioned(value, CURRENT_MILESTONE_SCHEMA_VERSION, "Milestone");
-    exact(milestone, ["schemaVersion", "id", "taskId", "title", "summary", "createdBy", "createdAt"], "Milestone");
-    requireRecordIdentity(milestone.id, "Milestone id");
-    requireRecordIdentity(milestone.taskId, "Milestone Task id");
-    validateTaskRecordReference({ taskId: milestone.taskId, localId: milestone.id }, "milestone");
-    requireNormalizedText(milestone.title, "Milestone title");
-    requireNormalizedText(milestone.summary, "Milestone summary");
-    if (milestone.createdBy !== "user"
-        && milestone.createdBy !== "operator"
-        && milestone.createdBy !== "leader") {
-        throw new StorageRecordError("Milestone createdBy is invalid.");
-    }
-    requireTimestamp(milestone.createdAt, "Milestone createdAt");
-    return milestone;
-}
-function storedTaskEvent(value) {
-    const event = versioned(value, CURRENT_EVENT_SCHEMA_VERSION, "Task event");
-    exact(event, ["schemaVersion", "id", "taskId", "type", "payload", "createdAt"], "Task event");
-    requireRecordIdentity(event.id, "Task event id");
-    requireRecordIdentity(event.taskId, "Task event Task id");
-    validateTaskRecordReference({ taskId: event.taskId, localId: event.id }, "event");
-    requireNormalizedText(event.type, "Task event type");
-    const payload = object(event.payload, "Task event payload");
-    for (const [key, payloadValue] of Object.entries(payload)) {
-        requireRecordIdentity(key, "Task event payload key");
-        if (typeof payloadValue !== "string" || payloadValue.includes("\0")) {
-            throw new StorageRecordError(`Task event payload value is invalid: ${key}.`);
-        }
-    }
-    requireTimestamp(event.createdAt, "Task event createdAt");
-    return event;
-}
 export function storedCapabilityGrant(value) {
     const grant = versioned(value, CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, "Capability grant");
     const fields = [
         "schemaVersion", "id", "taskId", "granter", "scope", "actions",
-        "parameterBounds", "usesUsed", "irreversibilityCeiling", "createdAt", "updatedAt"
+        "parameterBounds", "usesUsed", "useReservations", "irreversibilityCeiling",
+        "createdAt", "updatedAt"
     ];
     if (grant.expiresAt !== undefined)
         fields.push("expiresAt");
     if (grant.maxUses !== undefined)
         fields.push("maxUses");
-    if (grant.useReservations !== undefined)
-        fields.push("useReservations");
     if (grant.revokedAt !== undefined)
         fields.push("revokedAt");
     if (grant.revokedBy !== undefined)
@@ -2788,9 +351,9 @@ export function isValidCapabilityGrantTransition(existing, candidate) {
         && Date.parse(candidate.updatedAt) >= Date.parse(existing.updatedAt);
 }
 function reservationsAppendOnly(existing, candidate) {
-    if (existing === undefined || existing.length === 0)
+    if (existing.length === 0)
         return true;
-    if (candidate === undefined || candidate.length < existing.length)
+    if (candidate.length < existing.length)
         return false;
     return existing.every((key, index) => candidate[index] === key);
 }
@@ -2935,28 +498,6 @@ export function storedPublicationReference(value) {
         throw new StorageRecordError(error instanceof Error ? error.message : String(error));
     }
 }
-function latestPublicationReference(references) {
-    const byId = new Map(references.map((reference) => [reference.id, reference]));
-    const superseded = new Set(references
-        .map((reference) => reference.supersedes)
-        .filter((id) => id !== undefined));
-    const roots = references.filter((reference) => !superseded.has(reference.id));
-    const latest = roots.length === 1 ? roots[0] : [...byId.values()].sort((left, right) => (right.id.localeCompare(left.id, undefined, { numeric: true })))[0];
-    let current = latest;
-    const seen = new Set();
-    while (current.supersedes !== undefined) {
-        if (seen.has(current.id)) {
-            throw new StorageRecordError(`Publication supersession cycle at ${current.id}.`);
-        }
-        seen.add(current.id);
-        const previous = byId.get(current.supersedes);
-        if (previous === undefined) {
-            throw new StorageRecordError(`Publication supersession target not found: ${current.id}/${current.supersedes}.`);
-        }
-        current = previous;
-    }
-    return latest;
-}
 function storedReleaseWorkflowSource(source) {
     const value = object(source, "Release workflow source");
     const sourceFields = ["repository", "commit"];
@@ -3087,35 +628,6 @@ function isLegalStepTransition(from, to) {
         return true;
     return LEGAL_STEP_TRANSITIONS[from]?.includes(to) ?? false;
 }
-function isValidDecisionSupersession(existing, candidate) {
-    return existing.status === "active"
-        && candidate.status === "superseded"
-        && candidate.id === existing.id
-        && candidate.taskId === existing.taskId
-        && candidate.title === existing.title
-        && candidate.rationale === existing.rationale
-        && candidate.createdAt === existing.createdAt
-        && Date.parse(candidate.updatedAt) >= Date.parse(existing.updatedAt);
-}
-function isValidInputRequestTransition(existing, candidate) {
-    if (existing.status !== "open" || candidate.status === "open")
-        return false;
-    return candidate.id === existing.id
-        && candidate.taskId === existing.taskId
-        && isDeepStrictEqual(candidate.requester, existing.requester)
-        && candidate.question === existing.question
-        && isDeepStrictEqual(candidate.choices, existing.choices)
-        && isDeepStrictEqual(candidate.blockedRefs, existing.blockedRefs)
-        && isDeepStrictEqual(candidate.policy, existing.policy)
-        && candidate.createdAt === existing.createdAt
-        && Date.parse(candidate.updatedAt) >= Date.parse(existing.updatedAt);
-}
-function requireTaskFromState(state, taskId) {
-    const aggregate = state.tasks[taskId];
-    if (aggregate === undefined)
-        throw new StorageRecordError(`Task not found: ${taskId}`);
-    return aggregate;
-}
 function requireRecordIdentity(value, label) {
     const normalized = requireNormalizedText(value, label);
     if (["__proto__", "prototype", "constructor", ".", ".."].includes(normalized)
@@ -3135,26 +647,12 @@ function requireNormalizedText(value, label) {
         throw new StorageRecordError(`${label} must be normalized.`);
     return normalized;
 }
-function requireOptionalNormalizedText(value, label) {
-    if (typeof value !== "string" || value.includes("\0")) {
-        throw new StorageRecordError(`${label} is invalid.`);
-    }
-    const normalized = value.trim();
-    if (normalized !== value)
-        throw new StorageRecordError(`${label} must be normalized.`);
-    return normalized;
-}
 function requireTimestamp(value, label) {
     if (typeof value !== "string" || !Number.isFinite(Date.parse(value))) {
         throw new StorageRecordError(`${label} is invalid.`);
     }
     return value;
 }
-function parseMap(value, parse, label) {
-    const records = object(value, label);
-    for (const [key, entry] of Object.entries(records))
-        parse(entry, key);
-}
 function versioned(value, schemaVersion, label) {
     assertJsonValue(value, label);
     const record = object(value, label);
@@ -3162,15 +660,6 @@ function versioned(value, schemaVersion, label) {
         throw new StorageRecordError(`${label} must use schemaVersion ${schemaVersion}.`);
     return clone(record);
 }
-function identified(value, schemaVersion, key, expected, label) {
-    const record = versioned(value, schemaVersion, label);
-    if (record[key] !== expected)
-        throw new StorageRecordError(`${label} identity is inconsistent: ${expected}.`);
-    return record;
-}
-function identifiedChangeSet(value, expectedId) {
-    return identified(value, CURRENT_CHANGE_SET_SCHEMA_VERSION, "id", expectedId, "ChangeSet");
-}
 function object(value, label) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         throw new StorageRecordError(`${label} must be an object.`);
@@ -3207,13 +696,10 @@ function assertJsonValue(value, label, seen = new Set()) {
     seen.delete(value);
 }
 function clone(value) { assertJsonValue(value, "Stored value"); return JSON.parse(JSON.stringify(value)); }
-function optional(value) { return value === undefined ? null : clone(value); }
-function values(records, identity) {
-    return Object.values(records).map(clone).sort((left, right) => numericCompare(typeof identity === "function" ? identity(left) : String(left[identity]), typeof identity === "function" ? identity(right) : String(right[identity])));
-}
-function numericCompare(left, right) { return left.localeCompare(right, undefined, { numeric: true }); }
 export function pendingWakeupProjection(mailbox) {
-    const pending = mailbox === null ? null : pendingLane(mailbox, "normal");
+    const pending = mailbox?.processing?.owner.startsWith("leader-steer:") === true
+        ? mailbox.processing.batch
+        : mailbox?.pending ?? null;
     if (mailbox === null || mailbox.target.kind !== "role" || mailbox.target.roleName !== "leader"
         || pending === null) {
         return null;
@@ -3227,841 +713,3 @@ export function pendingWakeupProjection(mailbox) {
         lastRequestedAt: pending.lastQueuedAt
     };
 }
-function validateMailboxReferences(state, mailbox) {
-    if (mailbox.target.kind === "task"
-        || mailbox.target.kind === "role"
-        || mailbox.target.kind === "role-runtime") {
-        const aggregate = state.tasks[mailbox.target.taskId];
-        if (aggregate === undefined) {
-            throw new StorageRecordError(`WorkMailbox target Task not found: ${mailbox.target.taskId}`);
-        }
-        if (mailbox.target.kind === "role" && aggregate.roles[mailbox.target.roleName] === undefined) {
-            throw new StorageRecordError(`WorkMailbox target Role not found: ${mailbox.target.taskId}/${mailbox.target.roleName}`);
-        }
-    }
-    const refs = [];
-    if (mailbox.processing !== null) {
-        if (mailbox.processing.executionRef !== undefined)
-            refs.push(mailbox.processing.executionRef);
-    }
-    for (const batch of mailboxBatches(mailbox))
-        refs.push(...batch.refs);
-    for (const ref of refs) {
-        if (!mailboxReferenceExists(state, ref)) {
-            const identity = "taskId" in ref ? `${ref.taskId}/${ref.id}` : ref.id;
-            throw new StorageRecordError(`WorkMailbox reference does not exist: ${ref.type}/${identity}`);
-        }
-    }
-}
-function validateCanonicalTaskReferences(state, aggregate) {
-    const taskId = aggregate.task.id;
-    if (aggregate.task.replacementTaskId !== undefined) {
-        const replacement = state.tasks[aggregate.task.replacementTaskId];
-        if (replacement === undefined || replacement.task.id === taskId) {
-            throw new StorageRecordError(`Replacement Task reference is invalid: ${taskId}/${aggregate.task.replacementTaskId}.`);
-        }
-    }
-    const boundProjects = new Set(aggregate.task.projectBindings.map(({ projectId }) => projectId));
-    assertAcyclicWorkItems(aggregate.workItems);
-    for (const item of Object.values(aggregate.workItems)) {
-        for (const dependencyId of item.dependsOn) {
-            if (aggregate.workItems[dependencyId] === undefined) {
-                throw new StorageRecordError(`Work Item dependency not found: ${taskId}/${dependencyId}.`);
-            }
-        }
-        if (item.writeProjectIds.some((projectId) => !boundProjects.has(projectId))) {
-            throw new StorageRecordError(`Work Item writable Project does not belong to Task: ${taskId}/${item.id}.`);
-        }
-        const writableProjects = new Set(item.writeProjectIds);
-        if (item.baseRefs?.some(({ projectId }) => !boundProjects.has(projectId))) {
-            throw new StorageRecordError(`Work Item base-ref Project does not belong to Task: ${taskId}/${item.id}.`);
-        }
-        if (item.baseRefs?.some(({ projectId }) => !writableProjects.has(projectId))) {
-            throw new StorageRecordError(`Work Item base-ref Project must be writable: ${taskId}/${item.id}.`);
-        }
-        const replacementWorkItemId = item.disposition?.replacementWorkItemId;
-        if (replacementWorkItemId !== undefined) {
-            if (replacementWorkItemId === item.id) {
-                throw new StorageRecordError(`Work Item cannot replace itself: ${taskId}/${item.id}.`);
-            }
-            const replacement = aggregate.workItems[replacementWorkItemId];
-            if (replacement === undefined || replacement.taskId !== taskId) {
-                throw new StorageRecordError(`Replacement Work Item must belong to the same Task: ${taskId}/${replacementWorkItemId}.`);
-            }
-        }
-        for (const candidate of item.candidates) {
-            assertWorkItemCandidateReferences(aggregate, item, candidate, `Work Item candidate ${item.id}`);
-        }
-    }
-    for (const workspace of Object.values(aggregate.managedWorkspaces)) {
-        if (workspace.owner.type === "work-item"
-            && aggregate.workItems[workspace.owner.workItemId] === undefined) {
-            throw new StorageRecordError(`Managed workspace Work Item not found: ${taskId}/${workspace.owner.workItemId}.`);
-        }
-        if (workspace.owner.type === "review-round") {
-            const round = aggregate.reviewRounds[workspace.owner.reviewRoundId];
-            if (round === undefined) {
-                throw new StorageRecordError(`Managed workspace ReviewRound is invalid: ${taskId}/${workspace.owner.reviewRoundId}.`);
-            }
-        }
-    }
-    for (const [roleName, sessions] of Object.entries(aggregate.roleSessionSets)) {
-        if (sessions.inFlight !== null) {
-            const run = aggregate.agentRuns[sessions.inFlight.runId];
-            if (run === undefined || run.roleName !== roleName
-                || sessions.inFlight.receiptId !== agentRunDeliveryReceiptId(run)) {
-                throw new StorageRecordError(`Task Role in-flight Run is invalid: ${taskId}/${roleName}.`);
-            }
-        }
-    }
-    for (const run of Object.values(aggregate.agentRuns)) {
-        if (run.workItemId !== undefined && aggregate.workItems[run.workItemId] === undefined) {
-            throw new StorageRecordError(`Agent Run Work Item not found: ${taskId}/${run.id}.`);
-        }
-        if (run.reviewRoundId !== undefined
-            && aggregate.reviewRounds[run.reviewRoundId] === undefined) {
-            throw new StorageRecordError(`Agent Run ReviewRound not found: ${taskId}/${run.id}.`);
-        }
-        assertAgentRunExecutionReferences(aggregate, run);
-    }
-    for (const message of Object.values(aggregate.messages)) {
-        if (message.runId !== undefined && aggregate.agentRuns[message.runId] === undefined) {
-            throw new StorageRecordError(`Message Run not found: ${taskId}/${message.id}.`);
-        }
-        if (message.workItemId !== undefined
-            && aggregate.workItems[message.workItemId] === undefined) {
-            throw new StorageRecordError(`Message Work Item not found: ${taskId}/${message.id}.`);
-        }
-    }
-    for (const request of Object.values(aggregate.inputRequests)) {
-        if (aggregate.agentRuns[request.requester.runId] === undefined) {
-            throw new StorageRecordError(`Input requester Run not found: ${taskId}/${request.id}.`);
-        }
-        for (const reference of request.blockedRefs) {
-            const found = reference.type === "run"
-                ? aggregate.agentRuns[reference.id]
-                : aggregate.workItems[reference.id];
-            if (found === undefined) {
-                throw new StorageRecordError(`Input blocked ${reference.type} not found: ${taskId}/${request.id}/${reference.id}.`);
-            }
-        }
-    }
-    for (const round of Object.values(aggregate.reviewRounds)) {
-        if ((round.scope ?? "work-item") === "task") {
-            const frozenProjects = round.taskCandidate?.projects ?? [];
-            if (frozenProjects.length !== boundProjects.size
-                || frozenProjects.some(({ projectId }) => !boundProjects.has(projectId))) {
-                throw new StorageRecordError(`Task ReviewRound Projects do not match Task scope: ${round.id}.`);
-            }
-        }
-        else {
-            const item = aggregate.workItems[round.workItemId];
-            if (item === undefined) {
-                throw new StorageRecordError(`ReviewRound references are invalid: ${round.id}.`);
-            }
-            const candidate = item.candidates.find(({ id }) => id === round.candidateId);
-            if (candidate === undefined) {
-                throw new StorageRecordError(`ReviewRound Candidate not found: ${round.candidateId}.`);
-            }
-            assertWorkItemCandidateReferences(aggregate, item, candidate, `ReviewRound candidate ${round.id}`);
-        }
-        if (round.reviewerRunId !== undefined) {
-            const reviewerRun = aggregate.agentRuns[round.reviewerRunId];
-            if (reviewerRun === undefined
-                || reviewerRun.reviewRoundId !== round.id
-                || reviewerRun.purpose !== "review") {
-                throw new StorageRecordError(`ReviewRound Reviewer Run is invalid: ${round.id}.`);
-            }
-        }
-    }
-    for (const changeSet of Object.values(aggregate.changeSets)) {
-        if (aggregate.workItems[changeSet.workItemId] === undefined) {
-            throw new StorageRecordError(`ChangeSet Work Item not found: ${changeSet.id}.`);
-        }
-        if (!aggregate.task.projectBindings.some(({ projectId }) => projectId === changeSet.projectId)) {
-            throw new StorageRecordError(`ChangeSet Project does not match Task: ${changeSet.id}.`);
-        }
-        const evidenceRound = Object.values(aggregate.reviewRounds).find(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit && evidenceCommit === changeSet.headCommit);
-        if (evidenceRound !== undefined) {
-            throw new StorageRecordError(`ReviewRound evidence commit ${evidenceRound.id}/${changeSet.headCommit} cannot become a ChangeSet.`);
-        }
-    }
-    for (const integration of Object.values(aggregate.integrationAttempts)) {
-        if (!boundProjects.has(integration.projectId)) {
-            throw new StorageRecordError(`Integration Project does not match Task: ${integration.id}.`);
-        }
-        for (const changeSetId of integration.changeSetIds) {
-            const changeSet = aggregate.changeSets[changeSetId];
-            if (changeSet === undefined) {
-                throw new StorageRecordError(`Integration ChangeSet not found: ${integration.id}/${changeSetId}.`);
-            }
-            if (changeSet.projectId !== integration.projectId) {
-                throw new StorageRecordError(`Integration ChangeSet belongs to another Project: ${integration.id}/${changeSetId}.`);
-            }
-            const evidenceRound = Object.values(aggregate.reviewRounds).find(({ evidenceCommit, reviewBaseCommit }) => evidenceCommit !== undefined && evidenceCommit !== reviewBaseCommit && evidenceCommit === changeSet.headCommit);
-            if (evidenceRound !== undefined) {
-                throw new StorageRecordError(`ReviewRound evidence commit ${evidenceRound.id}/${changeSet.headCommit} cannot become an Integration source.`);
-            }
-        }
-    }
-    for (const reference of Object.values(aggregate.publicationReferences)) {
-        if (!boundProjects.has(reference.projectId)) {
-            throw new StorageRecordError(`Publication reference Project does not match Task: ${reference.id}.`);
-        }
-        if (reference.supersedes !== undefined) {
-            const target = aggregate.publicationReferences[reference.supersedes];
-            if (target === undefined) {
-                throw new StorageRecordError(`Publication reference supersedes target not found: ${reference.id}/${reference.supersedes}.`);
-            }
-            if (publicationExternalKey(target) !== publicationExternalKey(reference)) {
-                throw new StorageRecordError(`Publication reference supersedes a different external identity: ${reference.id}/${reference.supersedes}.`);
-            }
-        }
-    }
-    assertPublicationExternalIdentityUniqueness(state);
-    for (const workspace of Object.values(aggregate.managedWorkspaces)) {
-        assertManagedWorkspaceReferences(aggregate, workspace, "Managed workspace");
-    }
-}
-function assertPublicationExternalIdentityUniqueness(state) {
-    const owners = new Map();
-    for (const aggregate of Object.values(state.tasks)) {
-        for (const reference of Object.values(aggregate.publicationReferences)) {
-            const key = publicationExternalKey(reference);
-            const owner = owners.get(key);
-            if (owner !== undefined && owner !== aggregate.task.id) {
-                throw new StorageRecordError(`Publication external identity belongs to multiple Tasks: ${key}.`);
-            }
-            owners.set(key, aggregate.task.id);
-        }
-    }
-}
-/**
- * Enforce the owner-specific scope at the storage boundary.  The map key and
- * foreign-record checks prevent dangling identities; these checks prevent a
- * valid owner from being paired with another lifecycle's Project scope.
- */
-function assertManagedWorkspaceReferences(aggregate, workspace, label, workItemOverride) {
-    const taskId = aggregate.task.id;
-    const boundProjects = aggregate.task.projectBindings.map(({ projectId }) => projectId).sort();
-    const actualProjects = workspace.entries.map(({ projectId }) => projectId).sort();
-    const requireVisibleTaskScope = () => {
-        // Project bindings are persisted before the physical workspace is
-        // reconciled.  During that bounded hand-off a workspace may be missing a
-        // newly-bound Project, but it must never expose a Project outside the
-        // current Task.  Launch preparation closes the temporary subset before
-        // the workspace can be used.
-        if (actualProjects.some((projectId) => !boundProjects.includes(projectId))) {
-            throw new StorageRecordError(`${label} Project scope does not match Task: ${taskId}.`);
-        }
-    };
-    switch (workspace.owner.type) {
-        case "task":
-            requireVisibleTaskScope();
-            if (workspace.entries.some(({ access }) => access !== "write")) {
-                throw new StorageRecordError(`${label} Task workspace must be writable: ${taskId}.`);
-            }
-            return;
-        case "work-item": {
-            const item = workItemOverride?.id === workspace.owner.workItemId
-                ? workItemOverride
-                : aggregate.workItems[workspace.owner.workItemId];
-            if (item === undefined) {
-                throw new StorageRecordError(`${label} WorkItem not found: ${taskId}/${workspace.owner.workItemId}.`);
-            }
-            requireVisibleTaskScope();
-            const writable = workspace.entries
-                .filter(({ access }) => access === "write")
-                .map(({ projectId }) => projectId)
-                .sort();
-            const expectedWritable = [...item.writeProjectIds].sort();
-            // Write scope expansion is persisted before the physical WorkItem
-            // workspace is reconciled.  The stored workspace may therefore expose
-            // a temporary subset, but it may never grant write access outside the
-            // current WorkItem authorization.
-            if (writable.some((projectId) => !expectedWritable.includes(projectId))) {
-                throw new StorageRecordError(`${label} WorkItem write scope does not match: ${taskId}/${item.id}.`);
-            }
-            return;
-        }
-        case "review-round": {
-            const round = aggregate.reviewRounds[workspace.owner.reviewRoundId];
-            if (round === undefined) {
-                throw new StorageRecordError(`${label} ReviewRound not found: ${taskId}/${workspace.owner.reviewRoundId}.`);
-            }
-            requireVisibleTaskScope();
-            if (workspace.entries.some(({ access }) => access !== "write")) {
-                throw new StorageRecordError(`${label} ReviewRound workspace must be writable: ${taskId}/${round.id}.`);
-            }
-            const item = round.workItemId === undefined
-                ? undefined
-                : aggregate.workItems[round.workItemId];
-            const candidate = item?.candidates.find(({ id }) => id === round.candidateId);
-            const frozenProjects = round.scope === "task"
-                ? round.taskCandidate?.projects
-                : candidate?.gitSnapshot?.projects;
-            if (frozenProjects !== undefined) {
-                const expected = [...frozenProjects]
-                    .map(({ projectId, commit }) => ({ projectId, commit }))
-                    .sort((left, right) => left.projectId.localeCompare(right.projectId));
-                const actual = workspace.entries
-                    .map(({ projectId, baseCommit }) => ({ projectId, commit: baseCommit }))
-                    .sort((left, right) => left.projectId.localeCompare(right.projectId));
-                const matches = expected.length === actual.length
-                    && expected.every((frozen, index) => {
-                        const reviewEntry = actual[index];
-                        return reviewEntry?.projectId === frozen.projectId
-                            && reviewEntry.commit === frozen.commit;
-                    });
-                if (!matches) {
-                    const provenance = round.scope === "task"
-                        ? "Task frozen project set"
-                        : "Candidate frozen commit";
-                    throw new StorageRecordError(`${label} ReviewRound does not use the ${provenance}: ${taskId}/${round.id}.`);
-                }
-            }
-            return;
-        }
-        case "integration-attempt": {
-            const attempt = aggregate.integrationAttempts[workspace.owner.integrationAttemptId];
-            if (attempt === undefined) {
-                throw new StorageRecordError(`${label} Integration Attempt not found: ${taskId}/${workspace.owner.integrationAttemptId}.`);
-            }
-            if (workspace.entries.length !== 1
-                || workspace.entries[0].projectId !== attempt.projectId
-                || workspace.entries[0].access !== "write") {
-                throw new StorageRecordError(`${label} Integration Attempt scope is invalid: ${taskId}/${attempt.id}.`);
-            }
-            return;
-        }
-        case "execution-lane": {
-            const owner = workspace.owner;
-            const laneItem = owner.purpose === "execution"
-                ? aggregate.workItems[owner.workItemId ?? ""]
-                : undefined;
-            const group = owner.purpose === "execution"
-                ? (laneItem === undefined
-                    ? undefined
-                    : workItemExecutionGroupById(laneItem, owner.executionGroupId))
-                : aggregate.reviewRounds[owner.reviewRoundId ?? ""]?.executionGroup;
-            if (group === undefined || group.id !== owner.executionGroupId
-                || !group.lanes.some(({ id }) => id === owner.executionLaneId)) {
-                throw new StorageRecordError(`${label} Execution Lane lineage is invalid: ${taskId}/${owner.executionGroupId}/${owner.executionLaneId}.`);
-            }
-            requireVisibleTaskScope();
-            const writable = workspace.entries
-                .filter(({ access }) => access === "write")
-                .map(({ projectId }) => projectId)
-                .sort();
-            const expectedWritable = owner.purpose === "execution"
-                ? [...(aggregate.workItems[owner.workItemId ?? ""]?.writeProjectIds ?? [])].sort()
-                : boundProjects;
-            if (!isDeepStrictEqual(writable, expectedWritable)) {
-                throw new StorageRecordError(`${label} Execution Lane write scope does not match: ${taskId}/${owner.executionLaneId}.`);
-            }
-            return;
-        }
-    }
-}
-function validIntegrationTransition(before, after) {
-    if (before.id !== after.id
-        || before.taskId !== after.taskId
-        || before.projectId !== after.projectId
-        || before.targetRef !== after.targetRef
-        || before.expectedHead !== after.expectedHead
-        || !isDeepStrictEqual(before.changeSetIds, after.changeSetIds)
-        || !isDeepStrictEqual(before.checkCommands, after.checkCommands)
-        || before.createdAt !== after.createdAt)
-        return false;
-    const allowed = {
-        running: ["running", "blocked", "validating", "failed"],
-        blocked: ["blocked", "validating", "failed"],
-        validating: ["validating", "committed", "failed"],
-        committed: ["committed", "superseded"],
-        superseded: ["superseded"],
-        failed: ["failed"]
-    };
-    return allowed[before.status].includes(after.status);
-}
-/**
- * Storage-level defence in depth for the integration queue state machine: the
- * identity fields and the check/evidence lists are immutable once written, and
- * a status may only move along the queue's legal transitions.  The service
- * owns the CAS claim; this rejects a stale or forged write that slipped past it.
- */
-function validIntegrationQueueTransition(before, after) {
-    if (before.id !== after.id
-        || before.taskId !== after.taskId
-        || before.projectId !== after.projectId
-        || before.changeSetId !== after.changeSetId
-        || before.targetRef !== after.targetRef
-        || !isDeepStrictEqual(before.checkCommands, after.checkCommands)
-        || !isDeepStrictEqual(before.evidenceRefs, after.evidenceRefs)
-        || before.createdAt !== after.createdAt)
-        return false;
-    const allowed = {
-        queued: ["queued", "running", "validated", "superseded"],
-        running: ["running", "conflicted", "committed"],
-        conflicted: ["conflicted", "running", "committed", "queued", "superseded"],
-        validated: ["validated", "running", "queued", "superseded"],
-        committed: ["committed"],
-        superseded: ["superseded"]
-    };
-    return allowed[before.status].includes(after.status);
-}
-function assertAcyclicWorkItems(items) {
-    const visiting = new Set();
-    const visited = new Set();
-    const visit = (id) => {
-        if (visited.has(id))
-            return;
-        if (visiting.has(id))
-            throw new StorageRecordError(`Work Item dependency cycle detected: ${id}.`);
-        visiting.add(id);
-        const item = items[id];
-        if (item !== undefined) {
-            for (const dependencyId of item.dependsOn)
-                visit(dependencyId);
-        }
-        visiting.delete(id);
-        visited.add(id);
-    };
-    for (const id of Object.keys(items))
-        visit(id);
-}
-function mailboxReferenceExists(state, ref) {
-    if ("taskId" in ref) {
-        const aggregate = state.tasks[ref.taskId];
-        if (aggregate === undefined)
-            return false;
-        switch (ref.type) {
-            case "run": return aggregate.agentRuns[ref.id] !== undefined;
-            case "work-item": return aggregate.workItems[ref.id] !== undefined;
-            case "input": return aggregate.inputRequests[ref.id] !== undefined;
-            case "message": return aggregate.messages[ref.id] !== undefined;
-            case "event": return aggregate.events[ref.id] !== undefined;
-        }
-    }
-    switch (ref.type) {
-        case "task": return state.tasks[ref.id] !== undefined;
-        case "session":
-            return [
-                ...Object.values(state.globalRoleSessionSets),
-                ...Object.values(state.tasks).flatMap((task) => Object.values(task.roleSessionSets))
-            ].some((set) => Object.values(set.sessions).some((session) => session.nativeSessionId === ref.id));
-        default: return false;
-    }
-}
-function validWorkItemTransition(existing, candidate) {
-    if (isDeepStrictEqual(existing, candidate))
-        return true;
-    if (existing.id !== candidate.id
-        || existing.taskId !== candidate.taskId
-        || existing.assignee !== candidate.assignee
-        || existing.createdAt !== candidate.createdAt
-        || !isDeepStrictEqual(existing.baseRefs, candidate.baseRefs)
-        || candidate.revision !== existing.revision + 1
-        || Date.parse(candidate.updatedAt) < Date.parse(existing.updatedAt))
-        return false;
-    if (!compatibleWorkItemExecutionGroups(existing, candidate))
-        return false;
-    if (existing.status !== candidate.status
-        && (existing.title !== candidate.title
-            || existing.objective !== candidate.objective
-            || !isDeepStrictEqual(existing.acceptance, candidate.acceptance)
-            || !isDeepStrictEqual(existing.dependsOn, candidate.dependsOn)
-            || !isDeepStrictEqual(existing.writeProjectIds, candidate.writeProjectIds)))
-        return false;
-    const candidateProjects = new Set(candidate.writeProjectIds);
-    if (existing.writeProjectIds.some((projectId) => !candidateProjects.has(projectId))) {
-        return false;
-    }
-    const candidatesChanged = !isDeepStrictEqual(existing.candidates, candidate.candidates);
-    const submittedCandidate = existing.status === "running"
-        && candidate.status === "awaiting_acceptance"
-        && candidate.candidates.length === existing.candidates.length + 1
-        && isDeepStrictEqual(candidate.candidates.slice(0, existing.candidates.length), existing.candidates);
-    if (candidatesChanged && !submittedCandidate) {
-        return false;
-    }
-    const allowed = {
-        pending: ["pending", "running", "retired"],
-        running: [
-            "running",
-            "awaiting_acceptance",
-            "completed",
-            "failed",
-            "retired"
-        ],
-        awaiting_acceptance: [
-            "awaiting_acceptance",
-            "completed",
-            "failed",
-            "retired"
-        ],
-        completed: ["completed"],
-        failed: ["failed", "running", "retired"],
-        retired: ["retired"]
-    };
-    return allowed[existing.status].includes(candidate.status);
-}
-function compatibleWorkItemExecutionGroups(existing, candidate) {
-    if (candidate.executionGroups.length < existing.executionGroups.length)
-        return false;
-    for (const [index, historical] of existing.executionGroups.entries()) {
-        const next = candidate.executionGroups[index];
-        if (next === undefined || next.id !== historical.id)
-            return false;
-        const isCurrent = existing.currentExecutionGroupId === historical.id;
-        const mutableCurrent = isCurrent && historical.resolution === undefined;
-        if (!mutableCurrent && !isDeepStrictEqual(historical, next))
-            return false;
-        if (mutableCurrent && !compatibleExecutionGroups(historical, next))
-            return false;
-    }
-    const appended = candidate.executionGroups.slice(existing.executionGroups.length);
-    if (appended.length > 1)
-        return false;
-    if (appended.length === 1) {
-        const priorCurrent = existing.currentExecutionGroupId === undefined
-            ? undefined
-            : workItemExecutionGroupById(existing, existing.currentExecutionGroupId);
-        if (priorCurrent !== undefined && priorCurrent.resolution === undefined)
-            return false;
-        if (candidate.currentExecutionGroupId !== appended[0].id)
-            return false;
-    }
-    else if (candidate.currentExecutionGroupId !== existing.currentExecutionGroupId) {
-        const priorCurrent = existing.currentExecutionGroupId === undefined
-            ? undefined
-            : workItemExecutionGroupById(existing, existing.currentExecutionGroupId);
-        const clearingResolvedRetry = existing.status === "failed"
-            && candidate.status === "running"
-            && candidate.currentExecutionGroupId === undefined
-            && priorCurrent?.resolution !== undefined;
-        if (!clearingResolvedRetry)
-            return false;
-    }
-    if (candidate.currentExecutionGroupId !== undefined
-        && workItemExecutionGroupById(candidate, candidate.currentExecutionGroupId) === undefined) {
-        return false;
-    }
-    return true;
-}
-function assertWorkItemCandidateReferences(aggregate, item, candidate, label) {
-    if (candidate.workItemRevision > item.revision) {
-        throw new StorageRecordError(`${label} revision is invalid.`);
-    }
-    if ((candidate.executionGroupId === undefined) !== (candidate.executionLaneId === undefined)) {
-        throw new StorageRecordError(`${label} execution lineage is incomplete.`);
-    }
-    if (candidate.executionGroupId !== undefined) {
-        const group = workItemExecutionGroupById(item, candidate.executionGroupId);
-        const lane = group?.lanes.find(({ id }) => id === candidate.executionLaneId);
-        if (group === undefined
-            || group.id !== candidate.executionGroupId
-            || lane === undefined) {
-            throw new StorageRecordError(`${label} execution lineage is invalid: candidate=${candidate.executionGroupId}/${candidate.executionLaneId}; `
-                + `item=${group?.id ?? "none"}/${lane?.id ?? "none"}.`);
-        }
-    }
-    if (candidate.workspace !== undefined) {
-        if (candidate.workspace.owner.taskId !== item.taskId) {
-            throw new StorageRecordError(`${label} workspace belongs to another Task.`);
-        }
-        if (candidate.workspace.owner.type === "work-item"
-            && candidate.workspace.owner.workItemId !== item.id) {
-            throw new StorageRecordError(`${label} workspace belongs to another Work Item.`);
-        }
-        if (candidate.workspace.owner.type !== "work-item") {
-            throw new StorageRecordError(`${label} must use the WorkItem-owned Develop workspace.`);
-        }
-        assertManagedWorkspaceReferences(aggregate, candidate.workspace, label, item);
-    }
-    if (candidate.source.type === "direct") {
-        if (item.assignee !== undefined) {
-            throw new StorageRecordError(`${label} cannot be direct for an assigned Work Item.`);
-        }
-        if (candidate.workspace !== undefined
-            && (candidate.workspace.owner.type !== "work-item"
-                || candidate.workspace.owner.taskId !== item.taskId
-                || candidate.workspace.owner.workItemId !== item.id)) {
-            throw new StorageRecordError(`${label} must use the WorkItem-owned Develop workspace.`);
-        }
-        if (candidate.taskMainSnapshot !== undefined) {
-            const expectedProjects = [...item.writeProjectIds].sort();
-            const actualProjects = candidate.taskMainSnapshot.projects
-                .map(({ projectId }) => projectId)
-                .sort();
-            if (!isDeepStrictEqual(actualProjects, expectedProjects)) {
-                throw new StorageRecordError(`${label} Task-main snapshot scope is stale.`);
-            }
-            for (const project of candidate.taskMainSnapshot.projects) {
-                const binding = aggregate.task.projectBindings.find(({ projectId }) => projectId === project.projectId);
-                if (binding === undefined || binding.directory !== project.directory) {
-                    throw new StorageRecordError(`${label} Task-main snapshot Project is not bound: ${project.projectId}.`);
-                }
-            }
-        }
-        return;
-    }
-    const run = aggregate.agentRuns[candidate.source.runId];
-    const resolvedGroupSummary = candidate.executionGroupId === undefined
-        ? undefined
-        : workItemExecutionGroupById(item, candidate.executionGroupId)?.resolution?.summary;
-    if (run === undefined
-        || run.workItemId !== item.id
-        || run.purpose !== "execution"
-        || run.status !== "yielded"
-        || (run.summary !== candidate.summary && resolvedGroupSummary !== candidate.summary)) {
-        throw new StorageRecordError(`${label} Run is invalid: ${candidate.source.runId}.`);
-    }
-    if (candidate.executionGroupId !== run.executionGroupId
-        || candidate.executionLaneId !== run.executionLaneId) {
-        throw new StorageRecordError(`${label} execution lineage does not match its source Run.`);
-    }
-    // A Gitless execution Run still carries its durable Task-owned empty view
-    // for runtime fencing, while its Candidate intentionally has no Develop
-    // workspace or Git snapshot. This is the only source/run workspace
-    // mismatch permitted at the storage boundary.
-    const gitlessRunWorkspace = run.workspace?.owner.type === "task"
-        && run.workspace.owner.taskId === item.taskId
-        && aggregate.task.projectBindings.length === 0
-        && run.workspace.entries.length === 0
-        && (() => {
-            const durable = aggregate.managedWorkspaces[managedWorkspaceKey(run.workspace.owner)];
-            return durable !== undefined && isDeepStrictEqual(durable, run.workspace);
-        })();
-    if (!gitlessRunWorkspace
-        && (candidate.workspace === undefined) !== (run.workspace === undefined)) {
-        throw new StorageRecordError(`${label} workspace does not match its source Run.`);
-    }
-    if (!gitlessRunWorkspace && candidate.workspace !== undefined && run.workspace !== undefined) {
-        assertCandidateWorkspaceMatchesRun(candidate.workspace, run.workspace, label);
-    }
-    if (candidate.workspace !== undefined && (candidate.workspace.owner.type !== "work-item"
-        || candidate.workspace.owner.taskId !== item.taskId
-        || candidate.workspace.owner.workItemId !== item.id)) {
-        throw new StorageRecordError(`${label} must use the WorkItem-owned Develop workspace.`);
-    }
-}
-function assertAgentRunExecutionReferences(aggregate, run) {
-    if ((run.executionGroupId === undefined) !== (run.executionLaneId === undefined)) {
-        throw new StorageRecordError(`Agent Run execution lineage is incomplete: ${run.id}.`);
-    }
-    if (run.executionGroupId === undefined)
-        return;
-    const ownerGroup = run.purpose === "review"
-        ? (run.reviewRoundId === undefined
-            ? undefined
-            : aggregate.reviewRounds[run.reviewRoundId]?.executionGroup)
-        : (run.workItemId === undefined || run.executionGroupId === undefined
-            ? undefined
-            : (() => {
-                const item = aggregate.workItems[run.workItemId];
-                return item === undefined
-                    ? undefined
-                    : workItemExecutionGroupById(item, run.executionGroupId);
-            })());
-    if (ownerGroup === undefined) {
-        throw new StorageRecordError(`Agent Run ExecutionGroup not found: ${run.id}.`);
-    }
-    validateExecutionGroup(ownerGroup);
-    const lane = ownerGroup.lanes.find(({ id }) => id === run.executionLaneId);
-    if (ownerGroup.id !== run.executionGroupId || lane === undefined) {
-        throw new StorageRecordError(`Agent Run ExecutionLane does not match its owner: ${run.id}.`);
-    }
-    if (lane.roleName !== run.roleName) {
-        throw new StorageRecordError(`Agent Run Role does not match its ExecutionLane: ${run.id}.`);
-    }
-}
-function compatibleExecutionGroups(existing, candidate) {
-    if (existing === undefined)
-        return true;
-    if (candidate === undefined)
-        return false;
-    return isExecutionGroupTransition(existing, candidate);
-}
-/** Candidate freezes Git commits at yield time, so timestamp/baseCommit fields
- * may differ from the Run's dispatch snapshot while workspace identity and
- * execution scope must remain exact. */
-function assertCandidateWorkspaceMatchesRun(candidate, run, label) {
-    if (candidate.owner.type === "work-item" && run.owner.type === "execution-lane") {
-        if (candidate.owner.taskId !== run.owner.taskId
-            || run.owner.purpose !== "execution"
-            || candidate.owner.workItemId !== run.owner.workItemId
-            || candidate.entries.length !== run.entries.length) {
-            throw new StorageRecordError(`${label} workspace lineage does not match its source Lane.`);
-        }
-        for (const source of run.entries) {
-            const target = candidate.entries.find(({ projectId }) => projectId === source.projectId);
-            if (target === undefined || target.directory !== source.directory || target.access !== source.access) {
-                throw new StorageRecordError(`${label} workspace Project scope does not match its source Lane.`);
-            }
-        }
-        return;
-    }
-    if (candidate.owner.type !== run.owner.type
-        || candidate.owner.taskId !== run.owner.taskId
-        || candidate.root !== run.root
-        || candidate.entries.length !== run.entries.length) {
-        throw new StorageRecordError(`${label} workspace does not match its source Run.`);
-    }
-    for (const source of run.entries) {
-        const frozen = candidate.entries.find(({ projectId }) => projectId === source.projectId);
-        if (frozen === undefined
-            || frozen.directory !== source.directory
-            || frozen.access !== source.access
-            || frozen.path !== source.path
-            || frozen.branch !== source.branch
-            || frozen.baseRef !== source.baseRef) {
-            throw new StorageRecordError(`${label} workspace scope does not match its source Run.`);
-        }
-    }
-}
-function validReviewRoundTransition(existing, candidate) {
-    if (isDeepStrictEqual(existing, candidate))
-        return true;
-    if (existing.id !== candidate.id
-        || existing.taskId !== candidate.taskId
-        || existing.workItemId !== candidate.workItemId
-        || existing.candidateId !== candidate.candidateId
-        || existing.reviewerRoleName !== candidate.reviewerRoleName
-        || existing.reviewBaseCommit !== candidate.reviewBaseCommit
-        || (existing.scope ?? "work-item") !== (candidate.scope ?? "work-item")
-        || !isDeepStrictEqual(existing.taskCandidate, candidate.taskCandidate)
-        || !sameTaskFinalReviewContract(existing.taskFinalReviewContract, candidate.taskFinalReviewContract)
-        || !compatibleExecutionGroups(existing.executionGroup, candidate.executionGroup)
-        // Issue 06: an explicit Task-control retry resets a failed Task-final
-        // Round to pending, so requestedBy may change from the original actor.
-        || (existing.requestedBy !== candidate.requestedBy
-            && !(existing.status === "failed"
-                && candidate.status === "pending"
-                && (candidate.scope ?? "work-item") === "task"))
-        || existing.createdAt !== candidate.createdAt)
-        return false;
-    if (existing.status === "pending") {
-        if (candidate.status === "pending") {
-            return (existing.workspace === undefined
-                && candidate.workspace !== undefined
-                || existing.executionGroup === undefined
-                    && candidate.executionGroup !== undefined
-                || existing.executionGroup !== undefined
-                    && candidate.executionGroup !== undefined
-                    && !isDeepStrictEqual(existing.executionGroup, candidate.executionGroup))
-                && candidate.reviewerRunId === undefined
-                && candidate.summary === undefined
-                && candidate.checks === undefined
-                && candidate.evidenceCommit === undefined
-                && candidate.endedAt === undefined
-                && candidate.workspaceDisposition === undefined;
-        }
-        return ["running", "failed"].includes(candidate.status)
-            && (existing.workspace === undefined
-                || isDeepStrictEqual(existing.workspace, candidate.workspace));
-    }
-    if (existing.status === "running") {
-        if (candidate.status === "running") {
-            return existing.reviewerRunId === candidate.reviewerRunId
-                && isDeepStrictEqual(existing.workspace, candidate.workspace)
-                && existing.executionGroup !== undefined
-                && candidate.executionGroup !== undefined
-                && !isDeepStrictEqual(existing.executionGroup, candidate.executionGroup)
-                && candidate.summary === undefined
-                && candidate.report === undefined
-                && candidate.checks === undefined
-                && candidate.evidenceCommit === undefined
-                && candidate.endedAt === undefined
-                && candidate.workspaceDisposition === undefined;
-        }
-        return ["completed", "failed"].includes(candidate.status)
-            && existing.reviewerRunId === candidate.reviewerRunId
-            && isDeepStrictEqual(existing.workspace, candidate.workspace);
-    }
-    // Issue 06: a failed Task-final execution attempt may be reset to pending
-    // under the same semantic Round ID. AgentRun history remains the attempt
-    // trail; terminal Review metadata is cleared by retryTaskReviewRound.
-    if (existing.status === "failed"
-        && candidate.status === "pending"
-        && (candidate.scope ?? "work-item") === "task") {
-        return candidate.reviewerRunId === undefined
-            && candidate.summary === undefined
-            && candidate.report === undefined
-            && candidate.checks === undefined
-            && candidate.evidenceCommit === undefined
-            && candidate.endedAt === undefined
-            && candidate.workspaceDisposition === undefined
-            && (existing.workspace === undefined
-                || candidate.workspace === undefined
-                || isDeepStrictEqual(existing.workspace, candidate.workspace))
-            && compatibleExecutionGroups(existing.executionGroup, candidate.executionGroup);
-    }
-    if (existing.status === candidate.status
-        && (existing.status === "completed" || existing.status === "failed")) {
-        const { workspaceDisposition: _existingDisposition, ...existingResult } = existing;
-        const { workspaceDisposition: _candidateDisposition, ...candidateResult } = candidate;
-        return isDeepStrictEqual(existingResult, candidateResult)
-            && existing.workspaceDisposition?.kind !== "removed"
-            && candidate.workspaceDisposition !== undefined;
-    }
-    return false;
-}
-function synchronousResult(value) { if (typeof value === "object" && value !== null && "then" in value)
-    throw new StorageRecordError("FileTaskStore transactions must be synchronous."); return value; }
-function acquireStorageLock(rootDir) {
-    ensureYuiHome(rootDir);
-    const lock = join(rootDir, STORAGE_LOCK_DIRECTORY);
-    const deadline = Date.now() + LOCK_TIMEOUT_MS;
-    while (true) {
-        try {
-            mkdirSync(lock, { mode: 0o700 });
-            writeFileSync(join(lock, "owner"), `${process.pid}\n`, { mode: 0o600 });
-            return () => { rmSync(lock, { recursive: true, force: true }); };
-        }
-        catch (error) {
-            if (!(error instanceof Error && "code" in error && error.code === "EEXIST"))
-                throw error;
-            reclaimDeadLock(lock);
-            if (Date.now() >= deadline)
-                throw new StorageConflictError(`Timed out waiting for storage lock: ${lock}`);
-            Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, LOCK_RETRY_MS);
-        }
-    }
-}
-/**
- * Run `execute` while holding the same storage write lock the store uses, without
- * the version-gated {@link FileTaskStore} constructor. The upgrade orchestrator
- * uses this to re-pin the committed revision under the lock against a source Home
- * whose schema is not the current version (so a store cannot be constructed yet).
- */
-export function withStorageWriteLock(rootDir, execute) {
-    const release = acquireStorageLock(rootDir);
-    try {
-        return execute();
-    }
-    finally {
-        release();
-    }
-}
-function reclaimDeadLock(lock) {
-    try {
-        const age = Date.now() - statSync(lock).mtimeMs;
-        if (age < 1_000)
-            return;
-        const pid = Number.parseInt(readFileSync(join(lock, "owner"), "utf8"), 10);
-        if (Number.isInteger(pid) && processIsAlive(pid))
-            return;
-        rmSync(lock, { recursive: true, force: true });
-    }
-    catch (error) {
-        if (!(error instanceof Error && "code" in error && error.code === "ENOENT"))
-            return;
-    }
-}
-function processIsAlive(pid) { try {
-    process.kill(pid, 0);
-    return true;
-}
-catch (error) {
-    return error instanceof Error && "code" in error && error.code === "EPERM";
-} }