super-dsh 0.1.0 → 0.1.2

package/agent-omp/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/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/dist/store/reconcile.js

@@ -0,0 +1,51 @@
+/**
+ * Bridge session index — dsh↔omp identity mapping only.
+ *
+ * dsh-shape-session-log: the index is no longer a mirror of OMP's native
+ * store. The dsh session log is of record, and this index holds ONLY the
+ * `dsh_session_id ↔ omp_session_id ↔ session_file` mapping written at first
+ * spawn (plus the workspace-attach source for the UI). The union-era OMP-store
+ * scan, stat reconcile, prune, and the webui.json migration are all retired:
+ * pruning by an OMP-store scan deleted these mappings and broke resume.
+ */
+import { statSync } from "node:fs";
+/**
+ * Boot the index before anything reads session state: ensure the ungrouped
+ * fallback workspace exists. Idempotent.
+ */
+export function prepareIndex(store) {
+    store.ensureUngroupedWorkspace();
+}
+/** Event-driven INSERT at first spawn: record the identity mapping + preset. */
+export function upsertCreated(store, input) {
+    let size = 0;
+    let mtimeMs = Date.now();
+    try {
+        const stat = statSync(input.sessionFile);
+        size = stat.size;
+        mtimeMs = stat.mtimeMs;
+    }
+    catch {
+        // File not yet flushable — the next boot pass fills stat lazily.
+    }
+    store.upsert({
+        omp_session_id: input.ompSessionId,
+        dsh_session_id: input.dshSessionId,
+        session_file: input.sessionFile,
+        cwd: input.cwd ?? null,
+        title: null,
+        // v2 header identity: the row's created_at MUST equal the live session
+        // header's createdAt, or session-query's cross-observation header check
+        // (assertSessionHeadersCompatible) throws SOURCE_CONFLICT for the id.
+        created_at: input.createdAt ?? Date.now(),
+        last_modified_at: mtimeMs,
+        transcript_size: size,
+        model_provider: null,
+        model_id: null,
+        agent_preset: "omp",
+        permission_preset: input.preset ?? null,
+        forked_from: null,
+        archived: 0,
+        last_visited_at: null,
+    });
+}

package/agent-omp/dist/store/schema.js

