@zq-silk/yui 0.6.0 → 0.6.2

package/dist/storage/migration/productionRegistry.js

@@ -22,6 +22,15 @@ const WORK_ITEM_GROUP_HISTORY_FROM_VERSION = 8;
 const WORK_ITEM_GROUP_HISTORY_TO_VERSION = 9;
 const AGENT_RUN_FROM_VERSION = 5;
 const AGENT_RUN_TO_VERSION = 6;
+/**
+ * v7 combines the optional Issue 04 `providerRetry`/`yieldReceipt` fields and
+ * Issue 05 Leader actionability fields. All are optional, so the transition is
+ * a version-only rewrite; legacy v6 records without them remain valid.
+ */
+const AGENT_RUN_OPTIONAL_FIELDS_FROM_VERSION = 6;
+const AGENT_RUN_OPTIONAL_FIELDS_TO_VERSION = 7;
+const MESSAGE_WAKE_POLICY_FROM_VERSION = 2;
+const MESSAGE_WAKE_POLICY_TO_VERSION = 3;
 const REVIEW_ROUND_FROM_VERSION = 2;
 const REVIEW_ROUND_TO_VERSION = 3;
 const REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION = 3;
@@ -32,6 +41,22 @@ const ACTIVE_RUN_POINTER_NAMESPACE_FROM_VERSION = 2;
 const ACTIVE_RUN_POINTER_NAMESPACE_TO_VERSION = 3;
 const MANAGED_WORKSPACE_FROM_VERSION = 1;
 const MANAGED_WORKSPACE_TO_VERSION = 2;
