super-dsh 0.1.9 → 0.1.10-e

package/agent-omp-sdk/dist/sidecar-client.js

@@ -0,0 +1,197 @@
+/**
+ * Node-side client for the omp-sdk bun sidecar.
+ *
+ * The sidecar is NOT shipped as a runtime: this package declares no `bun` and
+ * no coding-agent dependency. `start()` is therefore the ONE place the lazy
+ * runtime bootstrap is awaited ({@link ensureSdkRuntime}) — it downloads bun +
+ * the pinned coding-agent package into `<worldHome>/sdk-runtime/` and copies
+ * this package's `sidecar/main.ts` + compiled `dist/protocol.js` there, then
+ * the child is spawned with `<runtime>/bin/bun run <runtime>/sidecar/main.ts`.
+ *
+ * Because `start()` is only reached from the first real dispatch (via
+ * `LazyOmpRpc#ensure`), construction — and every passive path — stays at zero
+ * network, zero download and zero process.
+ */
+import { spawn } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { createSdkRuntimeDeps, ensureSdkRuntime, sdkRuntimeLayout } from "./sdk-runtime.js";
+import { PROTOCOL_VERSION, } from "./protocol.js";
+/** This package's root (`sidecar/`, `dist/`, `package.json` live here). */
+const pkgDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
+/** The default fetcher: the real bun download + `bun add` install + smoke. */
+const defaultRuntimeFetch = (worldHome) => ensureSdkRuntime(worldHome, createSdkRuntimeDeps(pkgDir));
+/** The default child spawn: the fetched `bin/bun run <runtime>/sidecar/main.ts`. */
+const defaultSpawn = (command, args, options) => spawn(command, args, { cwd: options.cwd, env: options.env, stdio: ["pipe", "pipe", "pipe"] });
+export class OmpSdkSidecar {
+    options;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    eventHandlers = new Set();
+    readyPromise = null;
+    buffer = "";
+    startError = null;
+    constructor(options) {
+        this.options = options;
+    }
+    get started() {
+        return this.proc !== null;
+    }
+    onEvent(handler) {
+        this.eventHandlers.add(handler);
+        return () => this.eventHandlers.delete(handler);
+    }
+    /**
+     * Fetch/reuse the durable runtime and spawn the sidecar on it.
+     *
+     * This is the FIRST and ONLY place the runtime bootstrap runs — the whole
+     * point of the opt-in SDK row is that nothing is downloaded until a real
+     * prompt materializes the transport.
+     */
+    async start() {
+        if (this.readyPromise)
+            return this.readyPromise;
+        const fetchRuntime = this.options.runtimeFetch ?? defaultRuntimeFetch;
+        this.readyPromise = (async () => {
+            // (1) durable runtime (idempotent: a complete matching one is free).
+            const runtime = await fetchRuntime(this.options.worldHome);
+            // (2) the sidecar source + compiled protocol live INSIDE the runtime dir,
+            // so bun resolves `@oh-my-pi/pi-coding-agent` from the runtime's
+            // node_modules and `../dist/protocol.js` from the copy next to it.
+            const layout = sdkRuntimeLayout(this.options.worldHome);
+            const cwd = this.options.cwd ?? layout.dir;
+            return await new Promise((resolve, reject) => {
+                const env = {
+                    ...process.env,
+                    ...this.options.env,
+                };
+                let proc;
+                try {
+                    proc = (this.options.spawnProcess ?? defaultSpawn)(runtime.bunPath, ["run", layout.sidecarEntry], {
+                        cwd,
+                        env,
+                    });
+                }
+                catch (err) {
+                    reject(new Error(`failed to spawn bun sidecar: ${err.message}`));
+                    return;
+                }
+                this.proc = proc;
+                const readyTimeoutMs = this.options.readyTimeoutMs ?? 60_000;
+                const timeout = setTimeout(() => reject(new Error(`sidecar ready timeout (${readyTimeoutMs}ms): ${this.startError ?? "no output"}`)), readyTimeoutMs);
+                const settle = (fn) => { clearTimeout(timeout); fn(); };
+                // A dead sidecar surfaces as EPIPE on stdin writes; keep a permanent
+                // no-op error sink so no window exists where the stream throws out of the
+                // event loop (per-call degradation is handled by #writeSafe).
+                proc.stdin.on("error", () => { });
+                proc.stdout.setEncoding("utf8");
+                proc.stdout.on("data", (chunk) => this.consume(chunk, (r) => settle(() => resolve(r))));
+                proc.stderr.setEncoding("utf8");
+                proc.stderr.on("data", (chunk) => {
+                    this.startError = (this.startError ?? "") + chunk;
+                    process.stderr.write(`[omp-sdk-sidecar] ${chunk}`);
+                });
+                proc.on("exit", (code, signal) => {
+                    settle(() => reject(new Error(`sidecar exited before ready (${code ?? signal}): ${this.startError ?? ""}`)));
+                    for (const [, p] of this.pending)
+                        p.reject(new Error(`sidecar exited (${code ?? signal})`));
+                    this.pending.clear();
+                    this.proc = null;
+                });
+            });
+        })();
+        return this.readyPromise;
+    }
+    consume(chunk, onReady) {
+        this.buffer += chunk;
+        let nl;
+        while ((nl = this.buffer.indexOf("\n")) >= 0) {
+            const raw = this.buffer.slice(0, nl).trim();
+            this.buffer = this.buffer.slice(nl + 1);
+            if (!raw)
+                continue;
+            let frame;
+            try {
+                frame = JSON.parse(raw);
+            }
+            catch {
+                continue;
+            }
+            if (frame.event === "ready") {
+                onReady?.({ protocol: frame.payload?.protocol ?? PROTOCOL_VERSION });
+                continue;
+            }
+            if (typeof frame.id === "number" && ("ok" in frame)) {
+                const p = this.pending.get(frame.id);
+                if (p) {
+                    this.pending.delete(frame.id);
+                    if (frame.ok)
+                        p.resolve(frame.result);
+                    else
+                        p.reject(new Error(frame.error));
+                }
+                continue;
+            }
+            if (frame.event) {
+                for (const h of this.eventHandlers)
+                    h(frame);
+            }
+        }
+    }
+    call(method, params) {
+        if (!this.proc?.stdin)
+            return Promise.reject(new Error("sidecar not started"));
+        const id = this.nextId++;
+        const frame = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.#writeSafe(JSON.stringify(frame) + "\n", () => {
+                this.pending.delete(id);
+                reject(new Error(`sidecar write failed: ${method}`));
+            });
+        });
+    }
+    /** Write to the sidecar's stdin without ever throwing EPIPE out of the loop. */
+    #writeSafe(chunk, onLost) {
+        const stdin = this.proc?.stdin;
+        if (!stdin)
+            return onLost();
+        const fail = (err) => {
+            // EPIPE/ECONNRESET when the sidecar died between checks — a lost frame
+            // must degrade the caller, never crash the host process.
+            stdin.removeListener("error", fail);
+            try {
+                stdin.destroy();
+            }
+            catch { /* already gone */ }
+            onLost();
+        };
+        stdin.once("error", fail);
+        try {
+            stdin.write(chunk, () => stdin.removeListener("error", fail));
+        }
+        catch {
+            fail(new Error("write threw"));
+        }
+    }
+    notify(method, params) {
+        if (!this.proc?.stdin)
+            return;
+        this.#writeSafe(JSON.stringify({ method, params }) + "\n", () => { });
+    }
+    async stop() {
+        const proc = this.proc;
+        if (!proc)
+            return;
+        this.proc = null;
+        await new Promise((resolve) => {
+            proc.once("exit", () => resolve());
+            proc.stdin.end();
+            setTimeout(() => {
+                proc.kill("SIGTERM");
+                setTimeout(() => proc.kill("SIGKILL"), 3000);
+            }, 3000).unref?.();
+        });
+    }
+}

