super-dsh 0.1.0 → 0.1.2

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

@@ -0,0 +1,518 @@
+/**
+ * Read-only scanner over OMP's native session store
+ * (`$OMP_HOME/agent/sessions/<cwd-dashed>/<timestamp>_<uuid>.jsonl`).
+ *
+ * OMP owns the transcript format; this module extracts only what the Dash
+ * surfaces need per session — identity, cwd, creation time, and a display
+ * title — by reading a bounded HEAD of each JSONL file (never the full
+ * transcript). Parsed entries are memoized per file keyed on (size, mtime),
+ * so repeated `list()` calls re-stat but re-parse only changed files.
+ */
+import { closeSync, openSync, readFileSync, readSync, readdirSync, readlinkSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+import { OMP_NATIVE_HOME, resolveOmpNativeHome } from "./knobs.js";
+/** Root of OMP's native session store. */
+export const OMP_SESSIONS_ROOT = process.env.OMP_SESSIONS_ROOT ?? join(OMP_NATIVE_HOME, "agent", "sessions");
+/** How many head bytes of one session file the scanner will read. */
+const HEAD_BUDGET_BYTES = 256 * 1024;
+/** Title fallback budget (characters of the first user message). */
+const FALLBACK_TITLE_CHARS = 80;
+/** Memoized parse results, keyed by session file path. */
+const entryCache = new Map();
+/** Epoch ms from a `<YYYY>-<MM>-<DD>T<HH>-<MM>-<SS>-<mmm>Z` filename prefix. */
+function createdAtFromFileName(name) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})-(\d{3})Z_/.exec(name);
+    if (match === null)
+        return undefined;
+    const [year, month, day, hour, minute, second, ms] = match.slice(1).map(Number);
+    const epoch = Date.UTC(year, month - 1, day, hour, minute, second, ms);
+    return Number.isSafeInteger(epoch) ? epoch : undefined;
+}
+/** One normalized display-title fallback from a first user message. */
+function fallbackTitle(text) {
+    const firstLine = text.split("\n", 1)[0] ?? "";
+    const collapsed = firstLine.replaceAll(/\s+/gu, " ").trim();
+    return collapsed.length === 0 ? undefined : collapsed.slice(0, FALLBACK_TITLE_CHARS);
+}
+/**
+ * Read one OMP session transcript in a single pass, extracting both the
+ * `message` records and the `model_change` records.
+ */
+export function readOmpTranscript(path) {
+    const messages = [];
+    const modelChanges = [];
+    let buffer;
+    try {
+        buffer = readFileSync(path, "utf8");
+    }
+    catch {
+        return { messages, modelChanges };
+    }
+    for (const line of buffer.split("\n")) {
+        if (line === "")
+            continue;
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (record === null || typeof record !== "object")
+            continue;
+        const rec = record;
+        if (rec["type"] === "message") {
+            const message = rec["message"];
+            if (message === null || typeof message !== "object")
+                continue;
+            const msg = message;
+            const role = msg["role"];
+            if (role !== "user" && role !== "assistant" && role !== "toolResult")
+                continue;
+            messages.push({ ...msg, role });
+        }
+        else if (rec["type"] === "model_change") {
+            const model = rec["model"];
+            if (typeof model !== "string" || model === "")
+                continue;
+            modelChanges.push({ model, role: typeof rec["role"] === "string" ? rec["role"] : undefined });
+        }
+    }
+    return { messages, modelChanges };
+}
+/**
+ * Legacy fallback: the last assistant message that names a provider/model
+ * pair. Used only for transcripts without any `model_change` record; newer
+ * sessions derive their resume model from {@link lastRestorableModel}.
+ */
+export function lastModelCall(messages) {
+    for (let index = messages.length - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message.role !== "assistant")
+            continue;
+        const provider = typeof message.provider === "string" ? message.provider : "";
+        const model = typeof message.model === "string" ? message.model : "";
+        if (provider !== "" && model !== "")
+            return { provider, model };
+    }
+    return undefined;
+}
+/** Split a `provider/model[:variant]` selector into provider/model, dropping the variant suffix. */
+export function parseSelector(selector) {
+    if (selector === undefined)
+        return undefined;
+    const slash = selector.indexOf("/");
+    if (slash <= 0)
+        return undefined;
+    let model = selector.slice(slash + 1);
+    const colon = model.indexOf(":");
+    if (colon > 0)
+        model = model.slice(0, colon);
+    return { provider: selector.slice(0, slash), model };
+}
+/**
+ * The model OMP restores on `--resume`: the last non-fallback `model_change`.
+ * Mirrors OMP's `getRestorableSessionModels` (`session-context.ts`): a
+ * fallback switch is recorded under `role:"fallback"` (EPHEMERAL) and never
+ * restores — the last such switch falls back to the role's primary.
+ */
+export function lastRestorableModel(modelChanges) {
+    const models = {};
+    let lastRole;
+    for (const change of modelChanges) {
+        const role = change.role ?? "default";
+        models[role] = change.model;
+        lastRole = change.role;
+    }
+    const selector = lastRole === undefined || lastRole === "default" || lastRole === "fallback"
+        ? models["default"]
+        : (models[lastRole] ?? models["default"]);
+    return parseSelector(selector);
+}
+/**
+ * Path to OMP's per-user agent config (`<OMP_NATIVE_HOME>/agent/config.yml`).
+ *
+ * This is the OMP layer's own config, distinct from dsh's settings layer:
+ * upstream dsh keeps a home-level singleton settings document
+ * (`$DSH_HOME/settings.yaml`); the profile only composes bundles and has no
+ * per-profile settings isolation of its own. This bridge never reads that
+ * settings.yaml — OMP data lives under OMP_NATIVE_HOME, and the bridge's own
+ * index under `$DSH_HOME/bridge-store.sqlite` (see store/index.ts).
+ */
+function ompConfigPath() {
+    // Per-call resolution (not the frozen knob const) so tests can inject the
+    // native root via OMP_NATIVE_HOME at any time.
+    return join(resolveOmpNativeHome(), "agent", "config.yml");
+}
+/**
+ * Read the whole `modelRoles` map (role → "provider/model[:effort]") from
+ * OMP's config.yml. Returns undefined when the block is absent/empty or the
+ * file is unreadable. A deliberately minimal YAML scan — the bridge has no
+ * YAML dependency; one indent level of `key: value` lines inside the block.
+ */
+export function readOmpModelRolesFromConfig() {
+    let text;
+    try {
+        text = readFileSync(ompConfigPath(), "utf8");
+    }
+    catch {
+        return undefined;
+    }
+    const roles = {};
+    let inModelRoles = false;
+    for (const line of text.split("\n")) {
+        if (/^modelRoles:\s*$/.test(line)) {
+            inModelRoles = true;
+            continue;
+        }
+        if (!inModelRoles)
+            continue;
+        if (line !== "" && !/^\s/.test(line))
+            break; // left the modelRoles block
+        const match = /^\s*([A-Za-z0-9_-]+):\s*(\S+)\s*$/.exec(line);
+        if (match !== null)
+            roles[match[1]] = match[2];
+    }
+    return Object.keys(roles).length > 0 ? roles : undefined;
+}
+/**
+ * Read the configured default role model (`modelRoles.default`) from OMP's
+ * config.yml. Returns the provider/model pair (variant suffix dropped), or
+ * undefined when unset or unreadable. Delegates to the whole-map reader.
+ */
+export function readOmpDefaultModelFromConfig() {
+    const def = readOmpModelRolesFromConfig()?.default;
+    return def === undefined ? undefined : parseSelector(def);
+}
+/**
+ * Derive the working directory a session ran in from its location in OMP's
+ * store: the parent directory name is the cwd with every "/" flattened to
+ * "-" (leading "/" → leading "-"). Literal dashes in path segments are
+ * ambiguous, so segments are re-joined greedily longest-first against the
+ * filesystem and the candidate is accepted only as an existing directory
+ * (realpath'd). This is the trusted resume cwd — the omp-sessions.json
+ * mapping's verbatim `cwd` is user-writable and never consulted.
+ */
+export function cwdFromSessionFile(path) {
+    const dashed = basename(dirname(path));
+    if (!dashed.startsWith("-"))
+        return undefined;
+    const tokens = dashed.slice(1).split("-").filter((token) => token !== "");
+    if (tokens.length === 0)
+        return undefined;
+    // OMP flattens the cwd's "/" separators to "-"; home-relative cwds lose
+    // their "~/" prefix entirely ("-workspaces-x" ≡ ~/workspaces/x), absolute
+    // ones keep the leading slash ("-tmp-x" ≡ /tmp/x). Try the absolute base
+    // first, then home; literal dashes in segment names are ambiguous, so each
+    // walk consumes the LONGEST run of remaining tokens that names an existing
+    // directory (dash-joined), which resolves the common cases exactly.
+    for (const base of ["/", homedir()]) {
+        let current = base === "/" ? "" : base;
+        let consumed = 0;
+        let complete = true;
+        while (consumed < tokens.length) {
+            let stepped = false;
+            for (let take = tokens.length - consumed; take >= 1; take--) {
+                const candidate = `${current}/${tokens.slice(consumed, consumed + take).join("-")}`;
+                try {
+                    if (!statSync(candidate).isDirectory())
+                        continue;
+                }
+                catch {
+                    continue;
+                }
+                current = candidate;
+                consumed += take;
+                stepped = true;
+                break;
+            }
+            if (!stepped) {
+                complete = false;
+                break;
+            }
+        }
+        if (complete) {
+            try {
+                return realpathSync(current);
+            }
+            catch {
+                // try the next base
+            }
+        }
+    }
+    return undefined;
+}
+/** Parse the interesting head records of one OMP session file. */
+function scanHead(path) {
+    const out = {};
+    let buffer = "";
+    let remaining = HEAD_BUDGET_BYTES;
+    const chunks = [];
+    const fd = openSync(path, "r");
+    try {
+        while (remaining > 0) {
+            const chunk = Buffer.allocUnsafe(Math.min(remaining, 64 * 1024));
+            const read = readSync(fd, chunk, 0, chunk.length, null);
+            if (read === 0)
+                break;
+            chunks.push(chunk.subarray(0, read));
+            remaining -= read;
+        }
+    }
+    finally {
+        closeSync(fd);
+    }
+    buffer = Buffer.concat(chunks).toString("utf8");
+    for (const line of buffer.split("\n")) {
+        let record;
+        try {
+            record = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (record === null || typeof record !== "object")
+            continue;
+        const rec = record;
+        if (rec["type"] === "title" || rec["type"] === "title_change") {
+            // Latest wins: OMP renames titles over a session's life (replans), and
+            // the scan must surface the name the TUI shows today, not the first.
+            const title = rec["title"];
+            if (typeof title === "string" && title.trim().length > 0)
+                out.title = title.trim();
+        }
+        else if (rec["type"] === "session" && out.ompSessionId === undefined) {
+            const id = rec["id"];
+            const timestamp = rec["timestamp"];
+            const cwd = rec["cwd"];
+            if (typeof id === "string" && id.length > 0)
+                out.ompSessionId = id;
+            if (typeof timestamp === "string") {
+                const epoch = Date.parse(timestamp);
+                if (Number.isSafeInteger(epoch))
+                    out.createdAt = epoch;
+            }
+            if (typeof cwd === "string" && cwd.length > 0)
+                out.cwd = cwd;
+        }
+        else if (rec["type"] === "message" && out.firstUserText === undefined) {
+            const message = rec["message"];
+            if (message === null || typeof message !== "object")
+                continue;
+            const msg = message;
+            if (msg["role"] !== "user" || (msg["attribution"] !== undefined && msg["attribution"] !== "user"))
+                continue;
+            const content = msg["content"];
+            if (!Array.isArray(content))
+                continue;
+            for (const block of content) {
+                if (block === null || typeof block !== "object")
+                    continue;
+                const b = block;
+                if (b["type"] === "text" && typeof b["text"] === "string" && b["text"].trim().length > 0) {
+                    out.firstUserText = b["text"];
+                    break;
+                }
+            }
+        }
+    }
+    return out;
+}
+/** Read one session file's header id (the `session` record's `id`), no full scan. */
+export function sessionHeaderId(path) {
+    return scanHead(path).ompSessionId;
+}
+/**
+
+/**
+ * Scan OMP's native store (PURE DISK — sidecar-free). Returns sessions keyed
+ * by OMP session id; files without a parsable `session` header record are
+ * skipped (corrupt/foreign).
+ *
+ * The FILE LIST always comes from a fresh directory walk; per-session metadata
+ * (id/cwd/title/createdAt) comes from the self-written {@link scanHead},
+ * memoized by size+mtime in `entryCache`. The old SDK `sessions.listAll` fast
+ * path is GONE (sidecar-decoupling): the only consumer left is pairing.ts's
+ * store-absent fallback (unit tests).
+ */
+export function scanOmpSessions() {
+    const sessions = new Map();
+    let workspaceDirs;
+    try {
+        workspaceDirs = readdirSync(OMP_SESSIONS_ROOT, { withFileTypes: true })
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+    }
+    catch {
+        return sessions;
+    }
+    for (const dirName of workspaceDirs) {
+        let files;
+        try {
+            files = readdirSync(join(OMP_SESSIONS_ROOT, dirName));
+        }
+        catch {
+            continue;
+        }
+        for (const fileName of files) {
+            if (!fileName.endsWith(".jsonl"))
+                continue;
+            const path = join(OMP_SESSIONS_ROOT, dirName, fileName);
+            let size;
+            let mtimeMs;
+            try {
+                const stats = statSync(path);
+                size = stats.size;
+                mtimeMs = stats.mtimeMs;
+            }
+            catch {
+                entryCache.delete(path);
+                continue;
+            }
+            let cached = entryCache.get(path);
+            if (cached === undefined || cached.size !== size || cached.mtimeMs !== mtimeMs) {
+                const head = scanHead(path);
+                const parsed = head.ompSessionId === undefined
+                    ? undefined
+                    : {
+                        ompSessionId: head.ompSessionId,
+                        ompSessionFile: path,
+                        size,
+                        mtimeMs,
+                        ...(head.cwd === undefined ? {} : { cwd: head.cwd }),
+                        createdAt: head.createdAt ?? createdAtFromFileName(fileName) ?? 0,
+                        ...(head.title !== undefined
+                            ? { title: head.title }
+                            : head.firstUserText !== undefined
+                                ? { title: fallbackTitle(head.firstUserText) }
+                                : {}),
+                        revision: `omp:${size}:${mtimeMs}`,
+                    };
+                cached = { size, mtimeMs, entry: parsed };
+                entryCache.set(path, cached);
+            }
+            const entry = cached.entry;
+            if (entry !== undefined && !sessions.has(entry.ompSessionId)) {
+                sessions.set(entry.ompSessionId, entry);
+            }
+        }
+    }
+    return sessions;
+}
+/** Parent pid of a process, from `/proc/<pid>/stat` (undefined when unreadable). */
+function parentPid(pid) {
+    try {
+        const stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+        // The comm field may contain spaces and parens; fields resume after the LAST ')'.
+        const tail = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+        const ppid = Number.parseInt(tail[1] ?? "", 10);
+        return Number.isNaN(ppid) ? undefined : ppid;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Whether `pid` sits anywhere below `ancestor` in the process tree. */
+function isDescendantOf(pid, ancestor) {
+    let current = pid;
+    for (let hop = 0; hop < 32; hop += 1) {
+        if (current === ancestor)
+            return true;
+        const parent = parentPid(current);
+        if (parent === undefined || parent <= 1)
+            return false;
+        current = parent;
+    }
+    return false;
+}
+/**
+ * One /proc pass over every foreign process's write-mode file descriptors,
+ * returning `canonical path → first foreign writer pid`. Shared by every
+ * session in one tick so the daemon never re-scans /proc per file.
+ *
+ * OMP has no session-level exclusivity: neither the TUI nor `--mode rpc`
+ * locks its transcript, so two live writers interleave appends silently
+ * (verified: a TUI `omp` and a bridge `omp --mode rpc --resume` coexisted on
+ * one file with plain `w` descriptors and no advisory locks). The bridge
+ * therefore refuses to resume a transcript another process already writes —
+ * the TUI case — closing the split-brain at the only layer that can see it.
+ * Own descendants (a just-torn-down bridge child whose fds linger) are
+ * exempt to keep teardown races from wedging re-resume.
+ */
+export function scanForeignWriters() {
+    const holders = new Map();
+    let procEntries;
+    try {
+        procEntries = readdirSync("/proc");
+    }
+    catch {
+        return holders;
+    }
+    const self = process.pid;
+    for (const entry of procEntries) {
+        if (!/^[0-9]+$/.test(entry))
+            continue;
+        const pid = Number.parseInt(entry, 10);
+        if (pid === self || isDescendantOf(pid, self))
+            continue;
+        let fds;
+        try {
+            fds = readdirSync(`/proc/${entry}/fd`);
+        }
+        catch {
+            continue;
+        }
+        for (const fd of fds) {
+            let target;
+            try {
+                target = readlinkSync(`/proc/${entry}/fd/${fd}`);
+            }
+            catch {
+                continue;
+            }
+            // Non-path targets (socket:[…], pipe:[…], anon_inode:[…]) can never be a session file.
+            if (!target.startsWith("/"))
+                continue;
+            let flags;
+            try {
+                const info = readFileSync(`/proc/${entry}/fdinfo/${fd}`, "utf8");
+                const flagLine = info.split("\n").find((line) => line.startsWith("flags:"));
+                const raw = flagLine?.split(":")[1]?.trim();
+                flags = raw === undefined ? undefined : Number.parseInt(raw, 8);
+            }
+            catch {
+                continue;
+            }
+            if (flags === undefined || Number.isNaN(flags))
+                continue;
+            if ((flags & 0b11) === 0)
+                continue; // neither O_WRONLY nor O_RDWR
+            let canonical;
+            try {
+                canonical = realpathSync(target);
+            }
+            catch {
+                continue;
+            }
+            if (!holders.has(canonical))
+                holders.set(canonical, pid);
+        }
+    }
+    return holders;
+}
+/**
+ * Pid of a FOREIGN process holding `file` open for writing, if any.
+ * Convenience wrapper over {@link scanForeignWriters} for the single-file
+ * resume gate; the supervisor uses the shared collector directly per tick.
+ */
+export function foreignWriterPid(file) {
+    let canonical;
+    try {
+        canonical = realpathSync(file);
+    }
+    catch {
+        return undefined;
+    }
+    return scanForeignWriters().get(canonical);
+}

package/agent-omp/dist/pairing.js

@@ -0,0 +1,45 @@
+/**
+ * Dash↔OMP session id pairing, backed by the centralized index (DB).
+ *
+ * The index is the sole pairing authority (D3): bridge-created sessions carry
+ * their real Dash id (migrated from webui.json or written at createAgent);
+ * every other OMP session gets a deterministic derived id (`session-` + the
+ * OMP uuidv7, whose version nibble 7 ≠ 4 keeps it collision-free against
+ * apiproxy-minted ids). All id translation is now an O(1) indexed lookup —
+ * no webui.json read/write, no full-store scan.
+ */
+import { getBridgeStore } from "./store/index.js";
+import { scanOmpSessions } from "./omp-store.js";
+/** The Dash-format prefix apiproxy mints; derived ids reuse it verbatim. */
+const DASH_PREFIX = "session-";
+/** Reconstruct a scanned-entry-shaped view from an index row. */
+function rowToEntry(row) {
+    return {
+        ompSessionId: row.omp_session_id,
+        ompSessionFile: row.session_file,
+        ...(row.cwd === null ? {} : { cwd: row.cwd }),
+        createdAt: row.created_at,
+        ...(row.title === null ? {} : { title: row.title }),
+        size: row.transcript_size,
+        mtimeMs: row.last_modified_at,
+        revision: `omp:${row.transcript_size}:${row.last_modified_at}`,
+    };
+}
+/**
+ * Resolve an id from the Dash side back to its session entry. Indexed lookup
+ * (byDshId / byOmpId) — never a full scan. Falls back to the scanner only
+ * when the store is absent (unit tests running the supervisor in isolation).
+ */
+export function resolveEntryById(id) {
+    const store = getBridgeStore();
+    if (store !== undefined) {
+        const row = id.startsWith(DASH_PREFIX) ? store.byDshId(id) : store.byOmpId(id);
+        return row === undefined ? undefined : rowToEntry(row);
+    }
+    if (id.startsWith(DASH_PREFIX)) {
+        const stripped = id.slice(DASH_PREFIX.length);
+        const direct = scanOmpSessions().get(stripped);
+        return direct;
+    }
+    return scanOmpSessions().get(id);
+}

package/agent-omp/dist/permission.js

@@ -0,0 +1,96 @@
+/**
+ * Dash permission preset ↔ OMP approval mode.
+ *
+ * OMP has no runtime approval control: `--approval-mode` is a launch flag, no
+ * RPC changes it mid-session. Dash's 3-way permission preset is therefore
+ * resolved once, when the OMP child is spawned, and mapped explicitly:
+ *
+ *   danger-full-access → `--approval-mode yolo`   (OMP's own native default)
+ *   workspace-write    → `--approval-mode write`
+ *   read-only          → `--approval-mode always-ask`
+ *   no explicit preset → yolo (native default)
+ *
+ * `OMP_APPROVAL_MODE` (a valid mode) overrides the mapping — headless test
+ * runs pin the flag without composing a preset default.
+ *
+ * The preset is a Dash-side session fact OMP never records. It now lives in
+ * the centralized index (`sessions.permission_preset`), seeded once from the
+ * legacy per-session webui.json by the migration; webui.json stays on disk
+ * but is never read or written again (D3).
+ */
+import { dirname, join } from "node:path";
+/** The approval modes OMP actually implements (unknown modes degrade to yolo). */
+const APPROVAL_MODES = ["write", "always-ask", "yolo"];
+/** The Dash preset table (mirrors the base bundle's permission plugin config). */
+const PRESETS = {
+    "danger-full-access": { sandbox: "danger-full-access", approval: "never", ompMode: "yolo" },
+    "workspace-write": { sandbox: "workspace-write", approval: "ask", ompMode: "write" },
+    "read-only": { sandbox: "read-only", approval: "ask", ompMode: "always-ask" },
+};
+/** Narrow an untrusted value to a known preset name. */
+export function isPresetName(raw) {
+    return typeof raw === "string" && Object.hasOwn(PRESETS, raw);
+}
+/**
+ * `OMP_APPROVAL_MODE` when it names a mode OMP implements, else undefined.
+ * An invalid value is IGNORED (the preset mapping applies) — the old
+ * fall-back-to-`write` behavior silently downgraded from OMP's native yolo.
+ */
+export function envApprovalMode() {
+    const raw = process.env.OMP_APPROVAL_MODE;
+    return raw !== undefined && APPROVAL_MODES.includes(raw) ? raw : undefined;
+}
+/** Map a preset onto OMP's `--approval-mode` flag value; no preset → yolo. */
+export function ompApprovalMode(preset) {
+    return isPresetName(preset) ? PRESETS[preset].ompMode : "yolo";
+}
+/**
+ * The default preset for FUTURE sessions, as the permission service
+ * resolves it (settings-backed; the profile patch pins the base default).
+ * Undefined when the service is absent or its getter fails — callers fall
+ * back to OMP's native default.
+ */
+export function defaultPermissionPreset(ctx) {
+    const service = ctx.get("permissionPresets");
+    if (service === undefined)
+        return undefined;
+    try {
+        const preset = service.defaultPreset;
+        return isPresetName(preset) ? preset : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The session's effective preset: the last `permission/preset` event. */
+export function presetFromEvents(events) {
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        if (event.type === "permission/preset" && isPresetName(event.data?.preset))
+            return event.data.preset;
+    }
+    return undefined;
+}
+/**
+ * The three Dash events `pinInitialPermission` stamps for a fresh session,
+ * in its append order (preset, sandbox, approval). Cold replay prepends
+ * them so the UI shows the session's permission after wrapper restarts.
+ */
+export function permissionEventsFor(preset, time) {
+    const spec = PRESETS[preset];
+    return [
+        { type: "permission/preset", time, data: { preset } },
+        { type: "sandbox/mode", time, data: { mode: spec.sandbox } },
+        { type: "approval/policy", time, data: { policy: spec.approval } },
+    ];
+}
+/**
+ * The bridge's legacy per-session artifact path (the migration reads this to
+ * import the old `dashSessionId` / `permissionPreset` once). Kept read-only;
+ * nothing writes it after the migration.
+ */
+export function webuiArtifactPath(sessionFile) {
+    const base = sessionFile.split("/").pop() ?? sessionFile;
+    const stem = base.endsWith(".jsonl") ? base.slice(0, -".jsonl".length) : base;
+    return join(dirname(sessionFile), stem, "webui.json");
+}

package/agent-omp/dist/protocol.js

@@ -0,0 +1,13 @@
+/**
+ * omp-web sidecar protocol (v0).
+ *
+ * Transport: JSON lines over stdio of the bun sidecar process.
+ *  - Node → sidecar: request  frame  { id, method, params }
+ *  - sidecar → Node: response frame  { id, ok: true, result } | { id, ok: false, error }
+ *  - sidecar → Node: event     frame  { event: "<channel>", sessionId?, payload }
+ *  - Node → sidecar: notification    { method, params }  (no id, no response — e.g. session.prompt cancel is out of band via abort)
+ *
+ * Handshake: on start the sidecar pushes { event: "ready", payload: { protocol: 0, sdk: <version> } }.
+ * Every request gets exactly one response, in any order (correlate by id).
+ */
+export const PROTOCOL_VERSION = 0;

package/agent-omp/dist/rpc-types.js

@@ -0,0 +1 @@
+export {};