@zq-silk/yui 2.8.1 → 2.10.0

package/dist/repository/projectRefresh.js

@@ -0,0 +1,58 @@
+import { createHash } from "node:crypto";
+import { CliError, usageError } from "../errors/cliError.js";
+import { assertProjectActive } from "./project.js";
+import { GitWorkspaceRefreshError, NodeGitWorkspace } from "./gitWorkspace.js";
+import { acquireProjectMaintenanceLock } from "./projectMaintenanceLock.js";
+/** Bind maintenance intent to catalog identity, not a caller-supplied path. */
+export function projectRefreshTargetDigest(project) {
+    return createHash("sha256").update(JSON.stringify([
+        project.id, project.path, project.remoteUrl, project.stableBranch,
+        project.developmentBranch, project.ownership, project.status
+    ])).digest("hex");
+}
+export function requireRefreshProject(store, id, automatic = false) {
+    const project = store.listProjects().find(project => project.id === id);
+    if (!project)
+        throw usageError(`Project not found: ${id}.`);
+    assertProjectActive(project, "refresh");
+    if (automatic && project.ownership !== "managed") {
+        throw usageError(`Automatic Project refresh requires a managed Project: ${id}.`);
+    }
+    if (project.remoteUrl === undefined)
+        throw usageError(`Project refresh requires a remote URL: ${id}.`);
+    if (project.stableBranch !== project.developmentBranch) {
+        throw usageError(`Project refresh requires matching stable and development branches: ${id}.`);
+    }
+    return project;
+}
+/** Shared manual/background operation. Waiting never authorizes a changed target. */
+export async function refreshRegisteredProject(store, id, options = {}) {
+    const project = requireRefreshProject(store, id, options.automatic);
+    const expected = options.expectedDigest ?? projectRefreshTargetDigest(project);
+    const check = () => {
+        const current = requireRefreshProject(store, id, options.automatic);
+        if (projectRefreshTargetDigest(current) !== expected) {
+            throw new Error(`Project changed while waiting to refresh: ${id}; read current state before retrying.`);
+        }
+        return current;
+    };
+    check();
+    const release = await acquireProjectMaintenanceLock(store.rootDirectory(), id, { signal: options.signal });
+    try {
+        const current = check();
+        options.beforeRefresh?.();
+        const refreshed = await (options.git ?? new NodeGitWorkspace()).refresh({
+            repositoryPath: current.path, remoteUrl: current.remoteUrl, stableRef: current.stableBranch
+        });
+        return { project: current, ...refreshed };
+    }
+    catch (error) {
+        if (error instanceof GitWorkspaceRefreshError) {
+            throw new CliError("RUNTIME_ERROR", error.message, undefined, { projectId: id, refresh: error.result });
+        }
+        throw error;
+    }
+    finally {
+        release();
+    }
+}

package/dist/repository/taskWorkspacePreparer.js

