@haaaiawd/second-nature 0.1.16 → 0.1.18

package/runtime/storage/bootstrap/native-sqlite-probe.js

@@ -1,28 +1,28 @@
-/**
- * Optional better-sqlite3 load probe (T4.1.4). Second Nature state DB currently uses sql.js only;
- * this probe records whether the native module can load for packaging / host diagnostics.
- */
-import { createRequire } from "node:module";
-const require = createRequire(import.meta.url);
-export function probeNativeSqliteLoad() {
-    try {
-        const Database = require("better-sqlite3");
-        const db = new Database(":memory:");
-        db.close();
-        let version;
-        try {
-            const pkg = require("better-sqlite3/package.json");
-            version = pkg.version;
-        }
-        catch {
-            version = undefined;
-        }
-        return { moduleLoadOk: true, version };
-    }
-    catch (error) {
-        return {
-            moduleLoadOk: false,
-            errorMessage: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
+/**
+ * Optional better-sqlite3 load probe (T4.1.4). Second Nature state DB currently uses sql.js only;
+ * this probe records whether the native module can load for packaging / host diagnostics.
+ */
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export function probeNativeSqliteLoad() {
+    try {
+        const Database = require("better-sqlite3");
+        const db = new Database(":memory:");
+        db.close();
+        let version;
+        try {
+            const pkg = require("better-sqlite3/package.json");
+            version = pkg.version;
+        }
+        catch {
+            version = undefined;
+        }
+        return { moduleLoadOk: true, version };
+    }
+    catch (error) {
+        return {
+            moduleLoadOk: false,
+            errorMessage: error instanceof Error ? error.message : String(error),
+        };
+    }
+}

package/runtime/storage/bootstrap/repair-gate.d.ts

@@ -1,17 +1,17 @@
-import type { StateDatabase } from "../db/index.js";
-import { createRepairAndBackupService, type RepairAndBackupOptions } from "../services/repair-and-backup.js";
-export interface RepairStateIndexesOptions {
-    startupGate?: boolean;
-    workspaceRoot: string;
-    /** When true, also runs asset registry repair + backup (existing repair service) */
-    reconcileAssets?: boolean;
-    assetRepairOptions?: RepairAndBackupOptions;
-}
-export type RepairGateStatus = "ok" | "repair_required";
-export interface RepairSummary {
-    status: RepairGateStatus;
-    repairedEvidenceIndexRows: number;
-    repairNotes: string[];
-    assetRepair?: Awaited<ReturnType<ReturnType<typeof createRepairAndBackupService>["runStartupRepair"]>>;
-}
-export declare function repairStateIndexes(state: StateDatabase, options: RepairStateIndexesOptions): Promise<RepairSummary>;
+import type { StateDatabase } from "../db/index.js";
+import { createRepairAndBackupService, type RepairAndBackupOptions } from "../services/repair-and-backup.js";
+export interface RepairStateIndexesOptions {
+    startupGate?: boolean;
+    workspaceRoot: string;
+    /** When true, also runs asset registry repair + backup (existing repair service) */
+    reconcileAssets?: boolean;
+    assetRepairOptions?: RepairAndBackupOptions;
+}
+export type RepairGateStatus = "ok" | "repair_required";
+export interface RepairSummary {
+    status: RepairGateStatus;
+    repairedEvidenceIndexRows: number;
+    repairNotes: string[];
+    assetRepair?: Awaited<ReturnType<ReturnType<typeof createRepairAndBackupService>["runStartupRepair"]>>;
+}
+export declare function repairStateIndexes(state: StateDatabase, options: RepairStateIndexesOptions): Promise<RepairSummary>;

package/runtime/storage/bootstrap/repair-gate.js

@@ -1,71 +1,71 @@
-/**
- * Startup repair gate for state indexes (T4.1.3) — reconciles life evidence filesystem vs SQLite index.
- *
- * Core logic: scan `.second-nature/evidence/*.json`; on startupGate, corrupt JSON fails closed with repair_required;
- * otherwise backfill missing `life_evidence_index` rows from parsed artifacts.
- *
- * Test coverage: tests/unit/storage/repair-gate.test.ts
- */
-import fs from "node:fs";
-import path from "node:path";
-import { eq } from "drizzle-orm";
-import { lifeEvidenceIndex } from "../db/schema/life-evidence-index.js";
-import { createRepairAndBackupService, } from "../services/repair-and-backup.js";
-export async function repairStateIndexes(state, options) {
-    const notes = [];
-    let repaired = 0;
-    const evidenceDir = path.join(options.workspaceRoot, ".second-nature", "evidence");
-    if (!fs.existsSync(evidenceDir)) {
-        notes.push("no_evidence_dir");
-    }
-    else {
-        const entries = fs.readdirSync(evidenceDir);
-        for (const name of entries) {
-            if (!name.endsWith(".json") || name.startsWith(".")) {
-                continue;
-            }
-            const abs = path.join(evidenceDir, name);
-            let parsed;
-            try {
-                parsed = JSON.parse(fs.readFileSync(abs, "utf-8"));
-            }
-            catch {
-                if (options.startupGate) {
-                    return {
-                        status: "repair_required",
-                        repairedEvidenceIndexRows: repaired,
-                        repairNotes: [...notes, `corrupt_evidence_json:${name}`],
-                    };
-                }
-                notes.push(`skip_corrupt:${name}`);
-                continue;
-            }
-            const existing = await state.db.select().from(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, parsed.id)).limit(1);
-            if (existing.length === 0) {
-                await state.db.insert(lifeEvidenceIndex).values({
-                    id: parsed.id,
-                    timestamp: parsed.timestamp,
-                    evidenceType: parsed.evidenceType,
-                    sensitivity: parsed.sensitivity,
-                    producer: parsed.producer,
-                    artifactPath: path.join(".second-nature", "evidence", `${parsed.id}.json`).replace(/\\/g, "/"),
-                    platformId: parsed.platformId ?? null,
-                    sourceRefsJson: JSON.stringify(parsed.sourceRefs),
-                });
-                repaired += 1;
-                notes.push(`reindexed:${parsed.id}`);
-            }
-        }
-    }
-    let assetRepair;
-    if (options.reconcileAssets) {
-        const svc = createRepairAndBackupService(state);
-        assetRepair = await svc.runStartupRepair(options.assetRepairOptions ?? {});
-    }
-    return {
-        status: "ok",
-        repairedEvidenceIndexRows: repaired,
-        repairNotes: notes,
-        assetRepair,
-    };
-}
+/**
+ * Startup repair gate for state indexes (T4.1.3) — reconciles life evidence filesystem vs SQLite index.
+ *
+ * Core logic: scan `.second-nature/evidence/*.json`; on startupGate, corrupt JSON fails closed with repair_required;
+ * otherwise backfill missing `life_evidence_index` rows from parsed artifacts.
+ *
+ * Test coverage: tests/unit/storage/repair-gate.test.ts
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { eq } from "drizzle-orm";
+import { lifeEvidenceIndex } from "../db/schema/life-evidence-index.js";
+import { createRepairAndBackupService, } from "../services/repair-and-backup.js";
+export async function repairStateIndexes(state, options) {
+    const notes = [];
+    let repaired = 0;
+    const evidenceDir = path.join(options.workspaceRoot, ".second-nature", "evidence");
+    if (!fs.existsSync(evidenceDir)) {
+        notes.push("no_evidence_dir");
+    }
+    else {
+        const entries = fs.readdirSync(evidenceDir);
+        for (const name of entries) {
+            if (!name.endsWith(".json") || name.startsWith(".")) {
+                continue;
+            }
+            const abs = path.join(evidenceDir, name);
+            let parsed;
+            try {
+                parsed = JSON.parse(fs.readFileSync(abs, "utf-8"));
+            }
+            catch {
+                if (options.startupGate) {
+                    return {
+                        status: "repair_required",
+                        repairedEvidenceIndexRows: repaired,
+                        repairNotes: [...notes, `corrupt_evidence_json:${name}`],
+                    };
+                }
+                notes.push(`skip_corrupt:${name}`);
+                continue;
+            }
+            const existing = await state.db.select().from(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, parsed.id)).limit(1);
+            if (existing.length === 0) {
+                await state.db.insert(lifeEvidenceIndex).values({
+                    id: parsed.id,
+                    timestamp: parsed.timestamp,
+                    evidenceType: parsed.evidenceType,
+                    sensitivity: parsed.sensitivity,
+                    producer: parsed.producer,
+                    artifactPath: path.join(".second-nature", "evidence", `${parsed.id}.json`).replace(/\\/g, "/"),
+                    platformId: parsed.platformId ?? null,
+                    sourceRefsJson: JSON.stringify(parsed.sourceRefs),
+                });
+                repaired += 1;
+                notes.push(`reindexed:${parsed.id}`);
+            }
+        }
+    }
+    let assetRepair;
+    if (options.reconcileAssets) {
+        const svc = createRepairAndBackupService(state);
+        assetRepair = await svc.runStartupRepair(options.assetRepairOptions ?? {});
+    }
+    return {
+        status: "ok",
+        repairedEvidenceIndexRows: repaired,
+        repairNotes: notes,
+        assetRepair,
+    };
+}

package/runtime/storage/bootstrap/storage-mode-smoke.d.ts

@@ -1,38 +1,38 @@
-import { probeNativeSqliteLoad } from "./native-sqlite-probe.js";
-export interface StorageModeSmokeSemantics {
-    sqlJs: {
-        walAssumed: false;
-        journalConcurrencyNotes: string;
-        backupNotes: string;
-        repairNotes: string;
-    };
-    nativeSqliteWhenAvailable: {
-        journalConcurrencyNotes: string;
-        backupNotes: string;
-    };
-}
-export interface StorageModeSmokeRepairFixtureResult {
-    ran: boolean;
-    workspaceRoot?: string;
-    repairStatus?: "ok" | "repair_required";
-    repairedEvidenceIndexRows?: number;
-    repairNotes?: string[];
-}
-export interface StorageModeSmokeReport {
-    generatedAt: string;
-    /** Implementation backing `createStateDatabase` today — wasm sql.js, not native WAL */
-    runtimeIndexDriver: "sql_js";
-    nativeSqliteProbe: ReturnType<typeof probeNativeSqliteLoad> & {
-        /** Current code path does not use native driver even when load succeeds */
-        runtimeUsesNativeDriver: false;
-    };
-    semantics: StorageModeSmokeSemantics;
-    repairFromArtifactsFixture?: StorageModeSmokeRepairFixtureResult;
-}
-export interface RunStorageModeSmokeOptions {
-    /** Required when runRepairFixture is true — temp dir created if omitted */
-    workspaceRoot?: string;
-    /** Run artifact→index backfill smoke (sql.js path); uses temp workspace when workspaceRoot unset */
-    runRepairFixture?: boolean;
-}
-export declare function runStorageModeSmoke(options?: RunStorageModeSmokeOptions): Promise<StorageModeSmokeReport>;
+import { probeNativeSqliteLoad } from "./native-sqlite-probe.js";
+export interface StorageModeSmokeSemantics {
+    sqlJs: {
+        walAssumed: false;
+        journalConcurrencyNotes: string;
+        backupNotes: string;
+        repairNotes: string;
+    };
+    nativeSqliteWhenAvailable: {
+        journalConcurrencyNotes: string;
+        backupNotes: string;
+    };
+}
+export interface StorageModeSmokeRepairFixtureResult {
+    ran: boolean;
+    workspaceRoot?: string;
+    repairStatus?: "ok" | "repair_required";
+    repairedEvidenceIndexRows?: number;
+    repairNotes?: string[];
+}
+export interface StorageModeSmokeReport {
+    generatedAt: string;
+    /** Implementation backing `createStateDatabase` today — wasm sql.js, not native WAL */
+    runtimeIndexDriver: "sql_js";
+    nativeSqliteProbe: ReturnType<typeof probeNativeSqliteLoad> & {
+        /** Current code path does not use native driver even when load succeeds */
+        runtimeUsesNativeDriver: false;
+    };
+    semantics: StorageModeSmokeSemantics;
+    repairFromArtifactsFixture?: StorageModeSmokeRepairFixtureResult;
+}
+export interface RunStorageModeSmokeOptions {
+    /** Required when runRepairFixture is true — temp dir created if omitted */
+    workspaceRoot?: string;
+    /** Run artifact→index backfill smoke (sql.js path); uses temp workspace when workspaceRoot unset */
+    runRepairFixture?: boolean;
+}
+export declare function runStorageModeSmoke(options?: RunStorageModeSmokeOptions): Promise<StorageModeSmokeReport>;

package/runtime/storage/bootstrap/storage-mode-smoke.js

@@ -1,85 +1,85 @@
-/**
- * Storage driver mode smoke report (T4.1.4 / state-system §12.1.1).
- *
- * Actual runtime: `createStateDatabase` uses sql.js — no WAL; persistence via export + explicit flush on close.
- * Native SQLite (better-sqlite3) is probed separately; switching drivers is out of scope — report stays honest.
- */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { eq } from "drizzle-orm";
-import { appendLifeEvidence } from "../life-evidence/append-life-evidence.js";
-import { createStateDatabase } from "../db/index.js";
-import { lifeEvidenceIndex } from "../db/schema/life-evidence-index.js";
-import { repairStateIndexes } from "./repair-gate.js";
-import { probeNativeSqliteLoad } from "./native-sqlite-probe.js";
-const SEMANTICS = {
-    sqlJs: {
-        walAssumed: false,
-        journalConcurrencyNotes: "sql.js (WASM) has no host SQLite WAL; treat writes as a single-writer/single connection path with explicit export() flush on close (design: single-writer queue + atomic artifact write + explicit flush) — do not assume POSIX WAL or multi-writer journal semantics.",
-        backupNotes: "Backup for sql.js mode: export DB binary via sqlite.export(), pair with workspace artifact manifest; avoid copying a live in-memory DB without explicit flush/export.",
-        repairNotes: "Index rebuild uses canonical filesystem evidence artifacts under .second-nature/evidence — repairStateIndexes can repopulate life_evidence_index without WAL replay.",
-    },
-    nativeSqliteWhenAvailable: {
-        journalConcurrencyNotes: "Native better-sqlite3 may enable WAL where supported + busy timeout — applicable only if a future native-backed StateDatabase is wired.",
-        backupNotes: "Preferred: SQLite Backup API / VACUUM INTO plus artifact manifest — only when native driver owns the DB file.",
-    },
-};
-async function runRepairFixture(workspaceRoot) {
-    const state = createStateDatabase(":memory:");
-    await appendLifeEvidence(state, workspaceRoot, {
-        timestamp: new Date().toISOString(),
-        evidenceType: "platform_browse",
-        summary: "storage-mode-smoke fixture",
-        sourceRefs: [{ id: "smoke-ref", kind: "platform_item", uri: "platform://storage-smoke" }],
-        sensitivity: "public",
-        producer: "state-system",
-    });
-    const rows = await state.db.select().from(lifeEvidenceIndex);
-    const evidenceId = rows[0]?.id;
-    if (!evidenceId) {
-        state.close();
-        return {
-            ran: true,
-            workspaceRoot,
-            repairStatus: "repair_required",
-            repairNotes: ["fixture_failed_no_index_after_append"],
-        };
-    }
-    await state.db.delete(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, evidenceId));
-    const repair = await repairStateIndexes(state, { startupGate: true, workspaceRoot });
-    state.close();
-    return {
-        ran: true,
-        workspaceRoot,
-        repairStatus: repair.status,
-        repairedEvidenceIndexRows: repair.repairedEvidenceIndexRows,
-        repairNotes: repair.repairNotes,
-    };
-}
-export async function runStorageModeSmoke(options = {}) {
-    const nativeSqliteProbe = probeNativeSqliteLoad();
-    let repairFromArtifactsFixture;
-    if (options.runRepairFixture) {
-        const ws = options.workspaceRoot ??
-            fs.mkdtempSync(path.join(os.tmpdir(), "sn-storage-smoke-"));
-        try {
-            repairFromArtifactsFixture = await runRepairFixture(ws);
-        }
-        finally {
-            if (!options.workspaceRoot) {
-                fs.rmSync(ws, { recursive: true, force: true });
-            }
-        }
-    }
-    return {
-        generatedAt: new Date().toISOString(),
-        runtimeIndexDriver: "sql_js",
-        nativeSqliteProbe: {
-            ...nativeSqliteProbe,
-            runtimeUsesNativeDriver: false,
-        },
-        semantics: SEMANTICS,
-        repairFromArtifactsFixture,
-    };
-}
+/**
+ * Storage driver mode smoke report (T4.1.4 / state-system §12.1.1).
+ *
+ * Actual runtime: `createStateDatabase` uses sql.js — no WAL; persistence via export + explicit flush on close.
+ * Native SQLite (better-sqlite3) is probed separately; switching drivers is out of scope — report stays honest.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { eq } from "drizzle-orm";
+import { appendLifeEvidence } from "../life-evidence/append-life-evidence.js";
+import { createStateDatabase } from "../db/index.js";
+import { lifeEvidenceIndex } from "../db/schema/life-evidence-index.js";
+import { repairStateIndexes } from "./repair-gate.js";
+import { probeNativeSqliteLoad } from "./native-sqlite-probe.js";
+const SEMANTICS = {
+    sqlJs: {
+        walAssumed: false,
+        journalConcurrencyNotes: "sql.js (WASM) has no host SQLite WAL; treat writes as a single-writer/single connection path with explicit export() flush on close (design: single-writer queue + atomic artifact write + explicit flush) — do not assume POSIX WAL or multi-writer journal semantics.",
+        backupNotes: "Backup for sql.js mode: export DB binary via sqlite.export(), pair with workspace artifact manifest; avoid copying a live in-memory DB without explicit flush/export.",
+        repairNotes: "Index rebuild uses canonical filesystem evidence artifacts under .second-nature/evidence — repairStateIndexes can repopulate life_evidence_index without WAL replay.",
+    },
+    nativeSqliteWhenAvailable: {
+        journalConcurrencyNotes: "Native better-sqlite3 may enable WAL where supported + busy timeout — applicable only if a future native-backed StateDatabase is wired.",
+        backupNotes: "Preferred: SQLite Backup API / VACUUM INTO plus artifact manifest — only when native driver owns the DB file.",
+    },
+};
+async function runRepairFixture(workspaceRoot) {
+    const state = createStateDatabase(":memory:");
+    await appendLifeEvidence(state, workspaceRoot, {
+        timestamp: new Date().toISOString(),
+        evidenceType: "platform_browse",
+        summary: "storage-mode-smoke fixture",
+        sourceRefs: [{ id: "smoke-ref", kind: "platform_item", uri: "platform://storage-smoke" }],
+        sensitivity: "public",
+        producer: "state-system",
+    });
+    const rows = await state.db.select().from(lifeEvidenceIndex);
+    const evidenceId = rows[0]?.id;
+    if (!evidenceId) {
+        state.close();
+        return {
+            ran: true,
+            workspaceRoot,
+            repairStatus: "repair_required",
+            repairNotes: ["fixture_failed_no_index_after_append"],
+        };
+    }
+    await state.db.delete(lifeEvidenceIndex).where(eq(lifeEvidenceIndex.id, evidenceId));
+    const repair = await repairStateIndexes(state, { startupGate: true, workspaceRoot });
+    state.close();
+    return {
+        ran: true,
+        workspaceRoot,
+        repairStatus: repair.status,
+        repairedEvidenceIndexRows: repair.repairedEvidenceIndexRows,
+        repairNotes: repair.repairNotes,
+    };
+}
+export async function runStorageModeSmoke(options = {}) {
+    const nativeSqliteProbe = probeNativeSqliteLoad();
+    let repairFromArtifactsFixture;
+    if (options.runRepairFixture) {
+        const ws = options.workspaceRoot ??
+            fs.mkdtempSync(path.join(os.tmpdir(), "sn-storage-smoke-"));
+        try {
+            repairFromArtifactsFixture = await runRepairFixture(ws);
+        }
+        finally {
+            if (!options.workspaceRoot) {
+                fs.rmSync(ws, { recursive: true, force: true });
+            }
+        }
+    }
+    return {
+        generatedAt: new Date().toISOString(),
+        runtimeIndexDriver: "sql_js",
+        nativeSqliteProbe: {
+            ...nativeSqliteProbe,
+            runtimeUsesNativeDriver: false,
+        },
+        semantics: SEMANTICS,
+        repairFromArtifactsFixture,
+    };
+}