@zq-silk/yui 0.14.0 → 0.14.2

package/dist/storage/sqliteStore.js

@@ -40,8 +40,7 @@ import Database from "better-sqlite3";
 import { consumePendingBatch, mailboxTargetKey, validateWorkMailbox } from "../coordination/workMailbox.js";
 import { validateContextSnapshot } from "../context/contextSnapshot.js";
 import { compareRuntimeSessionCandidates, projectRuntimeSessionCandidate } from "../runtime/runtimeSessionCandidate.js";
-import { validateReviewFinding } from "../review/reviewFinding.js";
-import { reviewFindingLedgerMode } from "../review/reviewFindingLedger.js";
+import { validateReviewRound } from "../review/reviewRound.js";
 import { generateHomeIdentity, validateHomeIdentity } from "../repository/homeIdentity.js";
 import { validateIntegrationQueueEntry } from "../integration/integrationQueueEntry.js";
 import { validDurableJobTransition, validateDurableJob } from "../job/durableJob.js";
@@ -53,6 +52,7 @@ import { CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION, exe
 import { publicationExternalKey } from "../task/publicationReference.js";
 import { gateArtifactKey, validateGateArtifact } from "../verification/gateArtifact.js";
 import { inspectSqliteSchemaMigrations, migrateSqliteSchema, SqliteSchemaMigrationError, SQLITE_AGGREGATE_VERSION, SQLITE_LAYOUT_VERSION, TELEMETRY_KEEP_PER_GENERATION, TELEMETRY_TURN_CAP } from "./sqliteSchema.js";
+import { StorageSchemaError } from "./storageSchema.js";
 /** Read the immutable Home identity without opening a writable Store connection. */
 export function readSqliteHomeIdentity(rootDir, databaseFilename = "yui.db") {
     const database = new Database(join(rootDir, databaseFilename), {
@@ -123,6 +123,10 @@ export class SqliteTaskStore {
         mkdirSync(rootDir, { recursive: true, mode: 0o700 });
         const filename = _options.databaseFilename ?? "yui.db";
         const databasePath = join(rootDir, filename);
+        // Remember whether the database file existed before this connection opened
+        // it. A store that creates the file is bootstrapping a fresh database and
+        // may seed its singleton rows; a store that opens an existing file missing
+        // those rows has found corruption, not a bootstrap opportunity.
         const databaseExisted = existsSync(databasePath);
         this.#db = new Database(databasePath);
         try {
@@ -140,8 +144,7 @@ export class SqliteTaskStore {
                 version: schema.currentVersion,
                 checksum: schema.currentChecksum
             };
-            this.#seedHomeMeta();
-            this.#seedConfig();
+            this.#ensureSeedRows(databaseExisted);
         }
         catch (error) {
             this.#db.close();
@@ -158,6 +161,34 @@ export class SqliteTaskStore {
      */
     databaseHandle() { return this.#db; }
     // -- transaction primitives -------------------------------------------------
+    /**
+     * Guarantee the `home_meta` and `config` singleton rows exist.
+     *
+     * A fresh database created by this connection is bootstrapped with defaults.
+     * An existing database that is missing either row is corrupt —
+     * truncated, partially migrated, or hand-edited — and must fail closed
+     * instead of silently masking the damage with fresh defaults (Issue 01
+     * cross-issue handoff: INSERT OR IGNORE could hide migration corruption).
+     */
+    #ensureSeedRows(databaseExisted) {
+        const hasHomeMeta = this.#db.prepare("SELECT 1 FROM home_meta WHERE id = 1").get() !== undefined;
+        const hasConfig = this.#db.prepare("SELECT 1 FROM config WHERE id = 1").get() !== undefined;
+        if (hasHomeMeta && hasConfig)
+            return;
+        if (databaseExisted) {
+            const missing = [
+                !hasHomeMeta ? "home_meta" : null,
+                !hasConfig ? "config" : null
+            ].filter((value) => value !== null).join(", ");
+            throw new StorageSchemaError("STORAGE_SCHEMA_INVALID", `SQLite database is corrupt: required singleton row(s) missing (${missing}). `
+                + "The database may be truncated or partially migrated. Restore yui.db from a "
+                + "backup, or preserve this Home for diagnosis and initialize a new Home.");
+        }
+        if (!hasHomeMeta)
+            this.#seedHomeMeta();
+        if (!hasConfig)
+            this.#seedConfig();
+    }
     #seedHomeMeta() {
         const now = new Date().toISOString();
         const identity = generateHomeIdentity(new Date());
@@ -731,9 +762,7 @@ export class SqliteTaskStore {
             activeTurns: runs.filter((run) => run.status === "active"),
             leaderTurns: runs.filter((run) => run.roleName === "leader"),
             reviewOutcomeEvidence: {
-                turns: this.#sortById(this.#listPayload("turns", "task_id = ?", [taskId]).filter((run) => run.purpose === "review"), (run) => run.id),
-                reviewFindings: this.listReviewFindings(taskId),
-                events: events.filter((event) => event.type === "review.completed")
+                turns: this.#sortById(this.#listPayload("turns", "task_id = ?", [taskId]).filter((run) => run.purpose === "review"), (run) => run.id)
             }
         };
     }
@@ -743,13 +772,9 @@ export class SqliteTaskStore {
             return null;
         return {
             ...base,
-            turns: operationalTaskRecords(this.listTurns(taskId), this.listEvents(taskId), "turn"),
             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). */
@@ -926,11 +951,11 @@ export class SqliteTaskStore {
            role_name = excluded.role_name, agent_id = excluded.agent_id,
            native_session_id = excluded.native_session_id,
            provider_root_pid = excluded.provider_root_pid,
-           payload = excluded.payload, recorded_at = excluded.recorded_at`).run(identity.launchId, owner.scope, owner.scope === "task" ? owner.taskId : null, owner.roleName, identity.agentId, identity.nativeSessionId ?? null, identity.providerRoot.pid, this.#json(identity), identity.recordedAt);
+           payload = excluded.payload, recorded_at = excluded.recorded_at`).run(identity.runtimeGenerationId, owner.scope, owner.scope === "task" ? owner.taskId : null, owner.roleName, identity.agentId, identity.nativeSessionId ?? null, identity.providerRoot.pid, this.#json(identity), identity.recordedAt);
         });
     }
-    getSessionOwner(launchId) {
-        const row = this.#db.prepare("SELECT payload FROM session_owners WHERE launch_id = ?").get(launchId);
+    getSessionOwner(runtimeGenerationId) {
+        const row = this.#db.prepare("SELECT payload FROM session_owners WHERE launch_id = ?").get(runtimeGenerationId);
         return row === undefined ? null : this.#parse(row.payload);
     }
     listSessionOwners() {
@@ -942,9 +967,9 @@ export class SqliteTaskStore {
         }
         return this.#listPayload("session_owners", "scope = 'task' AND task_id = ? AND role_name = ?", [owner.taskId, owner.roleName]);
     }
-    removeSessionOwner(launchId) {
+    removeSessionOwner(runtimeGenerationId) {
         this.#mutate(() => {
-            this.#db.prepare("DELETE FROM session_owners WHERE launch_id = ?").run(launchId);
+            this.#db.prepare("DELETE FROM session_owners WHERE launch_id = ?").run(runtimeGenerationId);
         });
     }
     // -- task roles -------------------------------------------------------------
@@ -1058,7 +1083,7 @@ export class SqliteTaskStore {
             ? ""
             : ` WHERE ${predicates.join(" AND ")}`;
         const rows = this.#db.prepare(`SELECT scope, task_id, role_name, agent_id, adapter_id,
-              native_session_id, launch_id, session_updated_at,
+              native_session_id, launch_id AS runtime_generation_id, session_updated_at,
               cleanup_required
        FROM runtime_session_candidates${where}`).all(...parameters);
         const candidates = rows.map((row) => ({
@@ -1068,7 +1093,7 @@ export class SqliteTaskStore {
             agentId: row.agent_id,
             adapterId: row.adapter_id,
             nativeSessionId: row.native_session_id,
-            ...(row.launch_id === null ? {} : { launchId: row.launch_id }),
+            ...(row.runtime_generation_id === null ? {} : { runtimeGenerationId: row.runtime_generation_id }),
             sessionUpdatedAt: row.session_updated_at,
             cleanupRequired: row.cleanup_required === 1
         })).sort(compareRuntimeSessionCandidates);
@@ -1123,7 +1148,7 @@ export class SqliteTaskStore {
            json_extract(active_session, '$.agentId') AS agent_id,
            json_extract(active_session, '$.adapterId') AS adapter_id,
            json_extract(active_session, '$.nativeSessionId') AS native_session_id,
-           json_extract(active_session, '$.launchId') AS launch_id,
+           json_extract(active_session, '$.runtimeGenerationId') AS runtime_generation_id,
            CASE
              WHEN json_extract(active_session, '$.status') = 'active'
              THEN 1 ELSE 0
@@ -1131,7 +1156,7 @@ export class SqliteTaskStore {
            json_extract(active_session, '$.updatedAt') AS session_updated_at,
            CASE
              WHEN json_extract(active_session, '$.status') = 'active'
-               AND json_type(active_session, '$.launchId') = 'text'
+               AND json_type(active_session, '$.runtimeGenerationId') = 'text'
              THEN 1 ELSE 0
            END AS cleanup_required
          FROM active`).get(...source.parameters);
@@ -1151,7 +1176,7 @@ export class SqliteTaskStore {
             && row.agent_id === candidate.agentId
             && row.adapter_id === candidate.adapterId
             && row.native_session_id === candidate.nativeSessionId
-            && (row.launch_id ?? undefined) === candidate.launchId
+            && (row.runtime_generation_id ?? undefined) === candidate.runtimeGenerationId
             && row.is_active === 1
             && row.session_updated_at === candidate.sessionUpdatedAt
             && row.cleanup_required === (candidate.cleanupRequired ? 1 : 0);
@@ -1192,7 +1217,7 @@ export class SqliteTaskStore {
          native_session_id = excluded.native_session_id,
          launch_id = excluded.launch_id,
          session_updated_at = excluded.session_updated_at,
-         cleanup_required = excluded.cleanup_required`).run(candidate.owner.scope, taskId, candidate.owner.roleName, candidate.agentId, candidate.adapterId, candidate.nativeSessionId, candidate.launchId ?? null, candidate.sessionUpdatedAt, candidate.cleanupRequired ? 1 : 0);
+         cleanup_required = excluded.cleanup_required`).run(candidate.owner.scope, taskId, candidate.owner.roleName, candidate.agentId, candidate.adapterId, candidate.nativeSessionId, candidate.runtimeGenerationId ?? null, candidate.sessionUpdatedAt, candidate.cleanupRequired ? 1 : 0);
     }
     #deleteRuntimeSessionCandidate(owner) {
         this.#db.prepare(`DELETE FROM runtime_session_candidates
@@ -1295,8 +1320,7 @@ export class SqliteTaskStore {
                 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}.`);
+                        throw new StorageRecordError(`Publication external identity conflicts with current record ${latest.id}: ${key}.`);
                     }
                 }
                 else if (stored.supersedes !== undefined) {
@@ -1500,6 +1524,7 @@ export class SqliteTaskStore {
         return this.#sortById(this.#listPayload("review_rounds", "task_id = ?", [taskId]), (round) => round.id);
     }
     saveReviewRound(taskId, round) {
+        validateReviewRound(round);
         if (round.taskId !== taskId)
             throw new StorageRecordError(`Review round belongs to another Task: ${round.taskId}`);
         this.#requireTask(taskId);
@@ -1509,27 +1534,6 @@ export class SqliteTaskStore {
            payload = excluded.payload, updated_at = excluded.updated_at`).run(taskId, round.id, round.status, this.#json(round), this.#now());
         });
     }
-    // -- review findings --------------------------------------------------------
-    nextReviewFindingId(taskId) { return this.#nextTaskRecordId(taskId, "reviewFinding"); }
-    getReviewFinding(taskId, findingId) {
-        return this.#getPayload("review_findings", "task_id = ? AND finding_id = ?", [taskId, findingId]);
-    }
-    listReviewFindings(taskId) {
-        return this.#sortById(this.#listPayload("review_findings", "task_id = ?", [taskId]), (finding) => finding.id);
-    }
-    saveReviewFinding(taskId, finding) {
-        validateReviewFinding(finding);
-        if (finding.taskId !== taskId) {
-            throw new StorageRecordError(`Review finding belongs to another Task: ${finding.taskId}`);
-        }
-        this.#requireTask(taskId);
-        this.#mutate(() => {
-            this.#db.prepare(`INSERT INTO review_findings (task_id, finding_id, stable_key, severity, payload, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?)
-         ON CONFLICT(task_id, finding_id) DO UPDATE SET stable_key = excluded.stable_key,
-           severity = excluded.severity, payload = excluded.payload, updated_at = excluded.updated_at`).run(taskId, finding.id, finding.stableKey, finding.severity, this.#json(finding), this.#now());
-        });
-    }
     // -- active turns ----------------------------------------------------------
     #saveActiveTurn(taskId, pointer, turnId) {
         this.#mutate(() => {
@@ -1721,6 +1725,18 @@ export class SqliteTaskStore {
             this.#observeHighWater(taskId, "message", seq);
         });
     }
+    updateMessage(taskId, message) {
+        if (message.taskId !== taskId) {
+            throw new StorageRecordError(`Message belongs to another Task: ${message.taskId}`);
+        }
+        this.#requireTask(taskId);
+        this.#mutate(() => {
+            const result = this.#db.prepare(`UPDATE messages SET payload = ? WHERE task_id = ? AND message_id = ?`).run(this.#json(message), taskId, message.id);
+            if (result.changes !== 1) {
+                throw new StorageRecordError(`Message does not exist: ${taskId}/${message.id}`);
+            }
+        });
+    }
     listMessages(taskId) {
         return this.#sortById(this.#listPayload("messages", "task_id = ?", [taskId]), (message) => message.id);
     }
@@ -2109,10 +2125,9 @@ function validIntegrationQueueTransition(before, after) {
         || before.createdAt !== after.createdAt)
         return false;
     const allowed = {
-        queued: ["queued", "running", "validated", "superseded"],
+        queued: ["queued", "running", "superseded"],
         running: ["running", "conflicted", "committed"],
         conflicted: ["conflicted", "running", "committed", "queued", "superseded"],
-        validated: ["validated", "running", "queued", "superseded"],
         committed: ["committed"],
         superseded: ["superseded"]
     };

package/dist/storage/storageSchema.js

@@ -136,9 +136,6 @@ export function ensureStorageSchema(rootDir, now = new Date()) {
     }
     requireInspectedSchema(state);
 }
-export function requireStorageSchema(rootDir) {
-    requireInspectedSchema(inspectStorageSchema(rootDir));
-}
 /** Persist the current three-axis manifest through the existing atomic-file seam. */
 export function writeCurrentStorageManifest(rootDir, now = new Date()) {
     const recordVersions = {};
@@ -176,7 +173,7 @@ function unsupportedVersion(current, required, component, recordFamily) {
             ? "Aggregate schema"
             : `Record family '${recordFamily}'`;
     if (current < required) {
-        return new StorageSchemaError("STORAGE_SCHEMA_UNSUPPORTED", `${label} ${current} is older than required ${component} version ${required}; no migration is available in this Yui release.`);
+        return new StorageSchemaError("STORAGE_SCHEMA_UNSUPPORTED", `${label} ${current} is older than required ${component} version ${required}; use the matching Yui version or initialize a new Home.`);
     }
     return new StorageSchemaError("STORAGE_SCHEMA_UNSUPPORTED", `${label} ${current} is newer than supported ${component} version ${required}; use a newer Yui release.`);
 }
@@ -229,10 +226,6 @@ export function parseStorageSchemaManifest(value) {
         updatedAt: value.updatedAt
     };
 }
-/** Read and strictly parse the durable manifest through the same contract. */
-export function readStorageSchemaManifest(rootDir) {
-    return parseStorageManifest(readFileSync(join(rootDir, STORAGE_SCHEMA_FILE), "utf8"));
-}
 function parseJsonObject(raw, label) {
     let value;
     try {

package/dist/storage/storageVersions.js

@@ -9,9 +9,12 @@
  * Version of the on-disk layout (`schema.json` plus the SQLite database).
  *
  * Layout 8 is the current SQLite WAL control-plane layout: the authoritative
- * store is `yui.db`. Layout 8 is the only layout this release reads and writes;
- * older Homes are rejected and must not be upgraded in place.
+ * store is `yui.db`. Layout 8 is the only physical layout this release reads
+ * and writes. Historical aggregate contracts are rejected without mutation.
  */
 export const CURRENT_STORAGE_LAYOUT_VERSION = 8;
-/** Version of the logical aggregates persisted in SQLite. */
-export const CURRENT_AGGREGATE_SCHEMA_VERSION = 21;
+/**
+ * Aggregate 31 makes Agent results opaque, removes parsed Review/finding
+ * authority, and intentionally has no upgrade path from earlier contracts.
+ */
+export const CURRENT_AGGREGATE_SCHEMA_VERSION = 31;

package/dist/storage/taskStore.js

@@ -13,18 +13,18 @@ export const CURRENT_CONFIG_SCHEMA_VERSION = 6;
 /** Current SQLite payload-family versions owned by this storage boundary. */
 export const CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION = 2;
 export const CURRENT_PROJECT_SCHEMA_VERSION = 5;
-export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 2;
+export const CURRENT_AGENT_PROFILE_SCHEMA_VERSION = 3;
 export const CURRENT_GLOBAL_ROLE_SCHEMA_VERSION = 3;
-export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 4;
-export const CURRENT_TASK_SCHEMA_VERSION = 6;
+export const CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION = 5;
+export const CURRENT_TASK_SCHEMA_VERSION = 7;
 export const CURRENT_TASK_BRIEF_SCHEMA_VERSION = 2;
 export const CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION = 1;
 export const CURRENT_TASK_ROLE_SCHEMA_VERSION = 4;
 export const CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION = 2;
-export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 13;
-export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 6;
+export const CURRENT_WORK_ITEM_SCHEMA_VERSION = 15;
+export const CURRENT_REVIEW_ROUND_SCHEMA_VERSION = 8;
 export const CURRENT_CHANGE_SET_SCHEMA_VERSION = 4;
-export const CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION = 5;
+export const CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION = 6;
 export const CURRENT_MESSAGE_SCHEMA_VERSION = 3;
 export const CURRENT_INPUT_REQUEST_SCHEMA_VERSION = 3;
 export const CURRENT_DECISION_SCHEMA_VERSION = 1;
@@ -65,8 +65,8 @@ export function executionLaneActiveTurnKeyParts(key) {
 /**
  * Nested-record versions consumed by the current SQLite payload validators.
  */
-export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 11;
-export const CURRENT_TURN_SCHEMA_VERSION = 1;
+export const CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION = 12;
+export const CURRENT_TURN_SCHEMA_VERSION = 5;
 export const CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION = 1;
 export class StorageRecordError extends Error {
     constructor(message) { super(message); this.name = "StorageRecordError"; }

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -1,126 +1,155 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { RUNTIME_OBSERVATION_TASK_EVENT, createRuntimeObservation } from "../../runtime/runtimeObservation.js";
+import { RUNTIME_PROCESS_EXIT_TASK_EVENT, validateRuntimeProcessExitObservation } from "../../runtime/processExitObservation.js";
+import { validateAgentProfile } from "../../profile/agentProfile.js";
+import { validateRoleSessionSet } from "../../executor/agentExecutor.js";
+import { validateReviewRound } from "../../review/reviewRound.js";
+import { validateTurn } from "../../turn/turn.js";
+import { validateWorkItem } from "../../workItem/workItem.js";
 import { SqliteTaskStore } from "../sqliteStore.js";
 import { inspectStorageSchema } from "../storageSchema.js";
 const CURRENT_DATABASE_FILENAME = "yui.db";
 /**
- * Current-only storage admission. Historical Homes are preserved byte-for-byte
- * and rejected; Yui never repairs, normalizes, or upgrades them in place.
+ * Validate the one supported storage contract.
+ *
+ * Aggregate 31 deliberately has no historical migration path. `upgrade`
+ * remains as a read-only compatibility/preflight surface for current Homes;
+ * every non-current contract is rejected without touching the Home.
  */
 export async function runStorageUpgrade(options) {
     const schema = inspectStorageSchema(options.home);
-    const classification = classifyCurrentHome(schema, options.latest);
     if (schema.status === "uninitialized") {
-        return blocked(classification, "uninitialized", "Yui storage is not initialized for this Home.", "Run `yui setup` with a new Home.");
+        return blocked({ ...currentClassification(options.latest), uninitialized: true }, "uninitialized", "Yui storage is not initialized for this Home.", "Run `yui setup` with a new Home.");
     }
     if (schema.status === "invalid") {
-        return blocked(classification, "corruption", `Storage schema is invalid: ${schema.detail}`, "Preserve this Home for diagnosis and initialize a new Home.");
-    }
-    if (schema.status === "unsupported") {
-        return blocked(classification, "unsupported", `Storage contract is ${schema.direction}: ${schema.incompatibleComponent}.`, "Open the old Home only with its original Yui version to export a summary; then let the new Operator create a new Task in a new Home.");
+        return blocked(corruptedClassification(options.latest, schema.detail), "corruption", `Storage schema is invalid: ${schema.detail}`, "Preserve this Home for diagnosis and restore it from a known-good backup.");
     }
     if (!existsSync(join(options.home, CURRENT_DATABASE_FILENAME))) {
-        return blocked(corruptedClassification(classification, "The current SQLite database is missing."), "corruption", "The current SQLite Home is incomplete: yui.db is missing.", "Preserve this Home for diagnosis and initialize a new Home.");
+        return blocked(corruptedClassification(options.latest, "The SQLite database is missing."), "corruption", "The SQLite Home is incomplete: yui.db is missing.", "Preserve this Home for diagnosis and restore it from a known-good backup.");
+    }
+    if (schema.status === "unsupported") {
+        const classification = unsupportedClassification(schema, options.latest);
+        return blocked(classification, "unsupported", "This Home does not exactly match the current storage contract; this release provides no migration path.", schema.direction === "newer"
+            ? "Use a newer Yui release that supports this exact Home."
+            : "Open it with its matching Yui version, or initialize a new Home.");
     }
     try {
-        const store = new SqliteTaskStore(options.home);
-        try {
-            store.getConfig();
-        }
-        finally {
-            store.close();
-        }
+        validateCurrentStore(options.home);
     }
     catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return blocked(corruptedClassification(classification, message), "corruption", `Current storage validation failed: ${message}`, "Preserve this Home for diagnosis and initialize a new Home.");
+        return blocked(corruptedClassification(options.latest, messageOf(error)), "corruption", `Current storage validation failed: ${messageOf(error)}`, "Preserve this Home for diagnosis and restore it from a known-good backup.");
     }
+    const classification = currentClassification(options.latest);
     if (options.mode === "update-preflight") {
         return {
             outcome: "update-preflight",
             status: "already-current",
             stepCount: 0,
+            steps: [],
             classification
         };
     }
-    const report = {
+    return {
         outcome: "already-current",
-        mode: options.mode,
-        source: options.latest,
-        target: options.latest
+        classification,
+        report: {
+            outcome: "already-current",
+            mode: options.mode,
+            source: options.latest,
+            target: options.latest
+        }
     };
-    return { outcome: "already-current", classification, report };
 }
-function classifyCurrentHome(schema, latest) {
-    const base = {
+function validateCurrentStore(home) {
+    const store = new SqliteTaskStore(home);
+    try {
+        store.getConfig();
+        for (const profile of store.listAgentProfiles())
+            validateAgentProfile(profile);
+        for (const sessions of store.listGlobalRoleSessionSets()) {
+            validateRoleSessionSet(sessions);
+        }
+        for (const owner of store.listSessionOwners()) {
+            if (owner.schemaVersion !== 2
+                || typeof owner.runtimeGenerationId !== "string"
+                || Object.hasOwn(owner, "launchId")) {
+                throw new Error("Session owner runtime generation identity is invalid.");
+            }
+        }
+        for (const taskId of store.listTasks().map(({ id }) => id)) {
+            for (const item of store.listWorkItems(taskId))
+                validateWorkItem(item);
+            for (const round of store.listReviewRounds(taskId))
+                validateReviewRound(round);
+            for (const turn of store.listTurns(taskId))
+                validateTurn(turn);
+            for (const sessions of store.listRoleSessionSets(taskId)) {
+                validateRoleSessionSet(sessions);
+            }
+            for (const event of store.listEvents(taskId)) {
+                if (event.type === RUNTIME_OBSERVATION_TASK_EVENT) {
+                    createRuntimeObservation(JSON.parse(event.payload.observation ?? ""));
+                }
+                else if (event.type === RUNTIME_PROCESS_EXIT_TASK_EVENT) {
+                    validateRuntimeProcessExitObservation(JSON.parse(event.payload.observation ?? ""));
+                }
+            }
+        }
+    }
+    finally {
+        store.close();
+    }
+}
+function currentClassification(latest) {
+    return {
+        classification: { verdict: "USABLE", status: "current" },
+        layoutVersion: latest.layout,
+        aggregateVersion: latest.aggregate,
         latestLayoutVersion: latest.layout,
         latestAggregateVersion: latest.aggregate
     };
-    if (schema.status === "uninitialized") {
-        return {
-            ...base,
-            classification: { verdict: "USABLE", status: "current" },
-            uninitialized: true
-        };
-    }
-    if (schema.status === "invalid") {
-        return corruptedClassification({
-            ...base,
-            classification: { verdict: "CORRUPTED", status: "unsupported", detail: schema.detail }
-        }, schema.detail);
-    }
-    if (schema.status === "unsupported") {
-        const blocker = schema.direction === "newer"
-            ? {
-                reason: "future-version",
-                axis: schema.incompatibleComponent,
+}
+function unsupportedClassification(schema, latest) {
+    const axis = schema.incompatibleComponent;
+    const found = schema.currentVersion;
+    const supported = schema.latestVersion;
+    const future = schema.direction === "newer";
+    const action = future
+        ? "Use a newer Yui release that supports this exact Home."
+        : "Open it with its matching Yui version, or initialize a new Home.";
+    return {
+        classification: {
+            verdict: "NEEDS_NEW_VERSION",
+            status: "unsupported",
+            blocker: {
+                reason: future ? "future-version" : "missing-step",
+                axis,
                 ...(schema.recordFamily === undefined ? {} : { recordKind: schema.recordFamily }),
-                found: schema.currentVersion,
-                supported: schema.latestVersion,
-                message: "Historical storage contracts are not supported by this release.",
-                action: "Initialize a new Home."
+                ...(future ? { found, supported } : { from: found, to: supported }),
+                message: future
+                    ? "The Home is newer than this Yui release."
+                    : "This release provides no migration path for the older Home.",
+                action
             }
-            : {
-                reason: "missing-step",
-                axis: schema.incompatibleComponent,
-                ...(schema.recordFamily === undefined ? {} : { recordKind: schema.recordFamily }),
-                from: schema.currentVersion,
-                to: schema.latestVersion,
-                message: "Historical storage contracts are not supported by this release.",
-                action: "Initialize a new Home."
-            };
-        return {
-            ...base,
-            classification: {
-                verdict: "NEEDS_NEW_VERSION",
-                status: "unsupported",
-                blocker
-            },
-            layoutVersion: schema.currentLayoutVersion,
-            aggregateVersion: schema.currentAggregateSchemaVersion,
-            incompatibleComponent: schema.incompatibleComponent
-        };
-    }
-    return {
-        ...base,
-        classification: { verdict: "USABLE", status: "current" },
+        },
         layoutVersion: schema.currentLayoutVersion,
-        aggregateVersion: schema.currentAggregateSchemaVersion
+        aggregateVersion: schema.currentAggregateSchemaVersion,
+        latestLayoutVersion: latest.layout,
+        latestAggregateVersion: latest.aggregate,
+        incompatibleComponent: axis
     };
 }
-function corruptedClassification(classification, detail) {
+function corruptedClassification(latest, detail) {
     return {
-        ...classification,
-        classification: { verdict: "CORRUPTED", status: "unsupported", detail }
+        classification: { verdict: "CORRUPTED", status: "unsupported", detail },
+        latestLayoutVersion: latest.layout,
+        latestAggregateVersion: latest.aggregate
     };
 }
 function blocked(classification, stage, message, action) {
-    return {
-        outcome: "blocked",
-        stage,
-        message,
-        action,
-        classification,
-        sceneUnchanged: true
-    };
+    return { outcome: "blocked", stage, message, action, classification, sceneUnchanged: true };
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
 }