@@ -2,6 +2,7 @@ import { lstat, mkdir, readdir, readlink, rmdir, symlink, unlink } from "node:fs
 import { dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { isDeepStrictEqual } from "node:util";
 import { recordArchiveCleanup } from "../task/archiveDiagnostics.js";
+import { activationWakeRefs } from "../context/taskPhase.js";
 import { enqueueWork } from "../coordination/workMailboxQueue.js";
 import { createTaskEvent } from "../event/taskEvent.js";
 import { retireTaskRoleSessionsForWorkspace, updateRoleAgentSessionStatus } from "../executor/agentExecutor.js";
@@ -2282,7 +2283,7 @@ export class FileTaskWorkspacePreparer {
 function recordTaskActivation(store, previous, active, now, actor) {
     // Activation is the explicit request to enter delivery, not an ordinary
     // Leader-local edit. Preserve that transition for the replacement Session.
-    enqueueWork(store, { kind: "role", taskId: active.id, roleName: LEADER_ROLE }, "execution-started", now, [{ type: "task", id: active.id }]);
+    enqueueWork(store, { kind: "role", taskId: active.id, roleName: LEADER_ROLE }, "execution-started", now, [{ type: "task", id: active.id }, ...activationWakeRefs(store, active)]);
     enqueueWork(store, { kind: "task", taskId: active.id }, "task-activated", now, [{ type: "task", id: active.id }]);
     store.saveEvent(active.id, createTaskEvent(store.nextEventId(active.id), active.id, "task.activated", { fromStatus: previous.status, status: active.status, by: actor }, now));
 }

package/dist/repository/workspaceCleanupInspection.js

@@ -157,7 +157,12 @@ export async function inspectWorkspaceCleanup(store, git, workspace, disposition
                     const observed = (await git.inspect(entry.path, "HEAD")).baseCommit;
                     const baseline = task.projectBindings.find(binding => binding.projectId === entry.projectId)?.baseCommit;
                     const unchangedAbandonment = disposition === "abandoned" && baseline !== undefined && observed === baseline;
-                    if (!unchangedAbandonment && disposition === "abandoned" && (!covered?.merged || !covered.verified)) {
+                    if (covered?.deliveryRequirement === "excluded"
+                        && (baseline === undefined || observed !== baseline)
+                        && (!covered.merged || !covered.verified)) {
+                        check("excluded-project-retained", "Excluding delivery does not authorize discarding unique or unverified local commits.", { baseline: baseline ?? null, verifiedDelivery: true }, observed);
+                    }
+                    else if (!unchangedAbandonment && disposition === "abandoned" && (!covered?.merged || !covered.verified)) {
                         check("delivery-coverage", "Abandonment does not discard unverified local commits; only the exact unchanged baseline is disposable.", { baseline: baseline ?? null, verifiedDelivery: true }, observed);
                     }
                     else if (!unchangedAbandonment && expected != null && expected !== observed && covered?.deliveryLocalCommit !== observed) {

package/dist/schedule/schedule.js

@@ -0,0 +1,108 @@
+import { CronExpressionParser } from "cron-parser";
+import { requireKnownFields, requirePositiveInteger, requireTimestamp, requireText } from "../domain/validation.js";
+import { jobScopeKey } from "../job/jobDefinition.js";
+export function scheduleId(id) {
+    if (typeof id !== "string" || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/u.test(id)) {
+        throw new Error("An explicit safe Schedule/Job id is required.");
+    }
+}
+function instant(value) {
+    requireTimestamp(value, "Schedule instant");
+    if (!/(?:Z|[+-]\d{2}:\d{2})$/u.test(value))
+        throw new Error("Schedule instants require an explicit UTC offset.");
+}
+export function validateScheduleRule(rule) {
+    if (rule?.kind === "once") {
+        requireKnownFields(rule, ["kind", "at"], "Once rule");
+        instant(rule.at);
+    }
+    else if (rule?.kind === "interval") {
+        requireKnownFields(rule, ["kind", "anchor", "everyMs"], "Interval rule");
+        instant(rule.anchor);
+        if (!Number.isSafeInteger(rule.everyMs) || rule.everyMs < 1000)
+            throw new Error("Interval everyMs must be an integer of at least 1000.");
+    }
+    else if (rule?.kind === "cron") {
+        requireKnownFields(rule, ["kind", "expression", "timezone"], "Cron rule");
+        if (typeof rule.timezone !== "string" || !rule.timezone.trim())
+            throw new Error("An explicit IANA timezone is required.");
+        new Intl.DateTimeFormat("en", { timeZone: rule.timezone });
+        if (typeof rule.expression !== "string" || rule.expression.trim().split(/\s+/u).length !== 5
+            || /\bH\b/iu.test(rule.expression))
+            throw new Error("Cron requires five fields and does not support random H.");
+        CronExpressionParser.parse(rule.expression, { tz: rule.timezone, currentDate: "2026-01-01T00:00:00Z" });
+    }
+    else
+        throw new Error("Unknown Schedule rule.");
+    return rule;
+}
+/** Strictly after the fence; once returns null after its single occurrence. */
+export function nextScheduleDue(rule, after) {
+    validateScheduleRule(rule);
+    const at = after.getTime();
+    if (rule.kind === "once")
+        return Date.parse(rule.at) > at ? new Date(rule.at).toISOString() : null;
+    if (rule.kind === "interval") {
+        const anchor = Date.parse(rule.anchor);
+        return new Date(anchor + Math.max(0, Math.floor((at - anchor) / rule.everyMs) + 1) * rule.everyMs).toISOString();
+    }
+    return CronExpressionParser.parse(rule.expression, { currentDate: after, tz: rule.timezone }).next().toISOString();
+}
+export function validateSchedule(value) {
+    requireKnownFields(value, ["schemaVersion", "id", "scope", "jobId", "rule", "revision", "generation",
+        "state", "nextDue", "processedThrough", "authorization", "lastAttempt", "reason", "createdAt", "updatedAt"], "Schedule");
+    if (value.schemaVersion !== 1)
+        throw new Error("Invalid Schedule schema.");
+    scheduleId(value.id);
+    scheduleId(value.jobId);
+    if (!["task", "global"].includes(value.scope.kind))
+        throw new Error("Invalid Schedule scope.");
+    requireKnownFields(value.scope, value.scope.kind === "task" ? ["kind", "taskId"] : ["kind"], "Schedule scope");
+    jobScopeKey(value.scope);
+    validateScheduleRule(value.rule);
+    requirePositiveInteger(value.revision, "Schedule revision");
+    requirePositiveInteger(value.generation, "Schedule generation");
+    if (!["enabled", "disabled", "completed", "needs-attention", "retired"].includes(value.state))
+        throw new Error("Invalid Schedule state.");
+    if (value.state === "enabled" && value.nextDue === null)
+        throw new Error("Enabled Schedule requires nextDue.");
+    if (value.state === "completed" && (value.rule.kind !== "once" || value.nextDue !== null))
+        throw new Error("Only an admitted once Schedule is completed.");
+    if (value.nextDue !== null)
+        instant(value.nextDue);
+    if (value.processedThrough !== undefined)
+        instant(value.processedThrough);
+    instant(value.createdAt);
+    instant(value.updatedAt);
+    requireKnownFields(value.authorization, ["caller", "binding", "jobRevision"], "Schedule authorization");
+    requirePositiveInteger(value.authorization.jobRevision, "Schedule Job revision");
+    if (typeof value.authorization.binding !== "string" || !/^[a-f0-9]{64}$/u.test(value.authorization.binding))
+        throw new Error("Invalid Schedule authority binding.");
+    const caller = value.authorization.caller;
+    requireKnownFields(caller, ["scope", "taskId", "role", "agentId", "adapterId", "nativeSessionId", "runId"], "Schedule caller");
+    if (typeof caller.role !== "string" || typeof caller.nativeSessionId !== "string")
+        throw new Error("Schedule authority requires a Role and Session.");
+    requireText(caller.role, "Schedule caller role");
+    requireText(caller.nativeSessionId, "Schedule caller Session");
+    if (caller.scope === "global") {
+        if (caller.role !== "operator")
+            throw new Error("Global Schedule authority requires Operator.");
+    }
+    else if (caller.scope !== "task" || value.scope.kind !== "task" || caller.taskId !== value.scope.taskId) {
+        throw new Error("Schedule caller must belong to its scope.");
+    }
+    if (value.reason !== undefined)
+        requireText(value.reason, "Schedule reason");
+    if (value.lastAttempt !== undefined) {
+        requireKnownFields(value.lastAttempt, ["at", "dueAt", "outcome", "runId", "reason"], "Schedule attempt");
+        instant(value.lastAttempt.at);
+        instant(value.lastAttempt.dueAt);
+        if (!["admitted", "overlap", "blocked"].includes(value.lastAttempt.outcome))
+            throw new Error("Invalid Schedule attempt.");
+        if (value.lastAttempt.runId !== undefined)
+            requireText(value.lastAttempt.runId, "Schedule Run id");
+        if (value.lastAttempt.reason !== undefined)
+            requireText(value.lastAttempt.reason, "Schedule attempt reason");
+    }
+    return value;
+}

package/dist/scheduler/operatorEvent.js

@@ -16,6 +16,8 @@ export function claimOperatorAttention(mailbox, options) {
         || pending.toSequence - pending.fromSequence + 1 !== pending.requestCount
         || pending.dedupeKeys.some((key, index) => {
             const ref = pending.refs[index];
+            if (ref.type === "global-job-run")
+                return key !== `operator-global-job-run:${ref.id}`;
             return (ref.type !== "event" && ref.type !== "input")
                 || key !== `operator-${ref.type}:${ref.taskId}:${ref.id}`
                     && key !== `sequence:${pending.fromSequence + index}`;

package/dist/scheduler/operatorInputNotificationProcessor.js

@@ -20,6 +20,10 @@ export async function processOperatorInputNotifications(store, selection, now =
         return [];
     const processing = claim.processing;
     const attentions = deduplicateAttention(processing.batch.refs.flatMap((ref) => {
+        if (ref.type === "global-job-run") {
+            const run = store.getGlobalJobRun?.(ref.id);
+            return run == null ? [] : [{ kind: "global-job-run", run }];
+        }
         if (ref.type === "input") {
             const request = store.getInputRequest(ref.taskId, ref.id);
             return request !== null && request.status === "open"
@@ -70,6 +74,8 @@ function skipped(attention, reason) {
     };
 }
 function attentionIdentity(attention) {
+    if (attention.kind === "global-job-run")
+        return { sourceKind: "global-job-run", sourceId: attention.run.id };
     return attention.kind === "input"
         ? {
             sourceKind: "input",
@@ -83,6 +89,8 @@ function attentionIdentity(attention) {
         };
 }
 function toPresentationItem(attention) {
+    if (attention.kind === "global-job-run")
+        return attention;
     return attention.kind === "input"
         ? { kind: "input-request", request: attention.request }
         : { kind: "task-event", event: attention.event };

package/dist/storage/contextRecords.js

@@ -98,6 +98,14 @@ export function queryContextRecords(db, taskId, query) {
     const sequence = `CAST(substr(r.${key}, length(r.${key}) - length(ltrim(r.${key}, 'abcdefghijklmnopqrstuvwxyz-')) + 1) AS INTEGER)`;
     // Task-local numeric IDs are the stable historical order, not lexical 1,10,2.
     if (query.family === "task-event") {
+        if (query.eventRequestId !== undefined) {
+            where.push("json_extract(r.payload, '$.payload.requestId') = @requestId");
+            params.requestId = query.eventRequestId;
+        }
+        if (query.eventMessageId !== undefined) {
+            where.push("json_extract(r.payload, '$.payload.messageId') = @messageId");
+            params.messageId = query.eventMessageId;
+        }
         if (query.eventTypes !== undefined) {
             where.push("r.type IN (SELECT value FROM json_each(@types))");
             params.types = JSON.stringify(query.eventTypes);

package/dist/storage/jobSchema.js

@@ -0,0 +1,15 @@
+/** Additive DDL for storage 1.9; the published baseline is unchanged. */
+export const JOB_SCHEMA_SQL = `
+CREATE TABLE job_definitions (
+  scope_key TEXT NOT NULL,
+  definition_id TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  PRIMARY KEY (scope_key, definition_id)
+);
+CREATE TABLE global_job_runs (
+  run_id TEXT PRIMARY KEY,
+  payload TEXT NOT NULL,
+  status TEXT NOT NULL
+);
+CREATE INDEX idx_global_job_runs_status ON global_job_runs(status);
+`;

package/dist/storage/maintenanceCaller.js

@@ -22,7 +22,7 @@ export function maintenanceCallerEnvironment(home, env, operatorOnly = true) {
             if (storageMinorUpgradePlan(schema.currentVersion) === null) {
                 throw new ManagedRuntimeDriftError("Maintenance cannot authenticate an unsupported Home storage version.");
             }
-            validateSqliteSchemaObjects(db);
+            validateSqliteSchemaObjects(db, schema.currentVersion);
             const read = (table, where, params) => {
                 const row = db.prepare(`SELECT payload FROM ${table} WHERE ${where}`).get(...params);
                 if (!row)

package/dist/storage/recordValidation.js

@@ -8,6 +8,8 @@ import { validateInputRequest } from "../input/inputRequest.js";
 import { validateChangeSet } from "../integration/changeSet.js";
 import { validateIntegrationAttempt } from "../integration/integrationAttempt.js";
 import { validateDurableJob } from "../job/durableJob.js";
+import { validateJobDefinition } from "../job/jobDefinition.js";
+import { validateSchedule } from "../schedule/schedule.js";
 import { validateGlobalRoleMessage, validateTaskMessage } from "../message/message.js";
 import { validateMilestone } from "../milestone/milestone.js";
 import { validatePluginIntent } from "../plugins/pluginIntent.js";
@@ -54,6 +56,9 @@ const validators = {
     change_sets: check(validateChangeSet),
     integration_attempts: check(validateIntegrationAttempt),
     durable_jobs: check(validateDurableJob),
+    job_definitions: check(validateJobDefinition),
+    schedules: check(validateSchedule),
+    global_job_runs: check(validateDurableJob),
     context_snapshots: check(validateContextSnapshot),
     managed_workspaces: check(validateManagedWorkspace),
     input_requests: check(validateInputRequest),

package/dist/storage/scheduleSchema.js

@@ -0,0 +1,12 @@
+/** Additive storage 1.9 -> 1.10. No old records are rewritten. */
+export const SCHEDULE_SCHEMA_SQL = `
+CREATE TABLE schedules (
+  scope_key TEXT NOT NULL,
+  schedule_id TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  state TEXT NOT NULL,
+  next_due TEXT,
+  PRIMARY KEY(scope_key, schedule_id)
+);
+CREATE INDEX idx_schedules_due ON schedules(state, next_due);
+`;

package/dist/storage/sqliteSchema.js

@@ -1,13 +1,20 @@
 import { createHash } from "node:crypto";
 import Database from "../sqlite/driver.js";
-import { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES } from "./baselineSchema.js";
+import { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES as BASELINE_SCHEMA_TABLES } from "./baselineSchema.js";
 import { migrateTaskMainWorkspaces } from "./upgrade/taskMainWorkspaceMigration.js";
 import { migrateProjectKnowledge } from "./upgrade/projectKnowledgeMigration.js";
+import { JOB_SCHEMA_SQL } from "./jobSchema.js";
+import { SCHEDULE_SCHEMA_SQL } from "./scheduleSchema.js";
+import { migrateJobDefinitions } from "./upgrade/jobDefinitionMigration.js";
 import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION, STORAGE_FORMAT, isMinorStorageUpgrade, isStorageVersion, storageVersionParts } from "./storageVersions.js";
-export { BASELINE_SCHEMA_SQL, SQLITE_SCHEMA_TABLES };
+export { BASELINE_SCHEMA_SQL };
+export const SQLITE_SCHEMA_TABLES = [...BASELINE_SCHEMA_TABLES, "job_definitions", "global_job_runs", "schedules"];
 export const TELEMETRY_KEEP_PER_RUN = 200;
 export const TELEMETRY_RUN_CAP = 50_000;
-export const CURRENT_SCHEMA_CHECKSUM = createHash("sha256").update(BASELINE_SCHEMA_SQL).digest("hex");
+export const BASELINE_SCHEMA_CHECKSUM = createHash("sha256").update(BASELINE_SCHEMA_SQL).digest("hex");
+export const JOB_SCHEMA_CHECKSUM = createHash("sha256").update(BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL).digest("hex");
+export const CURRENT_SCHEMA_SQL = BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL + SCHEDULE_SCHEMA_SQL;
+export const CURRENT_SCHEMA_CHECKSUM = createHash("sha256").update(CURRENT_SCHEMA_SQL).digest("hex");
 export class SqliteSchemaError extends Error {
     code;
     constructor(detail, code = "STORAGE_SCHEMA_INVALID") {
@@ -21,8 +28,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.1",
         name: "task-main-workspace",
         introducedIn: "1.1.0",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         sql: "",
         dataMigration: "task-main-workspace"
     }, {
@@ -30,8 +37,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.2",
         name: "task-authorization-source",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         // New grants can carry source evidence. Valid historical Operator grants
         // remain unchanged; migration must not invent authorization provenance.
         sql: ""
@@ -40,8 +47,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.3",
         name: "selected-session-input",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         // Optional explicit Session fences apply only to new inputs. Preserve old
         // Role-addressed messages; never infer a historical user's Session choice.
         sql: ""
@@ -50,8 +57,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.4",
         name: "project-knowledge-applicability",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         sql: "",
         dataMigration: "project-knowledge"
     }, {
@@ -59,8 +66,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.5",
         name: "frozen-skill-packages",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         // Additive effective-launch/manifest package evidence. Historical envelopes
         // and their digests remain unchanged: absence explicitly means entrypoint-only
         // provenance, not an invitation to invent packages from today's source files.
@@ -72,8 +79,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.6",
         name: "runtime-cost-evidence",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         // Optional sourced monetary observations; historical missing costs stay unknown.
         sql: ""
     }, {
@@ -81,8 +88,8 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.7",
         name: "agent-inbox-consumption",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         // Additive handling receipts on canonical Messages and wakes. Never invent
         // historical processing or Provider acceptance; existing records stay intact.
         sql: ""
@@ -91,11 +98,62 @@ const MINOR_UPGRADES = Object.freeze([{
         toVersion: "1.8",
         name: "model-management-connection",
         introducedIn: "next",
-        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
-        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: BASELINE_SCHEMA_CHECKSUM,
         // Optional non-secret connection references. Existing Homes remain unconfigured;
         // never infer local credentials or adopt an existing external service.
         sql: ""
+    }, {
+        fromVersion: "1.8",
+        toVersion: "1.9",
+        name: "job-definitions-and-runs",
+        introducedIn: "next",
+        sourceChecksum: BASELINE_SCHEMA_CHECKSUM,
+        targetChecksum: JOB_SCHEMA_CHECKSUM,
+        sql: JOB_SCHEMA_SQL,
+        dataMigration: "job-definitions"
+    }, {
+        fromVersion: "1.9",
+        toVersion: "1.10",
+        name: "persistent-schedules",
+        introducedIn: "next",
+        sourceChecksum: JOB_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        sql: SCHEDULE_SCHEMA_SQL
+    }, {
+        fromVersion: "1.10",
+        toVersion: "1.11",
+        name: "activation-input-provenance",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Activation event payloads may now name an exact input or contain attributed
+        // native input text. Existing events remain immutable; missing old provenance
+        // stays explicitly missing. No historical source is guessed from timestamps.
+        // New Task Job semantic writes also append job.state-changed events; no old
+        // Job history is backfilled and the SQL layout remains unchanged.
+        sql: ""
+    }, {
+        fromVersion: "1.11",
+        toVersion: "1.12",
+        name: "project-delivery-scope",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // New append-only Project scope decisions use Task events. Preserve all old
+        // completion, binding and publication records; absence still means required.
+        sql: ""
+    }, {
+        fromVersion: "1.12",
+        toVersion: "1.13",
+        name: "inbox-turn-handling",
+        introducedIn: "next",
+        sourceChecksum: CURRENT_SCHEMA_CHECKSUM,
+        targetChecksum: CURRENT_SCHEMA_CHECKSUM,
+        // Claims may name their exact current attempt; explicit Global retirement
+        // and terminal-check notices preserve original records. Never backfill
+        // historical turn ownership, handling evidence or acknowledgements.
+        sql: ""
     }]);
 export function storageMinorUpgradePlan(from) {
     if (from === CURRENT_STORAGE_VERSION)
@@ -118,13 +176,24 @@ function objects(db) {
     return db.prepare(`SELECT type,name,sql FROM sqlite_master
     WHERE name NOT GLOB 'sqlite_*' ORDER BY type,name`).all();
 }
-let expectedObjects;
-export function validateSqliteSchemaObjects(db) {
+const schemaObjectsByChecksum = new Map();
+export function validateSqliteSchemaObjects(db, version = CURRENT_STORAGE_VERSION) {
+    // Maintenance authenticates before migration. Validate the declared source
+    // layout, not current-only tables that the migration has yet to create.
+    const checksum = version === CURRENT_STORAGE_VERSION
+        ? CURRENT_SCHEMA_CHECKSUM : storageMinorUpgradePlan(version)?.[0]?.sourceChecksum;
+    const sql = checksum === CURRENT_SCHEMA_CHECKSUM ? CURRENT_SCHEMA_SQL
+        : checksum === JOB_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL + JOB_SCHEMA_SQL
+            : checksum === BASELINE_SCHEMA_CHECKSUM ? BASELINE_SCHEMA_SQL : undefined;
+    if (sql === undefined || checksum === undefined)
+        throw new SqliteSchemaError(`unsupported schema definition for storage ${version}.`);
+    let expectedObjects = schemaObjectsByChecksum.get(checksum);
     if (expectedObjects === undefined) {
         const reference = new Database(":memory:");
         try {
-            reference.exec(BASELINE_SCHEMA_SQL);
+            reference.exec(sql);
             expectedObjects = objects(reference);
+            schemaObjectsByChecksum.set(checksum, expectedObjects);
         }
         finally {
             reference.close();
@@ -134,7 +203,7 @@ export function validateSqliteSchemaObjects(db) {
     for (const expected of expectedObjects) {
         const found = actual.find(object => object.type === expected.type && object.name === expected.name);
         if (found?.sql !== expected.sql)
-            throw new SqliteSchemaError(`required ${expected.type} '${expected.name}' differs from the current definition.`);
+            throw new SqliteSchemaError(`required ${expected.type} '${expected.name}' differs from the storage ${version} definition.`);
     }
     if (actual.length !== expectedObjects.length)
         throw new SqliteSchemaError("unexpected schema objects; preserve the database for diagnosis.");
@@ -183,7 +252,7 @@ export function initializeSqliteSchema(db) {
     }
     const { major, minor } = storageVersionParts(CURRENT_STORAGE_VERSION);
     return db.transaction(() => {
-        db.exec(BASELINE_SCHEMA_SQL);
+        db.exec(CURRENT_SCHEMA_SQL);
         db.prepare("INSERT INTO storage_schema VALUES (1,?,?,?,?,?)")
             .run(STORAGE_FORMAT, major, minor, CURRENT_SCHEMA_CHECKSUM, new Date().toISOString());
         return validateSqliteSchema(db);
@@ -207,6 +276,8 @@ export function applySqliteMinorUpgrades(db, home, createdRoots = []) {
             }
             if (step.dataMigration === "project-knowledge")
                 migrateProjectKnowledge(db);
+            if (step.dataMigration === "job-definitions")
+                migrateJobDefinitions(db);
             const { major, minor } = storageVersionParts(step.toVersion);
             db.prepare("UPDATE storage_schema SET major=?,minor=?,checksum=? WHERE id=1")
                 .run(major, minor, step.targetChecksum);