@zq-silk/yui 0.6.13 → 0.6.14

package/dist/storage/migration/productionRegistry.js

@@ -16,6 +16,8 @@ const SQLITE_LAYOUT_FROM_VERSION = 6;
 const SQLITE_LAYOUT_TO_VERSION = 7;
 const PROJECT_FROM_VERSION = 2;
 const PROJECT_TO_VERSION = 3;
+const PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION = 3;
+const PROJECT_KNOWLEDGE_PROPOSALS_TO_VERSION = 4;
 const TASK_FROM_VERSION = 3;
 const TASK_TO_VERSION = 4;
 const WORK_ITEM_FROM_VERSION = 6;
@@ -57,6 +59,12 @@ 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 STORED_TASK_WAKES_FROM_VERSION = 16;
+const STORED_TASK_WAKES_TO_VERSION = 17;
+const TASK_WAKE_FROM_VERSION = 0;
+const TASK_WAKE_TO_VERSION = 1;
+const STORED_TASK_PUBLICATION_REFERENCES_FROM_VERSION = 16;
+const STORED_TASK_PUBLICATION_REFERENCES_TO_VERSION = 17;
 const CAPABILITY_GRANT_FROM_VERSION = 0;
 const CAPABILITY_GRANT_TO_VERSION = 1;
 const RELEASE_WORKFLOW_FROM_VERSION = 0;
@@ -65,6 +73,8 @@ const WORK_MAILBOX_FROM_VERSION = 1;
 const WORK_MAILBOX_TO_VERSION = 2;
 const TASK_ROLE_SESSION_SET_FROM_VERSION = 4;
 const TASK_ROLE_SESSION_SET_TO_VERSION = 5;