+const CHANGE_SET_MANIFEST_FROM_VERSION = 2;
+const CHANGE_SET_MANIFEST_TO_VERSION = 3;
+const INTEGRATION_ATTEMPT_FROM_VERSION = 2;
+const INTEGRATION_ATTEMPT_TO_VERSION = 3;
+const INTEGRATION_ATTEMPT_GATE_IDENTITY_FROM_VERSION = 3;
+const INTEGRATION_ATTEMPT_GATE_IDENTITY_TO_VERSION = 4;
+const INTEGRATION_QUEUE_FROM_VERSION = 0;
+const INTEGRATION_QUEUE_TO_VERSION = 1;
+const STORED_TASK_DURABLE_JOBS_FROM_VERSION = 14;
+const STORED_TASK_DURABLE_JOBS_TO_VERSION = 15;
+const STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION = 15;
+const STORED_TASK_JOB_CALLER_KEY_HASHES_TO_VERSION = 16;
+const CAPABILITY_GRANT_FROM_VERSION = 0;
+const CAPABILITY_GRANT_TO_VERSION = 1;
+const RELEASE_WORKFLOW_FROM_VERSION = 0;
+const RELEASE_WORKFLOW_TO_VERSION = 1;
 /**
  * Build the authoritative production graph. Transition intent and executable
  * transforms are registered together here; compatible loading and offline
@@ -69,11 +94,22 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION, WORK_ITEM_GIT_SNAPSHOT_TO_VERSION, "workItems"))
         .registerOfflineMigration(workItemExecutionGroupHistoryStep())
         .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_FROM_VERSION, AGENT_RUN_TO_VERSION, "agentRuns"))
+        .registerOfflineMigration(recordFamilyStep("agentRun", AGENT_RUN_OPTIONAL_FIELDS_FROM_VERSION, AGENT_RUN_OPTIONAL_FIELDS_TO_VERSION, "agentRuns"))
+        .registerOfflineMigration(messageWakePolicyStep())
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_FROM_VERSION, REVIEW_ROUND_TO_VERSION, "reviewRounds"))
         .registerOfflineMigration(recordFamilyStep("reviewRound", REVIEW_ROUND_GIT_SNAPSHOT_FROM_VERSION, REVIEW_ROUND_GIT_SNAPSHOT_TO_VERSION, "reviewRounds"))
         .registerOfflineMigration(recordFamilyStep("activeRunPointer", ACTIVE_RUN_POINTER_FROM_VERSION, ACTIVE_RUN_POINTER_TO_VERSION, "activeRuns"))
         .registerOfflineMigration(managedWorkspaceFamilyStep())
-        .registerOfflineMigration(activeRunPointerNamespaceStep());
+        .registerOfflineMigration(activeRunPointerNamespaceStep())
+        .registerOfflineMigration(changeSetManifestStep())
+        .registerOfflineMigration(integrationAttemptSupersededStep())
+        .registerOfflineMigration(recordFamilyStep("integrationAttempt", INTEGRATION_ATTEMPT_GATE_IDENTITY_FROM_VERSION, INTEGRATION_ATTEMPT_GATE_IDENTITY_TO_VERSION, "integrationAttempts"))
+        .registerOfflineMigration(integrationQueueIntroductionStep())
+        .registerCompatible(storedTaskDurableJobsStep())
+        .registerCompatible(storedTaskJobCallerKeyHashesStep())
+        .registerCompatible(durableJobIntroductionStep())
+        .registerOfflineMigration(capabilityGrantIntroductionStep())
+        .registerOfflineMigration(releaseWorkflowIntroductionStep());
     assertRegistryCoversBaselineToCurrent(registry);
     return registry;
 }
@@ -88,6 +124,80 @@ function workItemExecutionGroupHistoryStep() {
         declaredEffects: []
     };
 }
+/**
+ * Task Messages gain an optional `wakePolicy` field (Issue 05). The field is
+ * absent on every older record, so this adjacent step only advances the
+ * family version; the strict current parser treats the omitted field as
+ * "no explicit policy" and preserves the existing routing.
+ */
+function messageWakePolicyStep() {
+    return {
+        axis: "record",
+        recordKind: "message",
+        fromVersion: MESSAGE_WAKE_POLICY_FROM_VERSION,
+        toVersion: MESSAGE_WAKE_POLICY_TO_VERSION,
+        preconditions: (snapshot) => requireMessageFamilyVersion(snapshot, MESSAGE_WAKE_POLICY_FROM_VERSION),
+        transform: migrateMessageWakePolicy,
+        declaredEffects: []
+    };
+}
+function requireMessageFamilyVersion(snapshot, version) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.message !== version) {
+        throw new Error(`Message migration requires manifest version ${version}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const messages = task.messages;
+        if (messages === undefined)
+            continue;
+        const map = asObject(messages, `message map ${taskId}`);
+        for (const [messageId, rawMessage] of Object.entries(map)) {
+            const message = asObject(rawMessage, `message ${taskId}/${messageId}`);
+            if (message.schemaVersion !== version) {
+                throw new Error(`Message ${taskId}/${messageId} must use schemaVersion ${version}.`);
+            }
+        }
+    }
+}
+function migrateMessageWakePolicy(snapshot) {
+    requireMessageFamilyVersion(snapshot, MESSAGE_WAKE_POLICY_FROM_VERSION);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            message: MESSAGE_WAKE_POLICY_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.messages === undefined) {
+            nextTasks[taskId] = { ...task };
+            continue;
+        }
+        const messages = asObject(task.messages, `message map ${taskId}`);
+        const nextMessages = {};
+        for (const [messageId, rawMessage] of Object.entries(messages)) {
+            nextMessages[messageId] = {
+                ...asObject(rawMessage, `message ${taskId}/${messageId}`),
+                schemaVersion: MESSAGE_WAKE_POLICY_TO_VERSION
+            };
+        }
+        nextTasks[taskId] = { ...task, messages: nextMessages };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 /**
  * ManagedWorkspace is stored once in the owner-keyed workspace map and copied
  * into Candidates, AgentRuns, and ReviewRounds as immutable lifecycle
@@ -366,6 +476,215 @@ function migrateActiveRunPointerNamespace(snapshot) {
         state: { ...snapshot.state, tasks: nextTasks }
     };
 }
+/**
+ * ChangeSet v3 adds the optional integration manifest (tags, deleted paths,
+ * target ref, evidence references).  The manifest is optional, so the
+ * transition only rewrites the record version; legacy records without a
+ * manifest remain valid and keep integrating.
+ */
+function changeSetManifestStep() {
+    return {
+        axis: "record",
+        recordKind: "changeSet",
+        fromVersion: CHANGE_SET_MANIFEST_FROM_VERSION,
+        toVersion: CHANGE_SET_MANIFEST_TO_VERSION,
+        preconditions: requireChangeSetManifestVersion,
+        transform: migrateChangeSetManifest,
+        declaredEffects: []
+    };
+}
+function requireChangeSetManifestVersion(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.changeSet !== CHANGE_SET_MANIFEST_FROM_VERSION) {
+        throw new Error(`Record changeSet migration requires manifest version ${CHANGE_SET_MANIFEST_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.changeSets === undefined)
+            continue;
+        const changeSets = asObject(task.changeSets, `changeSet map ${taskId}`);
+        for (const [changeSetId, rawRecord] of Object.entries(changeSets)) {
+            const record = asObject(rawRecord, `changeSet ${taskId}/${changeSetId}`);
+            if (record.schemaVersion !== CHANGE_SET_MANIFEST_FROM_VERSION) {
+                throw new Error(`changeSet ${taskId}/${changeSetId} must use schemaVersion ${CHANGE_SET_MANIFEST_FROM_VERSION}.`);
+            }
+        }
+    }
+}
+function migrateChangeSetManifest(snapshot) {
+    requireChangeSetManifestVersion(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            changeSet: CHANGE_SET_MANIFEST_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.changeSets === undefined) {
+            nextTasks[taskId] = { ...task };
+            continue;
+        }
+        const changeSets = asObject(task.changeSets, `changeSet map ${taskId}`);
+        const nextChangeSets = {};
+        for (const [changeSetId, rawRecord] of Object.entries(changeSets)) {
+            const record = asObject(rawRecord, `changeSet ${taskId}/${changeSetId}`);
+            nextChangeSets[changeSetId] = {
+                ...record,
+                schemaVersion: CHANGE_SET_MANIFEST_TO_VERSION
+            };
+        }
+        nextTasks[taskId] = { ...task, changeSets: nextChangeSets };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+/**
+ * IntegrationAttempt v2->v3 adds the "superseded" terminal status for
+ * committed Integrations that are obsolete.  The migration preserves all
+ * existing fields and advances the schema version; the new status is
+ * opt-in, so old records remain valid until explicitly superseded.
+ */
+function integrationAttemptSupersededStep() {
+    return {
+        axis: "record",
+        recordKind: "integrationAttempt",
+        fromVersion: INTEGRATION_ATTEMPT_FROM_VERSION,
+        toVersion: INTEGRATION_ATTEMPT_TO_VERSION,
+        preconditions: requireIntegrationAttemptV2,
+        transform: migrateIntegrationAttemptV2ToV3,
+        declaredEffects: []
+    };
+}
+function requireIntegrationAttemptV2(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.integrationAttempt !== INTEGRATION_ATTEMPT_FROM_VERSION) {
+        throw new Error(`Record integrationAttempt migration requires manifest version ${INTEGRATION_ATTEMPT_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.integrationAttempts === undefined)
+            continue;
+        const attempts = asObject(task.integrationAttempts, `integrationAttempt map ${taskId}`);
+        for (const [attemptId, rawRecord] of Object.entries(attempts)) {
+            const record = asObject(rawRecord, `integrationAttempt ${taskId}/${attemptId}`);
+            if (record.schemaVersion !== INTEGRATION_ATTEMPT_FROM_VERSION) {
+                throw new Error(`integrationAttempt ${taskId}/${attemptId} must use schemaVersion ${INTEGRATION_ATTEMPT_FROM_VERSION}.`);
+            }
+        }
+    }
+}
+function migrateIntegrationAttemptV2ToV3(snapshot) {
+    requireIntegrationAttemptV2(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            integrationAttempt: INTEGRATION_ATTEMPT_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.integrationAttempts === undefined) {
+            nextTasks[taskId] = { ...task };
+            continue;
+        }
+        const attempts = asObject(task.integrationAttempts, `integrationAttempt map ${taskId}`);
+        const nextAttempts = {};
+        for (const [attemptId, rawRecord] of Object.entries(attempts)) {
+            const record = asObject(rawRecord, `integrationAttempt ${taskId}/${attemptId}`);
+            nextAttempts[attemptId] = {
+                ...record,
+                schemaVersion: INTEGRATION_ATTEMPT_TO_VERSION
+            };
+        }
+        nextTasks[taskId] = { ...task, integrationAttempts: nextAttempts };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+/**
+ * The integration queue is a post-baseline per-Task record family.  Its
+ * explicit 0->1 introduction adds the empty map and its id high-water mark to
+ * every Task aggregate and the family to the record manifest; old Homes keep
+ * integrating without it until the queue is first used.
+ */
+function integrationQueueIntroductionStep() {
+    return {
+        axis: "record",
+        recordKind: "integrationQueue",
+        fromVersion: INTEGRATION_QUEUE_FROM_VERSION,
+        toVersion: INTEGRATION_QUEUE_TO_VERSION,
+        introduction: true,
+        preconditions: requireIntegrationQueueIntroduction,
+        transform: introduceIntegrationQueue,
+        declaredEffects: []
+    };
+}
+function requireIntegrationQueueIntroduction(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.integrationQueue !== undefined) {
+        throw new Error("integrationQueue is already introduced in the record manifest.");
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.integrationQueue !== undefined) {
+            throw new Error(`Task aggregate already carries an integrationQueue map: ${taskId}.`);
+        }
+    }
+}
+function introduceIntegrationQueue(snapshot) {
+    requireIntegrationQueueIntroduction(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            integrationQueue: INTEGRATION_QUEUE_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const highWaterMarks = asObject(task.idHighWaterMarks ?? {}, `Task id high-water marks ${taskId}`);
+        nextTasks[taskId] = {
+            ...task,
+            idHighWaterMarks: { ...highWaterMarks, integrationQueue: 0 },
+            integrationQueue: {}
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 function legacyLaneKeyParts(key) {
     const match = /^lane:([^:]+):([^:]+)$/u.exec(key);
     if (match === null)
@@ -378,6 +697,274 @@ function executionLaneNamespaceKey(executionGroupId, executionLaneId) {
 function encodeLaneKeyPart(value) {
     return encodeURIComponent(value).replace(/:/gu, "%3A");
 }
+/**
+ * The StoredTask aggregate gains the `durableJobs` record family. Every v14
+ * task defaults to an empty map; the compatible normalizer adds it in place
+ * without rewriting any other field. The strict source validator rejects
+ * unknown fields so a pre-v15 Home cannot smuggle an unrecognized shape.
+ */
+function storedTaskDurableJobsStep() {
+    return {
+        kind: "compatible",
+        axis: "record",
+        recordKind: "storedTask",
+        fromVersion: STORED_TASK_DURABLE_JOBS_FROM_VERSION,
+        toVersion: STORED_TASK_DURABLE_JOBS_TO_VERSION,
+        defaults: [
+            "durableJobs defaults to an empty map on every Task aggregate",
+            "idHighWaterMarks.durableJob defaults to 0 on every Task aggregate"
+        ],
+        validateSource: (snapshot) => requireStoredTaskV14Shape(snapshot),
+        normalize: (snapshot) => normalizeStoredTaskV14ToV15(snapshot)
+    };
+}
+const STORED_TASK_V14_FIELDS = [
+    "schemaVersion",
+    "task",
+    "idHighWaterMarks",
+    "brief",
+    "changeSets",
+    "integrationAttempts",
+    "integrationQueue",
+    // durableJobs may already be present on a v14 task when the Home was
+    // written by a build that had the family before the storedTask version
+    // advanced (or after a state.json→SQLite repair round-trip, which
+    // reconstructs every current family map). The 14→15 normalizer preserves
+    // existing records instead of overwriting them with an empty map.
+    "durableJobs",
+    // jobCallerKeyHashes is introduced at v16 but the state.json→SQLite repair
+    // round-trip reconstructs every current family map, so a v14 task may carry
+    // an empty map after the repair. The 14→15 normalizer preserves it.
+    "jobCallerKeyHashes",
+    "capabilityGrants",
+    "releaseWorkflows",
+    "roles",
+    "managedWorkspaces",
+    "roleSessionSets",
+    "workItems",
+    "agentRuns",
+    "reviewRounds",
+    "activeRuns",
+    "messages",
+    "inputRequests",
+    "decisions",
+    "milestones",
+    "events",
+    "leaderFailure",
+    "operatorNotification"
+];
+function requireStoredTaskV14Shape(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.storedTask !== STORED_TASK_DURABLE_JOBS_FROM_VERSION) {
+        throw new Error(`Record storedTask compatible step requires manifest version ${STORED_TASK_DURABLE_JOBS_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.schemaVersion !== STORED_TASK_DURABLE_JOBS_FROM_VERSION) {
+            throw new Error(`Task aggregate ${taskId} must use schemaVersion ${STORED_TASK_DURABLE_JOBS_FROM_VERSION}.`);
+        }
+        const allowed = new Set(STORED_TASK_V14_FIELDS);
+        const unknown = Object.keys(task).find((key) => !allowed.has(key));
+        if (unknown !== undefined) {
+            throw new Error(`Task aggregate ${taskId} has an unknown v14 field: ${unknown}.`);
+        }
+    }
+}
+function normalizeStoredTaskV14ToV15(snapshot) {
+    requireStoredTaskV14Shape(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            storedTask: STORED_TASK_DURABLE_JOBS_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        // The v14 high-water marks have no durableJob family; the strict current
+        // parser requires every family key, so the normalizer supplies the zero
+        // default in the same pass as the empty durableJobs map.
+        const highWaterMarks = asObject(task.idHighWaterMarks, `Task aggregate ${taskId} idHighWaterMarks`);
+        const existingJobs = task.durableJobs === undefined
+            ? {}
+            : asObject(task.durableJobs, `Task aggregate ${taskId} durableJobs`);
+        const existingJobMark = highWaterMarks.durableJob;
+        nextTasks[taskId] = {
+            ...task,
+            schemaVersion: STORED_TASK_DURABLE_JOBS_TO_VERSION,
+            idHighWaterMarks: {
+                ...highWaterMarks,
+                durableJob: typeof existingJobMark === "number" ? existingJobMark : 0
+            },
+            durableJobs: existingJobs
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+/**
+ * rr13: The StoredTask aggregate gains the `jobCallerKeyHashes` map. Every v15
+ * task defaults to an empty map; the compatible normalizer adds it in place
+ * without rewriting any other field. A v15 task must not already carry the
+ * field. No legacy fallback: a Session whose hash is absent is rejected at the
+ * Controller boundary (fail-closed).
+ */
+function storedTaskJobCallerKeyHashesStep() {
+    return {
+        kind: "compatible",
+        axis: "record",
+        recordKind: "storedTask",
+        fromVersion: STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION,
+        toVersion: STORED_TASK_JOB_CALLER_KEY_HASHES_TO_VERSION,
+        defaults: [
+            "jobCallerKeyHashes defaults to an empty map on every Task aggregate"
+        ],
+        validateSource: (snapshot) => requireStoredTaskV15Shape(snapshot),
+        normalize: (snapshot) => normalizeStoredTaskV15ToV16(snapshot)
+    };
+}
+const STORED_TASK_V15_FIELDS = [
+    "schemaVersion",
+    "task",
+    "idHighWaterMarks",
+    "brief",
+    "changeSets",
+    "integrationAttempts",
+    "integrationQueue",
+    "durableJobs",
+    // May already be present after a state.json→SQLite repair round-trip (the
+    // reverse reader reconstructs every current family map). The 15→16
+    // normalizer preserves existing hashes instead of overwriting them.
+    "jobCallerKeyHashes",
+    "capabilityGrants",
+    "releaseWorkflows",
+    "roles",
+    "managedWorkspaces",
+    "roleSessionSets",
+    "workItems",
+    "agentRuns",
+    "reviewRounds",
+    "activeRuns",
+    "messages",
+    "inputRequests",
+    "decisions",
+    "milestones",
+    "events",
+    "leaderFailure",
+    "operatorNotification"
+];
+function requireStoredTaskV15Shape(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.storedTask !== STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION) {
+        throw new Error(`Record storedTask compatible step requires manifest version ${STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.schemaVersion !== STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION) {
+            throw new Error(`Task aggregate ${taskId} must use schemaVersion ${STORED_TASK_JOB_CALLER_KEY_HASHES_FROM_VERSION}.`);
+        }
+        const allowed = new Set(STORED_TASK_V15_FIELDS);
+        const unknown = Object.keys(task).find((key) => !allowed.has(key));
+        if (unknown !== undefined) {
+            throw new Error(`Task aggregate ${taskId} has an unknown v15 field: ${unknown}.`);
+        }
+    }
+}
+function normalizeStoredTaskV15ToV16(snapshot) {
+    requireStoredTaskV15Shape(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            storedTask: STORED_TASK_JOB_CALLER_KEY_HASHES_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const existingHashes = task.jobCallerKeyHashes === undefined
+            ? {}
+            : asObject(task.jobCallerKeyHashes, `Task aggregate ${taskId} jobCallerKeyHashes`);
+        nextTasks[taskId] = {
+            ...task,
+            schemaVersion: STORED_TASK_JOB_CALLER_KEY_HASHES_TO_VERSION,
+            jobCallerKeyHashes: existingHashes
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+/**
+ * The durableJob record family is introduced alongside the StoredTask v15
+ * aggregate. A pre-baseline Home has no durableJobs map and no manifest entry;
+ * the introduction declares the family at version 1. The StoredTask 14->15
+ * compatible step supplies the empty map; this step only advances the manifest
+ * record version so the planner can resolve the 0->1 boundary.
+ */
+function durableJobIntroductionStep() {
+    return {
+        kind: "compatible",
+        axis: "record",
+        recordKind: "durableJob",
+        fromVersion: 0,
+        toVersion: 1,
+        introduction: true,
+        defaults: ["durableJob family is introduced as an empty map on every Task"],
+        validateSource: (snapshot) => {
+            const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+            const declared = manifestVersions.durableJob;
+            if (declared !== undefined && declared !== 0) {
+                throw new Error(`Record durableJob introduction requires manifest version 0 or absent, found ${String(declared)}.`);
+            }
+            if (snapshot.state === null)
+                return;
+            const tasks = asObject(snapshot.state.tasks, "state tasks");
+            for (const [taskId, rawTask] of Object.entries(tasks)) {
+                const task = asObject(rawTask, `Task aggregate ${taskId}`);
+                if (task.durableJobs !== undefined) {
+                    const jobs = asObject(task.durableJobs, `durableJobs map ${taskId}`);
+                    if (Object.keys(jobs).length > 0) {
+                        throw new Error(`Task aggregate ${taskId} must not carry durableJobs before introduction.`);
+                    }
+                }
+            }
+        },
+        normalize: (snapshot) => {
+            const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+            return {
+                schemaManifest: {
+                    ...snapshot.schemaManifest,
+                    recordVersions: {
+                        ...manifestVersions,
+                        durableJob: 1
+                    }
+                },
+                state: snapshot.state === null
+                    ? null
+                    : { ...snapshot.state }
+            };
+        }
+    };
+}
 /**
  * Upgrade one nested Task record family without guessing fields or repairing
  * malformed state. The new execution lineage fields are optional, so legal
@@ -386,6 +973,154 @@ function encodeLaneKeyPart(value) {
  * durable and centralized, which keeps old Homes out of the strict current
  * parser until this step has run.
  */
+/**
+ * The post-baseline introduction of the task-scoped CapabilityGrant family.
+ * A pre-introduction Home names no capabilityGrant manifest version and its
+ * Task aggregates carry no `capabilityGrants` map; this explicit 0->1 step
+ * adds the empty family to every Task (plus the matching high-water mark) so
+ * the strict current parser can open the migrated state.
+ */
+function capabilityGrantIntroductionStep() {
+    return {
+        axis: "record",
+        recordKind: "capabilityGrant",
+        fromVersion: CAPABILITY_GRANT_FROM_VERSION,
+        toVersion: CAPABILITY_GRANT_TO_VERSION,
+        introduction: true,
+        preconditions: requireCapabilityGrantIntroduction,
+        transform: introduceCapabilityGrantFamily,
+        declaredEffects: []
+    };
+}
+function requireCapabilityGrantIntroduction(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const namedVersion = manifestVersions.capabilityGrant;
+    if (namedVersion !== undefined && namedVersion !== CAPABILITY_GRANT_FROM_VERSION) {
+        throw new Error(`Record capabilityGrant introduction requires an absent manifest version or ${CAPABILITY_GRANT_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.capabilityGrants !== undefined) {
+            const grants = asObject(task.capabilityGrants, `capabilityGrant map ${taskId}`);
+            if (Object.keys(grants).length > 0) {
+                throw new Error(`Capability grant introduction found existing records: ${taskId}.`);
+            }
+        }
+        const marks = task.idHighWaterMarks;
+        if (marks !== undefined) {
+            const highWaterMarks = asObject(marks, `Task id high-water marks ${taskId}`);
+            const mark = highWaterMarks.capabilityGrant;
+            if (mark !== undefined && mark !== CAPABILITY_GRANT_FROM_VERSION) {
+                throw new Error(`Capability grant introduction found a high-water mark: ${taskId}.`);
+            }
+        }
+    }
+}
+function introduceCapabilityGrantFamily(snapshot) {
+    requireCapabilityGrantIntroduction(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            capabilityGrant: CAPABILITY_GRANT_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const marks = asObject(task.idHighWaterMarks, `Task id high-water marks ${taskId}`);
+        nextTasks[taskId] = {
+            ...task,
+            idHighWaterMarks: { ...marks, capabilityGrant: CAPABILITY_GRANT_FROM_VERSION },
+            capabilityGrants: {}
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+/**
+ * The post-baseline introduction of the task-scoped ReleaseWorkflow family.
+ * A pre-introduction Home names no releaseWorkflow manifest version and its
+ * Task aggregates carry no `releaseWorkflows` map; this explicit 0->1 step
+ * adds the empty family to every Task (plus the matching high-water mark) so
+ * the strict current parser can open the migrated state.
+ */
+function releaseWorkflowIntroductionStep() {
+    return {
+        axis: "record",
+        recordKind: "releaseWorkflow",
+        fromVersion: RELEASE_WORKFLOW_FROM_VERSION,
+        toVersion: RELEASE_WORKFLOW_TO_VERSION,
+        introduction: true,
+        preconditions: requireReleaseWorkflowIntroduction,
+        transform: introduceReleaseWorkflowFamily,
+        declaredEffects: []
+    };
+}
+function requireReleaseWorkflowIntroduction(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const namedVersion = manifestVersions.releaseWorkflow;
+    if (namedVersion !== undefined && namedVersion !== RELEASE_WORKFLOW_FROM_VERSION) {
+        throw new Error(`Record releaseWorkflow introduction requires an absent manifest version or ${RELEASE_WORKFLOW_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        if (task.releaseWorkflows !== undefined) {
+            const workflows = asObject(task.releaseWorkflows, `releaseWorkflow map ${taskId}`);
+            if (Object.keys(workflows).length > 0) {
+                throw new Error(`Release workflow introduction found existing records: ${taskId}.`);
+            }
+        }
+        const marks = task.idHighWaterMarks;
+        if (marks !== undefined) {
+            const highWaterMarks = asObject(marks, `Task id high-water marks ${taskId}`);
+            const mark = highWaterMarks.releaseWorkflow;
+            if (mark !== undefined && mark !== RELEASE_WORKFLOW_FROM_VERSION) {
+                throw new Error(`Release workflow introduction found a high-water mark: ${taskId}.`);
+            }
+        }
+    }
+}
+function introduceReleaseWorkflowFamily(snapshot) {
+    requireReleaseWorkflowIntroduction(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            releaseWorkflow: RELEASE_WORKFLOW_TO_VERSION
+        }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const tasks = asObject(snapshot.state.tasks, "state tasks");
+    const nextTasks = {};
+    for (const [taskId, rawTask] of Object.entries(tasks)) {
+        const task = asObject(rawTask, `Task aggregate ${taskId}`);
+        const marks = asObject(task.idHighWaterMarks, `Task id high-water marks ${taskId}`);
+        nextTasks[taskId] = {
+            ...task,
+            idHighWaterMarks: { ...marks, releaseWorkflow: RELEASE_WORKFLOW_FROM_VERSION },
+            releaseWorkflows: {}
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 function recordFamilyStep(recordKind, fromVersion, toVersion, taskMapKey) {
     return {
         axis: "record",