@zq-silk/yui 0.13.9 → 0.14.0

package/dist/observability/executionAudit.js

@@ -2,7 +2,7 @@
  * Read-only execution audit aggregator (Issue 11 §3).
  *
  * The audit answers "what happened in this Home" from durable records alone:
- * Runs/failures/durations, wake reasons, Session generations, Review execution
+ * Turns/failures/durations, wake reasons, Session generations, Review execution
  * vs semantic failures, Integration failure classes and gate reuse, telemetry
  * volume, and the longest/stale executions. It never writes Task state, never
  * wakes a Leader, and never takes the storage write lock — it only calls the
@@ -12,16 +12,16 @@
  */
 import { readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { openCompatibleFileTaskStore } from "../storage/compatibleTaskStore.js";
+import { openCurrentTaskStore } from "../storage/currentTaskStore.js";
 import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { runtimeObservationFromTaskEvent } from "../runtime/runtimeObservation.js";
-import { classifyAgentRunFailure, classifyIntegrationAttempt, classifyReviewRound, classifyWakeReasons, countFaultClasses } from "./faultClassification.js";
+import { classifyTurnFailure, classifyIntegrationAttempt, classifyReviewRound, countFaultClasses } from "./faultClassification.js";
 import { RUNTIME_LAUNCH_KINDS, RUNTIME_LAUNCH_PHASES } from "../runtime/launchDiagnostics.js";
 import { UNSUPPORTED } from "./runtimeIdentity.js";
 import { projectTaskOrchestration } from "./orchestrationMetrics.js";
 export function createProductionExecutionAuditPorts() {
     return {
-        openStore: (home) => openCompatibleFileTaskStore(home),
+        openStore: (home) => openCurrentTaskStore(home),
         directorySize: (path) => directorySizeBytes(path)
     };
 }
@@ -86,10 +86,10 @@ function roleBucket(roleName) {
     }
     return "other";
 }
