super-dsh 0.1.9 → 0.1.10-e

package/agent-omp/dist/index.js

@@ -1,18 +1,18 @@
 /**
  * dsh-omp-provider — OMP provider plugin for DeepSeek Harness.
  *
- * Replaces the built-in agent loop with an `AgentFactory` that drives an
- * in-process OMP SDK sidecar (`bun run sidecar/main.ts`, spawned by
- * `OmpSdkClient`) and bridges its event stream into the Dash Agent/Session
- * contracts. There is no `omp --mode rpc` fallback: the legacy RPC client was
- * retired with the SDK migration. Mirrors `@deepseek-ai/dsh-agent-loop`'s creation transaction
+ * Replaces the built-in agent loop with an `AgentFactory` that spawns
+ * `omp --mode rpc` per session (RPC transport: `LazyOmpRpc` → `OmpRpcClient`)
+ * and bridges its event stream into the Dash Agent/Session contracts. The OMP
+ * runtime is the operator's own `omp` binary — the adapter bundles no OMP copy.
+ * Mirrors `@deepseek-ai/dsh-agent-loop`'s creation transaction
  * (prepare → setup → publish) so the session + agent publish as one ordered
  * lifecycle.
  *
  * Phase 3 adds resume:
  *   - `createAgent` records the Dash→OMP session identity in `OmpSessionIndex`
  *     (OMP owns the transcript, Dash owns the live identity).
- *   - `resume` re-attaches the OMP app-home session file through the SDK and restores
+ *   - `resume` re-attaches the OMP session file through the RPC child (`--resume`) and restores
  *     the persisted Dash session log (`sessionPersistence.prepare`), so the
  *     Web UI's cold listing/history/follow-up path (`session.list`,
  *     `session.history`, `session.prompt` → `agents.resume`) reopens the
@@ -33,7 +33,7 @@ import { readOmpDefaultModelFromConfig, sessionHeaderId } from "./omp-store.js";
 import { ompModelRoles, ompSetModelRoles } from "./omp-cli.js";
 import { loadOmpModels, ompProviderIds, refreshOmpModelsCli } from "./models.js";
 import { OMP_NATIVE_HOME, STORAGE_RECONCILE_INTERVAL_MS } from "./knobs.js";
-import { defaultPermissionPreset, envApprovalMode, ompApprovalMode, presetFromEvents } from "./permission.js";
+import { defaultPermissionPreset, envApprovalMode, resolveSpawnPermission } from "./permission.js";
 import { closeBridgeStore, getBridgeStore, initBridgeStore } from "./store/index.js";
 import { prepareIndex, upsertCreated } from "./store/reconcile.js";
 import { installMobileBootScript } from "./mobile-boot.js";
@@ -55,6 +55,28 @@ const trace = (...parts) => {
     if (process.env.OMP_TRACE === "1")
         process.stderr.write(`[omp-provider ${Date.now() % 1_000_000}] ${parts.join(" ")}\n`);
 };
+/**
+ * Whether any live OMP session currently holds an `omp --mode rpc` child.
+ *
+ * The reconcile tick used to read the catalog through the shared sidecar's
+ * live gate; with the RPC transport the equivalent fact is "a session's
+ * transport child exists". `refreshOmpModelsCli()` is a real
+ * `omp models --json` subprocess, so this gate is load-bearing (AGENTS.md
+ * §五·五: the periodic tick never materializes an `omp`). Sessions count only
+ * once they actually spawned — a draft session holds a `LazyOmpRpc` with no
+ * child yet, and an idle daemon's tick must pull ZERO children.
+ *
+ * Exported beside the plugin (the cordis surface itself is unchanged) so the
+ * no-sidecar guard can pin this gate's truth table behaviourally — a shape
+ * regex alone cannot see an empty input set.
+ */
+export function liveOmpSessionExists(sessions) {
+    for (const rpc of sessions) {
+        if (rpc.spawned)
+            return true;
+    }
+    return false;
+}
 export class OmpProvider extends Service {
     /**
      * `agentDefaultModel` is load-bearing, not decorative: the harness owns the
@@ -71,6 +93,12 @@ export class OmpProvider extends Service {
     /** Stops the supervisor's follow loop on provider teardown. */
     /** Live RPC-backed agents by dash id, for avoidance hand-off. */
     heldAgents = new Map();
+    /**
+     * Live RPC wrappers by dash id — the reconcile tick's liveness gate (AGENTS.md
+     * §五·五): the catalog refresh runs only while one of these holds an
+     * `omp --mode rpc` child (`spawned`). Entries are dropped with the handle.
+     */
+    liveSessions = new Set();
     /**
      * Persist the default selection into the settings section.
      *
@@ -99,9 +127,10 @@ export class OmpProvider extends Service {
         super(ctx, "ompProvider");
         this.runtime = { ctx };
         ctx.effect(() => ctx.agents.setFactory(this), "ompProvider.setFactory()");
-        // Native-home ruling (2026-09-17): the sidecar/SDK runs on the operator's
-        // native OMP home (`~/.omp`; $OMP_HOME overrides in tests) — no app-home
-        // bootstrap, no config seeding. The world DSH home only holds DSH state.
+        // Native-home ruling (2026-09-17): the spawned `omp` child runs on the
+        // operator's native OMP home (`~/.omp`; $OMP_HOME overrides in tests) — no
+        // app-home bootstrap, no config seeding. The world DSH home only holds DSH
+        // state.
         this.#registerModelCatalog();
         // Boot the centralized index BEFORE any service reads session state: warm
         // pass + migration, so the first landing sees real titles/models (D5.1).
@@ -136,9 +165,9 @@ export class OmpProvider extends Service {
      */
     async #syncModelDefaultTick() {
         const service = this.runtime.ctx.get("agentDefaultModel");
-        // Source of truth is OMP's config.yml ON DISK, never the sidecar: the
-        // sidecar is cold at boot and this tick must publish OMP's default to
-        // `ctx.agentDefaultModel` immediately (archived default-model contract).
+        // Source of truth is OMP's config.yml ON DISK, never the live transport:
+        // the `omp` child is cold at boot and this tick must publish OMP's default
+        // to `ctx.agentDefaultModel` immediately (archived default-model contract).
         const ompParsed = readOmpDefaultModelFromConfig();
         const ompKey = ompParsed === undefined ? undefined : `${ompParsed.provider}/${ompParsed.model}`;
         const dsh = service?.currentSelection?.();
@@ -205,7 +234,12 @@ export class OmpProvider extends Service {
                 if (store !== undefined)
                     prepareIndex(store);
                 void this.#syncModelDefaultTick();
-                void refreshOmpModelsCli();
+                // AGENTS.md §五·五 "tick 永不 spawn": the catalog refresh runs a real
+                // `omp models --json` subprocess, so it may only fire while an OMP
+                // session is live. An idle daemon's tick pulls ZERO children; the
+                // on-disk model cache (models.ts) keeps serving the boot catalog.
+                if (liveOmpSessionExists(this.liveSessions))
+                    void refreshOmpModelsCli();
                 void this.#attachScannedSessions(registry);
             };
             run();
@@ -292,16 +326,14 @@ export class OmpProvider extends Service {
         if (meta.parentSession !== undefined) {
             throw new Error(`cannot fork session "${meta.parentSession}" onto the OMP provider: OMP has no native session fork`);
         }
-        // Approval policy is pinned at OMP launch and the Dash session does not
-        // exist yet at this point (it is prepared + announced — which is what
-        // stamps `permission/preset` via pinInitialPermission — only inside
-        // setupAndPublish, AFTER this spawn), so the effective preset cannot
-        // come from session events: read the permission service's default and
-        // map it onto the launch flag. OMP_APPROVAL_MODE (headless runs) wins.
-        const envMode = envApprovalMode();
-        const preset = defaultPermissionPreset(loopCtx);
-        const approvalMode = envMode ?? ompApprovalMode(preset);
-        trace(`create id=${id} preset=${preset ?? "none"} approval-mode=${approvalMode}${envMode === undefined ? "" : " (env override)"}`);
+        // Approval policy is pinned at OMP launch — but it is NOT frozen here.
+        // The Dash session is prepared (and `pinInitialPermission`-stamped) only
+        // inside setupAndPublish, AFTER this wrapper exists, and the new-chat
+        // `/permission` pick arrives as a later `permission/preset`; the child
+        // materializes on the first prompt. The launch flag is therefore resolved
+        // at spawn time from the session's own events
+        // (`resolveSpawnPermission`), with the composition default as the fallback
+        // and OMP_APPROVAL_MODE (headless runs) as the override.
         // Backend takes ZERO part in the UI's browser-local new-session draft:
         // no OMP child, no transcript, no index row, no session events — the
         // session announces blank, exactly like the native agent-loop factory's
@@ -309,11 +341,13 @@ export class OmpProvider extends Service {
         // (LazyOmpRpc); adoptSpawnedChild writes the index row and the
         // supervisor's held baseline at that moment, so a draft abandoned before
         // the first prompt costs and leaves NOTHING server-side.
-        const rpc = new LazyOmpRpc(["--approval-mode", approvalMode], cwd);
         const preparation = SessionPreparation.create(loopCtx.sessions.prepare(id, {
             ...(options.seed === undefined ? {} : { seed: options.seed }),
             ...(meta === undefined ? {} : { meta }),
         }));
+        const session = preparation.session;
+        const spawnPermission = () => resolveSpawnPermission(session.snapshotEvents(), defaultPermissionPreset(loopCtx), envApprovalMode());
+        const rpc = new LazyOmpRpc(() => ["--approval-mode", spawnPermission().approvalMode], cwd);
         // The prepared header is the single source of truth for the row the
         // first-spawn adoption writes: v2 folds header identity across
         // live/listed/loaded observations, so created_at/cwd must be copied from
@@ -328,13 +362,13 @@ export class OmpProvider extends Service {
             ? undefined
             : { handle: await persistence.create(header, { inheritedEventCount: preparation.session.inheritedEventCount }) };
         rpc.onSpawned((client) => {
-            void adoptSpawnedChild(id, header, client, preset);
+            void adoptSpawnedChild(id, header, client, spawnPermission().preset);
         });
         // Nothing can fail from the child here (none exists yet); the publish
         // transaction below unwinds its own half-published state on failure — its
         // catch calls rpc.close(), a no-op until the first prompt spawns.
-        const handle = await setupAndPublish(loopCtx, ownerCtx, id, options.agentOptions ?? {}, options.setup, preparation.session, rpc, options.parentAgent, "startup", { enterSession: true, preparation, stored });
-        return this.registerHeld(id, "", handle);
+        const handle = await setupAndPublish(loopCtx, ownerCtx, id, options.agentOptions ?? {}, options.setup, session, rpc, options.parentAgent, "startup", { enterSession: true, preparation, stored });
+        return this.registerHeld(id, "", handle, rpc);
     }
     async resume(ownerCtx, options) {
         const loopCtx = this.runtime.ctx;
@@ -374,14 +408,12 @@ export class OmpProvider extends Service {
         const freshOmp = record === undefined;
         const ompFile = record?.ompSessionFile;
         const spawnCwd = validatedCwd(record?.cwd) ?? validatedCwd(stored.header.cwd);
-        // Approval mode: persisted permission preset from the dsh log seed
-        // (synthesized at create), falling back to the bridge-store row.
-        const envMode = envApprovalMode();
-        const preset = getBridgeStore()?.byDshId(String(id))?.permission_preset ??
-            presetFromEvents([...coldRead.events]);
-        const approvalMode = envMode ?? ompApprovalMode(preset);
-        trace(`resume id=${id} preset=${preset ?? "none"} approval-mode=${approvalMode}${envMode === undefined ? "" : " (env override)"}${freshOmp ? " fresh-omp" : ""}`);
-        // OMP live runtime — ALWAYS LAZY (sidecar-decoupling ruling, both branches).
+        // Approval mode: the session's own last `permission/preset` (= what the
+        // `/permission` pick wrote, or the event synthesized at create), with the
+        // bridge-index row as the fallback for logs that predate the event. Resolved
+        // AT SPAWN so a pick made after this resume but before the first prompt
+        // still reaches the child; OMP_APPROVAL_MODE (headless) wins.
+        // OMP live runtime — ALWAYS LAZY (lazy-transport ruling, both branches).
         // Opening/replaying a persisted session in the WebUI promotes it through
         // history.follow → resume; a read-only visit must NOT materialize the OMP
         // child. `LazyOmpRpc` spawns on the FIRST dispatch (prompt/followUp/steer/
@@ -391,15 +423,8 @@ export class OmpProvider extends Service {
         // With content: the child re-attaches its OWN app-home file via --resume
         // (never the dsh transcript); the mapping already exists in the bridge
         // store, so no adoption hook is needed.
+        // Both branches are LAZY and both resolve their launch flag at spawn.
         let rpc;
-        if (ompFile === undefined) {
-            const lazy = new LazyOmpRpc(["--approval-mode", approvalMode], spawnCwd);
-            lazy.onSpawned((client) => { void adoptSpawnedChild(id, stored.header, client, preset); });
-            rpc = lazy;
-        }
-        else {
-            rpc = new LazyOmpRpc(["--approval-mode", approvalMode, "--resume", ompFile], spawnCwd);
-        }
         try {
             // Fresh attach: seed the dsh session from the dsh log (native replay),
             // header identity folded from the stored header verbatim.
@@ -409,32 +434,47 @@ export class OmpProvider extends Service {
                 inheritedEventCount: stored.inheritedEventCount,
                 eventState: coldRead.eventState,
             }));
-            trace(`resume id=${id} seeded from dsh session log (${coldRead.events.length} events)`);
+            const rowPreset = () => getBridgeStore()?.byDshId(String(id))?.permission_preset ?? undefined;
+            trace(`resume id=${id} seeded from dsh session log (${coldRead.events.length} events), approval=resolve-at-spawn (row fallback ${rowPreset() ?? "none"})${freshOmp ? " fresh-omp" : ""}`);
+            const spawnPermission = () => resolveSpawnPermission(preparation.session.snapshotEvents(), rowPreset(), envApprovalMode());
+            if (ompFile === undefined) {
+                const lazy = new LazyOmpRpc(() => ["--approval-mode", spawnPermission().approvalMode], spawnCwd);
+                lazy.onSpawned((client) => { void adoptSpawnedChild(id, stored.header, client, spawnPermission().preset); });
+                rpc = lazy;
+            }
+            else {
+                rpc = new LazyOmpRpc(() => ["--approval-mode", spawnPermission().approvalMode, "--resume", ompFile], spawnCwd);
+            }
             const handle = await setupAndPublish(loopCtx, ownerCtx, id, options.agentOptions ?? {}, options.setup, preparation.session, rpc, options.parentAgent, "resume", { enterSession: true, preparation, stored: { handle: stored, written: coldRead.events.length } });
-            return this.registerHeld(id, ompFile ?? "", handle);
+            return this.registerHeld(id, ompFile ?? "", handle, rpc);
         }
         catch (error) {
             trace(`resume ${id} THREW: ${String(error)} | stack=${error instanceof Error ? error.stack?.slice(0, 400) : "n/a"}`);
             await stored.close().catch(() => { });
-            rpc.close();
+            rpc?.close();
             throw error;
         }
     }
     /**
-     * Track a published RPC-backed agent and hand the session to the supervisor
-     * as held. Arrow FIELD (not a `#` method): the provider is exposed through
-     * a Cordis tracing proxy, and hard-private methods fail their brand check
-     * on the proxy receiver (the same reason setupAndPublish is module-level).
+     * Track a published RPC-backed agent, register its transport wrapper with the
+     * tick's liveness gate, and hand the session to the supervisor as held. Arrow
+     * FIELD (not a `#` method): the provider is exposed through a Cordis tracing
+     * proxy, and hard-private methods fail their brand check on the proxy receiver
+     * (the same reason setupAndPublish is module-level).
      */
-    registerHeld = (id, file, handle) => {
+    registerHeld = (id, file, handle, rpc) => {
         const wrapped = {
             agent: handle.agent,
             dispose: async () => {
                 this.heldAgents.delete(String(id));
+                this.liveSessions.delete(rpc);
                 await handle.dispose();
             },
         };
         this.heldAgents.set(String(id), wrapped);
+        // Populate the tick's liveness gate: without this the gate is a constant
+        // false and the catalog refresh never runs (dead-input regression).
+        this.liveSessions.add(rpc);
         return wrapped;
     };
 }

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

@@ -1,4 +1,4 @@
-import { OmpSdkClient } from "./sdk-client.js";
+import { OmpRpcClient } from "./rpc-client.js";
 /** Synthetic state for a not-yet-spawned child: quiescent by definition. */
 const IDLE_STATE = { isStreaming: false };
 export class LazyOmpRpc {
@@ -12,6 +12,12 @@ export class LazyOmpRpc {
     #failureListeners = new Set();
     #pendingModel;
     #onSpawned;
+    /**
+     * @param spawnArgs - the child's argv after `--mode rpc`, or a thunk called
+     *   AT SPAWN. Use the thunk whenever a launch fact can still change between
+     *   construction and the first prompt — the new-chat permission pick does.
+     * @param cwd - the spawn cwd.
+     */
     constructor(spawnArgs, cwd) {
         this.#spawnArgs = spawnArgs;
         this.#cwd = cwd;
@@ -35,7 +41,8 @@ export class LazyOmpRpc {
         if (this.#client !== undefined)
             return Promise.resolve(this.#client);
         if (this.#spawn === undefined) {
-            this.#spawn = OmpSdkClient.spawn(this.#spawnArgs, this.#cwd).then((client) => {
+            const args = typeof this.#spawnArgs === "function" ? this.#spawnArgs() : this.#spawnArgs;
+            this.#spawn = OmpRpcClient.spawn(args, this.#cwd).then((client) => {
                 // A close() that raced the in-flight spawn wins: dispose immediately.
                 if (this.#closed) {
                     client.close();
@@ -89,8 +96,8 @@ export class LazyOmpRpc {
     }
     async prompt(message) {
         const client = await this.#ensure();
-        // Apply a pre-spawn model selection now, ahead of the prompt (the sidecar
-        // records it as the session's model_change, like a pre-turn set_model).
+        // Apply a pre-spawn model selection now, ahead of the prompt (the child
+        // emits a config_update, like a pre-turn set_model).
         const pending = this.#pendingModel;
         if (pending !== undefined) {
             this.#pendingModel = undefined;

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

@@ -1,147 +1,164 @@
 /**
- * OMP model catalog + modelRoles data plane, served by the shared bun sidecar
- * (which embeds the OMP core via @oh-my-pi/pi-coding-agent) instead of
- * spawning `omp` CLI subprocesses.
+ * OMP CLI subprocess data plane — the model catalog and the `modelRoles` map
+ * are read from (and written through) the operator's own `omp` binary, the
+ * first-party entries the bridge uses instead of parsing OMP's files or
+ * hitting frame-limited RPC:
  *
- * Two data planes are bridged:
- *   - `models.list`             → the credential-resolved AVAILABLE model
- *     catalog (the same set `omp models --json` returned: ~50 models / 5
- *     providers), keyed the way `models.ts` normalizes them (id/provider/name/
- *     api/baseUrl/reasoning/input/contextWindow/maxTokens/thinking).
- *   - `settings.modelRoles.get/set` → the role→"provider/model[:effort]" map,
- *     including the persisted `default` selector (TUI semantics: the default
- *     model IS config state, surviving sessions). `set` is a whole-object
- *     roundtrip write, matching `omp config set modelRoles` (dotted keys are
- *     rejected; the entire modelRoles object is the unit).
+ * - `omp models --json`     → the credential-resolved AVAILABLE model catalog
+ *   (documented selectability rule: provider not in `disabledProviders` and
+ *   keyless or with a resolvable credential — 7-level precedence, including
+ *   OAuth/login keys stored in agent.db that no config file reveals).
+ * - `omp config get modelRoles --json` → the role→"provider/model[:effort]"
+ *   map, including the persisted `default` selector (TUI semantics: the
+ *   default model IS config state, surviving sessions).
+ * - `omp config set modelRoles --json <obj>` → whole-object roundtrip write
+ *   (dotted keys are rejected; the entire modelRoles object is the unit).
  *
- * The sidecar is a SHARED SINGLETON (src/sdk-client.ts acquire/release) — this
- * module goes through the same instance via `callShared`, never spawning a
- * second sidecar process.
+ * All calls run with cwd = `OMP_HOME` (omp writes its own state db next to
+ * the agent dir) and inherit the daemon environment. The binary is resolved
+ * per call ({@link resolveOmpExecutable}), so `$OMP_EXECUTABLE` and PATH
+ * changes take effect without a reload.
  *
- * Sync variants (`*Sync`) cannot block on sidecar IPC, so they return the last
- * cache and warm it asynchronously: the first boot-time call returns
- * `undefined` (the caller's on-disk fallback engages) and a later background
- * fetch repopulates the cache. The async variants always fetch fresh.
- *
- * Fail-soft: any sidecar failure (not started / crashed) yields `undefined`
- * (reads) or `false` (write), so the provider never fails to boot on a down
- * sidecar.
+ * Fail-soft: a missing, broken or unresponsive `omp` yields `undefined`
+ * (reads) or `false` (write) — the provider never fails to boot because the
+ * CLI is down.
  *
  * @module agent-omp/omp-cli
  */
-import { callShared, callSharedIfLive } from "./sdk-client.js";
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+import { OMP_HOME } from "./knobs.js";
+import { resolveOmpExecutable } from "./rpc-client.js";
+const execFileAsync = promisify(execFile);
+const TIMEOUT_MS = 15_000;
+const MAX_BUFFER = 64 * 1024 * 1024;
 // ---------------------------------------------------------------------------
-// Sidecar plumbing (fail-soft: any failure → undefined/false)
+// Subprocess plumbing (fail-soft: any failure → undefined/false)
 // ---------------------------------------------------------------------------
-/** `models.list` over the shared sidecar → validated OmpCliModel[], undefined on failure. */
-async function sidecarModelsList() {
-    // LIVE-GATED: resolves only when the shared sidecar already exists (a live
-    // session or an on-demand op). Cold → undefined → the disk fallback engages;
-    // the reconcile tick can never spawn a sidecar (sidecar-decoupling ruling).
+/** One `omp <args>` invocation parsed as JSON; undefined on any failure. */
+async function ompCliJson(args) {
     try {
-        const data = await callSharedIfLive("models.list", { refresh: true });
-        if (data === null || typeof data !== "object")
-            return undefined;
-        const models = data.models;
-        if (!Array.isArray(models))
-            return undefined;
-        const out = [];
-        for (const model of models) {
-            if (model !== null &&
-                typeof model === "object" &&
-                typeof model.provider === "string" &&
-                typeof model.id === "string") {
-                out.push(model);
-            }
-        }
-        return out.length > 0 ? out : undefined;
+        const { stdout } = await execFileAsync(resolveOmpExecutable(), args, {
+            cwd: OMP_HOME,
+            timeout: TIMEOUT_MS,
+            maxBuffer: MAX_BUFFER,
+        });
+        return JSON.parse(stdout);
     }
     catch {
         return undefined;
     }
 }
-/** `settings.modelRoles.get` over the shared sidecar → validated OmpModelRoles, undefined on failure. */
-async function sidecarModelRolesGet() {
+/** Synchronous variant of {@link ompCliJson} — the boot-time path. */
+function ompCliJsonSync(args) {
     try {
-        const data = await callShared("settings.modelRoles.get", {});
-        const value = data?.modelRoles;
-        if (value === null || typeof value !== "object" || Array.isArray(value))
-            return undefined;
-        const out = {};
-        for (const [role, selector] of Object.entries(value)) {
-            if (typeof selector === "string" && selector !== "")
-                out[role] = selector;
-        }
-        return Object.keys(out).length > 0 ? out : undefined;
+        const stdout = execFileSync(resolveOmpExecutable(), args, {
+            cwd: OMP_HOME,
+            timeout: TIMEOUT_MS,
+            encoding: "utf8",
+            maxBuffer: MAX_BUFFER,
+        });
+        return JSON.parse(stdout);
     }
     catch {
         return undefined;
     }
 }
-/** `settings.modelRoles.set` over the shared sidecar → true only on a durable write. */
-async function sidecarModelRolesSet(roles) {
-    try {
-        const data = await callShared("settings.modelRoles.set", { modelRoles: roles });
-        return data?.ok === true;
+/** Validate an `omp models --json` payload; undefined when empty or invalid. */
+function parseModels(json) {
+    if (json === null || typeof json !== "object")
+        return undefined;
+    const models = json.models;
+    if (!Array.isArray(models))
+        return undefined;
+    const out = [];
+    for (const model of models) {
+        if (model !== null && typeof model === "object" && typeof model.provider === "string") {
+            out.push(model);
+        }
     }
-    catch {
-        return false;
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Validate a `modelRoles` payload; undefined when unset, empty or invalid.
+ *
+ * `omp config get <key> --json` prints `{key, value, type, description}`, but
+ * the bare value map appears in older builds, so both shapes are accepted. A
+ * wrapped payload for a different key is rejected rather than misread as a
+ * role map.
+ */
+function parseModelRoles(json) {
+    if (json === null || typeof json !== "object" || Array.isArray(json))
+        return undefined;
+    const record = json;
+    let value = record;
+    if ("key" in record || "value" in record) {
+        if (typeof record.key === "string" && record.key !== "modelRoles")
+            return undefined;
+        value = record.value;
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return undefined;
+    const out = {};
+    for (const [role, selector] of Object.entries(value)) {
+        if (typeof selector === "string" && selector !== "")
+            out[role] = selector;
     }
+    return Object.keys(out).length > 0 ? out : undefined;
 }
 // ---------------------------------------------------------------------------
 // Model catalog
 // ---------------------------------------------------------------------------
-let modelsCache;
 /**
- * Synchronous catalog read — MEMO-ONLY by design (sidecar-decoupling): no boot
- * warm, no sidecar touch. `undefined` until something live swaps the cache in
- * ({@link ompAvailableModels} on an already-live sidecar), so the boot path in
- * `models.ts` falls back to the on-disk registry without spawning anything.
+ * Synchronous `omp models --json` — the boot-time variant (the adapter's
+ * provider route list must be known before `registerAdapter` returns).
+ * Blocks up to the timeout; prefer the async variant everywhere else.
  */
 export function ompAvailableModelsSync() {
-    return modelsCache;
+    return parseModels(ompCliJsonSync(["models", "--json"]));
 }
 /**
- * `models.list` — the credential-resolved catalog, LIVE-GATED: fetched only
- * when the shared sidecar already exists (a live session); `undefined` and the
- * cache untouched when cold. Callers fall back to the on-disk sources.
+ * `omp models --json` — the AVAILABLE model catalog (credential-resolved,
+ * `disabledProviders`-aware). `undefined` when the CLI fails; callers fall
+ * back to the on-disk sources.
  */
 export async function ompAvailableModels() {
-    const models = await sidecarModelsList();
-    if (models !== undefined)
-        modelsCache = models;
-    return models;
+    return parseModels(await ompCliJson(["models", "--json"]));
 }
 // ---------------------------------------------------------------------------
 // modelRoles
 // ---------------------------------------------------------------------------
-let rolesCache;
 /**
- * Synchronous roles read — memo-only, same contract as
- * {@link ompAvailableModelsSync}. The boot path reads modelRoles from
- * `config.yml` on disk (omp-store); this cache only ever reflects what a live
- * sidecar reported. The write path (`ompModelRoles`/`ompSetModelRoles`) may
- * spawn on real need — a default-model change is a user action, not a tick.
+ * Synchronous `omp config get modelRoles --json` — boot-time variant of
+ * {@link ompModelRoles}.
  */
 export function ompModelRolesSync() {
-    return rolesCache;
+    return parseModelRoles(ompCliJsonSync(["config", "get", "modelRoles", "--json"]));
 }
 /**
- * `settings.modelRoles.get` — the current modelRoles object, fetched fresh
- * from the sidecar on every call (the OMP TUI may have rewritten config.yml).
- * `undefined` when unset or the sidecar fails.
+ * `omp config get modelRoles --json` — the current modelRoles object, read
+ * fresh on every call (the OMP TUI may have rewritten config.yml). `undefined`
+ * when unset or the CLI fails.
  */
 export async function ompModelRoles() {
-    const roles = await sidecarModelRolesGet();
-    if (roles !== undefined)
-        rolesCache = roles;
-    return roles;
+    return parseModelRoles(await ompCliJson(["config", "get", "modelRoles", "--json"]));
 }
 /**
- * `settings.modelRoles.set` — the TUI-grade default-model write: the sidecar
- * replaces the whole modelRoles object (matching `omp config set modelRoles`
- * whole-object semantics) and confirms the write landed before returning true.
+ * `omp config set modelRoles --json <obj>` — the TUI-grade default-model
+ * write: OMP persists `modelRoles.default` itself, so every new session
+ * (TUI or Web) inherits the selection. Whole-object roundtrip: dotted keys
+ * are rejected by the CLI. `false` on any failure (fail-soft).
  */
 export async function ompSetModelRoles(roles) {
-    return sidecarModelRolesSet(roles);
+    try {
+        await execFileAsync(resolveOmpExecutable(), ["config", "set", "modelRoles", "--json", JSON.stringify(roles)], {
+            cwd: OMP_HOME,
+            timeout: TIMEOUT_MS,
+            maxBuffer: MAX_BUFFER,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }

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

@@ -434,9 +434,10 @@ function isDescendantOf(pid, ancestor) {
  * 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.
+ * one file with plain `w` descriptors and no advisory locks). The intended
+ * enforcement is to refuse resuming a transcript another process already writes
+ * (the TUI case), closing the split-brain at the only layer that can see it —
+ * but see {@link foreignWriterPid}: that hold is NOT wired in this round.
  * Own descendants (a just-torn-down bridge child whose fds linger) are
  * exempt to keep teardown races from wedging re-resume.
  */
@@ -504,7 +505,14 @@ export function scanForeignWriters() {
 /**
  * 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.
+ * resume gate.
+ *
+ * UNWIRED (2026-10-03): this helper has no caller — the `resume` path never
+ * invokes it, so nothing currently refuses a transcript another process (the
+ * TUI) is writing. Spec §3.4 of `docs/specs/omp-rpc-transport/spec.md`
+ * registers that accepted exposure and the planned follow-up: a fail-loud
+ * `foreignWriterPid(<sessionFile>)` check wired into `resume`, to be decided
+ * by the operator. Helper kept exported for that follow-up.
  */
 export function foreignWriterPid(file) {
     let canonical;