@zq-silk/yui 0.14.2 → 0.15.0

package/dist/storage/upgrade/upgradeOrchestrator.js

@@ -1,5 +1,6 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { basename, dirname, join } from "node:path";
+import { copyFileSync, existsSync, mkdirSync, rmSync } from "node:fs";
+import Database from "better-sqlite3";
 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";
@@ -8,56 +9,168 @@ 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";
+import { migrateSqliteSchema, storageMigrationPlan } from "../sqliteSchema.js";
+import { CURRENT_DATABASE_FILENAME, inspectStorageSchema } from "../storageSchema.js";
+import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "../storageVersions.js";
 /**
- * Validate the one supported storage contract.
+ * Upgrade one valid Home through the complete linear migration chain.
  *
- * 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.
+ * Supported earlier versions are readable only here. Ordinary stores still
+ * admit exactly {@link CURRENT_STORAGE_VERSION}; no old-shape normalizer or
+ * dual read path enters runtime code. Execute mode is an offline primitive:
+ * its caller must own the maintenance fence and keep the Controller quiesced
+ * for the whole backup, migration, and validation interval.
  */
 export async function runStorageUpgrade(options) {
-    const schema = inspectStorageSchema(options.home);
-    if (schema.status === "uninitialized") {
-        return blocked({ ...currentClassification(options.latest), uninitialized: true }, "uninitialized", "Yui storage is not initialized for this Home.", "Run `yui setup` with a new Home.");
+    const state = inspectStorageSchema(options.home);
+    if (state.status === "uninitialized") {
+        return blocked({ ...corruptedClassification("Storage is not initialized."), uninitialized: true }, "uninitialized", "Yui storage is not initialized for this Home.", "Run `yui setup` with a new Home.");
     }
-    if (schema.status === "invalid") {
-        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 (state.status === "invalid") {
+        return blocked(corruptedClassification(state.detail), "corruption", `Storage is invalid: ${state.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(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 (state.status === "unsupported") {
+        const classification = unsupportedClassification(state);
+        return blocked(classification, "unsupported", classification.classification.verdict === "NEEDS_NEW_VERSION"
+            ? classification.classification.blocker.message
+            : "Storage is unsupported.", classification.classification.verdict === "NEEDS_NEW_VERSION"
+            ? classification.classification.blocker.action
+            : "Use a compatible Yui release.");
     }
-    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.");
+    if (state.status === "current") {
+        try {
+            validateCurrentStore(options.home);
+        }
+        catch (error) {
+            return blocked(corruptedClassification(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();
+        if (options.mode === "update-preflight") {
+            return {
+                outcome: "update-preflight",
+                status: "already-current",
+                stepCount: 0,
+                steps: [],
+                classification
+            };
+        }
+        return {
+            outcome: "already-current",
+            classification,
+            report: {
+                outcome: "already-current",
+                mode: options.mode,
+                sourceVersion: CURRENT_STORAGE_VERSION,
+                targetVersion: CURRENT_STORAGE_VERSION,
+                steps: []
+            }
+        };
+    }
+    const plan = storageMigrationPlan(state.currentVersion);
+    if (plan === null) {
+        return blocked(corruptedClassification(`No complete migration path exists from ${state.currentVersion} `
+            + `to ${CURRENT_STORAGE_VERSION}.`), "corruption", "The storage migration registry is incomplete.", "Install a Yui release that carries the complete migration chain.");
+    }
+    const classification = migratableClassification(state.currentVersion);
+    if (options.mode === "update-preflight") {
+        return {
+            outcome: "update-preflight",
+            status: "migration-ready",
+            stepCount: plan.length,
+            steps: plan,
+            classification
+        };
     }
+    if (options.mode === "dry-run") {
+        return {
+            outcome: "upgrade-plan",
+            classification,
+            report: {
+                outcome: "upgrade-plan",
+                mode: "dry-run",
+                sourceVersion: state.currentVersion,
+                targetVersion: CURRENT_STORAGE_VERSION,
+                steps: plan
+            }
+        };
+    }
+    let backupPath;
     try {
+        backupPath = await createDatabaseBackup(options.home, state.currentVersion, options.now ?? new Date());
+    }
+    catch (error) {
+        return {
+            outcome: "failed",
+            stage: "backup",
+            message: `Storage backup failed: ${messageOf(error)}`,
+            action: "Storage was not modified. Resolve the backup path, permissions, or free-space problem "
+                + "and rerun `yui upgrade`.",
+            classification,
+            sceneUnchanged: true
+        };
+    }
+    let migrationCommitted = false;
+    try {
+        const database = new Database(join(options.home, CURRENT_DATABASE_FILENAME));
+        try {
+            database.pragma("journal_mode = WAL");
+            database.pragma("synchronous = FULL");
+            database.pragma("foreign_keys = ON");
+            database.pragma("busy_timeout = 5000");
+            migrateSqliteSchema(database, { mode: "apply" });
+            migrationCommitted = true;
+        }
+        finally {
+            database.close();
+        }
         validateCurrentStore(options.home);
+        rmSync(join(options.home, "schema.json"), { force: true });
     }
     catch (error) {
-        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 restoration = migrationCommitted
+            ? tryRestoreDatabaseBackup(options.home, backupPath)
+            : { restored: true };
+        return {
+            outcome: "failed",
+            stage: "migration",
+            message: `Storage migration failed: ${messageOf(error)}`,
+            action: restoration.restored
+                ? "The original database was restored from the timestamped backup. "
+                    + "Resolve the reported problem and rerun `yui upgrade`."
+                : "Automatic restore also failed. Keep the Home quiesced and restore "
+                    + `${backupPath} manually before retrying. Restore error: ${restoration.error}`,
+            backupPath,
+            classification,
+            sceneUnchanged: restoration.restored
+        };
     }
-    const classification = currentClassification(options.latest);
-    if (options.mode === "update-preflight") {
+    const finalState = inspectStorageSchema(options.home);
+    if (finalState.status !== "current") {
+        const restoration = tryRestoreDatabaseBackup(options.home, backupPath);
         return {
-            outcome: "update-preflight",
-            status: "already-current",
-            stepCount: 0,
-            steps: [],
-            classification
+            outcome: "failed",
+            stage: "migration",
+            message: `Storage migration did not reach version ${CURRENT_STORAGE_VERSION}.`,
+            action: restoration.restored
+                ? "The original database was restored from the timestamped backup. "
+                    + "Inspect the migration registry before retrying."
+                : "Automatic restore also failed. Keep the Home quiesced and restore "
+                    + `${backupPath} manually before retrying. Restore error: ${restoration.error}`,
+            backupPath,
+            classification,
+            sceneUnchanged: restoration.restored
         };
     }
     return {
-        outcome: "already-current",
-        classification,
+        outcome: "upgraded",
+        classification: currentClassification(),
         report: {
-            outcome: "already-current",
-            mode: options.mode,
-            source: options.latest,
-            target: options.latest
+            outcome: "upgraded",
+            mode: "execute",
+            sourceVersion: state.currentVersion,
+            targetVersion: CURRENT_STORAGE_VERSION,
+            steps: plan,
+            backupPath
         }
     };
 }
@@ -96,59 +209,108 @@ function validateCurrentStore(home) {
                 }
             }
         }
+        const quickCheck = store.databaseHandle().pragma("quick_check", { simple: true });
+        if (quickCheck !== "ok") {
+            throw new Error(`SQLite quick_check failed: ${String(quickCheck)}.`);
+        }
     }
     finally {
         store.close();
     }
 }
-function currentClassification(latest) {
+async function createDatabaseBackup(home, sourceVersion, now) {
+    const source = join(home, CURRENT_DATABASE_FILENAME);
+    if (!existsSync(source))
+        throw new Error("The authoritative yui.db is missing.");
+    const backupDirectory = join(dirname(home), `${basename(home)}-backups`);
+    mkdirSync(backupDirectory, { recursive: true, mode: 0o700 });
+    const timestamp = now.toISOString().replaceAll(":", "-");
+    const backupPath = join(backupDirectory, `pre-storage-v${sourceVersion}-${timestamp}.db`);
+    const database = new Database(source, { readonly: true, fileMustExist: true });
+    try {
+        await database.backup(backupPath);
+    }
+    finally {
+        database.close();
+    }
+    return backupPath;
+}
+function restoreDatabaseBackup(home, backupPath) {
+    const databasePath = join(home, CURRENT_DATABASE_FILENAME);
+    rmSync(`${databasePath}-wal`, { force: true });
+    rmSync(`${databasePath}-shm`, { force: true });
+    copyFileSync(backupPath, databasePath);
+}
+function tryRestoreDatabaseBackup(home, backupPath) {
+    try {
+        restoreDatabaseBackup(home, backupPath);
+        return { restored: true };
+    }
+    catch (error) {
+        return { restored: false, error: messageOf(error) };
+    }
+}
+function currentClassification() {
     return {
         classification: { verdict: "USABLE", status: "current" },
-        layoutVersion: latest.layout,
-        aggregateVersion: latest.aggregate,
-        latestLayoutVersion: latest.layout,
-        latestAggregateVersion: latest.aggregate
+        storageVersion: CURRENT_STORAGE_VERSION,
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
     };
 }
-function unsupportedClassification(schema, latest) {
-    const axis = schema.incompatibleComponent;
-    const found = schema.currentVersion;
-    const supported = schema.latestVersion;
-    const future = schema.direction === "newer";
+function migratableClassification(storageVersion) {
+    return {
+        classification: { verdict: "MIGRATABLE", status: "migration-ready" },
+        storageVersion,
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
+    };
+}
+function unsupportedClassification(state) {
+    const future = state.direction === "newer";
+    const message = future
+        ? `Storage version ${state.currentVersion} is newer than this CLI supports `
+            + `(${CURRENT_STORAGE_VERSION}).`
+        : `Storage version ${state.currentVersion} is older than the minimum supported `
+            + `migration version ${MIN_SUPPORTED_STORAGE_VERSION}.`;
     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.";
+        ? "Use a newer Yui release."
+        : "Preserve this Home for use with its matching historical Yui release, "
+            + "or initialize a new Home with Yui 0.15.0 or later.";
     return {
         classification: {
             verdict: "NEEDS_NEW_VERSION",
             status: "unsupported",
             blocker: {
-                reason: future ? "future-version" : "missing-step",
-                axis,
-                ...(schema.recordFamily === undefined ? {} : { recordKind: schema.recordFamily }),
-                ...(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.",
+                reason: future ? "future-version" : "below-minimum",
+                found: state.currentVersion,
+                current: CURRENT_STORAGE_VERSION,
+                minimum: MIN_SUPPORTED_STORAGE_VERSION,
+                message,
                 action
             }
         },
-        layoutVersion: schema.currentLayoutVersion,
-        aggregateVersion: schema.currentAggregateSchemaVersion,
-        latestLayoutVersion: latest.layout,
-        latestAggregateVersion: latest.aggregate,
-        incompatibleComponent: axis
+        storageVersion: state.currentVersion,
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
     };
 }
-function corruptedClassification(latest, detail) {
+function corruptedClassification(detail) {
     return {
         classification: { verdict: "CORRUPTED", status: "unsupported", detail },
-        latestLayoutVersion: latest.layout,
-        latestAggregateVersion: latest.aggregate
+        currentStorageVersion: CURRENT_STORAGE_VERSION,
+        minimumSupportedStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
     };
 }
 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);

package/dist/version.js

@@ -1,13 +1,13 @@
 import { readFileSync } from "node:fs";
 import { FILE_TASK_CONTROLLER_PROTOCOL_VERSION } from "./core/protocol.js";
-import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "./storage/storageSchema.js";
+import { CURRENT_STORAGE_VERSION, MIN_SUPPORTED_STORAGE_VERSION } from "./storage/storageVersions.js";
 export const YUI_VERSION = readPackageVersion();
 export function yuiVersionIdentity() {
     return {
         version: YUI_VERSION,
         controllerProtocolVersion: FILE_TASK_CONTROLLER_PROTOCOL_VERSION,
-        storageLayoutVersion: CURRENT_STORAGE_LAYOUT_VERSION,
-        aggregateSchemaVersion: CURRENT_AGGREGATE_SCHEMA_VERSION
+        storageVersion: CURRENT_STORAGE_VERSION,
+        minimumStorageVersion: MIN_SUPPORTED_STORAGE_VERSION
     };
 }
 function readPackageVersion() {

package/docs/task-local-identity.md

@@ -51,12 +51,12 @@ There is no compatibility lookup, cross-Task guess, or bare-ID fallback.
 
 ## Current-schema boundary
 
-Runtime opens only aggregate v31 / Task v7. It does not convert,
-dual-read, or infer records from an older schema. If an existing `YUI_HOME`
-does not match the current schema, keep it untouched for external archival
-and initialize a fresh home for this runtime.
-
-This hard cut keeps Task-local references, Role desired configuration, and
-immutable Turn/RoleSession effective snapshots under one unambiguous
-contract. There is no compatibility lookup, conversion command, or
-intermediate storage format.
+Runtime opens only the current Home storage version and current record shapes.
+It does not dual-read or infer historical records during ordinary work.
+Historical decoding and rewriting are confined to the explicit `yui upgrade`
+boundary and the migration phase of `yui update`; every valid Home at or above
+the CLI's minimum supported storage version can advance directly to current.
+
+This boundary keeps Task-local references, Role desired configuration, and
+immutable Turn/RoleSession effective snapshots under one unambiguous runtime
+contract while the append-only migration chain preserves supported history.

package/i18n/README.zh-CN.md

@@ -101,7 +101,11 @@ export YUI_HOME=/absolute/path/to/yui-home
 yui setup
 ```
 
-home 中包含 `schema.json`、权威 SQLite 数据库 `yui.db`、Project Catalog、项目知识和 Controller 发现文件。稳定 Project checkout 与受管理 worktree 位于 home 外部的 workspace。运行时只接受当前存储契约：不会回退读取 `state.json`、转换旧 schema 或猜测旧 ID。
+home 中包含权威 SQLite 数据库 `yui.db`、Project Catalog、项目知识和
+Controller 发现文件。稳定 Project checkout 与受管理 worktree 位于 home
+外部的 workspace。旧 `schema.json` 与 `state.json` 只作为历史证据存在，
+不再是版本权威。运行时只接受当前存储契约；支持区间内的早期存储版本只允许
+通过显式升级入口。
 
 所有 Task-owned 记录族都在各自 Task 内分配单调递增的本地 ID。因此，不同
 Task 可以同时拥有 `work-item-1`、`turn-1` 或 `input-1`。受管 Task
@@ -111,8 +115,12 @@ Task 的命令（例如 `task work create`、`task integration start`）仍使
 Task 内的本地子记录 ID。Candidate 只在所属 WorkItem 内递增，并同时保存
 Task 与 WorkItem provenance。
 
-Yui 只支持当前 aggregate-v31 / Task-v7 schema。旧 home 不提供转换、
-双读或历史记录推断；需要使用新版本时初始化全新的 `YUI_HOME`。当前引用契约见
+Yui Home 只有一个存储版本，权威值是 SQLite 中连续且校验和有效的迁移
+ledger 头。CLI 同时公布当前存储版本和最小支持迁移版本。普通运行时代码只读取
+最新结构，不提供双读；`yui upgrade --dry-run` 只显示迁移计划，
+`yui upgrade` 会停住正在运行的 Controller、创建一致性备份、在一个事务中执行
+全部缺失迁移并校验最新结构。处于支持区间内的任意历史 Home 都可以直接跨多个
+版本升级，无需逐个安装中间版本。当前引用契约见
 [Task 本地 ID](../docs/task-local-identity.md)。
 
 ## 快速开始
@@ -627,13 +635,13 @@ yui task role release <task-id> <role>
 
 Codex Role thread 可在 Desktop 中直接查看和操作；Desktop 已有 active Turn 时，Yui 只保留待投递工作并等待，不会失败或重复投递。`view`、`takeover`、`release` 继续作为 Claude 等独立进程 Provider 的人工控制入口。Yui 不写入全局 Hook/config，也不启动、重启或停止共享 daemon；Codex CLI/daemon 故障由 Task 生命周期之外修复。Global Operator 与 global Role 继续使用原生交互式 CLI，不属于受管理 Task Provider 协议；Yui 在内部将 Codex 的 Global TUI 连接到同一个默认 App Server，用户不能通过 Agent 或 Role 参数覆盖该连接，Session Manifest 自带不依赖启动进程环境的 Global Context 命令，因此同一 thread 可直接切换到 Desktop 继续对话。
 
-当新版本需要离线迁移 Home 时，应等待当前 Turn 完成，然后从普通 shell
-执行 `yui session stop --all`，再重新执行 `yui update`。停止命令会先整体预检：
-只要仍有 Session 正在运行或存在未决生命周期工作，就不会开始停止；全部空闲
-时会先阻止新的 Leader 调度，停止并等待 Controller 完全退出，重新检查运行时
-事实后再停止 Task Role 和 global Role Session。成功后 Controller 保持停止，
-应紧接着执行 `yui update`。如果当前安装版本还没有这条命令，应手动退出提示中
-列出的全部 managed Session；新的 staged CLI 不能写入尚待迁移的旧 Home。
+`yui update` 会用目标版本先做只读预检，在停住精确的旧 Controller 后自动执行
+所需的离线迁移，再校验并启动新 Controller。若升级前希望结束所有 Agent
+活动，可先执行 `yui session stop --all`；这不是存储版本链的一部分。
+Yui 0.15.0 建立 storage version 1 和迁移下限。更早版本（包括 0.14.2）
+创建的 Home 不在这条兼容链上：应保留给匹配的历史 Yui 版本查看，或者初始化
+新的 Home。从 0.15.0 开始，后续版本必须保留完整迁移链，因此可以由
+`yui update` 直接跨版本升级。
 
 tmux 会在 pane 创建时固定其历史容量。配置该限制之前创建的 Role 会保留原容量；Yui 会在 Terminal attach 和 Web 中提示用户退出并重新进入一次，从而创建具有 100,000 行历史的新 pane。
 
@@ -675,10 +683,10 @@ yui controller restart
 
 `controller restart` 会用当前安装的 Yui 版本替换 Controller 进程及其调度循环、socket 服务，不会停止或重启已受管的 tmux/Agent 会话；普通 Session 命令按协议与存储身份兼容，不要求 Controller 与 CLI 包版本完全相同。
 
-成功的 `setup`、`upgrade` 和 `update` 都会确保当前 Home 有一个运行中的
-Controller；如果之前没有运行，会在完成后启动。只读命令和
-`upgrade --dry-run` 不会启动 Controller。`update` 只有在新二进制健康检查通过后，
-才会替换或启动 Controller。
+成功的 `setup` 和 `update` 会确保当前 Home 有一个运行中的 Controller。
+`upgrade` 只会在迁移前存在 Controller 时恢复它；只读命令和
+`upgrade --dry-run` 不会启动 Controller。`update` 只有在迁移和新二进制健康
+检查都通过后，才会替换或启动 Controller。
 
 恢复 reconciliation 默认每 120 秒执行一次。普通持久状态变化只会将 Task、Role 或 Operator key 放入队列并立即返回；固定 100ms 窗口内到达的 key 会合并触发一次不重叠的定向处理。Operator 呈现使用独立 lane，不会被 Task 的 Git/worktree 操作阻塞；周期 Git/worktree 处理只覆盖仍有持久 Task mailbox 工作的 Task，活动 Role 的存活检查合并为一次 tmux inventory。来自 Provider 原生事件或受支持 Hook 的结构化 Agent Driver observation，会经过精确 fence 后进入持久 runtime inbox。终态 Turn observation 会原子记录精确的 Turn 结果。持久 WorkMailbox 会冻结当前 processing 批次，期间的新事件合并到下一 pending 批次；失败会释放当前批次供恢复。推荐输入与 pending Turn 共用最近 deadline 选择器，不依赖恢复扫描间隔；显式 `task reconcile` 仍会立即请求恢复扫描。保留的闭环为：
 
@@ -724,6 +732,7 @@ Web 端可以通过与 Terminal 相同的持久化 CLI 路径回答 open InputRe
 
 ```sh
 yui update
+yui upgrade [--dry-run]
 yui config agent add|list|show|capabilities|update|remove
 yui config role add|list|show|update|remove|bind|unbind
 yui config profile add|list|show|update|remove|reset
@@ -749,9 +758,9 @@ npm test
 npm run lint
 ```
 
-`npm test` 只保留秒级核心 smoke：CLI 启动、正常 SQLite Task、受支持迁移和内置
-Agent Driver。针对当前修改编写的 TDD、异常数据和故障复现仅作为开发期证据，需求完成后
-删除，不累积为常驻回归测试。具体约束见
+`npm test` 只保留秒级核心 smoke：CLI 启动、正常 SQLite Task、存储基线、
+目标驱动更新和内置 Agent Driver。针对当前修改编写的 TDD、异常数据和故障复现
+仅作为开发期证据，需求完成后删除，不累积为常驻回归测试。具体约束见
 [验证策略](../docs/testing/verification-levels.md)。
 
 如需让用户终端使用当前 checkout，可逆地接管用户级 `yui` 命令：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zq-silk/yui",
-  "version": "0.14.2",
+  "version": "0.15.0",
   "description": "Local control plane for long-running native agent CLI sessions backed by tmux.",
   "license": "MIT",
   "private": false,

package/dist/storage/upgrade/recordVersions.js

@@ -1,82 +0,0 @@
-/** Current record-family versions for the single SQLite storage contract. */
-import { CURRENT_AGGREGATE_SCHEMA_VERSION, CURRENT_STORAGE_LAYOUT_VERSION } from "../storageVersions.js";
-import { CURRENT_TURN_SCHEMA_VERSION, CURRENT_AGENT_PROFILE_SCHEMA_VERSION, CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION, CURRENT_CONFIG_SCHEMA_VERSION, CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION, CURRENT_CHANGE_SET_SCHEMA_VERSION, CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION, CURRENT_DECISION_SCHEMA_VERSION, CURRENT_EVENT_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SCHEMA_VERSION, CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_INPUT_REQUEST_SCHEMA_VERSION, CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION, CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION, CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION, CURRENT_MESSAGE_SCHEMA_VERSION, CURRENT_MILESTONE_SCHEMA_VERSION, CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION, CURRENT_PROJECT_SCHEMA_VERSION, CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION, CURRENT_REVIEW_ROUND_SCHEMA_VERSION, CURRENT_TASK_BRIEF_SCHEMA_VERSION, CURRENT_TASK_ROLE_SCHEMA_VERSION, CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION, CURRENT_TASK_SCHEMA_VERSION, CURRENT_WORK_ITEM_SCHEMA_VERSION, CURRENT_WORK_MAILBOX_SCHEMA_VERSION } from "../taskStore.js";
-import { CURRENT_LEADER_FAILURE_SCHEMA_VERSION } from "../../scheduler/leaderFailure.js";
-import { CURRENT_TASK_WAKE_SCHEMA_VERSION } from "../../scheduler/taskWake.js";
-import { CURRENT_DURABLE_JOB_SCHEMA_VERSION } from "../../job/durableJob.js";
-function descriptor(kind, version) {
-    return Object.freeze({ version, path: `sqlite:${kind}` });
-}
-// Lazy construction avoids the taskStore -> storageSchema -> recordVersions
-// initialization cycle while keeping one canonical family list.
-let currentDescriptors = null;
-function getCurrentRecordDescriptors() {
-    if (currentDescriptors === null) {
-        const versions = {
-            config: CURRENT_CONFIG_SCHEMA_VERSION,
-            configuredAgent: CURRENT_CONFIGURED_AGENT_SCHEMA_VERSION,
-            project: CURRENT_PROJECT_SCHEMA_VERSION,
-            agentProfile: CURRENT_AGENT_PROFILE_SCHEMA_VERSION,
-            globalRole: CURRENT_GLOBAL_ROLE_SCHEMA_VERSION,
-            globalRoleSessionSet: CURRENT_GLOBAL_ROLE_SESSION_SET_SCHEMA_VERSION,
-            task: CURRENT_TASK_SCHEMA_VERSION,
-            taskBrief: CURRENT_TASK_BRIEF_SCHEMA_VERSION,
-            taskRole: CURRENT_TASK_ROLE_SCHEMA_VERSION,
-            managedWorkspace: CURRENT_MANAGED_WORKSPACE_SCHEMA_VERSION,
-            taskRoleSessionSet: CURRENT_TASK_ROLE_SESSION_SET_SCHEMA_VERSION,
-            workItem: CURRENT_WORK_ITEM_SCHEMA_VERSION,
-            contextSnapshot: CURRENT_CONTEXT_SNAPSHOT_SCHEMA_VERSION,
-            turn: CURRENT_TURN_SCHEMA_VERSION,
-            reviewRound: CURRENT_REVIEW_ROUND_SCHEMA_VERSION,
-            changeSet: CURRENT_CHANGE_SET_SCHEMA_VERSION,
-            integrationAttempt: CURRENT_INTEGRATION_ATTEMPT_SCHEMA_VERSION,
-            integrationQueue: CURRENT_INTEGRATION_QUEUE_SCHEMA_VERSION,
-            durableJob: CURRENT_DURABLE_JOB_SCHEMA_VERSION,
-            message: CURRENT_MESSAGE_SCHEMA_VERSION,
-            inputRequest: CURRENT_INPUT_REQUEST_SCHEMA_VERSION,
-            decision: CURRENT_DECISION_SCHEMA_VERSION,
-            milestone: CURRENT_MILESTONE_SCHEMA_VERSION,
-            event: CURRENT_EVENT_SCHEMA_VERSION,
-            taskWake: CURRENT_TASK_WAKE_SCHEMA_VERSION,
-            capabilityGrant: CURRENT_CAPABILITY_GRANT_SCHEMA_VERSION,
-            releaseWorkflow: CURRENT_RELEASE_WORKFLOW_SCHEMA_VERSION,
-            publicationReference: CURRENT_PUBLICATION_REFERENCE_SCHEMA_VERSION,
-            leaderFailure: CURRENT_LEADER_FAILURE_SCHEMA_VERSION,
-            workMailbox: CURRENT_WORK_MAILBOX_SCHEMA_VERSION
-        };
-        currentDescriptors = Object.freeze(Object.fromEntries(Object.entries(versions).map(([kind, version]) => [kind, descriptor(kind, version)])));
-    }
-    return currentDescriptors;
-}
-/** Defensive copy of the current record-family contract. */
-export function currentRecordVersions(candidate = getCurrentRecordDescriptors()) {
-    assertRecordVersionDescriptors(candidate);
-    return { ...candidate };
-}
-/** Reject missing, extra, stale, or non-SQLite record descriptors. */
-export function assertRecordVersionDescriptors(candidate = getCurrentRecordDescriptors()) {
-    const expected = getCurrentRecordDescriptors();
-    const expectedKinds = Object.keys(expected);
-    const mappedKinds = Object.keys(candidate);
-    const missing = expectedKinds.filter((kind) => !Object.hasOwn(candidate, kind));
-    const unexpected = mappedKinds.filter((kind) => !Object.hasOwn(expected, kind));
-    if (missing.length > 0 || unexpected.length > 0) {
-        throw new Error(`Record version map completeness drift: missing=${missing.join(",") || "none"}; `
-            + `unexpected=${unexpected.join(",") || "none"}.`);
-    }
-    for (const kind of expectedKinds) {
-        const wanted = expected[kind];
-        const found = candidate[kind];
-        if (found?.version !== wanted.version || found.path !== wanted.path) {
-            throw new Error(`Record version map drift for ${kind}: expected=${wanted.version}@${wanted.path}; `
-                + `actual=${String(found?.version)}@${String(found?.path)}.`);
-        }
-    }
-}
-export function latestStorageVersionState(recordDescriptors = getCurrentRecordDescriptors()) {
-    return {
-        layout: CURRENT_STORAGE_LAYOUT_VERSION,
-        aggregate: CURRENT_AGGREGATE_SCHEMA_VERSION,
-        record: currentRecordVersions(recordDescriptors)
-    };
-}