@wowok/agent-mcp 2.5.2 → 2.5.4

package/dist/project/migration.d.ts

@@ -0,0 +1,22 @@
+export interface MigrationStep {
+    from: string;
+    to: string;
+    description: string;
+    migrate: (projectDirPath: string) => void;
+}
+export interface MigrationResult {
+    migrated: boolean;
+    from_version: string;
+    to_version: string;
+    steps_executed: string[];
+    backup_path?: string;
+    needs_recalibration: boolean;
+    message: string;
+}
+export declare function migrateProject(prefix: string, version: string): MigrationResult;
+export declare function needsMigration(prefix: string, version: string): boolean;
+export declare function listAvailableMigrations(): Array<{
+    from: string;
+    to: string;
+    description: string;
+}>;

package/dist/project/migration.js

@@ -0,0 +1,125 @@
+import { copyFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+import { CURRENT_SCHEMA_VERSION, projectDir, loadManifest, saveManifest, } from "./project-store.js";
+const MIGRATIONS = [];
+function backupProject(prefix, version) {
+    const srcDir = projectDir(prefix, version);
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const backupDir = join(srcDir, ".backup", timestamp);
+    mkdirSync(backupDir, { recursive: true });
+    function copyDir(srcRel) {
+        const srcAbs = join(srcDir, srcRel);
+        const items = readdirSync(srcAbs, { withFileTypes: true });
+        for (const item of items) {
+            if (srcRel === "" && item.name === ".backup")
+                continue;
+            const rel = srcRel ? join(srcRel, item.name) : item.name;
+            const abs = join(srcDir, rel);
+            if (item.isDirectory()) {
+                mkdirSync(join(backupDir, rel), { recursive: true });
+                copyDir(rel);
+            }
+            else if (item.isFile()) {
+                copyFileSync(abs, join(backupDir, rel));
+            }
+        }
+    }
+    copyDir("");
+    return backupDir;
+}
+export function migrateProject(prefix, version) {
+    const manifest = loadManifest(prefix, version);
+    const fromVersion = manifest.schema_version;
+    if (fromVersion === CURRENT_SCHEMA_VERSION) {
+        return {
+            migrated: false,
+            from_version: fromVersion,
+            to_version: CURRENT_SCHEMA_VERSION,
+            steps_executed: [],
+            needs_recalibration: manifest.needs_recalibration ?? false,
+            message: `Project schema is up-to-date (${fromVersion}). No migration needed.`,
+        };
+    }
+    const backupPath = backupProject(prefix, version);
+    const dir = projectDir(prefix, version);
+    const stepsExecuted = [];
+    let current = fromVersion;
+    let safetyCounter = 0;
+    const MAX_STEPS = 50;
+    while (current !== CURRENT_SCHEMA_VERSION && safetyCounter < MAX_STEPS) {
+        const step = MIGRATIONS.find((m) => m.from === current);
+        if (!step) {
+            const updatedManifest = {
+                ...manifest,
+                needs_recalibration: true,
+                updated_at: new Date().toISOString(),
+            };
+            saveManifest(prefix, version, updatedManifest);
+            return {
+                migrated: false,
+                from_version: fromVersion,
+                to_version: current,
+                steps_executed: stepsExecuted,
+                backup_path: backupPath,
+                needs_recalibration: true,
+                message: `No migration path from schema ${current} to ${CURRENT_SCHEMA_VERSION}. ` +
+                    `Project backed up to ${backupPath}. Manual recalibration required.`,
+            };
+        }
+        try {
+            step.migrate(dir);
+            stepsExecuted.push(`${step.from}→${step.to}: ${step.description}`);
+            current = step.to;
+        }
+        catch (e) {
+            const updatedManifest = {
+                ...manifest,
+                needs_recalibration: true,
+                updated_at: new Date().toISOString(),
+            };
+            saveManifest(prefix, version, updatedManifest);
+            return {
+                migrated: false,
+                from_version: fromVersion,
+                to_version: current,
+                steps_executed: stepsExecuted,
+                backup_path: backupPath,
+                needs_recalibration: true,
+                message: `Migration ${step.from}→${step.to} failed: ${e instanceof Error ? e.message : String(e)}. ` +
+                    `Project backed up to ${backupPath}. Manual intervention required.`,
+            };
+        }
+        safetyCounter++;
+    }
+    const updatedManifest = {
+        ...manifest,
+        schema_version: CURRENT_SCHEMA_VERSION,
+        needs_recalibration: true,
+        updated_at: new Date().toISOString(),
+    };
+    saveManifest(prefix, version, updatedManifest);
+    return {
+        migrated: true,
+        from_version: fromVersion,
+        to_version: CURRENT_SCHEMA_VERSION,
+        steps_executed: stepsExecuted,
+        backup_path: backupPath,
+        needs_recalibration: true,
+        message: `Project migrated from schema ${fromVersion} to ${CURRENT_SCHEMA_VERSION}. ` +
+            `${stepsExecuted.length} migration step(s) executed. ` +
+            `Recalibration recommended: re-run aggregate_risks and generate_deployment_doc. ` +
+            `Backup saved to ${backupPath}.`,
+    };
+}
+export function needsMigration(prefix, version) {
+    try {
+        const manifest = loadManifest(prefix, version);
+        return manifest.schema_version !== CURRENT_SCHEMA_VERSION;
+    }
+    catch {
+        return false;
+    }
+}
+export function listAvailableMigrations() {
+    return MIGRATIONS.map((m) => ({ from: m.from, to: m.to, description: m.description }));
+}

package/dist/project/project-store.d.ts

@@ -0,0 +1,110 @@
+export declare const CURRENT_SCHEMA_VERSION = "1.0.0";
+export declare function projectsRootDir(): string;
+export declare function projectDir(prefix: string, version: string): string;
+export declare function deploymentDir(prefix: string, version: string): string;
+export interface ProjectManifest {
+    schema_version: string;
+    mcp_version: string;
+    prefix: string;
+    version: string;
+    created_at: string;
+    updated_at: string;
+    forked_from?: string;
+    needs_recalibration?: boolean;
+}
+export type ProjectStage = 1 | 2 | 3 | 4 | 5;
+export interface StageState {
+    stage: ProjectStage;
+    updated_at: number;
+    stage_meta: Record<ProjectStage, {
+        committed: boolean;
+        committed_at?: number;
+        gate_passed: boolean;
+        blocking_issues: string[];
+        completion: number;
+    }>;
+    has_published_object: boolean;
+    archived: boolean;
+}
+export type AuditEventType = "stage_commit" | "stage_rollback" | "risk_acknowledged" | "fork_created" | "migration_applied" | "gate_validation" | "object_published";
+export interface AuditRecord {
+    timestamp: string;
+    event: AuditEventType;
+    stage?: ProjectStage;
+    reason: string;
+    affected_files: string[];
+    user_confirmed?: boolean;
+}
+export declare function ensureProjectDir(prefix: string, version: string): string;
+export declare function initProject(prefix: string, version: string, options?: {
+    mcpVersion?: string;
+    forkedFrom?: string;
+}): ProjectManifest;
+export declare function loadManifest(prefix: string, version: string): ProjectManifest;
+export declare function saveManifest(prefix: string, version: string, manifest: ProjectManifest): void;
+export declare function loadStageState(prefix: string, version: string): StageState | undefined;
+export declare function saveStageState(prefix: string, version: string, state: StageState): void;
+export declare function saveProjectFile(prefix: string, version: string, relPath: string, data: unknown): string;
+export declare function loadProjectFile<T = unknown>(prefix: string, version: string, relPath: string): T | undefined;
+export declare function saveProjectMarkdown(prefix: string, version: string, relPath: string, markdown: string): string;
+export declare function appendJsonl(prefix: string, version: string, relPath: string, record: unknown): string;
+export declare function appendAudit(prefix: string, version: string, record: AuditRecord): void;
+export declare function readAuditLog(prefix: string, version: string): AuditRecord[];
+export interface LocalProjectEntry {
+    dir_name: string;
+    prefix: string;
+    version: string;
+    path: string;
+    initialized: boolean;
+    archived: boolean;
+    needs_migration: boolean;
+    forked_from?: string;
+    mtime: number;
+}
+export declare function parseProjectDirName(dirName: string): {
+    prefix: string;
+    version: string;
+} | undefined;
+export declare function listLocalProjects(): LocalProjectEntry[];
+export declare function projectExists(prefix: string, version: string): boolean;
+export interface ForkOptions {
+    newVersion: string;
+    newPrefix?: string;
+    mcpVersion?: string;
+}
+export interface ForkResult {
+    new_prefix: string;
+    new_version: string;
+    new_path: string;
+    forked_from: string;
+    copied_files: string[];
+}
+export declare function forkProject(srcPrefix: string, srcVersion: string, opts: ForkOptions): ForkResult;
+export interface ProjectFileEntry {
+    path: string;
+    abs_path: string;
+    size: number;
+    mtime: number;
+    kind: "json" | "markdown" | "jsonl" | "other";
+}
+export declare function listProjectFiles(prefix: string, version: string): ProjectFileEntry[];
+export declare function readProjectFile(prefix: string, version: string, relPath: string): string | undefined;
+export declare function commitStage(prefix: string, version: string, stage: ProjectStage, options?: {
+    gatePassed?: boolean;
+    blockingIssues?: string[];
+    completion?: number;
+    reason?: string;
+    userConfirmed?: boolean;
+}): StageState;
+export declare function rollbackStage(prefix: string, version: string, toStage: ProjectStage, options?: {
+    reason?: string;
+    affectedFiles?: string[];
+}): StageState;
+export declare function markObjectPublished(prefix: string, version: string, objectName: string): void;
+export interface ProjectSyncStatus {
+    local_exists: boolean;
+    initialized: boolean;
+    needs_migration: boolean;
+    archived: boolean;
+}
+export declare function getLocalSyncStatus(prefix: string, version: string): ProjectSyncStatus;

package/dist/project/project-store.js

@@ -0,0 +1,425 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, copyFileSync, statSync, appendFileSync, } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+export const CURRENT_SCHEMA_VERSION = "1.0.0";
+export function projectsRootDir() {
+    const base = process.env.WOWOK_CONFIG_DIR
+        ? process.env.WOWOK_CONFIG_DIR
+        : join(homedir(), ".wowok");
+    return join(base, "projects");
+}
+export function projectDir(prefix, version) {
+    return join(projectsRootDir(), `${prefix}_${version}`);
+}
+export function deploymentDir(prefix, version) {
+    return join(projectDir(prefix, version), "deployment");
+}
+function manifestPath(prefix, version) {
+    return join(projectDir(prefix, version), "manifest.json");
+}
+function stageStatePath(prefix, version) {
+    return join(projectDir(prefix, version), "stage.json");
+}
+function auditLogPath(prefix, version) {
+    return join(projectDir(prefix, version), "audit.jsonl");
+}
+export function ensureProjectDir(prefix, version) {
+    const dir = projectDir(prefix, version);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    return dir;
+}
+export function initProject(prefix, version, options = {}) {
+    ensureProjectDir(prefix, version);
+    const now = new Date().toISOString();
+    const manifest = {
+        schema_version: CURRENT_SCHEMA_VERSION,
+        mcp_version: options.mcpVersion ?? "unknown",
+        prefix,
+        version,
+        created_at: now,
+        updated_at: now,
+        forked_from: options.forkedFrom,
+    };
+    writeFileSync(manifestPath(prefix, version), JSON.stringify(manifest, null, 2), "utf-8");
+    const stageState = {
+        stage: 1,
+        updated_at: Date.now(),
+        stage_meta: {
+            1: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            2: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            3: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            4: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            5: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+        },
+        has_published_object: false,
+        archived: false,
+    };
+    saveStageState(prefix, version, stageState);
+    appendAudit(prefix, version, {
+        timestamp: now,
+        event: "stage_commit",
+        stage: 1,
+        reason: `project initialized${options.forkedFrom ? ` (forked from ${options.forkedFrom})` : ""}`,
+        affected_files: ["manifest.json", "stage.json"],
+    });
+    return manifest;
+}
+export function loadManifest(prefix, version) {
+    const p = manifestPath(prefix, version);
+    if (!existsSync(p)) {
+        throw new Error(`project not initialized: ${prefix}_${version} (missing manifest.json)`);
+    }
+    const raw = readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+}
+export function saveManifest(prefix, version, manifest) {
+    manifest.updated_at = new Date().toISOString();
+    writeFileSync(manifestPath(prefix, version), JSON.stringify(manifest, null, 2), "utf-8");
+}
+export function loadStageState(prefix, version) {
+    const p = stageStatePath(prefix, version);
+    if (!existsSync(p))
+        return undefined;
+    const raw = readFileSync(p, "utf-8");
+    return JSON.parse(raw);
+}
+export function saveStageState(prefix, version, state) {
+    state.updated_at = Date.now();
+    ensureProjectDir(prefix, version);
+    writeFileSync(stageStatePath(prefix, version), JSON.stringify(state, null, 2), "utf-8");
+}
+export function saveProjectFile(prefix, version, relPath, data) {
+    const abs = join(projectDir(prefix, version), relPath);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, JSON.stringify(data, null, 2), "utf-8");
+    return abs;
+}
+export function loadProjectFile(prefix, version, relPath) {
+    const abs = join(projectDir(prefix, version), relPath);
+    if (!existsSync(abs))
+        return undefined;
+    const raw = readFileSync(abs, "utf-8");
+    return JSON.parse(raw);
+}
+export function saveProjectMarkdown(prefix, version, relPath, markdown) {
+    const abs = join(projectDir(prefix, version), relPath);
+    mkdirSync(dirname(abs), { recursive: true });
+    writeFileSync(abs, markdown, "utf-8");
+    return abs;
+}
+export function appendJsonl(prefix, version, relPath, record) {
+    const abs = join(projectDir(prefix, version), relPath);
+    ensureProjectDir(prefix, version);
+    mkdirSync(dirname(abs), { recursive: true });
+    appendFileSync(abs, JSON.stringify(record) + "\n", "utf-8");
+    return abs;
+}
+export function appendAudit(prefix, version, record) {
+    appendJsonl(prefix, version, "audit.jsonl", record);
+}
+export function readAuditLog(prefix, version) {
+    const abs = auditLogPath(prefix, version);
+    if (!existsSync(abs))
+        return [];
+    const raw = readFileSync(abs, "utf-8");
+    return raw
+        .split("\n")
+        .filter((l) => l.trim().length > 0)
+        .map((l) => JSON.parse(l));
+}
+export function parseProjectDirName(dirName) {
+    const m = dirName.match(/^(.+)_v(\d+)$/);
+    if (!m)
+        return undefined;
+    return { prefix: m[1], version: `v${m[2]}` };
+}
+export function listLocalProjects() {
+    const root = projectsRootDir();
+    if (!existsSync(root))
+        return [];
+    const entries = readdirSync(root, { withFileTypes: true });
+    const out = [];
+    for (const e of entries) {
+        if (!e.isDirectory())
+            continue;
+        const parsed = parseProjectDirName(e.name);
+        if (!parsed)
+            continue;
+        const fullPath = join(root, e.name);
+        const manifestFile = join(fullPath, "manifest.json");
+        const stageFile = join(fullPath, "stage.json");
+        let initialized = false;
+        let archived = false;
+        let needsMigration = false;
+        let forkedFrom;
+        if (existsSync(manifestFile)) {
+            initialized = true;
+            try {
+                const m = JSON.parse(readFileSync(manifestFile, "utf-8"));
+                needsMigration = m.schema_version !== CURRENT_SCHEMA_VERSION;
+                forkedFrom = m.forked_from;
+            }
+            catch {
+            }
+        }
+        if (existsSync(stageFile)) {
+            try {
+                const s = JSON.parse(readFileSync(stageFile, "utf-8"));
+                archived = s.archived;
+            }
+            catch {
+            }
+        }
+        let mtime = 0;
+        try {
+            mtime = statSync(fullPath).mtimeMs;
+        }
+        catch {
+        }
+        out.push({
+            dir_name: e.name,
+            prefix: parsed.prefix,
+            version: parsed.version,
+            path: fullPath,
+            initialized,
+            archived,
+            needs_migration: needsMigration,
+            forked_from: forkedFrom,
+            mtime,
+        });
+    }
+    return out.sort((a, b) => b.mtime - a.mtime);
+}
+export function projectExists(prefix, version) {
+    return existsSync(manifestPath(prefix, version));
+}
+export function forkProject(srcPrefix, srcVersion, opts) {
+    if (!projectExists(srcPrefix, srcVersion)) {
+        throw new Error(`source project not found: ${srcPrefix}_${srcVersion}`);
+    }
+    const newPrefix = opts.newPrefix ?? srcPrefix;
+    if (opts.newVersion === srcVersion && newPrefix === srcPrefix) {
+        throw new Error("fork target must differ from source (set newVersion or newPrefix)");
+    }
+    ensureProjectDir(newPrefix, opts.newVersion);
+    const srcDir = projectDir(srcPrefix, srcVersion);
+    const dstDir = projectDir(newPrefix, opts.newVersion);
+    const copiedFiles = [];
+    function walkDir(relBase) {
+        const absBase = join(srcDir, relBase);
+        if (!existsSync(absBase))
+            return;
+        const items = readdirSync(absBase, { withFileTypes: true });
+        for (const item of items) {
+            const rel = relBase ? join(relBase, item.name) : item.name;
+            const srcAbs = join(srcDir, rel);
+            const dstAbs = join(dstDir, rel);
+            if (item.isDirectory()) {
+                mkdirSync(dstAbs, { recursive: true });
+                walkDir(rel);
+            }
+            else if (item.isFile()) {
+                if (rel === "stage.json" || rel === "audit.jsonl")
+                    continue;
+                mkdirSync(dirname(dstAbs), { recursive: true });
+                copyFileSync(srcAbs, dstAbs);
+                copiedFiles.push(rel);
+            }
+        }
+    }
+    walkDir("");
+    const now = new Date().toISOString();
+    const manifest = {
+        schema_version: CURRENT_SCHEMA_VERSION,
+        mcp_version: opts.mcpVersion ?? "unknown",
+        prefix: newPrefix,
+        version: opts.newVersion,
+        created_at: now,
+        updated_at: now,
+        forked_from: srcDir,
+    };
+    writeFileSync(manifestPath(newPrefix, opts.newVersion), JSON.stringify(manifest, null, 2), "utf-8");
+    const stageState = {
+        stage: 1,
+        updated_at: Date.now(),
+        stage_meta: {
+            1: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            2: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            3: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            4: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+            5: { committed: false, gate_passed: false, blocking_issues: [], completion: 0 },
+        },
+        has_published_object: false,
+        archived: false,
+    };
+    saveStageState(newPrefix, opts.newVersion, stageState);
+    appendAudit(newPrefix, opts.newVersion, {
+        timestamp: now,
+        event: "fork_created",
+        reason: `forked from ${srcPrefix}_${srcVersion}; objects must be re-created (project isolation §3.0)`,
+        affected_files: ["manifest.json", "stage.json"],
+    });
+    const srcStage = loadStageState(srcPrefix, srcVersion);
+    if (srcStage) {
+        srcStage.archived = true;
+        saveStageState(srcPrefix, srcVersion, srcStage);
+        appendAudit(srcPrefix, srcVersion, {
+            timestamp: now,
+            event: "stage_commit",
+            reason: `archived after fork to ${newPrefix}_${opts.newVersion}`,
+            affected_files: ["stage.json"],
+        });
+    }
+    return {
+        new_prefix: newPrefix,
+        new_version: opts.newVersion,
+        new_path: dstDir,
+        forked_from: srcDir,
+        copied_files: copiedFiles,
+    };
+}
+export function listProjectFiles(prefix, version) {
+    const dir = projectDir(prefix, version);
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    function walk(relBase) {
+        const absBase = join(dir, relBase);
+        const items = readdirSync(absBase, { withFileTypes: true });
+        for (const item of items) {
+            const rel = relBase ? join(relBase, item.name) : item.name;
+            const abs = join(dir, rel);
+            if (item.isDirectory()) {
+                walk(rel);
+            }
+            else if (item.isFile()) {
+                let stat;
+                try {
+                    stat = statSync(abs);
+                }
+                catch {
+                    continue;
+                }
+                let kind = "other";
+                if (abs.endsWith(".json"))
+                    kind = "json";
+                else if (abs.endsWith(".md"))
+                    kind = "markdown";
+                else if (abs.endsWith(".jsonl"))
+                    kind = "jsonl";
+                out.push({
+                    path: rel,
+                    abs_path: abs,
+                    size: stat.size,
+                    mtime: stat.mtimeMs,
+                    kind,
+                });
+            }
+        }
+    }
+    walk("");
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+export function readProjectFile(prefix, version, relPath) {
+    const abs = join(projectDir(prefix, version), relPath);
+    if (!existsSync(abs))
+        return undefined;
+    return readFileSync(abs, "utf-8");
+}
+export function commitStage(prefix, version, stage, options = {}) {
+    const state = loadStageState(prefix, version);
+    if (!state) {
+        throw new Error(`project not initialized: ${prefix}_${version}`);
+    }
+    const gatePassed = options.gatePassed ?? false;
+    state.stage_meta[stage] = {
+        committed: true,
+        committed_at: Date.now(),
+        gate_passed: gatePassed,
+        blocking_issues: options.blockingIssues ?? [],
+        completion: options.completion ?? (gatePassed ? 100 : 0),
+    };
+    if (stage < 5 && gatePassed) {
+        state.stage = (stage + 1);
+    }
+    saveStageState(prefix, version, state);
+    appendAudit(prefix, version, {
+        timestamp: new Date().toISOString(),
+        event: "stage_commit",
+        stage,
+        reason: options.reason ?? `stage ${stage} committed`,
+        affected_files: ["stage.json"],
+        user_confirmed: options.userConfirmed,
+    });
+    return state;
+}
+export function rollbackStage(prefix, version, toStage, options = {}) {
+    const state = loadStageState(prefix, version);
+    if (!state) {
+        throw new Error(`project not initialized: ${prefix}_${version}`);
+    }
+    if (state.has_published_object) {
+        throw new Error(`cannot rollback: project has published objects — must fork new version (§3.3)`);
+    }
+    const oldStage = state.stage;
+    for (let s = toStage + 1; s <= 5; s++) {
+        state.stage_meta[s] = {
+            committed: false,
+            gate_passed: false,
+            blocking_issues: [],
+            completion: 0,
+        };
+    }
+    state.stage = toStage;
+    saveStageState(prefix, version, state);
+    appendAudit(prefix, version, {
+        timestamp: new Date().toISOString(),
+        event: "stage_rollback",
+        stage: toStage,
+        reason: options.reason ?? `rollback from stage ${oldStage} to ${toStage}`,
+        affected_files: options.affectedFiles ?? ["stage.json"],
+    });
+    return state;
+}
+export function markObjectPublished(prefix, version, objectName) {
+    const state = loadStageState(prefix, version);
+    if (!state)
+        return;
+    if (state.has_published_object)
+        return;
+    state.has_published_object = true;
+    saveStageState(prefix, version, state);
+    appendAudit(prefix, version, {
+        timestamp: new Date().toISOString(),
+        event: "object_published",
+        stage: 5,
+        reason: `object published: ${objectName} — rollback now requires fork (§3.3)`,
+        affected_files: ["stage.json"],
+    });
+}
+export function getLocalSyncStatus(prefix, version) {
+    const exists = projectExists(prefix, version);
+    if (!exists) {
+        return { local_exists: false, initialized: false, needs_migration: false, archived: false };
+    }
+    let initialized = true;
+    let needsMigration = false;
+    let archived = false;
+    try {
+        const m = loadManifest(prefix, version);
+        needsMigration = m.schema_version !== CURRENT_SCHEMA_VERSION;
+    }
+    catch {
+        initialized = false;
+    }
+    try {
+        const s = loadStageState(prefix, version);
+        if (s)
+            archived = s.archived;
+    }
+    catch {
+    }
+    return { local_exists: true, initialized, needs_migration: needsMigration, archived };
+}