@@ -0,0 +1,40 @@
+/**
+ * SQLite schema for the bridge's centralized session index.
+ *
+ * One `sessions` table carries mapping + metadata + UI fields 1:1 (D2); two
+ * aux tables carry workspace grouping/ordering and singleton UI state. The
+ * schema is idempotent (`IF NOT EXISTS`), applied on every open.
+ */
+export const SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS sessions (
+  omp_session_id    TEXT PRIMARY KEY,           -- OMP uuidv7 (session header id)
+  dsh_session_id    TEXT NOT NULL UNIQUE,       -- DSH-facing id (real or derived)
+  session_file      TEXT NOT NULL UNIQUE,       -- transcript absolute path
+  cwd               TEXT,                       -- working directory (NULL → ungrouped)
+  title             TEXT,                       -- display title (latest wins)
+  created_at        INTEGER NOT NULL,           -- epoch ms
+  last_modified_at  INTEGER NOT NULL,           -- transcript mtime (default sort key)
+  transcript_size   INTEGER NOT NULL,           -- bytes (reconcile change detection)
+  model_provider    TEXT,                       -- last model provider (complete, D6)
+  model_id          TEXT,                       -- last model id
+  agent_preset      TEXT,                       -- DSH composition id (always "omp")
+  permission_preset TEXT,                       -- approval preset (danger-full-access/workspace-write/read-only)
+  forked_from       TEXT,                       -- fork source dsh_session_id (NULL = not a fork)
+  archived          INTEGER NOT NULL DEFAULT 0, -- archive flag (default list excludes)
+  last_visited_at   INTEGER                     -- last view epoch ms (refresh priority, D10)
+);
+CREATE INDEX IF NOT EXISTS sessions_cwd   ON sessions(cwd);
+CREATE INDEX IF NOT EXISTS sessions_mtime ON sessions(last_modified_at DESC);
+CREATE INDEX IF NOT EXISTS sessions_visit ON sessions(last_visited_at DESC);
+
+CREATE TABLE IF NOT EXISTS workspaces (
+  workspace_id  TEXT PRIMARY KEY,               -- = cwd path; 'ungrouped' sentinel (D8)
+  title         TEXT,
+  manual_order  TEXT                            -- JSON array of dsh_session_id (manual mode, D9)
+);
+
+CREATE TABLE IF NOT EXISTS ui_state (
+  key   TEXT PRIMARY KEY,
+  value TEXT                                    -- e.g. sort_mode = 'last_updated' | 'manual'
+);
+`;

package/agent-omp/dist/world-plugin.js

@@ -0,0 +1,96 @@
+/**
+ * aw.agent-adapter-omp — the adapter's world plugin (spec S2): activation IS
+ * roster membership.
+ *
+ * AW-B (DL1–DL5): the world is spawned as a sibling ROOT context with NO
+ * listener (see `worldMountPatches`) and mounts itself under `/<label>` through
+ * the hub:
+ *
+ *   1. ctx0 publishes the host mount (real webServer instance) before spawn.
+ *   2. the world's entry row provides the virtual `webServer` in the world root,
+ *      translating every route its plugins declare into `/<label>+path`.
+ *   3. the hub's carrier answers `/<label>/api` + `/<label>/api/remote.mux` in
+ *      ctx0's auth domain and dispatches into this world's gateway instance.
+ */
+import { mkdirSync } from 'node:fs';
+import { resolveDshHome } from '@deepseek-ai/dsh-home-paths';
+import { join } from 'node:path';
+import { spawnWorld, registerAgent, setReady, registerForeignTarget, registerHostMount, mountWorld, worldMountPatches, provisionWorldProfile, } from '../../agent-hub/dist/index.js';
+export const name = 'aw.agent-adapter-omp';
+/** Runtime key — also the mount label. */
+const KEY = 'omp';
+const ANCHOR = process.env.SUPERD_DSH_ANCHOR
+    ?? '/home/u1/.local/lib/node_modules/@deepseek-ai/dsh/package.json';
+export function apply(ctx) {
+    registerAgent({ key: KEY, label: 'OMP', ready: false });
+    // Harness resolver (env → ~/.dsh): a consumer install has no DSH_HOME and
+    // no cwd contract — deriving the world root from cwd spawns worlds into a
+    // garbage tree or throws inside apply() and kills the whole host boot.
+    const root = resolveDshHome();
+    // S7 nested home: every runtime owns one root under `agents/<label>`, and the
+    // world's DSH data lives INSIDE it (sessions / settings / workspaces), so no
+    // two runtimes ever share a session list. The foreign app's own store sits in
+    // the same root (adapter-owned app home, see AW-C0).
+    const worldHome = join(root, 'agents', KEY);
+    mkdirSync(join(worldHome, 'profiles'), { recursive: true });
+    // Publish story: a foreign install has no line bootstrap, so the nested
+    // profile + @pgmi-builds links are provisioned HERE (idempotent; dev lines
+    // keep parity — smoke.mjs wrote the same layout, and AW_BARE_BASE still
+    // overrides the resolved base).
+    const bareBase = provisionWorldProfile({
+        key: KEY,
+        adapterPkg: '@pgmi-builds/agent-adapter-omp',
+        worldHome,
+    });
+    const world = (async () => {
+        // Wait for ctx0's listening stack: the mount needs the real webServer and
+        // the browser-trust fence from the live connection service.
+        const host = await new Promise((resolve) => {
+            ctx.inject(['webServer', 'connection'], (hostCtx) => { resolve(hostCtx); });
+        });
+        const real = host['webServer'];
+        const connection = host['connection'];
+        const dropHostMount = registerHostMount({
+            key: KEY,
+            labelPath: `/${KEY}`,
+            real,
+            // ctx0's index gate, applied by the mount to this world's pages and assets:
+            // the world is reached in-ctx and owns no listener, so ctx0 decides auth.
+            authorize: (req, res) => connection.authorizeIndex(req, res),
+        });
+        const ctxW = await spawnWorld({
+            appName: `aw-${KEY}`,
+            profileName: 'web',
+            installAnchor: ANCHOR,
+            home: worldHome,
+            dataHome: worldHome,
+            // Adapter-local bundle names resolve from the profile's own
+            // node_modules (heal owns @deepseek-ai there; @pgmi-builds links are
+            // provisioned by provisionWorldProfile above, or by the line bootstrap
+            // when the adapter package was not resolvable — env wins over both).
+            bareModuleBaseUrl: process.env.AW_BARE_BASE ?? bareBase ?? undefined,
+            extraPatches: worldMountPatches(KEY),
+        });
+        const gateway = ctxW.get('typertGateway');
+        registerForeignTarget({ key: KEY, gateway });
+        const mounted = mountWorld({
+            real,
+            label: KEY,
+            gateway,
+            requestRejection: (request) => connection
+                .requestRejection(request),
+        });
+        setReady(KEY, true);
+        ctx.effect?.(() => () => {
+            mounted.dispose();
+            dropHostMount();
+        }, `aw.agent-adapter-${KEY}: mount`);
+        return ctxW;
+    })().catch((cause) => {
+        // A failed world degrades to a not-ready roster row; a rejected provided
+        // promise would fail the entire host boot (loader entry apply).
+        console.error(`[super-dsh] ${KEY} world failed:`, cause);
+        return null;
+    });
+    ctx.provide(`aw.world.${KEY}`, world);
+}

package/agent-omp/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@pgmi-builds/agent-adapter-omp",
+  "version": "0.1.0",
+  "description": "OMP Web: OMP provider for DeepSeek Harness (dsh) — an AgentFactory that embeds OMP via the @oh-my-pi/pi-coding-agent SDK (Bun sidecar) and bridges OMP's session surface into Dash Agent/Session contracts.",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./client": "./lib/client/index.js",
+    "./world": "./dist/world-plugin.js"
+  },
+  "files": [
+    "dist",
+    "lib",
+    "sidecar",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout"
+      ],
+      "platform": "web"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build-client": "tsx scripts/build-client.ts",
+    "test": "node --test test/*.test.mjs"
+  },
+  "dependencies": {
+    "@oh-my-pi/pi-coding-agent": "^18.1.14",
+    "bun": "^1.4.2",
+    "@pgmi-builds/agent-hub": "file:../agent-hub"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-agent-presets": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-llm": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-scope": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-session-persistence": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-typert-protocol": "0.1.5-rc.2",
+    "@deepseek-ai/dsh-home-paths": "0.1.5-rc.2"
+  },
+  "peerDependenciesMeta": {
+    "@deepseek-ai/cordis": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-agent-presets": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-llm": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-scope": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-session-persistence": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-typert-protocol": {
+      "optional": true
+    },
+    "@deepseek-ai/dsh-home-paths": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/node": "^26.2.0",
+    "tsdown": "^0.15.12",
+    "tsx": "^4.23.13",
+    "typescript": "^5.6.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "main": "dist/index.js",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pgmi-builds/omp-web.git"
+  },
+  "engines": {
+    "node": ">=22.18"
+  }
+}