@zq-silk/yui 0.6.12 → 0.6.14

package/dist/storage/taskStore.js

@@ -5,6 +5,7 @@ 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, resolveLeaderNextActionMode, resolveResourcesGcAutoQuarantine, resolveResourcesGcMode } from "../config/yuiConfig.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { mailboxBatches, consumePendingBatch, mailboxHasWork, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
@@ -16,6 +17,7 @@ import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from
 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";
@@ -27,6 +29,7 @@ import { CURRENT_DURABLE_JOB_SCHEMA_VERSION, validDurableJobTransition, validate
 import { validateGlobalRole, validateTaskRole } from "../role/role.js";
 import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../scheduler/leaderFailure.js";
 import { CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION } from "../scheduler/operatorNotification.js";
+import { CURRENT_TASK_WAKE_SCHEMA_VERSION, validateTaskWake } from "../scheduler/taskWake.js";
 import { validateTask } from "../task/task.js";
 import { formatAgentRunReceiptId, TASK_RECORD_ID_PREFIXES, validateTaskRecordReference } from "../task/taskRecordReference.js";
 import { workItemExecutionGroupById, validateWorkItem } from "../workItem/workItem.js";
@@ -51,7 +54,7 @@ export const CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION = 3;
  * below, but are not independent record-axis families.
  */
 export const CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION = 2;
-export const CURRENT_PROJECT_SCHEMA_VERSION = 3;
+export const CURRENT_PROJECT_SCHEMA_VERSION = 4;
 export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 2;
 export const CURRENT_GLOBAL_ROLE_SCHEMA_VERSION = 3;
 export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 3;
@@ -71,6 +74,7 @@ export const CURRENT_EVENT_SCHEMA_VERSION = 2;
 export const CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION = 1;
 export const CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION = 1;
 export const CURRENT_WORK_MAILBOX_SCHEMA_VERSION = 2;
+export const CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION = 1;
 export const CURRENT_ROLE_AGENT_SESSION_SCHEMA_VERSION = 3;
 export const CURRENT_PENDING_WAKEUP_SCHEMA_VERSION = 1;
 const STORAGE_LOCK_DIRECTORY = ".state.lock";
@@ -104,7 +108,7 @@ export function executionLaneActiveRunKeyParts(key) {
     }
 }
 /** The schema version of each persisted `state.json#/tasks/*` aggregate. */