package/agent-omp-sdk/dist/store/adapter.d.ts

@@ -0,0 +1,17 @@
+/** A prepared statement: run / get / all with positional params. */
+export interface SqliteStatement {
+    run(...params: unknown[]): {
+        changes: number | bigint;
+        lastInsertRowid: number | bigint;
+    };
+    get(...params: unknown[]): Record<string, unknown> | undefined;
+    all(...params: unknown[]): Record<string, unknown>[];
+}
+/** A SQLite connection, normalized across drivers. */
+export interface SqliteDb {
+    exec(sql: string): void;
+    prepare(sql: string): SqliteStatement;
+    close(): void;
+}
+/** Open a SQLite connection on whichever builtin the runtime provides. */
+export declare function openDb(path: string): SqliteDb;

package/agent-omp-sdk/dist/store/adapter.js

@@ -0,0 +1,47 @@
+/**
+ * SQLite driver adapter — one thin interface over whichever builtin the
+ * runtime ships. Bun → `bun:sqlite`; Node (≥22.5) → `node:sqlite`. The store
+ * never cares which: it sees exec / prepare→(run|get|all) / close.
+ *
+ * Both builtins load through `createRequire` (never a static ESM import) so
+ * neither `bun:` nor `node:sqlite` is resolved at module load: under Node the
+ * `bun:` branch is dead code, under Bun the `node:sqlite` branch is dead code.
+ */
+import { createRequire } from "node:module";
+const nodeRequire = createRequire(import.meta.url);
+function openNode(path) {
+    const { DatabaseSync: Driver } = nodeRequire("node:sqlite");
+    const db = new Driver(path);
+    return {
+        exec: (sql) => db.exec(sql),
+        prepare: (sql) => {
+            const statement = db.prepare(sql);
+            return {
+                run: (...params) => statement.run(...params),
+                get: (...params) => statement.get(...params),
+                all: (...params) => statement.all(...params),
+            };
+        },
+        close: () => db.close(),
+    };
+}
+function openBun(path) {
+    const { Database: Driver } = nodeRequire("bun:sqlite");
+    const db = new Driver(path, { create: true });
+    return {
+        exec: (sql) => db.exec(sql),
+        prepare: (sql) => {
+            const query = db.query(sql);
+            return {
+                run: (...params) => query.run(...params),
+                get: (...params) => query.get(...params),
+                all: (...params) => query.all(...params),
+            };
+        },
+        close: () => db.close(),
+    };
+}
+/** Open a SQLite connection on whichever builtin the runtime provides. */
+export function openDb(path) {
+    return globalThis.Bun !== undefined ? openBun(path) : openNode(path);
+}

