@zq-silk/yui 0.6.13 → 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/sqliteStateMigration.js

@@ -189,11 +189,13 @@ function asStoredTask(value) {
         decisions: asObjectMap(record.decisions),
         milestones: asObjectMap(record.milestones),
         events: asObjectMap(record.events),
+        wakes: asObjectMap(record.wakes),
         leaderFailure: asNullableObject(record.leaderFailure),
         operatorNotification: asNullableObject(record.operatorNotification),
         idHighWaterMarks: asObject(record.idHighWaterMarks),
         capabilityGrants: asObjectMap(record.capabilityGrants),
-        releaseWorkflows: asObjectMap(record.releaseWorkflows)
+        releaseWorkflows: asObjectMap(record.releaseWorkflows),
+        publicationReferences: asObjectMap(record.publicationReferences)
     };
 }
 function tasksOf(state) {
@@ -335,6 +337,9 @@ export function populateSqliteFromState(home, state, databaseFilename) {
                 for (const event of Object.values(stored.events)) {
                     store.saveEvent(taskId, event);
                 }
+                for (const wake of Object.values(stored.wakes)) {
+                    store.saveTaskWake(taskId, wake);
+                }
                 if (stored.leaderFailure !== null) {
                     store.saveLeaderFailure(stored.leaderFailure);
                 }
@@ -354,6 +359,9 @@ export function populateSqliteFromState(home, state, databaseFilename) {
                 for (const workflow of Object.values(stored.releaseWorkflows)) {
                     store.saveReleaseWorkflow(taskId, workflow);
                 }
+                for (const reference of Object.values(stored.publicationReferences)) {
+                    store.savePublicationReference(taskId, reference);
+                }
             }
             // Work mailboxes.
             for (const mailbox of Object.values(asObjectMap(state.mailboxes))) {
@@ -456,10 +464,12 @@ export function computeStateFamilyChecksums(state) {
     const decisions = [];
     const milestones = [];
     const events = [];
+    const wakes = [];
     const leaderFailures = [];
     const operatorNotifications = [];
     const capabilityGrants = [];
     const releaseWorkflows = [];
+    const publicationReferences = [];
     for (const stored of Object.values(tasks)) {
         taskRecords.push(stored.task);
         if (stored.brief !== null)
@@ -492,12 +502,14 @@ export function computeStateFamilyChecksums(state) {
         decisions.push(...Object.values(stored.decisions));
         milestones.push(...Object.values(stored.milestones));
         events.push(...Object.values(stored.events));
+        wakes.push(...Object.values(stored.wakes));
         if (stored.leaderFailure !== null)
             leaderFailures.push(stored.leaderFailure);
         if (stored.operatorNotification !== null)
             operatorNotifications.push(stored.operatorNotification);
         capabilityGrants.push(...Object.values(stored.capabilityGrants));
         releaseWorkflows.push(...Object.values(stored.releaseWorkflows));
+        publicationReferences.push(...Object.values(stored.publicationReferences));
     }
     checksums.task = hashRecords(taskRecords);
     checksums.taskBrief = hashRecords(briefs);
@@ -518,10 +530,12 @@ export function computeStateFamilyChecksums(state) {
     checksums.decision = hashRecords(decisions);
     checksums.milestone = hashRecords(milestones);
     checksums.event = hashRecords(events);
+    checksums.taskWake = hashRecords(wakes);
     checksums.leaderFailure = hashRecords(leaderFailures);
     checksums.operatorNotification = hashRecords(operatorNotifications);
     checksums.capabilityGrant = hashRecords(capabilityGrants);
     checksums.releaseWorkflow = hashRecords(releaseWorkflows);
+    checksums.publicationReference = hashRecords(publicationReferences);
     checksums.workMailbox = hashRecords(Object.values(asObjectMap(state.mailboxes)));
     return checksums;
 }
@@ -609,10 +623,12 @@ export function computeDbFamilyChecksums(home, databaseFilename) {
         checksums.decision = hashPayloadTable(db, "SELECT payload FROM decisions");
         checksums.milestone = hashPayloadTable(db, "SELECT payload FROM milestones");
         checksums.event = hashPayloadTable(db, "SELECT payload FROM events");
+        checksums.taskWake = hashPayloadTable(db, "SELECT payload FROM task_wakes");
         checksums.leaderFailure = hashPayloadTable(db, "SELECT payload FROM task_projections WHERE kind = 'leader-failure' AND payload IS NOT NULL");
         checksums.operatorNotification = hashPayloadTable(db, "SELECT payload FROM task_projections WHERE kind = 'operator-notification' AND payload IS NOT NULL");
         checksums.capabilityGrant = hashPayloadTable(db, "SELECT payload FROM capability_grants");
         checksums.releaseWorkflow = hashPayloadTable(db, "SELECT payload FROM release_workflows");
+        checksums.publicationReference = hashPayloadTable(db, "SELECT payload FROM publication_references");
         // Mailboxes are reconstructed from typed columns (no payload column).
         const mailboxRows = readWorkMailboxRows(db);
         checksums.workMailbox = hashRecords(mailboxRows.map(rowToMailbox));
@@ -730,11 +746,13 @@ export function readStateFromSqlite(home) {
                 decisions: {},
                 milestones: {},
                 events: {},
+                wakes: {},
                 leaderFailure: null,
                 operatorNotification: null,
                 idHighWaterMarks: {},
                 capabilityGrants: {},
-                releaseWorkflows: {}
+                releaseWorkflows: {},
+                publicationReferences: {}
             };
         }
         // Per-task record families, keyed by their state.json map keys.
@@ -753,8 +771,10 @@ export function readStateFromSqlite(home) {
         loadTaskPayloadMap(db, "decisions", tasks, "decisions", (record) => record.id);
         loadTaskPayloadMap(db, "milestones", tasks, "milestones", (record) => record.id);
         loadTaskPayloadMap(db, "events", tasks, "events", (record) => record.id);
+        loadTaskPayloadMap(db, "task_wakes", tasks, "wakes", (record) => record.id);
         loadTaskPayloadMap(db, "capability_grants", tasks, "capabilityGrants", (record) => record.id);
         loadTaskPayloadMap(db, "release_workflows", tasks, "releaseWorkflows", (record) => record.id);
+        loadTaskPayloadMap(db, "publication_references", tasks, "publicationReferences", (record) => record.id);
         // Job caller key hashes: keyed by `${roleName}\0${agentId}`.
         const callerHashRows = db.prepare("SELECT task_id, role_name, agent_id, hash FROM job_caller_key_hashes").all();
         for (const row of callerHashRows) {