-function durationMs(run) {
-    if (run.endedAt === undefined)
+function durationMs(turn) {
+    if (turn.result === undefined)
         return 0;
-    return Math.max(0, Date.parse(run.endedAt) - Date.parse(run.createdAt));
+    return Math.max(0, Date.parse(turn.result.completedAt) - Date.parse(turn.createdAt));
 }
 function emptyLaunchFailureCounts() {
     const counts = {
@@ -116,35 +116,35 @@ function addLaunchFailureCounts(counts, summary) {
 }
 /**
  * Issue 09: classify a terminal Session (stopped/broken) by its relationship
- * to the last Run it carried. Runs and Sessions are separate axes: a Session
- * that stops after its Run yielded is a post-completion stop, not a Run
+ * to the last Turn it carried. Turns and Sessions are separate axes: a Session
+ * that stops after its Turn completed is a post-completion stop, not a Turn
  * failure. Correlation is by Role + Agent + Adapter (the durable identity a
- * Run and its Session share) and the Session's terminal update timestamp.
+ * Turn and its Session share) and the Session's terminal update timestamp.
  */
-function classifyTerminalSessionRunRelation(runs, roleName, session, counts) {
+function classifyTerminalSessionTurnRelation(turns, roleName, session, counts) {
     const terminalAt = Date.parse(session.updatedAt);
-    const carried = runs
-        .filter((run) => (run.roleName === roleName
-        && run.effective.agentId === session.agentId
-        && run.effective.adapterId === session.adapterId
-        && Date.parse(run.createdAt) <= terminalAt))
+    const carried = turns
+        .filter((turn) => (turn.roleName === roleName
+        && turn.effective.agentId === session.agentId
+        && turn.effective.adapterId === session.adapterId
+        && Date.parse(turn.createdAt) <= terminalAt))
         .sort((left, right) => Date.parse(right.createdAt) - Date.parse(left.createdAt));
-    const lastRun = carried[0];
-    if (lastRun === undefined) {
-        counts.noRun += 1;
+    const lastTurn = carried[0];
+    if (lastTurn === undefined) {
+        counts.noTurn += 1;
         return;
     }
-    if (lastRun.status === "yielded"
-        && lastRun.endedAt !== undefined
-        && Date.parse(lastRun.endedAt) <= terminalAt) {
-        counts.postRunYielded += 1;
+    if (lastTurn.status === "completed"
+        && lastTurn.result !== undefined
+        && Date.parse(lastTurn.result.completedAt) <= terminalAt) {
+        counts.postTurnCompleted += 1;
         return;
     }
-    if (lastRun.status === "failed") {
-        counts.runFailed += 1;
+    if (lastTurn.status === "failed") {
+        counts.turnFailed += 1;
         return;
     }
-    counts.activeRun += 1;
+    counts.activeTurn += 1;
 }
 function ok(data) {
     return { status: "ok", data };
@@ -156,7 +156,7 @@ function failed(error) {
     };
 }
 /**
- * Run the read-only audit. The store is opened once and only read methods are
+ * Execute the read-only audit. The store is opened once and only read methods are
  * called; no transaction, no Event, no Message, no wake is produced.
  */
 export function runExecutionAudit(home, options = {}, ports = createProductionExecutionAuditPorts()) {
@@ -178,7 +178,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             homeIdentity: UNSUPPORTED,
             scope,
             tasks: section,
-            runs: section,
+            turns: section,
             wakes: section,
             sessions: section,
             reviews: section,
@@ -224,11 +224,11 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             return failed(error);
         }
     })();
-    const runs = (() => {
+    const turns = (() => {
         try {
             let total = 0;
             let active = 0;
-            let yielded = 0;
+            let completed = 0;
             let failedCount = 0;
             let cumulativeDurationMs = 0;
             let failedDurationMs = 0;
@@ -237,37 +237,37 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             const failures = [];
             const launchFailures = emptyLaunchFailureCounts();
             for (const taskId of taskIds) {
-                for (const run of store.listAgentRuns(taskId)) {
-                    if (!inWindow(run.createdAt, options))
+                for (const turn of store.listTurns(taskId)) {
+                    if (!inWindow(turn.createdAt, options))
                         continue;
                     total += 1;
-                    byRole[roleBucket(run.roleName)] += 1;
-                    if (run.purpose === "review")
+                    byRole[roleBucket(turn.roleName)] += 1;
+                    if (turn.purpose === "review")
                         byPurpose.review += 1;
                     else
                         byPurpose.execution += 1;
-                    const duration = durationMs(run);
-                    if (run.status === "active") {
+                    const duration = durationMs(turn);
+                    if (turn.status === "active") {
                         active += 1;
-                        cumulativeDurationMs += Math.max(0, Date.now() - Date.parse(run.createdAt));
+                        cumulativeDurationMs += Math.max(0, Date.now() - Date.parse(turn.createdAt));
                     }
-                    else if (run.status === "yielded") {
-                        yielded += 1;
+                    else if (turn.status === "completed") {
+                        completed += 1;
                         cumulativeDurationMs += duration;
                     }
-                    else if (run.status === "failed") {
+                    else if (turn.status === "failed") {
                         failedCount += 1;
                         failedDurationMs += duration;
                         cumulativeDurationMs += duration;
-                        addLaunchFailureCounts(launchFailures, run.summary);
-                        failures.push(classifyAgentRunFailure(run));
+                        addLaunchFailureCounts(launchFailures, turn.result?.output);
+                        failures.push(classifyTurnFailure(turn));
                     }
                 }
             }
             return ok({
                 total,
                 active,
-                yielded,
+                completed,
                 failed: failedCount,
                 failureRate: total === 0 ? 0 : failedCount / total,
                 cumulativeDurationMs,
@@ -284,20 +284,18 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
     })();
     const wakes = (() => {
         try {
-            let leaderRuns = 0;
+            let leaderTurns = 0;
             let withWakeReasons = 0;
-            let orphanWakes = 0;
-            let orphanYieldOnly = 0;
             let suppressedWakes = 0;
             const byReason = new Map();
             for (const taskId of taskIds) {
-                for (const run of store.listAgentRuns(taskId)) {
-                    if (run.roleName !== "leader")
+                for (const turn of store.listTurns(taskId)) {
+                    if (turn.roleName !== "leader")
                         continue;
-                    if (!inWindow(run.createdAt, options))
+                    if (!inWindow(turn.createdAt, options))
                         continue;
-                    leaderRuns += 1;
-                    const match = WAKE_REASON_PATTERN.exec(run.assignment.directive ?? "");
+                    leaderTurns += 1;
+                    const match = WAKE_REASON_PATTERN.exec(turn.inputs[0].input.directive ?? "");
                     if (match === null)
                         continue;
                     withWakeReasons += 1;
@@ -305,12 +303,6 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     for (const reason of reasons) {
                         byReason.set(reason, (byReason.get(reason) ?? 0) + 1);
                     }
-                    if (classifyWakeReasons(reasons).faultClass
-                        === "scheduler-duplicate-suppressed-wake") {
-                        orphanWakes += 1;
-                        if (run.status === "yielded")
-                            orphanYieldOnly += 1;
-                    }
                 }
                 for (const event of store.listEvents(taskId)) {
                     if (event.type !== "wake.suppressed")
@@ -321,14 +313,12 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 }
             }
             return ok({
-                leaderRuns,
+                leaderTurns,
                 withWakeReasons,
-                orphanWakes,
-                orphanYieldOnly,
                 byReason: Object.fromEntries([...byReason.entries()].sort((left, right) => right[1] - left[1])),
                 // Scheduler single-flight suppression: wakes that were coalesced
                 // because the Role runtime lifecycle lane was busy. These are
-                // scheduler outcomes, never failed Runs.
+                // scheduler outcomes, never failed Turns.
                 suppressedWakes: { status: "ok", data: suppressedWakes }
             });
         }
@@ -346,14 +336,14 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let conversationSwitches = 0;
             let lifecycleEvents = 0;
             let stopFailures = 0;
-            const terminalByRunRelation = {
-                postRunYielded: 0,
-                runFailed: 0,
-                activeRun: 0,
-                noRun: 0
+            const terminalByTurnRelation = {
+                postTurnCompleted: 0,
+                turnFailed: 0,
+                activeTurn: 0,
+                noTurn: 0
             };
             for (const taskId of taskIds) {
-                const runs = store.listAgentRuns(taskId);
+                const turns = store.listTurns(taskId);
                 for (const set of store.listRoleSessionSets(taskId)) {
                     const history = Array.isArray(set.history) ? set.history : [];
                     for (const session of [...history, ...Object.values(set.sessions)]) {
@@ -365,7 +355,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                         else
                             other += 1;
                         if (session.status === "ended") {
-                            classifyTerminalSessionRunRelation(runs, set.owner.roleName, session, terminalByRunRelation);
+                            classifyTerminalSessionTurnRelation(turns, set.owner.roleName, session, terminalByTurnRelation);
                         }
                     }
                 }
@@ -393,7 +383,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                 conversationSwitches,
                 lifecycleEvents,
                 stopFailures,
-                terminalByRunRelation
+                terminalByTurnRelation
             });
         }
         catch (error) {
@@ -602,7 +592,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     entries.push({
                         taskId,
                         eventId: event.id,
-                        runId: event.payload.runId ?? "",
+                        turnId: event.payload.turnId ?? "",
                         roleName: event.payload.roleName ?? "",
                         source: event.payload.source ?? "unknown",
                         phase: event.payload.phase ?? "unknown",
@@ -656,7 +646,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
                     return [];
                 return [projectTaskOrchestration({
                         task,
-                        runs: withinWindow(store.listAgentRuns(taskId), options),
+                        turns: withinWindow(store.listTurns(taskId), options),
                         roleSessionSets: sessionSetsWithinWindow(store.listRoleSessionSets(taskId), options),
                         workItems: withinWindow(store.listWorkItems(taskId), options),
                         changeSets: withinWindow(store.listChangeSets(taskId), options),
@@ -723,14 +713,12 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
             let processExitObservations = 0;
             let compactionEvents = 0;
             for (const taskId of taskIds) {
-                for (const run of store.listAgentRuns(taskId)) {
+                for (const run of store.listTurns(taskId)) {
                     if (!inWindow(run.createdAt, options))
                         continue;
-                    const version = String(run.effective.contextProtocolVersion ?? "legacy");
+                    const version = String(run.effective.contextProtocolVersion);
                     protocolVersions.set(version, (protocolVersions.get(version) ?? 0) + 1);
-                    if (run.effective.sessionManifestCompatibilityDigest !== undefined) {
-                        manifestDigests.add(run.effective.sessionManifestCompatibilityDigest);
-                    }
+                    manifestDigests.add(run.effective.sessionManifestCompatibilityDigest);
                 }
                 for (const event of store.listEvents(taskId)) {
                     if (!inWindow(event.createdAt, options))
@@ -777,21 +765,21 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         try {
             const entries = [];
             for (const taskId of taskIds) {
-                for (const run of store.listAgentRuns(taskId)) {
-                    if (!inWindow(run.createdAt, options))
+                for (const turn of store.listTurns(taskId)) {
+                    if (!inWindow(turn.createdAt, options))
                         continue;
-                    const duration = run.status === "active"
-                        ? Math.max(0, Date.now() - Date.parse(run.createdAt))
-                        : durationMs(run);
+                    const duration = turn.status === "active"
+                        ? Math.max(0, Date.now() - Date.parse(turn.createdAt))
+                        : durationMs(turn);
                     if (duration <= 0)
                         continue;
                     entries.push({
                         taskId,
-                        runId: run.id,
-                        roleName: run.roleName,
-                        status: run.status,
+                        turnId: turn.id,
+                        roleName: turn.roleName,
+                        status: turn.status,
                         durationMs: duration,
-                        startedAt: run.createdAt
+                        startedAt: turn.createdAt
                     });
                 }
             }
@@ -809,7 +797,7 @@ export function runExecutionAudit(home, options = {}, ports = createProductionEx
         homeIdentity,
         scope,
         tasks,
-        runs,
+        turns,
         wakes,
         sessions,
         reviews,

package/dist/observability/faultClassification.js

@@ -3,9 +3,8 @@ export const FAULT_CLASSES = [
     "provider-transient",
     "policy-denied",
     "session-dead",
-    "delivery-yield-uncertain",
+    "delivery-uncertain",
     "storage-backend-lock",
-    "scheduler-duplicate-suppressed-wake",
     "review-infra",
     "review-semantic-negative",
     "integration-environment",
@@ -23,7 +22,7 @@ const PROVIDER_TRANSIENT_PATTERN = /\b5\d{2}\b|gateway time|connection lost|serv
 const POLICY_DENIED_PATTERN = /policy|permission denied|forbidden|not authorized|\b403\b/iu;
 const SESSION_DEAD_PATTERN = /tmux session exited|session cannot be replaced|could not start|pane[^\n]*(dead|exited)|session[^\n]*(dead|exited|broken)|native session|launch reservation/iu;
 const STORAGE_LOCK_PATTERN = /storage lock|database is locked|SQLITE_BUSY|lock timeout|COMMAND_TIMED_OUT|storage conflict|timed out waiting/iu;
-const DELIVERY_UNCERTAIN_PATTERN = /delivery[^\n]*(uncertain|unknown)|yield[^\n]*(uncertain|unknown)|uncertain[^\n]*(yield|delivery)|push[^\n]*uncertain/iu;
+const DELIVERY_UNCERTAIN_PATTERN = /delivery[^\n]*(uncertain|unknown)|uncertain[^\n]*delivery|push[^\n]*uncertain/iu;
 const STALE_BASE_PATTERN = /stale (role|agent|base|target|state)|expected head|base[^\n]*(changed|moved)|conflict|CAS/iu;
 const INTEGRATION_ENVIRONMENT_PATTERN = /tsc: not found|command not found|ENOENT|runner disappeared|runner vanished|dirty target|wrong argument|not a git repository|npm error|node: not found/iu;
 function excerpt(text, max = 160) {
@@ -31,11 +30,11 @@ function excerpt(text, max = 160) {
     return normalized.length <= max ? normalized : `${normalized.slice(0, max)}…`;
 }
 /**
- * Classify a failed AgentRun. A structured hint (from a future capability
+ * Classify a failed Turn. A structured hint (from a future capability
  * provider) always wins; otherwise the summary is matched as historical
- * import text. Active/yielded runs return {@link NO_FAULT}.
+ * import text. Non-failed Turns return {@link NO_FAULT}.
  */
-export function classifyAgentRunFailure(run, structured) {
+export function classifyTurnFailure(run, structured) {
     if (run.status !== "failed")
         return NO_FAULT;
     if (structured !== undefined) {
@@ -45,7 +44,7 @@ export function classifyAgentRunFailure(run, structured) {
             evidence: structured.evidence
         };
     }
-    const summary = run.summary ?? "";
+    const summary = run.result?.output ?? "";
     if (summary.length === 0) {
         return { faultClass: "other", basis: "text-historical", evidence: "" };
     }
@@ -60,7 +59,7 @@ export function classifyAgentRunFailure(run, structured) {
         return { faultClass: "storage-backend-lock", basis: "text-historical", evidence: text };
     }
     if (DELIVERY_UNCERTAIN_PATTERN.test(summary)) {
-        return { faultClass: "delivery-yield-uncertain", basis: "text-historical", evidence: text };
+        return { faultClass: "delivery-uncertain", basis: "text-historical", evidence: text };
     }
     if (STALE_BASE_PATTERN.test(summary)) {
         return { faultClass: "stale-base-target-cas", basis: "text-historical", evidence: text };
@@ -134,22 +133,6 @@ export function classifyIntegrationAttempt(attempt) {
         evidence: "failed without checks or conflict"
     };
 }
-/**
- * Wake reason classification. An orphan wake (the scheduler re-woke a Leader
- * with no new fact) is the duplicate/suppressed-wake class. Quiescence
- * suppression counters are owned by the scheduler Issue; when absent the
- * audit reports `unsupported` instead of guessing.
- */
-export function classifyWakeReasons(reasons) {
-    if (reasons.some((reason) => reason === "task-orphaned")) {
-        return {
-            faultClass: "scheduler-duplicate-suppressed-wake",
-            basis: "structured",
-            evidence: reasons.join(",")
-        };
-    }
-    return NO_FAULT;
-}
 export function emptyFaultClassCounts() {
     return Object.freeze(Object.fromEntries(FAULT_CLASSES.map((name) => [name, 0])));
 }

package/dist/observability/orchestrationMetrics.js

@@ -4,7 +4,7 @@ import { projectFirstProgressAdvisory } from "../runtime/firstProgressAdvisory.j
 /** One Task's orchestration cost and advisory projection, with no writes. */
 export function projectTaskOrchestration(facts) {
     const evidence = {
-        listAgentRuns: () => facts.runs,
+        listTurns: () => facts.turns,
         listReviewFindings: () => facts.reviewFindings,
         listEvents: () => facts.events
     };
@@ -57,10 +57,10 @@ export function projectTaskOrchestration(facts) {
         timeToFirstProjectCommitMs: firstCommitAt === undefined
             ? null
             : Math.max(0, Date.parse(firstCommitAt) - Date.parse(facts.task.createdAt)),
-        runs: {
-            total: facts.runs.length,
-            byStatus: counts(facts.runs.map(({ status }) => status)),
-            byRole: counts(facts.runs.map(({ roleName }) => roleName))
+        turns: {
+            total: facts.turns.length,
+            byStatus: counts(facts.turns.map(({ status }) => status)),
+            byRole: counts(facts.turns.map(({ roleName }) => roleName))
         },
         workItems: facts.workItems.length,
         reviews: {

package/dist/observability/runtimeIdentity.js

@@ -14,7 +14,6 @@ import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "n
 import { join } from "node:path";
 import Database from "better-sqlite3";
 import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "../storage/storageVersions.js";
-import { resolveTaskStoreBackendForHome } from "../storage/sqliteStore.js";
 import { resolveStoreWorkerEnabledForHome } from "../storage/storeRpc.js";
 export const UNSUPPORTED = "unsupported";
 /**
@@ -178,10 +177,8 @@ export function createProductionStorageIdentityPorts(env = process.env) {
     };
 }
 /**
- * Collect durable-vs-physical storage evidence for one Home. The manifest
- * declares a logical layout; the directory carries physical evidence
- * (state.json vs yui.db + WAL). Contradictions between the two are the
- * pseudo-layout-7 class of failure and fail closed.
+ * Collect read-only evidence for the exact current SQLite contract. Old files
+ * are never treated as an alternate authority or a repair source.
  */
 export function collectStorageIdentity(home, ports = createProductionStorageIdentityPorts()) {
     const manifestPath = join(home, "schema.json");
@@ -201,10 +198,10 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
                 && Number.isFinite(manifest.aggregateSchemaVersion)) {
                 aggregateSchemaVersion = manifest.aggregateSchemaVersion;
             }
-            if (typeof logicalLayout === "number"
-                && (logicalLayout > CURRENT_STORAGE_LAYOUT_VERSION
-                    || (typeof aggregateSchemaVersion === "number"
-                        && aggregateSchemaVersion > CURRENT_AGGREGATE_SCHEMA_VERSION))) {
+            if (typeof logicalLayout !== "number"
+                || typeof aggregateSchemaVersion !== "number"
+                || logicalLayout !== CURRENT_STORAGE_LAYOUT_VERSION
+                || aggregateSchemaVersion !== CURRENT_AGGREGATE_SCHEMA_VERSION) {
                 manifestStatus = "unsupported";
             }
         }
@@ -222,120 +219,57 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
     const dbBytes = ports.fileSize(dbPath);
     const walPresent = ports.exists(`${dbPath}-wal`);
     const shmPresent = ports.exists(`${dbPath}-shm`);
-    const configuredBackend = resolveTaskStoreBackendForHome(home, ports.env);
+    const configuredBackend = "sqlite";
     const workerEnabled = resolveStoreWorkerEnabledForHome(home, ports.env);
     const dbHealth = dbPresent ? ports.probeDatabaseHealth(dbPath) : null;
-    const hasMigrationReceipt = ports.exists(join(home, "migration-receipt.json"));
     const findings = [];
-    // A readable state.json is a JSON object (the file store's record container).
-    // Pseudo-layout-7 is only repairable when state.json is a valid fallback.
-    const stateText = statePresent ? ports.readText(statePath) : null;
-    let stateReadable = false;
-    if (stateText !== null) {
-        try {
-            const parsed = JSON.parse(stateText);
-            stateReadable = typeof parsed === "object" && parsed !== null && !Array.isArray(parsed);
-        }
-        catch {
-            stateReadable = false;
-        }
-    }
-    const layout7 = manifestStatus === "current"
-        && typeof logicalLayout === "number"
-        && logicalLayout >= CURRENT_STORAGE_LAYOUT_VERSION;
-    if (layout7 && !dbPresent) {
-        if (stateReadable) {
-            // Pseudo-layout-7: manifest claims SQLite WAL but yui.db was never
-            // materialized. state.json is the readable fallback; `yui upgrade`
-            // rebuilds yui.db from it. This is the recognized NEEDS_STORAGE_REPAIR
-            // state, not a hard contradiction — the file store is legitimately
-            // serving until repair runs.
-            findings.push({
-                code: "pseudo-layout-7",
-                severity: "needs-repair",
-                message: `Manifest declares layout ${logicalLayout} (SQLite WAL) but `
-                    + `${dbPath} does not exist; state.json is the only authoritative `
-                    + "copy (pseudo-layout-7).",
-                remediation: "Run `yui upgrade` to rebuild yui.db from state.json."
-            });
-        }
-        else {
-            findings.push({
-                code: "no-authoritative-backend",
-                severity: "contradiction",
-                message: `Manifest declares layout ${logicalLayout} but neither `
-                    + "yui.db nor a readable state.json exists; there is no "
-                    + "authoritative backend.",
-                remediation: "Restore one copy from a backup; do not guess which is newer."
-            });
-        }
-    }
-    if (dbPresent && dbHealth !== null && dbHealth !== "ok") {
+    if (manifestStatus === "current" && !dbPresent) {
         findings.push({
-            code: "database-unhealthy",
+            code: "current-database-missing",
             severity: "contradiction",
-            message: `yui.db exists but failed integrity check (${dbHealth}).`,
-            remediation: "Restore yui.db from backup, or run `yui upgrade` to rebuild "
-                + "it from state.json."
+            message: `The current storage contract requires ${dbPath}, but it is missing.`,
+            remediation: "Preserve this Home for diagnosis and initialize a new Home."
         });
     }
-    if (dbPresent && statePresent && !hasMigrationReceipt && layout7) {
+    if (manifestStatus === "unsupported") {
         findings.push({
-            code: "dual-copy-conflict",
+            code: "unsupported-storage-contract",
             severity: "contradiction",
-            message: "Both state.json and yui.db exist without a migration receipt; "
-                + "the authoritative copy is ambiguous.",
-            remediation: "Restore one copy from a backup; do not guess which is newer."
+            message: "The Home does not match this release's exact storage contract.",
+            remediation: "Open it read-only with its original Yui version, then let the Operator recreate unfinished work in a new Home."
         });
     }
-    if (configuredBackend === "sqlite" && !dbPresent) {
+    if (manifestStatus === "invalid") {
         findings.push({
-            code: "backend-sqlite-without-database",
+            code: "invalid-storage-manifest",
             severity: "contradiction",
-            message: "YUI_STORE_BACKEND=sqlite is set but no yui.db exists; the "
-                + "SQLite store cannot open this Home.",
-            remediation: "Run `yui upgrade` to create yui.db, or unset "
-                + "YUI_STORE_BACKEND to keep using the file store explicitly."
+            message: "schema.json is invalid.",
+            remediation: "Preserve this Home for diagnosis and initialize a new Home."
         });
     }
-    if (configuredBackend === "file"
-        && dbPresent
-        && manifestStatus === "current") {
+    if (dbPresent && dbHealth !== null && dbHealth !== "ok") {
         findings.push({
-            code: "database-present-but-file-backend",
-            severity: "warning",
-            message: "yui.db exists but the file backend is selected; this process "
-                + "is serving state.json, not the database.",
-            remediation: "Unset YUI_STORE_BACKEND to let the Home manifest select "
-                + "SQLite, or remove the stale yui.db."
+            code: "database-unhealthy",
+            severity: "contradiction",
+            message: `yui.db exists but failed integrity check (${dbHealth}).`,
+            remediation: "Preserve this Home for diagnosis and initialize a new Home."
         });
     }
-    const rawWorkerFlag = ports.env.YUI_STORE_WORKER;
-    if (rawWorkerFlag !== undefined
-        && !workerEnabled
-        && configuredBackend !== "sqlite") {
+    if (statePresent) {
         findings.push({
-            code: "worker-flag-without-sqlite",
+            code: "ignored-historical-store",
             severity: "warning",
-            message: `YUI_STORE_WORKER=${rawWorkerFlag} is set but the worker `
-                + "requires YUI_STORE_BACKEND=sqlite; the worker is off.",
-            remediation: "Set YUI_STORE_BACKEND=sqlite to activate the worker, or "
-                + "unset YUI_STORE_WORKER."
+            message: "state.json is present but is not read or written by the current store.",
+            remediation: "Keep it only as read-only historical evidence or archive it outside the active Home."
         });
     }
-    // Only fire for pre-layout-7 Homes where the file store is the legitimate
-    // backend. A layout-7 Home without state.json is already covered by
-    // no-authoritative-backend above (the file store is just a fallback there).
-    if (configuredBackend === "file"
-        && !statePresent
-        && manifestStatus === "current"
-        && !(typeof logicalLayout === "number" && logicalLayout >= CURRENT_STORAGE_LAYOUT_VERSION)) {
+    const rawWorkerFlag = ports.env.YUI_STORE_WORKER;
+    if (rawWorkerFlag !== undefined && !["0", "1", "false", "true"].includes(rawWorkerFlag.toLowerCase())) {
         findings.push({
-            code: "file-store-missing-state",
-            severity: "contradiction",
-            message: "The file backend is selected but state.json is missing.",
-            remediation: "Restore state.json from backup, or run the storage "
-                + "migration to create yui.db."
+            code: "invalid-worker-flag",
+            severity: "warning",
+            message: `YUI_STORE_WORKER=${rawWorkerFlag} is invalid.`,
+            remediation: "Use 1/true, 0/false, or unset YUI_STORE_WORKER."
         });
     }
     return {
@@ -356,7 +290,6 @@ export function collectStorageIdentity(home, ports = createProductionStorageIden
             shm: shmPresent,
             health: dbHealth ?? UNSUPPORTED
         },
-        hasMigrationReceipt,
         findings
     };
 }