-export const CURRENT_STORED_TASK_SCHEMA_VERSION = 16;
+export const CURRENT_STORED_TASK_SCHEMA_VERSION = 17;
 /**
  * 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
@@ -406,7 +410,8 @@ export class FileTaskStore {
             task: {
                 id: aggregate.task.id,
                 status: aggregate.task.status,
-                projectBindings: aggregate.task.projectBindings
+                projectBindings: aggregate.task.projectBindings,
+                requireIntegration: aggregate.task.requireIntegration
             },
             workItems: values(aggregate.workItems, "id"),
             changeSets: values(aggregate.changeSets, "id"),
@@ -419,6 +424,31 @@ export class FileTaskStore {
             leaderRuns: agentRuns.filter((run) => run.roleName === "leader")
         };
     }
+    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,
+            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);
     }
@@ -1246,6 +1276,28 @@ export class FileTaskStore {
         });
     }
     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;
@@ -1317,6 +1369,62 @@ export class FileTaskStore {
     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
@@ -1820,8 +1928,10 @@ function emptyStoredTask(task) {
         decisions: {},
         milestones: {},
         events: {},
+        wakes: {},
         capabilityGrants: {},
         releaseWorkflows: {},
+        publicationReferences: {},
         leaderFailure: null,
         operatorNotification: null
     };
@@ -1841,8 +1951,10 @@ function emptyTaskIdHighWaterMarks() {
         decision: 0,
         milestone: 0,
         event: 0,
+        taskWake: 0,
         capabilityGrant: 0,
-        releaseWorkflow: 0
+        releaseWorkflow: 0,
+        publicationReference: 0
     };
 }
 function nextTaskRecordSequence(aggregate, taskId, kind) {
@@ -2033,8 +2145,10 @@ function parseStoredTask(value, taskId) {
         "decisions",
         "milestones",
         "events",
+        "wakes",
         "capabilityGrants",
         "releaseWorkflows",
+        "publicationReferences",
         "leaderFailure",
         "operatorNotification"
     ], `Task aggregate ${taskId}`);
@@ -2190,6 +2304,14 @@ function parseStoredTask(value, 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) {
@@ -2210,6 +2332,16 @@ function parseStoredTask(value, 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");
     for (const [key, label] of [["leaderFailure", "Leader failure"], ["operatorNotification", "Operator notification"]]) {
         const record = aggregate[key];
         if (record !== null) {
@@ -2239,8 +2371,10 @@ function validateTaskIdHighWaterCoverage(aggregate, taskId) {
         decision: aggregate.decisions,
         milestone: aggregate.milestones,
         event: aggregate.events,
+        taskWake: aggregate.wakes,
         capabilityGrant: aggregate.capabilityGrants,
-        releaseWorkflow: aggregate.releaseWorkflows
+        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+)$`);
@@ -2649,6 +2783,101 @@ export function storedReleaseWorkflow(value) {
         throw new StorageRecordError(error instanceof Error ? error.message : String(error));
     }
 }
+export function storedPublicationReference(value) {
+    const reference = versioned(value, CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION, "Publication reference");
+    const fields = [
+        "schemaVersion", "id", "taskId", "projectId", "provider", "repository",
+        "externalKind", "externalId", "state", "verification", "recordedBy",
+        "source", "createdAt"
+    ];
+    if (reference.externalUrl !== undefined)
+        fields.push("externalUrl");
+    if (reference.title !== undefined)
+        fields.push("title");
+    if (reference.sourceBranch !== undefined)
+        fields.push("sourceBranch");
+    if (reference.targetBranch !== undefined)
+        fields.push("targetBranch");
+    if (reference.localCommit !== undefined)
+        fields.push("localCommit");
+    if (reference.remoteCommit !== undefined)
+        fields.push("remoteCommit");
+    if (reference.evidence !== undefined)
+        fields.push("evidence");
+    if (reference.supersedes !== undefined)
+        fields.push("supersedes");
+    if (reference.mergedAt !== undefined)
+        fields.push("mergedAt");
+    exact(reference, fields, "Publication reference");
+    requireRecordIdentity(reference.id, "Publication reference id");
+    requireRecordIdentity(reference.taskId, "Publication reference Task id");
+    validateTaskRecordReference({ taskId: reference.taskId, localId: reference.id }, "publicationReference");
+    requireRecordIdentity(reference.projectId, "Publication reference Project id");
+    requireNormalizedText(reference.provider, "Publication reference provider");
+    requireNormalizedText(reference.repository, "Publication reference repository");
+    requireNormalizedText(reference.externalKind, "Publication reference external kind");
+    requireNormalizedText(reference.externalId, "Publication reference external id");
+    if (reference.externalUrl !== undefined) {
+        requireNormalizedText(reference.externalUrl, "Publication reference external URL");
+    }
+    if (reference.title !== undefined) {
+        requireNormalizedText(reference.title, "Publication reference title");
+    }
+    if (reference.sourceBranch !== undefined) {
+        requireNormalizedText(reference.sourceBranch, "Publication reference source branch");
+    }
+    if (reference.targetBranch !== undefined) {
+        requireNormalizedText(reference.targetBranch, "Publication reference target branch");
+    }
+    if (reference.localCommit !== undefined) {
+        requireNormalizedText(reference.localCommit, "Publication reference local commit");
+    }
+    if (reference.remoteCommit !== undefined) {
+        requireNormalizedText(reference.remoteCommit, "Publication reference remote commit");
+    }
+    requireNormalizedText(reference.state, "Publication reference state");
+    requireNormalizedText(reference.verification, "Publication reference verification");
+    if (reference.evidence !== undefined) {
+        requireNormalizedText(reference.evidence, "Publication reference evidence");
+    }
+    if (reference.supersedes !== undefined) {
+        requireNormalizedText(reference.supersedes, "Publication reference supersedes id");
+    }
+    requireNormalizedText(reference.recordedBy, "Publication reference recordedBy");
+    requireNormalizedText(reference.source, "Publication reference source");
+    if (reference.mergedAt !== undefined) {
+        requireTimestamp(reference.mergedAt, "Publication reference mergedAt");
+    }
+    requireTimestamp(reference.createdAt, "Publication reference createdAt");
+    try {
+        return validatePublicationReference(reference);
+    }
+    catch (error) {
+        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"];
@@ -3097,10 +3326,38 @@ function validateCanonicalTaskReferences(state, aggregate) {
             }
         }
     }
+    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

package/dist/storage/upgrade/recordVersions.js

@@ -16,9 +16,10 @@
  * transform in the production migration graph.
  */
 import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "../storageVersions.js";