package/agent-omp-sdk/dist/store/db.d.ts

@@ -0,0 +1,70 @@
+/** One row of the `sessions` table (snake_case, matching SQL columns 1:1). */
+export interface SessionRow {
+    omp_session_id: string;
+    dsh_session_id: string;
+    session_file: string;
+    cwd: string | null;
+    title: string | null;
+    created_at: number;
+    last_modified_at: number;
+    transcript_size: number;
+    model_provider: string | null;
+    model_id: string | null;
+    agent_preset: string | null;
+    permission_preset: string | null;
+    forked_from: string | null;
+    archived: number;
+    last_visited_at: number | null;
+}
+/** One row of the `workspaces` table. */
+export interface WorkspaceRow {
+    workspace_id: string;
+    title: string | null;
+    manual_order: string | null;
+}
+/** The fallback workspace id for sessions whose cwd is missing/corrupt (D8). */
+export declare const UNGROUPED_WORKSPACE = "ungrouped";
+export declare class BridgeStore {
+    private readonly db;
+    private constructor();
+    /** Open (WAL + schema + integrity check). Throws on a corrupt/invalid database. */
+    static open(path: string): BridgeStore;
+    close(): void;
+    private all;
+    private get;
+    private run;
+    /** All session rows, default `last_modified_at DESC`, manual mode per-workspace order. */
+    list(): SessionRow[];
+    /** All workspace rows. */
+    workspaces(): WorkspaceRow[];
+    byDshId(dshSessionId: string): SessionRow | undefined;
+    byOmpId(ompSessionId: string): SessionRow | undefined;
+    byFile(sessionFile: string): SessionRow | undefined;
+    /** Full-row upsert, keyed by `omp_session_id`. */
+    upsert(row: SessionRow): void;
+    /** Drop every row whose session file is not in `keepFiles`. */
+    prune(keepFiles: Set<string>): void;
+    /** Migration only: overwrite the DSH pairing for one OMP session. */
+    setDshId(ompSessionId: string, dshSessionId: string): void;
+    setPermissionPreset(ompSessionId: string, preset: string | null): void;
+    setArchived(dshSessionId: string, archived: boolean): void;
+    setForkedFrom(dshSessionId: string, forkedFrom: string | null): void;
+    touchVisited(dshSessionId: string, at: number): void;
+    /** Persist a workspace's manual ordering (upsert the workspace row first). */
+    setWorkspaceOrder(workspaceId: string, order: string[]): void;
+    /** Ensure the `ungrouped` sentinel workspace row exists (D8). */
+    ensureUngroupedWorkspace(): void;
+    getUiState(key: string): string | undefined;
+    setUiState(key: string, value: string): void;
+    /** The tracked OMP default model (`modelRoles.default`), or undefined when unset. */
+    getOmpDefaultModel(): {
+        provider: string;
+        model: string;
+    } | undefined;
+    /** Persist the tracked OMP default model. */
+    setOmpDefaultModel(provider: string, model: string): void;
+    /** Event-driven model update after a live model switch (D5.3). */
+    updateModel(dshSessionId: string, provider: string | null, model: string | null): void;
+    /** Event-driven stat refresh on teardown/cold transition (D5.3). */
+    updateStat(dshSessionId: string, size: number, mtimeMs: number): void;
+}