+const PUBLICATION_REFERENCE_FROM_VERSION = 0;
+const PUBLICATION_REFERENCE_TO_VERSION = 1;
 /**
  * Build the authoritative production graph. Transition intent and executable
  * transforms are registered together here; compatible loading and offline
@@ -113,6 +123,7 @@ export function createProductionStorageRegistry() {
         declaredEffects: []
     })
         .registerOfflineMigration(projectOwnershipStep())
+        .registerCompatible(projectKnowledgeProposalsStep())
         .registerOfflineMigration(taskWorkspaceIdentityStep())
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_FROM_VERSION, WORK_ITEM_TO_VERSION, "workItems"))
         .registerOfflineMigration(recordFamilyStep("workItem", WORK_ITEM_GIT_SNAPSHOT_FROM_VERSION, WORK_ITEM_GIT_SNAPSHOT_TO_VERSION, "workItems"))
@@ -131,11 +142,14 @@ export function createProductionStorageRegistry() {
         .registerOfflineMigration(integrationQueueIntroductionStep())
         .registerCompatible(storedTaskDurableJobsStep())
         .registerCompatible(storedTaskJobCallerKeyHashesStep())
+        .registerCompatible(storedTaskWakesAndPublicationReferencesStep())
+        .registerCompatible(taskWakeIntroductionStep())
         .registerCompatible(durableJobIntroductionStep())
         .registerOfflineMigration(capabilityGrantIntroductionStep())
         .registerOfflineMigration(releaseWorkflowIntroductionStep())
         .registerOfflineMigration(workMailboxV2Step())
-        .registerOfflineMigration(taskRoleSessionSetV5Step());
+        .registerOfflineMigration(taskRoleSessionSetV5Step())
+        .registerOfflineMigration(publicationReferenceIntroductionStep());
     assertRegistryCoversBaselineToCurrent(registry);
     return registry;
 }
@@ -939,6 +953,158 @@ function normalizeStoredTaskV15ToV16(snapshot) {
         state: { ...snapshot.state, tasks: nextTasks }
     };
 }
+/**
+ * StoredTask v17 introduces both the durable TaskWake ledger (Issue 04
+ * long-term design) and the publicationReferences map (Issue 11). Every
+ * aggregate gains empty `wakes` and `publicationReferences` maps and zero
+ * high-water marks.
+ */
+function storedTaskWakesAndPublicationReferencesStep() {
+    return {
+        kind: "compatible",
+        axis: "record",
+        recordKind: "storedTask",
+        fromVersion: STORED_TASK_WAKES_FROM_VERSION,
+        toVersion: STORED_TASK_WAKES_TO_VERSION,
+        defaults: [
+            "wakes defaults to an empty map on every Task aggregate",
+            "publicationReferences defaults to an empty map on every Task aggregate"
+        ],
+        validateSource: (snapshot) => requireStoredTaskV16Shape(snapshot),
+        normalize: (snapshot) => normalizeStoredTaskV16ToV17(snapshot)
+    };
+}
+const STORED_TASK_V16_FIELDS = [
+    "schemaVersion",
+    "task",
+    "idHighWaterMarks",
+    "brief",
+    "changeSets",
+    "integrationAttempts",
+    "integrationQueue",
+    "durableJobs",
+    "jobCallerKeyHashes",
+    // May already be present after the publicationReference introduction runs
+    // first; the 16->17 normalizer preserves the empty introduced map.
+    "publicationReferences",
+    "capabilityGrants",
+    "releaseWorkflows",
+    "roles",
+    "managedWorkspaces",
+    "roleSessionSets",
+    "workItems",
+    "agentRuns",
+    "reviewRounds",
+    "activeRuns",
+    "messages",
+    "inputRequests",
+    "decisions",
+    "milestones",
+    "events",
+    "leaderFailure",
+    "operatorNotification"
+];
+function requireStoredTaskV16Shape(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.storedTask !== STORED_TASK_WAKES_FROM_VERSION) {
+        throw new Error(`Record storedTask compatible step requires manifest version ${STORED_TASK_WAKES_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_WAKES_FROM_VERSION) {
+            throw new Error(`Task aggregate ${taskId} must use schemaVersion ${STORED_TASK_WAKES_FROM_VERSION}.`);
+        }
+        const allowed = new Set(STORED_TASK_V16_FIELDS);
+        const unknown = Object.keys(task).find((key) => !allowed.has(key));
+        if (unknown !== undefined) {
+            throw new Error(`Task aggregate ${taskId} has an unknown v16 field: ${unknown}.`);
+        }
+        if (task.publicationReferences !== undefined) {
+            const references = asObject(task.publicationReferences, `Task aggregate ${taskId} publicationReferences`);
+            if (Object.keys(references).length > 0) {
+                throw new Error(`Task aggregate ${taskId} already has publication references before v17.`);
+            }
+        }
+    }
+}
+function normalizeStoredTaskV16ToV17(snapshot) {
+    requireStoredTaskV16Shape(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            storedTask: STORED_TASK_WAKES_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 existingReferences = task.publicationReferences === undefined
+            ? {}
+            : asObject(task.publicationReferences, `Task aggregate ${taskId} publicationReferences`);
+        const marks = asObject(task.idHighWaterMarks, `Task id high-water marks ${taskId}`);
+        const existingMark = marks.publicationReference;
+        const existingWakeMark = marks.taskWake;
+        nextTasks[taskId] = {
+            ...task,
+            schemaVersion: STORED_TASK_WAKES_TO_VERSION,
+            idHighWaterMarks: {
+                ...marks,
+                publicationReference: typeof existingMark === "number" ? existingMark : 0,
+                taskWake: typeof existingWakeMark === "number" ? existingWakeMark : TASK_WAKE_FROM_VERSION
+            },
+            publicationReferences: existingReferences,
+            wakes: {}
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
+/**
+ * The taskWake record family is introduced alongside StoredTask v17. The
+ * compatible step supplies the empty map and high-water mark; this step only
+ * advances the manifest record version so the planner can resolve the 0->1
+ * boundary.
+ */
+function taskWakeIntroductionStep() {
+    return {
+        kind: "compatible",
+        axis: "record",
+        recordKind: "taskWake",
+        fromVersion: TASK_WAKE_FROM_VERSION,
+        toVersion: TASK_WAKE_TO_VERSION,
+        introduction: true,
+        defaults: [
+            "taskWake family starts at version 1 with an empty ledger"
+        ],
+        validateSource: (snapshot) => {
+            const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+            const namedVersion = manifestVersions.taskWake;
+            if (namedVersion !== undefined && namedVersion !== TASK_WAKE_FROM_VERSION) {
+                throw new Error(`Record taskWake introduction requires an absent manifest version or ${TASK_WAKE_FROM_VERSION}.`);
+            }
+        },
+        normalize: (snapshot) => ({
+            schemaManifest: {
+                ...snapshot.schemaManifest,
+                recordVersions: {
+                    ...asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions"),
+                    taskWake: TASK_WAKE_TO_VERSION
+                }
+            },
+            state: snapshot.state
+        })
+    };
+}
 /**
  * The durableJob record family is introduced alongside the StoredTask v15
  * aggregate. A pre-baseline Home has no durableJobs map and no manifest entry;
@@ -1147,6 +1313,79 @@ function introduceReleaseWorkflowFamily(snapshot) {
         state: { ...snapshot.state, tasks: nextTasks }
     };
 }
+/**
+ * Issue 11: introduce the task-scoped PublicationReference family. A
+ * pre-introduction Home names no publicationReference manifest version and its
+ * Task aggregates carry no `publicationReferences` map; this explicit 0->1
+ * step adds the empty family to every Task (plus the matching high-water mark).
+ */
+function publicationReferenceIntroductionStep() {
+    return {
+        axis: "record",
+        recordKind: "publicationReference",
+        fromVersion: PUBLICATION_REFERENCE_FROM_VERSION,
+        toVersion: PUBLICATION_REFERENCE_TO_VERSION,
+        introduction: true,
+        preconditions: requirePublicationReferenceIntroduction,
+        transform: introducePublicationReferenceFamily,
+        declaredEffects: []
+    };
+}
+function requirePublicationReferenceIntroduction(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const namedVersion = manifestVersions.publicationReference;
+    if (namedVersion !== undefined && namedVersion !== PUBLICATION_REFERENCE_FROM_VERSION) {
+        throw new Error(`Record publicationReference introduction requires an absent manifest version or ${PUBLICATION_REFERENCE_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.publicationReferences !== undefined) {
+            const references = asObject(task.publicationReferences, `publicationReference map ${taskId}`);
+            if (Object.keys(references).length > 0) {
+                throw new Error(`Publication reference 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.publicationReference;
+            if (mark !== undefined && mark !== PUBLICATION_REFERENCE_FROM_VERSION) {
+                throw new Error(`Publication reference introduction found a high-water mark: ${taskId}.`);
+            }
+        }
+    }
+}
+function introducePublicationReferenceFamily(snapshot) {
+    requirePublicationReferenceIntroduction(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: {
+            ...manifestVersions,
+            publicationReference: PUBLICATION_REFERENCE_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, publicationReference: PUBLICATION_REFERENCE_FROM_VERSION },
+            publicationReferences: {}
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, tasks: nextTasks }
+    };
+}
 function recordFamilyStep(recordKind, fromVersion, toVersion, taskMapKey) {
     return {
         axis: "record",
@@ -1911,6 +2150,91 @@ function migrateProjectV2ToV3(snapshot) {
         state: { ...snapshot.state, projects: nextProjects }
     };
 }
+/**
+ * Project v4 adds the `knowledgeProposals` workflow list (Leader-proposed
+ * Knowledge candidates awaiting an Operator decision). Every v3 Project
+ * defaults to an empty list; the compatible normalizer adds it in place
+ * without rewriting any other field.
+ */
+function projectKnowledgeProposalsStep() {
+    return {
+        kind: "compatible",
+        axis: "record",
+        recordKind: "project",
+        fromVersion: PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION,
+        toVersion: PROJECT_KNOWLEDGE_PROPOSALS_TO_VERSION,
+        defaults: [
+            "knowledgeProposals defaults to an empty list on every Project"
+        ],
+        validateSource: (snapshot) => requireProjectV3Shape(snapshot),
+        normalize: (snapshot) => normalizeProjectV3ToV4(snapshot)
+    };
+}
+function requireProjectV3Shape(snapshot) {
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    if (manifestVersions.project !== PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION) {
+        throw new Error(`Record project compatible step requires manifest version ${PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION}.`);
+    }
+    if (snapshot.state === null)
+        return;
+    const projects = snapshot.state.projects;
+    if (projects === undefined)
+        return;
+    const map = asObject(projects, "project map");
+    const allowed = new Set(PROJECT_V3_FIELDS);
+    for (const [projectId, rawProject] of Object.entries(map)) {
+        const project = asObject(rawProject, `Project ${projectId}`);
+        if (project.schemaVersion !== PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION) {
+            throw new Error(`Project ${projectId} must use schemaVersion ${PROJECT_KNOWLEDGE_PROPOSALS_FROM_VERSION}.`);
+        }
+        const unknown = Object.keys(project).find((key) => !allowed.has(key));
+        if (unknown !== undefined) {
+            throw new Error(`Project ${projectId} has an unknown v3 field: ${unknown}.`);
+        }
+    }
+}
+const PROJECT_V3_FIELDS = [
+    "schemaVersion",
+    "id",
+    "name",
+    "aliases",
+    "path",
+    "ownership",
+    "remoteUrl",
+    "stableBranch",
+    "developmentBranch",
+    "knowledge",
+    "createdAt",
+    "updatedAt"
+];
+function normalizeProjectV3ToV4(snapshot) {
+    requireProjectV3Shape(snapshot);
+    const manifestVersions = asObject(snapshot.schemaManifest.recordVersions, "schema manifest recordVersions");
+    const schemaManifest = {
+        ...snapshot.schemaManifest,
+        recordVersions: { ...manifestVersions, project: PROJECT_KNOWLEDGE_PROPOSALS_TO_VERSION }
+    };
+    if (snapshot.state === null)
+        return { schemaManifest, state: null };
+    const projects = snapshot.state.projects;
+    if (projects === undefined) {
+        return { schemaManifest, state: { ...snapshot.state } };
+    }
+    const map = asObject(projects, "project map");
+    const nextProjects = {};
+    for (const [projectId, rawProject] of Object.entries(map)) {
+        const project = asObject(rawProject, `Project ${projectId}`);
+        nextProjects[projectId] = {
+            ...project,
+            schemaVersion: PROJECT_KNOWLEDGE_PROPOSALS_TO_VERSION,
+            knowledgeProposals: []
+        };
+    }
+    return {
+        schemaManifest,
+        state: { ...snapshot.state, projects: nextProjects }
+    };
+}
 /**
  * Task v4 adds the optional durable workspace identity. Historical Tasks have
  * no identity; they keep working against their existing (legacy) refs until the

package/dist/storage/sqliteSchema.js

@@ -27,7 +27,7 @@ export const SQLITE_LAYOUT_VERSION = 7;
 /** The aggregate version of the normalized SQLite schema. */
 export const SQLITE_AGGREGATE_VERSION = 1;
 /** The current schema migration version. */
-export const SQLITE_SCHEMA_VERSION = 14;
+export const SQLITE_SCHEMA_VERSION = 16;
 /** Telemetry retention bounds (§4.4). Open question 3 in §11; defaults from the design. */
 export const TELEMETRY_KEEP_PER_GENERATION = 200;
 export const TELEMETRY_RUN_CAP = 50_000;
@@ -855,6 +855,62 @@ CREATE INDEX idx_mailboxes_ready
 DROP TABLE pending_runtime_turn_completions;
 DROP TABLE IF EXISTS mailbox_signals;
 `;
+/**
+ * Migration 15: Issue 11 external publication evidence. Records are immutable;
+ * a corrected MR/PR state appends a superseding record with the same
+ * external_key, so only the unsuperseded root is globally unique.
+ */
+const MIGRATION_15_SQL = `
+CREATE TABLE IF NOT EXISTS publication_references (
+  task_id         TEXT NOT NULL,
+  publication_id  TEXT NOT NULL,
+  project_id      TEXT NOT NULL,
+  provider        TEXT NOT NULL,
+  repository      TEXT NOT NULL,
+  external_kind   TEXT NOT NULL,
+  external_id     TEXT NOT NULL,
+  external_key    TEXT NOT NULL,
+  state           TEXT NOT NULL,
+  verification    TEXT NOT NULL,
+  external_url    TEXT,
+  title           TEXT,
+  source_branch   TEXT,
+  target_branch   TEXT,
+  local_commit    TEXT,
+  remote_commit   TEXT,
+  supersedes      TEXT,
+  payload         TEXT NOT NULL,
+  merged_at       TEXT,
+  created_at      TEXT NOT NULL,
+  PRIMARY KEY (task_id, publication_id)
+);
+CREATE INDEX IF NOT EXISTS idx_publication_references_task
+  ON publication_references(task_id);
+CREATE INDEX IF NOT EXISTS idx_publication_references_external
+  ON publication_references(external_key);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_publication_references_external_root
+  ON publication_references(external_key) WHERE supersedes IS NULL;
+`;
+const MIGRATION_16_SQL = `
+-- Durable Leader wake ledger (Issue 04 long-term design). A wake is a
+-- notification envelope, not a context dump: the record holds the aggregated
+-- reason tags and the delta window; the Agent reads delta content on demand.
+CREATE TABLE IF NOT EXISTS task_wakes (
+  task_id     TEXT NOT NULL,
+  wake_id     TEXT NOT NULL,
+  seq         INTEGER NOT NULL,
+  status      TEXT NOT NULL CHECK (status IN ('dispatched','consumed')),
+  run_id      TEXT,
+  from_cursor TEXT NOT NULL,
+  to_cursor   TEXT NOT NULL,
+  reasons     TEXT NOT NULL,
+  payload     TEXT NOT NULL,
+  created_at  TEXT NOT NULL,
+  consumed_at TEXT,
+  PRIMARY KEY (task_id, wake_id)
+);
+CREATE INDEX IF NOT EXISTS idx_task_wakes_seq ON task_wakes(task_id, seq);
+`;
 const MIGRATIONS = [
     { version: 1, axis: "layout", sql: MIGRATION_1_SQL },
     { version: 2, axis: "record", recordKind: "durableJob+capability-grant+release-workflow", sql: MIGRATION_2_SQL },
@@ -869,7 +925,9 @@ const MIGRATIONS = [
     { version: 11, axis: "layout", sql: MIGRATION_11_SQL },
     { version: 12, axis: "layout", sql: MIGRATION_12_SQL },
     { version: 13, axis: "layout", sql: MIGRATION_13_SQL },
-    { version: 14, axis: "record", recordKind: "workMailbox", sql: MIGRATION_14_SQL }
+    { version: 14, axis: "record", recordKind: "workMailbox", sql: MIGRATION_14_SQL },
+    { version: 15, axis: "record", recordKind: "publicationReference", sql: MIGRATION_15_SQL },
+    { version: 16, axis: "record", recordKind: "taskWake", sql: MIGRATION_16_SQL }
 ];
 /** Current hot-path indexes whose absence would invalidate a current Home. */
 const REQUIRED_SCHEMA_INDEXES = [
@@ -1127,6 +1185,7 @@ export const SQLITE_SCHEMA_TABLES = [
     "telemetry_aggregate",
     "capability_grants",
     "release_workflows",
+    "publication_references",
     "session_owners",
     "runtime_session_candidates",
     "resource_registry",

package/dist/storage/sqliteStore.js

@@ -41,13 +41,16 @@ import Database from "better-sqlite3";
 import { consumePendingBatch, mailboxTargetKey, pendingLane, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
 import { validateReviewFinding } from "../review/reviewFinding.js";
+import { reviewFindingLedgerMode } from "../review/reviewFindingLedger.js";
 import { generateHomeIdentity, validateHomeIdentity } from "../repository/homeIdentity.js";
 import { validateIntegrationQueueEntry } from "../integration/integrationQueueEntry.js";
 import { validDurableJobTransition, validateDurableJob } from "../job/durableJob.js";
+import { validateTaskWake } from "../scheduler/taskWake.js";
 import { TASK_RECORD_ID_PREFIXES } from "../task/taskRecordReference.js";
 import { managedWorkspaceKey } from "../worktree/managedWorkspace.js";
 import { assertHomeWritable } from "./upgradeFence.js";
-import { CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_PENDING_WAKEUP_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION, executionLaneActiveRunKey, executionLaneActiveRunKeyParts, StorageConflictError, StorageCancelledError, StorageRecordError, FileTaskStore, storedCapabilityGrant, storedReleaseWorkflow, isValidCapabilityGrantTransition, isValidReleaseWorkflowTransition, validateYuiConfig } from "./taskStore.js";
+import { CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_PENDING_WAKEUP_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION, executionLaneActiveRunKey, executionLaneActiveRunKeyParts, StorageConflictError, StorageCancelledError, StorageRecordError, FileTaskStore, storedCapabilityGrant, storedPublicationReference, storedReleaseWorkflow, isValidCapabilityGrantTransition, isValidReleaseWorkflowTransition, validateYuiConfig } from "./taskStore.js";
+import { publicationExternalKey } from "../task/publicationReference.js";
 import { gateArtifactKey, validateGateArtifact } from "../verification/gateArtifact.js";
 import { migrateSqliteSchema, SQLITE_AGGREGATE_VERSION, SQLITE_LAYOUT_VERSION, TELEMETRY_KEEP_PER_GENERATION, TELEMETRY_RUN_CAP } from "./sqliteSchema.js";
 import { inspectStorageSchema } from "./storageSchema.js";
@@ -79,6 +82,30 @@ const DEFAULT_CONFIG = { schemaVersion: CURRENT_CONFIG_SCHEMA_VERSION };
 function numericCompare(left, right) {
     return left.localeCompare(right, undefined, { numeric: true });
 }
+function latestSqlitePublicationReference(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]
+        : [...references].sort((left, right) => numericCompare(right.id, left.id))[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;
+}
 /** True when the better-sqlite3 error is a UNIQUE/PRIMARY KEY constraint failure. */
 function isUniqueConstraint(error) {
     return error instanceof Error
@@ -685,7 +712,8 @@ export class SqliteTaskStore {
             task: {
                 id: task.id,
                 status: task.status,
-                projectBindings: task.projectBindings
+                projectBindings: task.projectBindings,
+                requireIntegration: task.requireIntegration
             },
             workItems: this.#sortById(this.#listPayload("work_items", "task_id = ?", [taskId]), (item) => item.id),
             changeSets: this.#sortById(this.#listPayload("change_sets", "task_id = ?", [taskId]), (changeSet) => changeSet.id),
@@ -697,6 +725,20 @@ export class SqliteTaskStore {
             leaderRuns: runs.filter((run) => run.roleName === "leader")
         };
     }
+    readCompletionReadinessFacts(taskId) {
+        const base = this.readNextActionFacts(taskId);
+        if (base === null)
+            return null;
+        return {
+            ...base,
+            managedWorkspaces: this.#sortById(this.#listPayload("managed_workspaces", "task_id = ?", [taskId]), (workspace) => managedWorkspaceKey(workspace.owner)),
+            durableJobs: this.#sortById(this.#listPayload("durable_jobs", "task_id = ?", [taskId]), (job) => job.id),
+            integrationQueueEntries: this.#sortById(this.#listPayload("integration_queue", "task_id = ?", [taskId]), (entry) => entry.id),
+            reviewFindings: this.#sortById(this.#listPayload("review_findings", "task_id = ?", [taskId]), (finding) => finding.id),
+            reviewFindingLedgerMode: reviewFindingLedgerMode(this.getConfig()),
+            events: this.#sortById(this.#listPayload("events", "task_id = ?", [taskId]), (event) => event.id)
+        };
+    }
     /** Task ids flagged active in the catalog projection (the global active index). */
     listActiveTaskIds() {
         const rows = this.#db.prepare("SELECT task_id FROM tasks_catalog WHERE is_active = 1 ORDER BY task_id").all();
@@ -1217,6 +1259,58 @@ export class SqliteTaskStore {
     getReleaseWorkflow(taskId, workflowId) {
         return this.#getPayload("release_workflows", "task_id = ? AND workflow_id = ?", [taskId, workflowId]);
     }
+    // -- publication references -------------------------------------------------
+    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.#requireTask(taskId);
+        this.#mutate(() => {
+            const key = publicationExternalKey(stored);
+            const existing = this.#getPayload("publication_references", "task_id = ? AND publication_id = ?", [taskId, stored.id]);
+            if (existing !== null && !isDeepStrictEqual(existing, stored)) {
+                throw new StorageRecordError(`Publication reference cannot be overwritten: ${taskId}/${stored.id}`);
+            }
+            if (existing === null) {
+                const sameExternal = this.#listPayload("publication_references", "external_key = ?", [key]);
+                const otherTask = sameExternal.find((candidate) => candidate.taskId !== taskId);
+                if (otherTask !== undefined) {
+                    throw new StorageRecordError(`Publication external identity already belongs to Task ${otherTask.taskId}: ${key}.`);
+                }
+                if (sameExternal.length > 0) {
+                    const latest = latestSqlitePublicationReference(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}.`);
+                }
+            }
+            this.#db.prepare(`INSERT INTO publication_references
+           (task_id, publication_id, project_id, provider, repository, external_kind,
+            external_id, external_key, state, verification, external_url, local_commit,
+            remote_commit, supersedes, payload, merged_at, created_at,
+            title, source_branch, target_branch)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+         ON CONFLICT(task_id, publication_id) DO UPDATE SET payload = excluded.payload`).run(taskId, stored.id, stored.projectId, stored.provider, stored.repository, stored.externalKind, stored.externalId, key, stored.state, stored.verification, stored.externalUrl ?? null, stored.localCommit ?? null, stored.remoteCommit ?? null, stored.supersedes ?? null, this.#json(stored), stored.mergedAt ?? null, this.#now(), stored.title ?? null, stored.sourceBranch ?? null, stored.targetBranch ?? null);
+        });
+    }
+    listPublicationReferences(taskId) {
+        return this.#sortById(this.#listPayload("publication_references", "task_id = ?", [taskId]), (reference) => reference.id);
+    }
+    getPublicationReference(taskId, referenceId) {
+        return this.#getPayload("publication_references", "task_id = ? AND publication_id = ?", [taskId, referenceId]);
+    }
+    findPublicationReferenceByExternalKey(externalKey) {
+        const matches = this.#listPayload("publication_references", "external_key = ?", [externalKey]);
+        return matches.length === 0 ? null : latestSqlitePublicationReference(matches);
+    }
     // -- gate artifacts (Issue 08) ----------------------------------------------
     saveGateArtifact(artifact, logs) {
         validateGateArtifact(artifact);
@@ -1696,6 +1790,39 @@ export class SqliteTaskStore {
             return removed;
         });
     }
+    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}`);
+        }
+        validateTaskWake(wake);
+        this.#requireTask(taskId);
+        this.#mutate(() => {
+            const seq = this.#idSequence(wake.id, "taskWake");
+            this.#db.prepare(`INSERT INTO task_wakes
+          (task_id, wake_id, seq, status, run_id, from_cursor, to_cursor, reasons, payload, created_at, consumed_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+                + ` ON CONFLICT(task_id, wake_id) DO UPDATE SET
+           status = excluded.status,
+           run_id = excluded.run_id,
+           reasons = excluded.reasons,
+           payload = excluded.payload,
+           consumed_at = excluded.consumed_at`).run(taskId, wake.id, wake.seq, wake.status, wake.runId ?? null, wake.fromCursor, wake.toCursor, this.#json([...wake.reasons]), this.#json(wake), wake.createdAt, wake.consumedAt ?? null);
+            this.#observeHighWater(taskId, "taskWake", seq);
+        });
+    }
+    getTaskWake(taskId, wakeId) {
+        const row = this.#db.prepare("SELECT payload FROM task_wakes WHERE task_id = ? AND wake_id = ?").get(taskId, wakeId);
+        if (row === undefined)
+            return null;
+        const wake = this.#parse(row.payload);
+        validateTaskWake(wake);
+        return wake;
+    }
+    listTaskWakes(taskId) {
+        return this.#sortById(this.#listPayload("task_wakes", "task_id = ?", [taskId]), (wake) => wake.id);
+    }
     // -- high-water maintenance ---------------------------------------------------
     /** Extract the numeric suffix of a `<prefix>-<n>` record id. */
     #idSequence(id, kind) {

package/dist/storage/storeRpc.js

@@ -49,6 +49,7 @@ const READ_ONLY_STORE_METHODS = new Set([
     "listTasks",
     "getTask",
     "readNextActionFacts",
+    "readCompletionReadinessFacts",
     "listActiveTaskIds",
     "getTaskBrief",
     "listChangeSets",