-import { CURRENT_AGENT_RUN_SCHEMA_VERSION, CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, CURRENT_CHANGE_SET_SCHEMA_VERSION, CURRENT_DECISION_SCHEMA_VERSION, CURRENT_EVENT_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, CURRENT_MESSAGE_SCHEMA_VERSION, CURRENT_MILESTONE_SCHEMA_VERSION, CURRENT_PROJECT_SCHEMA_VERSION, CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, CURRENT_STORED_TASK_SCHEMA_VERSION, CURRENT_TASK_BRIEF_SCHEMA_VERSION, CURRENT_TASK_ROLE_SCHEMA_VERSION, CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_TASK_SCHEMA_VERSION, CURRENT_WORK_ITEM_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION } from "../taskStore.js";
+import { CURRENT_AGENT_RUN_SCHEMA_VERSION, CURRENT_ACTIVE_RUN_POINTER_SCHEMA_VERSION, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, CURRENT_CHANGE_SET_SCHEMA_VERSION, CURRENT_DECISION_SCHEMA_VERSION, CURRENT_EVENT_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, CURRENT_MESSAGE_SCHEMA_VERSION, CURRENT_MILESTONE_SCHEMA_VERSION, CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION, CURRENT_PROJECT_SCHEMA_VERSION, CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, CURRENT_STORED_TASK_SCHEMA_VERSION, CURRENT_TASK_BRIEF_SCHEMA_VERSION, CURRENT_TASK_ROLE_SCHEMA_VERSION, CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_TASK_SCHEMA_VERSION, CURRENT_WORK_ITEM_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION } from "../taskStore.js";
 import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../../scheduler/leaderFailure.js";
 import { CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION } from "../../scheduler/operatorNotification.js";