package/agent-omp-sdk/dist/store/db.js

@@ -0,0 +1,210 @@
+/**
+ * `BridgeStore` — the bridge's centralized session index over SQLite.
+ *
+ * Owns the schema, the query interface (list / byDshId / byOmpId / byFile /
+ * upsert / prune + UI setters), and the connection lifecycle (WAL, integrity
+ * check). The driver behind it is abstracted by `./adapter.js`; this class
+ * only talks to the normalized `SqliteDb` surface.
+ */
+import { openDb } from "./adapter.js";
+import { SCHEMA_SQL } from "./schema.js";
+/** The fallback workspace id for sessions whose cwd is missing/corrupt (D8). */
+export const UNGROUPED_WORKSPACE = "ungrouped";
+const SESSIONS_COLUMNS = [
+    "omp_session_id",
+    "dsh_session_id",
+    "session_file",
+    "cwd",
+    "title",
+    "created_at",
+    "last_modified_at",
+    "transcript_size",
+    "model_provider",
+    "model_id",
+    "agent_preset",
+    "permission_preset",
+    "forked_from",
+    "archived",
+    "last_visited_at",
+];
+const UPSERT_SQL = `INSERT INTO sessions (${SESSIONS_COLUMNS.join(", ")})
+VALUES (${SESSIONS_COLUMNS.map(() => "?").join(", ")})
+ON CONFLICT(omp_session_id) DO UPDATE SET
+  dsh_session_id   = excluded.dsh_session_id,
+  session_file     = excluded.session_file,
+  cwd              = excluded.cwd,
+  title            = excluded.title,
+  created_at       = excluded.created_at,
+  last_modified_at = excluded.last_modified_at,
+  transcript_size  = excluded.transcript_size,
+  model_provider   = excluded.model_provider,
+  model_id         = excluded.model_id,
+  agent_preset     = excluded.agent_preset,
+  permission_preset = excluded.permission_preset,
+  forked_from      = excluded.forked_from,
+  archived         = excluded.archived,
+  last_visited_at  = excluded.last_visited_at`;
+/** Parse a stored JSON array, failing soft to `undefined`. */
+function parseOrder(raw) {
+    if (raw === null)
+        return undefined;
+    try {
+        const value = JSON.parse(raw);
+        return Array.isArray(value) && value.every((entry) => typeof entry === "string") ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Order a flat row list per workspace under manual mode (D9). */
+function orderManual(rows, workspaces) {
+    const byCwd = new Map();
+    for (const row of rows) {
+        const key = row.cwd ?? UNGROUPED_WORKSPACE;
+        const group = byCwd.get(key);
+        if (group === undefined)
+            byCwd.set(key, [row]);
+        else
+            group.push(row);
+    }
+    const orderFor = new Map(workspaces.map((w) => [w.workspace_id, parseOrder(w.manual_order)]));
+    const ordered = [];
+    for (const [cwd, group] of byCwd) {
+        const manual = orderFor.get(cwd);
+        if (manual !== undefined && manual.length > 0) {
+            const rank = new Map(manual.map((id, index) => [id, index]));
+            group.sort((a, b) => {
+                const ai = rank.get(a.dsh_session_id) ?? Number.MAX_SAFE_INTEGER;
+                const bi = rank.get(b.dsh_session_id) ?? Number.MAX_SAFE_INTEGER;
+                return ai !== bi ? ai - bi : b.last_modified_at - a.last_modified_at;
+            });
+        }
+        else {
+            group.sort((a, b) => b.last_modified_at - a.last_modified_at);
+        }
+        ordered.push(...group);
+    }
+    return ordered;
+}
+export class BridgeStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    /** Open (WAL + schema + integrity check). Throws on a corrupt/invalid database. */
+    static open(path) {
+        const db = openDb(path);
+        db.exec("PRAGMA journal_mode=WAL");
+        db.exec(SCHEMA_SQL);
+        const check = db.prepare("PRAGMA integrity_check").all();
+        const ok = check.length === 1 && check[0]?.["integrity_check"] === "ok";
+        if (!ok) {
+            db.close();
+            throw new Error(`bridge-store integrity check failed: ${JSON.stringify(check)}`);
+        }
+        return new BridgeStore(db);
+    }
+    close() {
+        this.db.close();
+    }
+    all(sql, ...params) {
+        return this.db.prepare(sql).all(...params);
+    }
+    get(sql, ...params) {
+        return this.db.prepare(sql).get(...params);
+    }
+    run(sql, ...params) {
+        this.db.prepare(sql).run(...params);
+    }
+    /** All session rows, default `last_modified_at DESC`, manual mode per-workspace order. */
+    list() {
+        const rows = this.all("SELECT * FROM sessions ORDER BY last_modified_at DESC");
+        if (this.getUiState("sort_mode") !== "manual")
+            return rows;
+        return orderManual(rows, this.workspaces());
+    }
+    /** All workspace rows. */
+    workspaces() {
+        return this.all("SELECT * FROM workspaces");
+    }
+    byDshId(dshSessionId) {
+        return this.get("SELECT * FROM sessions WHERE dsh_session_id = ?", dshSessionId);
+    }
+    byOmpId(ompSessionId) {
+        return this.get("SELECT * FROM sessions WHERE omp_session_id = ?", ompSessionId);
+    }
+    byFile(sessionFile) {
+        return this.get("SELECT * FROM sessions WHERE session_file = ?", sessionFile);
+    }
+    /** Full-row upsert, keyed by `omp_session_id`. */
+    upsert(row) {
+        this.run(UPSERT_SQL, row.omp_session_id, row.dsh_session_id, row.session_file, row.cwd, row.title, row.created_at, row.last_modified_at, row.transcript_size, row.model_provider, row.model_id, row.agent_preset, row.permission_preset, row.forked_from, row.archived, row.last_visited_at);
+    }
+    /** Drop every row whose session file is not in `keepFiles`. */
+    prune(keepFiles) {
+        const files = this.all("SELECT session_file FROM sessions");
+        const del = this.db.prepare("DELETE FROM sessions WHERE session_file = ?");
+        for (const { session_file } of files) {
+            if (!keepFiles.has(session_file))
+                del.run(session_file);
+        }
+    }
+    /** Migration only: overwrite the DSH pairing for one OMP session. */
+    setDshId(ompSessionId, dshSessionId) {
+        this.run("UPDATE sessions SET dsh_session_id = ? WHERE omp_session_id = ?", dshSessionId, ompSessionId);
+    }
+    setPermissionPreset(ompSessionId, preset) {
+        this.run("UPDATE sessions SET permission_preset = ? WHERE omp_session_id = ?", preset, ompSessionId);
+    }
+    setArchived(dshSessionId, archived) {
+        this.run("UPDATE sessions SET archived = ? WHERE dsh_session_id = ?", archived ? 1 : 0, dshSessionId);
+    }
+    setForkedFrom(dshSessionId, forkedFrom) {
+        this.run("UPDATE sessions SET forked_from = ? WHERE dsh_session_id = ?", forkedFrom, dshSessionId);
+    }
+    touchVisited(dshSessionId, at) {
+        this.run("UPDATE sessions SET last_visited_at = ? WHERE dsh_session_id = ?", at, dshSessionId);
+    }
+    /** Persist a workspace's manual ordering (upsert the workspace row first). */
+    setWorkspaceOrder(workspaceId, order) {
+        this.run("INSERT INTO workspaces (workspace_id, title, manual_order) VALUES (?, NULL, ?) ON CONFLICT(workspace_id) DO UPDATE SET manual_order = excluded.manual_order", workspaceId, JSON.stringify(order));
+    }
+    /** Ensure the `ungrouped` sentinel workspace row exists (D8). */
+    ensureUngroupedWorkspace() {
+        this.run("INSERT INTO workspaces (workspace_id, title, manual_order) VALUES (?, NULL, NULL) ON CONFLICT(workspace_id) DO NOTHING", UNGROUPED_WORKSPACE);
+    }
+    getUiState(key) {
+        return this.get("SELECT value FROM ui_state WHERE key = ?", key)?.value ?? undefined;
+    }
+    setUiState(key, value) {
+        this.run("INSERT INTO ui_state (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value", key, value);
+    }
+    /** The tracked OMP default model (`modelRoles.default`), or undefined when unset. */
+    getOmpDefaultModel() {
+        const raw = this.getUiState("omp_default_model");
+        if (raw === undefined)
+            return undefined;
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.provider === "string" && typeof parsed.model === "string") {
+                return { provider: parsed.provider, model: parsed.model };
+            }
+        }
+        catch {
+            return undefined;
+        }
+        return undefined;
+    }
+    /** Persist the tracked OMP default model. */
+    setOmpDefaultModel(provider, model) {
+        this.setUiState("omp_default_model", JSON.stringify({ provider, model }));
+    }
+    /** Event-driven model update after a live model switch (D5.3). */
+    updateModel(dshSessionId, provider, model) {
+        this.run("UPDATE sessions SET model_provider = ?, model_id = ? WHERE dsh_session_id = ?", provider, model, dshSessionId);
+    }
+    /** Event-driven stat refresh on teardown/cold transition (D5.3). */
+    updateStat(dshSessionId, size, mtimeMs) {
+        this.run("UPDATE sessions SET transcript_size = ?, last_modified_at = ? WHERE dsh_session_id = ?", size, mtimeMs, dshSessionId);
+    }
+}

package/agent-omp-sdk/dist/store/index.d.ts

@@ -0,0 +1,23 @@
+import { BridgeStore } from "./db.js";
+/**
+ * Resolve the index path: `OMP_BRIDGE_DB` (absolute) or the profile's own
+ * state dir (`$DSH_HOME/bridge-store.sqlite`). Throws on a relative/invalid
+ * path, or one that falls inside OMP's native store (D7: OMP scans that dir
+ * and would treat the `.sqlite` as a foreign session file).
+ *
+ * `$DSH_HOME` also anchors dsh's home-level singleton settings document
+ * (`$DSH_HOME/settings.yaml`), which this bridge never reads; the profile
+ * isolates that document via its own `settings.path` patch (settings-under-
+ * profile), independent of this store.
+ */
+export declare function resolveBridgeDbPath(): string;
+/**
+ * Open the store, run the boot warm pass, then the one-time migration. The
+ * warm pass must complete before the bridge serves traffic (D5.1): the first
+ * landing already reads real titles/models from the index.
+ */
+export declare function initBridgeStore(path?: string): BridgeStore;
+/** The live store, or undefined when not initialized (tests, no DB). */
+export declare function getBridgeStore(): BridgeStore | undefined;
+/** Close and release the singleton (teardown). */
+export declare function closeBridgeStore(): void;