+import { CURRENT_TASK_WAKE_SCHEMA_VERSION } from "../../scheduler/taskWake.js";
 import { CURRENT_DURABLE_JOB_SCHEMA_VERSION } from "../../job/durableJob.js";
 function descriptor(version, path) {
     return Object.freeze({ version, path });
@@ -55,8 +56,10 @@ const EXPECTED_DIRECT_RECORD_LOCATORS = Object.freeze({
     decision: "state.json#/tasks/*/decisions",
     milestone: "state.json#/tasks/*/milestones",
     event: "state.json#/tasks/*/events",
+    taskWake: "state.json#/tasks/*/wakes",
     capabilityGrant: "state.json#/tasks/*/capabilityGrants",
     releaseWorkflow: "state.json#/tasks/*/releaseWorkflows",
+    publicationReference: "state.json#/tasks/*/publicationReferences",
     leaderFailure: "state.json#/tasks/*/leaderFailure",
     operatorNotification: "state.json#/tasks/*/operatorNotification",
     workMailbox: "state.json#/mailboxes"
@@ -108,8 +111,10 @@ function getCurrentRecordDescriptors() {
             decision: descriptor(CURRENT_DECISION_SCHEMA_VERSION, "state.json#/tasks/*/decisions"),
             milestone: descriptor(CURRENT_MILESTONE_SCHEMA_VERSION, "state.json#/tasks/*/milestones"),
             event: descriptor(CURRENT_EVENT_SCHEMA_VERSION, "state.json#/tasks/*/events"),
+            taskWake: descriptor(CURRENT_TASK_WAKE_SCHEMA_VERSION, "state.json#/tasks/*/wakes"),
             capabilityGrant: descriptor(CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, "state.json#/tasks/*/capabilityGrants"),
             releaseWorkflow: descriptor(CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION, "state.json#/tasks/*/releaseWorkflows"),
+            publicationReference: descriptor(CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION, "state.json#/tasks/*/publicationReferences"),
             leaderFailure: descriptor(CURRENT_LEADER_FAILURE_SCHEMA_VERSION, "state.json#/tasks/*/leaderFailure"),
             operatorNotification: descriptor(CURRENT_OPERATOR_NOTIFICATION_SCHEMA_VERSION, "state.json#/tasks/*/operatorNotification"),
             workMailbox: descriptor(CURRENT_WORK_MAILBOX_SCHEMA_VERSION, "state.json#/mailboxes")

package/dist/storage/upgrade/sqliteFileSet.js

@@ -0,0 +1,50 @@
+import { existsSync, renameSync, rmSync } from "node:fs";
+const SQLITE_FILE_SUFFIXES = ["", "-wal", "-shm"];
+/**
+ * Move a SQLite database together with any live WAL/SHM sidecars.
+ *
+ * A WAL database is one logical file set. Moving only the main file can leave
+ * the old WAL under the promoted database name, causing SQLite to replay it
+ * against an unrelated database. The migration fence guarantees there are no
+ * writers while this bounded rename runs.
+ */
+export function moveSqliteFileSet(sourcePath, targetPath, rename = renameSync) {
+    const suffixes = SQLITE_FILE_SUFFIXES.filter((suffix) => existsSync(`${sourcePath}${suffix}`));
+    for (const suffix of suffixes) {
+        if (existsSync(`${targetPath}${suffix}`)) {
+            throw new Error(`Refusing to overwrite an existing SQLite switch target: ${targetPath}${suffix}.`);
+        }
+    }
+    const moved = [];
+    try {
+        for (const suffix of suffixes) {
+            rename(`${sourcePath}${suffix}`, `${targetPath}${suffix}`);
+            moved.push(suffix);
+        }
+    }
+    catch (error) {
+        let rollbackError;
+        for (const suffix of moved.reverse()) {
+            try {
+                rename(`${targetPath}${suffix}`, `${sourcePath}${suffix}`);
+            }
+            catch (candidate) {
+                rollbackError ??= candidate;
+            }
+        }
+        if (rollbackError !== undefined) {
+            throw new Error(`SQLite file-set move failed and rollback was incomplete: ${messageOf(error)}; `
+                + `rollback failed: ${messageOf(rollbackError)}`);
+        }
+        throw error;
+    }
+}
+/** Remove a promoted SQLite file set before restoring its timestamped backup. */
+export function removeSqliteFileSet(databasePath) {
+    for (const suffix of SQLITE_FILE_SUFFIXES) {
+        rmSync(`${databasePath}${suffix}`, { force: true });
+    }
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/storage/upgrade/sqliteMigrationTarget.js

@@ -42,6 +42,7 @@ import { describeActiveRuntime, homeRuntimeIsActive, inspectHomeRuntime, inspect
 import { COMMITTED_DATABASE_FILENAME, STAGED_DATABASE_FILENAME, computeDbFamilyChecksums, computeStateFamilyChecksums, populateSqliteFromState } from "./sqliteStateMigration.js";
 import { latestStateBackupPath } from "./pseudoLayoutRepair.js";
 import { migrationReceiptPath, writeMigrationReceipt } from "./migrationReceipt.js";
+import { moveSqliteFileSet, removeSqliteFileSet } from "./sqliteFileSet.js";
 /** Build the SQLite-backed migration target. */
 export function createSqliteMigrationTarget(options) {
     const home = options.home;
@@ -155,7 +156,7 @@ export function createSqliteMigrationTarget(options) {
                     if (existsSync(backupPath)) {
                         throw new Error(`Refusing to overwrite an existing database backup: ${backupPath}.`);
                     }
-                    renameSync(committedDbPath, backupPath);
+                    moveSqliteFileSet(committedDbPath, backupPath);
                 }
                 renameSync(stagedDbPath, committedDbPath);
                 // The staged connection may leave empty WAL/SHM sidecars behind
@@ -167,7 +168,7 @@ export function createSqliteMigrationTarget(options) {
                 // Pre-promotion failure: restore the original database if we moved it.
                 if (backupPath !== undefined && existsSync(backupPath)) {
                     try {
-                        renameSync(backupPath, committedDbPath);
+                        moveSqliteFileSet(backupPath, committedDbPath);
                     }
                     catch {
                         throw new AmbiguousSwitchError({
@@ -208,10 +209,11 @@ export function createSqliteMigrationTarget(options) {
                 // is ambiguous and must be recovered manually.
                 try {
                     if (backupPath !== undefined && existsSync(backupPath)) {
-                        renameSync(backupPath, committedDbPath);
+                        removeSqliteFileSet(committedDbPath);
+                        moveSqliteFileSet(backupPath, committedDbPath);
                     }
                     else {
-                        rmSync(committedDbPath, { force: true });
+                        removeSqliteFileSet(committedDbPath);
                     }
                 }
                 catch {

package/dist/storage/upgrade/sqliteRecordMigrationTarget.js

@@ -37,6 +37,7 @@ import { planMigration } from "../migration/planner.js";
 import { AmbiguousSwitchError } from "../migration/index.js";
 import { describeActiveRuntime, homeRuntimeIsActive, inspectHomeRuntime, inspectSourceVersionState, inspectSnapshotVersionState } from "./homeMigrationTarget.js";
 import { writeSwitchProgress } from "./switchProgress.js";
+import { moveSqliteFileSet, removeSqliteFileSet } from "./sqliteFileSet.js";
 import { COMMITTED_DATABASE_FILENAME, STAGED_DATABASE_FILENAME, copySqlitePassthroughState, computeDbFamilyChecksums, computeStateFamilyChecksums, populateSqliteFromState, readStateFromSqlite } from "./sqliteStateMigration.js";
 /** Build the SQLite-backed record-migration target. */
 export function createSqliteRecordMigrationTarget(options) {
@@ -135,7 +136,7 @@ export function createSqliteRecordMigrationTarget(options) {
                     if (existsSync(backupPath)) {
                         throw new Error(`Refusing to overwrite an existing database backup: ${backupPath}.`);
                     }
-                    renameSync(committedDbPath, backupPath);
+                    moveSqliteFileSet(committedDbPath, backupPath);
                 }
                 promoteRename(stagedDbPath, committedDbPath);
                 // The staged connection may leave empty WAL/SHM sidecars behind
@@ -147,7 +148,7 @@ export function createSqliteRecordMigrationTarget(options) {
                 // Pre-promotion failure: restore the original database if we moved it.
                 if (backupPath !== undefined && existsSync(backupPath)) {
                     try {
-                        promoteRename(backupPath, committedDbPath);
+                        moveSqliteFileSet(backupPath, committedDbPath, promoteRename);
                     }
                     catch {
                         writeInterruptedMarker(home, backupPath, stagedDbPath, now);
@@ -175,10 +176,11 @@ export function createSqliteRecordMigrationTarget(options) {
                 // is ambiguous and must be recovered manually.
                 try {
                     if (backupPath !== undefined && existsSync(backupPath)) {
-                        promoteRename(backupPath, committedDbPath);
+                        removeSqliteFileSet(committedDbPath);
+                        moveSqliteFileSet(backupPath, committedDbPath, promoteRename);
                     }
                     else {
-                        rmSync(committedDbPath, { force: true });
+                        removeSqliteFileSet(committedDbPath);
                     }
                 }
                 catch {