package/agent-omp-sdk/dist/store/index.js

@@ -0,0 +1,59 @@
+/**
+ * Bridge store lifecycle: DB path resolution, open/close, and the module
+ * singleton the rest of the bridge reaches through {@link getBridgeStore}.
+ */
+import { mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { OMP_SESSIONS_ROOT } from "../omp-store.js";
+import { BridgeStore } from "./db.js";
+import { prepareIndex } from "./reconcile.js";
+let store;
+/**
+ * Resolve the index path: `OMP_BRIDGE_DB` (absolute) or the profile's own
+ * state dir (`$DSH_HOME/bridge-store.sqlite`). Throws on a relative/invalid
+ * path, or one that falls inside OMP's native store (D7: OMP scans that dir
+ * and would treat the `.sqlite` as a foreign session file).
+ *
+ * `$DSH_HOME` also anchors dsh's home-level singleton settings document
+ * (`$DSH_HOME/settings.yaml`), which this bridge never reads; the profile
+ * isolates that document via its own `settings.path` patch (settings-under-
+ * profile), independent of this store.
+ */
+export function resolveBridgeDbPath() {
+    const explicit = process.env.OMP_BRIDGE_DB;
+    if (explicit !== undefined && explicit !== "" && !explicit.startsWith("/")) {
+        throw new Error(`OMP_BRIDGE_DB must be an absolute path: ${explicit}`);
+    }
+    const path = resolve(explicit !== undefined && explicit !== ""
+        ? explicit
+        : join(process.env.DSH_HOME ?? join(homedir(), ".omp", "dsh"), "bridge-store.sqlite"));
+    const root = resolve(OMP_SESSIONS_ROOT);
+    if (path === root || path.startsWith(`${root}/`)) {
+        throw new Error(`bridge store must not live under OMP_SESSIONS_ROOT (${root}): ${path}`);
+    }
+    return path;
+}
+/**
+ * Open the store, run the boot warm pass, then the one-time migration. The
+ * warm pass must complete before the bridge serves traffic (D5.1): the first
+ * landing already reads real titles/models from the index.
+ */
+export function initBridgeStore(path) {
+    if (store !== undefined)
+        return store;
+    const dbPath = path ?? resolveBridgeDbPath();
+    mkdirSync(dirname(dbPath), { recursive: true });
+    store = BridgeStore.open(dbPath);
+    prepareIndex(store);
+    return store;
+}
+/** The live store, or undefined when not initialized (tests, no DB). */
+export function getBridgeStore() {
+    return store;
+}
+/** Close and release the singleton (teardown). */
+export function closeBridgeStore() {
+    store?.close();
+    store = undefined;
+}

package/agent-omp-sdk/dist/store/reconcile.d.ts

@@ -0,0 +1,15 @@
+import type { BridgeStore } from "./db.js";
+/**
+ * Boot the index before anything reads session state: ensure the ungrouped
+ * fallback workspace exists. Idempotent.
+ */
+export declare function prepareIndex(store: BridgeStore): void;
+/** Event-driven INSERT at first spawn: record the identity mapping + preset. */
+export declare function upsertCreated(store: BridgeStore, input: {
+    ompSessionId: string;
+    sessionFile: string;
+    dshSessionId: string;
+    cwd?: string;
+    preset?: string;
+    createdAt?: number;
+}): void;