@openrig/cli 0.6.4-rc.1 → 0.6.5

package/daemon/dist/adapters/pi-runner.js

@@ -22,10 +22,11 @@ import nodePath from "node:path";
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
 import { StringDecoder } from "node:string_decoder";
-import { spawn } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { pathToFileURL } from "node:url";
 import { stripVTControlCharacters } from "node:util";
-import { piSeatPaths, buildPiChildArgs, buildPiChildEnv, buildPendingRunnerState, parsePiRunnerState, PI_RUNNER_READY_MARKER, PI_RUNNER_EXIT_MARKER, PI_RUNNER_ERROR_MARKER, } from "./pi-runner-protocol.js";
+import { formatDaemonHostForUrl } from "./daemon-url.js";
+import { piSeatPaths, buildPiChildArgs, buildPiChildEnv, buildPendingRunnerState, parsePiRunnerState, PI_RUNNER_READY_MARKER, PI_RUNNER_ERROR_MARKER, } from "./pi-runner-protocol.js";
 // ── Submitted input boundaries ─────────────────────────────────────────────
 // Canonical TTY buffers can overflow before Node sees even the paste terminator.
 // Use Node's line editor in raw mode, with only paste framing handled here.
@@ -143,21 +144,40 @@ export function createRunnerInput(input, output, onSubmit) {
     });
     return editor;
 }
-function errorNotice(detail) {
+function errorNotice(detail, runtime) {
     const text = typeof detail === "string"
         ? stripVTControlCharacters(detail).replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, " ").replace(/\s+/g, " ").trim()
         : "";
-    return `${PI_RUNNER_ERROR_MARKER} ${text.slice(0, 400) || "request failed"}`;
+    const marker = runtime === "omp" ? "[omp-runner] ERROR" : PI_RUNNER_ERROR_MARKER;
+    return `${marker} ${text.slice(0, 400) || "request failed"}`;
 }
-export function mapPiEvent(event) {
+/** The one model-failure detector for both runtimes. Pi and OMP report a
+ *  provider/auth failure on the assistant message itself and still end the
+ *  turn normally; OMP repeats the message on turn_end, and either runtime can
+ *  announce it again when automatic retries exhaust. The core coalesces the
+ *  repeats into one notice per failure. */
+function modelErrorNotice(event, runtime) {
+    if (event.type === "auto_retry_end") {
+        return event.success === false ? { errorNotice: errorNotice(event.finalError, runtime) } : {};
+    }
+    const message = event.message;
+    return message?.role === "assistant" && message.stopReason === "error"
+        ? { errorNotice: errorNotice(message.errorMessage, runtime) } : {};
+}
+export function mapPiEvent(event, runtime = "pi") {
     const type = typeof event.type === "string" ? event.type : "";
     switch (type) {
         case "agent_start":
             return { mirrorLines: [], activity: { hookEvent: "active", subtype: "agent_start" }, streaming: true };
         case "agent_end":
-            return { mirrorLines: [""], activity: { hookEvent: "Stop", subtype: "agent_end" }, streaming: false };
-        case "turn_start":
+            return runtime === "omp" && event.isTerminal === false
+                ? { mirrorLines: [], streaming: true }
+                : { mirrorLines: [""], activity: { hookEvent: "Stop", subtype: "agent_end" }, streaming: false };
         case "turn_end":
+            // OMP repeats an assistant failure on turn_end (sometimes only there).
+            // Pi keeps main's mapping: turn_end carries no notice.
+            return runtime === "omp" ? { mirrorLines: [], ...modelErrorNotice(event, runtime) } : { mirrorLines: [] };
+        case "turn_start":
         case "message_start":
             return { mirrorLines: [] };
         case "message_update": {
@@ -171,18 +191,12 @@ export function mapPiEvent(event) {
             const delta = update?.type === "text_delta" && typeof update.delta === "string" ? update.delta : "";
             return delta ? { mirrorLines: [], mirrorAppend: delta } : { mirrorLines: [] };
         }
-        case "message_end": {
+        case "message_end":
             // The message text already streamed via message_update appends; this
             // terminates the line. (mapPiEvent is stateless, so a hypothetical
             // updates-carried-nothing case is a VM-calibration follow-up, not
             // silently guessed here.)
-            const message = event.message;
-            return {
-                mirrorLines: [""],
-                ...(message?.role === "assistant" && message.stopReason === "error"
-                    ? { errorNotice: errorNotice(message.errorMessage) } : {}),
-            };
-        }
+            return { mirrorLines: [""], ...modelErrorNotice(event, runtime) };
         case "tool_execution_start": {
             const tool = typeof event.toolName === "string" ? event.toolName : (typeof event.name === "string" ? event.name : "tool");
             return { mirrorLines: [`  ⚙ ${tool} …`], activity: { hookEvent: "PreToolUse", subtype: tool } };
@@ -195,15 +209,23 @@ export function mapPiEvent(event) {
         case "queue_update":
             return { mirrorLines: [] };
         case "compaction_start":
-            return { mirrorLines: ["[pi] compacting context…"], activity: { hookEvent: "active", subtype: "compaction" } };
+            return { mirrorLines: [`[${runtime}] compacting context…`], activity: { hookEvent: "active", subtype: "compaction" } };
         case "compaction_end":
-            return { mirrorLines: ["[pi] compaction done"] };
+            return { mirrorLines: [`[${runtime}] compaction done`] };
+        // OMP names its automatic compaction separately. Pi keeps main's mapping
+        // (unmapped), so an idle Pi seat never reads as running after one.
+        case "auto_compaction_start":
+            return runtime === "omp"
+                ? { mirrorLines: ["[omp] compacting context…"], activity: { hookEvent: "active", subtype: "compaction" } }
+                : { mirrorLines: [] };
+        case "auto_compaction_end":
+            return runtime === "omp" ? { mirrorLines: ["[omp] compaction done"] } : { mirrorLines: [] };
         case "auto_retry_start":
             return { mirrorLines: ["[pi] transient error — retrying"], activity: { hookEvent: "active", subtype: "auto_retry" } };
-        case "auto_retry_end":
-            return event.success === false
-                ? { mirrorLines: [""], errorNotice: errorNotice(event.finalError) }
-                : { mirrorLines: [] };
+        case "auto_retry_end": {
+            const notice = modelErrorNotice(event, runtime);
+            return notice.errorNotice ? { mirrorLines: [""], ...notice } : { mirrorLines: [] };
+        }
         case "extension_error": {
             const message = typeof event.message === "string" ? event.message : "extension error";
             return { mirrorLines: [`${PI_RUNNER_ERROR_MARKER} extension: ${message}`] };
@@ -215,6 +237,9 @@ export function mapPiEvent(event) {
 const GET_STATE_ID = "pi-runner-get-state";
 const CATCH_UP_ID = "pi-runner-catch-up";
 const CURSOR_REFRESH_ID = "pi-runner-cursor-refresh";
+/** RPC commands that carry operator input. Their failure means the seat
+ *  cannot do the requested work; other command failures are not attention. */
+const INPUT_COMMANDS = { prompt: true, steer: true, follow_up: true };
 export class RunnerCore {
     io;
     identity;
@@ -225,6 +250,16 @@ export class RunnerCore {
     lastEntryId;
     ready = false;
     assistantErrorShown = false;
+    started = false;
+    /** OMP attention (runtime_error | permission_prompt) that must survive the
+     *  end of the turn; cleared by the next agent_start. */
+    attention = null;
+    /** Whether the last activity posted is that attention. Later activity in
+     *  the same turn (a tool call after a denied approval) replaces it. */
+    attentionIsLatest = false;
+    /** Set once the daemon confirms it persisted the resume token. */
+    identityPersisted = false;
+    identityInFlight = false;
     constructor(io, identity, opts = {}) {
         this.io = io;
         this.identity = identity;
@@ -234,8 +269,17 @@ export class RunnerCore {
         // newer entry supersedes it.
         this.lastEntryId = opts.catchUpSince;
     }
+    /** Runner readiness is the sidecar's acknowledged get_state, not RPC transport ready. */
+    isReady() { return this.ready; }
     /** Kick off identity capture. Called once pi's RPC stream is up. */
     start() {
+        // OMP's start is driven by the transport `ready` frame and must run once;
+        // Pi keeps main's unconditional start.
+        if (this.runtime === "omp") {
+            if (this.started)
+                return;
+            this.started = true;
+        }
         this.io.sendRpc({ type: "get_state", id: GET_STATE_ID });
         if (this.opts.catchUpSince) {
             // Durable catch-up cursor (FR-5): replay session entries the previous
@@ -267,6 +311,7 @@ export class RunnerCore {
         }
         this.handleEvent(record);
     }
+    get runtime() { return this.opts.runtime ?? "pi"; }
     /** One aggregated paste block from pane stdin. */
     handleUserBlock(block) {
         if (block === "/abort") {
@@ -290,34 +335,49 @@ export class RunnerCore {
         this.io.sendRpc({ type: "prompt", message: block });
         this.io.mirrorLine(`you ▸ ${block}`);
     }
-    /** Pi process exit — honest, loud, durable. */
+    /** Child process exit — honest, loud, durable. */
     handlePiExit(code) {
         this.ready = false;
-        this.io.mirrorLine(`${PI_RUNNER_EXIT_MARKER} pi exited (code ${code ?? "unknown"})`);
+        this.io.mirrorLine(`[${this.runtime}-runner] EXITED ${this.runtime} exited (code ${code ?? "unknown"})`);
         this.writeSidecar({ exited: { code, at: this.io.now() } });
-        this.io.postActivity(this.activityPayload("Stop", "pi_exited"));
+        this.io.postActivity(this.activityPayload("Stop", `${this.runtime}_exited`));
     }
     handleResponse(record) {
+        if (record.success === false || record.error != null) {
+            const message = typeof record.error === "string" ? record.error : "request failed";
+            if (record.id === GET_STATE_ID) {
+                this.ready = false;
+                this.writeSidecar({});
+                this.io.mirrorLine(this.runtime === "omp" ? `[omp-runner] ERROR rpc get_state: ${message}` : `${PI_RUNNER_ERROR_MARKER} rpc: ${message}`);
+                // OMP cannot provide a resume token without get_state; stop it so the
+                // launch fails now instead of waiting out readiness.
+                if (this.runtime === "omp")
+                    this.io.stopChild?.();
+                return;
+            }
+            this.io.mirrorLine(`[${this.runtime}-runner] ERROR rpc: ${message}`);
+            // Only a rejected input means the seat cannot do the requested work.
+            // A mistimed /abort (or any control command) leaves the seat idle.
+            if (this.runtime === "omp" && typeof record.command === "string" && Object.hasOwn(INPUT_COMMANDS, record.command)) {
+                this.raiseAttention("runtime_error");
+            }
+            return;
+        }
         if (record.id === GET_STATE_ID) {
             const data = (record.data ?? record.state ?? record);
             const sessionFile = typeof data.sessionFile === "string" ? data.sessionFile : undefined;
             const sessionId = typeof data.sessionId === "string" ? data.sessionId : undefined;
             this.sessionFile = sessionFile ?? this.sessionFile;
             this.sessionId = sessionId ?? this.sessionId;
-            this.ready = true;
+            this.ready = this.runtime === "pi" || !!this.sessionFile;
+            if (!this.ready) {
+                this.io.mirrorLine("[omp-runner] ERROR rpc get_state returned no session file; cannot provide a resume token");
+                this.io.stopChild?.();
+                return;
+            }
             this.writeSidecar({});
-            this.io.mirrorLine(`${PI_RUNNER_READY_MARKER} session=${this.sessionFile ?? "unknown"}`);
-            this.io.postActivity({
-                eventFamily: "session_identity",
-                sessionName: this.identity.sessionName,
-                nodeId: this.identity.nodeId ?? null,
-                generation: this.identity.generation ?? null,
-                runtime: "pi",
-                hookEvent: "SessionStart",
-                sessionId: this.sessionId ?? "unknown",
-                sessionFile: this.sessionFile ?? null,
-                occurredAt: this.io.now(),
-            });
+            this.io.mirrorLine(`${this.runtime === "omp" ? "[omp-runner] READY" : PI_RUNNER_READY_MARKER} session=${this.sessionFile ?? "unknown"}`);
+            this.postSessionIdentity();
             return;
         }
         if (record.id === CURSOR_REFRESH_ID || record.id === CATCH_UP_ID) {
@@ -333,13 +393,35 @@ export class RunnerCore {
             }
             return;
         }
-        // Other responses (prompt accepted, …) — surface errors.
-        if (record.success === false || record.error != null) {
-            const message = typeof record.error === "string" ? record.error : "request failed";
-            this.io.mirrorLine(`${PI_RUNNER_ERROR_MARKER} rpc: ${message}`);
-        }
+    }
+    raiseAttention(subtype) {
+        // Runtime failures outrank denied approvals. Only emit when the visible
+        // attention changes or intervening activity replaced it.
+        const next = this.attention === "runtime_error" ? this.attention : subtype;
+        if (this.attention === next && this.attentionIsLatest)
+            return;
+        this.attention = next;
+        this.attentionIsLatest = true;
+        this.io.postActivity(this.activityPayload("Notification", next));
+    }
+    clearAttention() {
+        this.attention = null;
+        this.attentionIsLatest = false;
     }
     handleEvent(event) {
+        if (this.runtime === "omp" && event.type === "extension_ui_request") {
+            const method = event.method;
+            // RPC does not mount an interactive UI. Reply at once; otherwise the
+            // child can wait forever for approval that cannot be given in the pane.
+            if (typeof event.id === "string") {
+                this.io.sendRpc({ type: "extension_ui_response", id: event.id, cancelled: true });
+            }
+            if (method === "select" || method === "confirm" || method === "input" || method === "editor") {
+                this.io.mirrorLine("[omp-runner] Approval/input requested; cancelled because the managed RPC pane cannot answer it. Operator action required: review the denied action and re-send a safe instruction, or change the seat permission policy explicitly.");
+                this.raiseAttention("permission_prompt");
+            }
+            return;
+        }
         const message = event.message;
         if (event.type === "agent_start" || (event.type === "message_start" && message?.role === "assistant")) {
             this.assistantErrorShown = false;
@@ -350,9 +432,23 @@ export class RunnerCore {
             this.lastEntryId = entryId;
             this.writeSidecar({});
         }
-        const mapped = mapPiEvent(event);
+        if (this.runtime === "omp") {
+            if (event.type === "agent_start")
+                this.clearAttention();
+            // A successful automatic retry supersedes the failed attempt.
+            if (event.type === "auto_retry_start" && this.attention === "runtime_error")
+                this.clearAttention();
+            // Some paths omit agent_start; turn_start still opens a new turn.
+            if (event.type === "turn_start")
+                this.assistantErrorShown = false;
+        }
+        const mapped = mapPiEvent(event, this.runtime);
         if (mapped.streaming !== undefined)
             this.streaming = mapped.streaming;
+        // OMP writes its JSONL lazily; re-announce identity after each turn until
+        // the daemon confirms the token. Pi's get_state identity is final.
+        if (event.type === "agent_end" && this.runtime === "omp")
+            this.postSessionIdentity();
         if (event.type === "agent_end") {
             // QA RED fold (qitem-20260707020922): live events do not reliably carry
             // session-entry ids, so the durable cursor starved (lastEntryId stayed
@@ -366,24 +462,67 @@ export class RunnerCore {
         for (const line of mapped.mirrorLines)
             this.io.mirrorLine(line);
         if (mapped.errorNotice) {
-            // Pi can announce the same failed message again when retries exhaust.
-            // Keep the first useful detail even if finalError is absent, then reset
-            // at the next assistant message/agent turn, not at agent_end.
-            if (event.type !== "auto_retry_end" || !this.assistantErrorShown) {
+            // Pi can announce the same failed message again when retries exhaust,
+            // and OMP repeats it on turn_end. Keep the first useful detail even if
+            // the repeat lacks it, then reset at the next assistant message/agent
+            // turn, not at agent_end.
+            if (event.type === "message_end" || !this.assistantErrorShown) {
                 this.io.mirrorLine(mapped.errorNotice);
             }
             this.assistantErrorShown = true;
+            // OMP still ends the turn normally after a model failure; the operator
+            // has to act, so the seat shows attention rather than idle.
+            if (this.runtime === "omp")
+                this.raiseAttention("runtime_error");
+        }
+        if (!mapped.activity)
+            return;
+        if (mapped.activity.hookEvent === "Stop" && this.attention) {
+            // The turn ended, but the operator still has to act. Drop the Stop; if
+            // later activity replaced the attention, restore it as the final state.
+            if (!this.attentionIsLatest)
+                this.raiseAttention(this.attention);
         }
-        if (mapped.activity) {
+        else {
+            this.attentionIsLatest = false;
             this.io.postActivity(this.activityPayload(mapped.activity.hookEvent, mapped.activity.subtype));
         }
     }
+    /** Re-deliver OMP identity until the daemon confirms the resume token.
+     *  Called from a timer so a daemon restart during the first turn cannot
+     *  leave a seat with history but no restorable token. */
+    retrySessionIdentity() {
+        if (this.runtime === "omp" && this.ready)
+            this.postSessionIdentity();
+    }
+    postSessionIdentity() {
+        if (this.runtime === "omp" && (!this.sessionFile || !this.io.sessionFileExists?.(this.sessionFile)))
+            return;
+        if (this.runtime === "omp" && (this.identityPersisted || this.identityInFlight))
+            return;
+        const result = this.io.postActivity({
+            eventFamily: "session_identity",
+            sessionName: this.identity.sessionName,
+            nodeId: this.identity.nodeId ?? null,
+            runtime: this.runtime,
+            generation: this.identity.generation ?? null,
+            hookEvent: "SessionStart",
+            sessionId: this.sessionId ?? "unknown",
+            sessionFile: this.sessionFile ?? null,
+            occurredAt: this.io.now(),
+        });
+        if (this.runtime !== "omp" || !result)
+            return;
+        this.identityInFlight = true;
+        void result.then((body) => { if (body?.tokenPersisted === true)
+            this.identityPersisted = true; }, () => { }).finally(() => { this.identityInFlight = false; });
+    }
     activityPayload(hookEvent, subtype) {
         return {
             sessionName: this.identity.sessionName,
             nodeId: this.identity.nodeId ?? null,
             generation: this.identity.generation ?? null,
-            runtime: "pi",
+            runtime: this.runtime,
             hookEvent,
             subtype,
             occurredAt: this.io.now(),
@@ -417,6 +556,13 @@ export function parseRunnerArgs(argv) {
             case "--session-name":
                 args.sessionName = next();
                 break;
+            case "--runtime": {
+                const runtime = next();
+                if (runtime !== "pi" && runtime !== "omp")
+                    throw new Error(`unsupported runtime: ${runtime}`);
+                args.runtime = runtime;
+                break;
+            }
             case "--state-root":
                 args.stateRoot = next();
                 break;
@@ -441,6 +587,13 @@ export function parseRunnerArgs(argv) {
             case "--no-approve":
                 args.trust = "no-approve";
                 break;
+            case "--approval-mode": {
+                const mode = next();
+                if (mode !== "yolo" && mode !== "always-ask")
+                    throw new Error(`unsupported OMP approval mode: ${mode}`);
+                args.trust = mode === "yolo" ? "approve" : "no-approve";
+                break;
+            }
             default: throw new Error(`unknown flag: ${flag}`);
         }
     }
@@ -452,8 +605,14 @@ export function parseRunnerArgs(argv) {
         throw new Error("--cwd is required");
     if (!args.launchId)
         throw new Error("--launch-id is required (launch-attempt scoping)");
-    if (!args.trust)
+    if (args.runtime === "omp") {
+        if (!argv.includes("--approval-mode") || argv.some((flag) => flag === "--approve" || flag === "--no-approve")) {
+            throw new Error("OMP requires --approval-mode yolo or always-ask, not Pi trust flags");
+        }
+    }
+    else if (!args.trust || argv.includes("--approval-mode")) {
         throw new Error("an explicit trust flag is required: --approve or --no-approve");
+    }
     if (args.sessionFile && args.forkRef)
         throw new Error("--session and --fork are mutually exclusive");
     return args;
@@ -462,7 +621,8 @@ function resolveActivityEndpoint(env) {
     let baseUrl = env.OPENRIG_URL?.trim() || null;
     let token = env.OPENRIG_ACTIVITY_HOOK_TOKEN?.trim() || null;
     if (!baseUrl && env.OPENRIG_PORT) {
-        baseUrl = `http://${env.OPENRIG_HOST?.trim() || "127.0.0.1"}:${env.OPENRIG_PORT.trim()}`;
+        const rawHost = env.OPENRIG_HOST?.trim() || "127.0.0.1";
+        baseUrl = `http://${formatDaemonHostForUrl(rawHost)}:${env.OPENRIG_PORT.trim()}`;
     }
     if (!baseUrl || !token) {
         try {
@@ -497,6 +657,59 @@ export function prepareRunnerSidecar(fsOps, runnerStatePath, launchId, resuming,
     catch { /* best-effort; the adapter pre-writes an equivalent pending record */ }
     return { catchUpSince: resuming ? prior?.lastEntryId : undefined };
 }
+/** How often an OMP runner re-delivers an unconfirmed session identity. */
+const IDENTITY_RETRY_MS = 30_000;
+const nodeResolverOps = {
+    isExecutable: (path) => {
+        try {
+            fs.accessSync(path, fs.constants.X_OK);
+            return fs.statSync(path).isFile();
+        }
+        catch {
+            return false;
+        }
+    },
+    realpath: (path) => fs.realpathSync(path),
+    run: (file, args, env) => execFileSync(file, args, { env, encoding: "utf8", timeout: 10_000, stdio: ["ignore", "pipe", "pipe"] }).trim(),
+};
+/** Resolve `name` to the absolute path of the real binary, using the
+ *  runner's own environment. The child later runs under a per-seat HOME, and
+ *  version-manager shims (mise) find their target through HOME, so the shim
+ *  itself must never be what the child executes. */
+export function resolveRuntimeExecutable(name, env, ops = nodeResolverOps) {
+    const onPath = (env.PATH ?? "").split(nodePath.delimiter)
+        .filter((dir) => nodePath.isAbsolute(dir))
+        .map((dir) => nodePath.join(dir, name))
+        .find((candidate) => ops.isExecutable(candidate));
+    if (!onPath)
+        return { ok: false, error: `'${name}' was not found on PATH (${env.PATH ?? ""})` };
+    let real;
+    try {
+        real = ops.realpath(onPath);
+    }
+    catch (err) {
+        return { ok: false, error: `could not resolve ${onPath}: ${err.message}` };
+    }
+    if (nodePath.basename(real) !== "mise")
+        return { ok: true, path: real };
+    // A mise shim is a symlink to mise itself; ask mise for the tool it maps to.
+    let target;
+    try {
+        target = ops.run(real, ["which", name], env);
+    }
+    catch (err) {
+        return { ok: false, error: `${onPath} is a mise shim and 'mise which ${name}' failed: ${err.message}` };
+    }
+    if (!nodePath.isAbsolute(target) || !ops.isExecutable(target)) {
+        return { ok: false, error: `${onPath} is a mise shim but 'mise which ${name}' returned no executable (${target || "empty"})` };
+    }
+    try {
+        return { ok: true, path: ops.realpath(target) };
+    }
+    catch (err) {
+        return { ok: false, error: `could not resolve ${target}: ${err.message}` };
+    }
+}
 export async function main(argv = process.argv.slice(2)) {
     let args;
     try {
@@ -507,6 +720,7 @@ export async function main(argv = process.argv.slice(2)) {
         process.exitCode = 2;
         return;
     }
+    const runtime = args.runtime ?? "pi";
     const paths = piSeatPaths(args.stateRoot, args.sessionName);
     fs.mkdirSync(paths.agentDir, { recursive: true });
     fs.mkdirSync(paths.sessionsDir, { recursive: true });
@@ -520,6 +734,11 @@ export async function main(argv = process.argv.slice(2)) {
         agentDir: paths.agentDir,
         sessionsDir: paths.sessionsDir,
         model: args.model,
+        runtime,
+        sessionName: args.sessionName,
+        nodeId: process.env.OPENRIG_NODE_ID,
+        openrigHome: process.env.OPENRIG_HOME,
+        openrigUrl: endpoint?.baseUrl ?? process.env.OPENRIG_URL,
     });
     const childArgs = buildPiChildArgs({
         sessionsDir: paths.sessionsDir,
@@ -528,10 +747,33 @@ export async function main(argv = process.argv.slice(2)) {
         trust: args.trust,
         sessionFile: args.sessionFile,
         forkRef: args.forkRef,
+        runtime,
     });
-    console.log(`[pi-runner] starting pi --mode rpc (seat ${args.sessionName})`);
-    console.log(`[pi-runner] send text normally; prefixes: "/followup <text>" queues after the turn, "/abort" cancels`);
-    const child = spawn("pi", childArgs, {
+    console.log(`[${runtime}-runner] starting ${runtime} --mode rpc (seat ${args.sessionName})`);
+    console.log(`[${runtime}-runner] send text normally; prefixes: "/followup <text>" queues after the turn, "/abort" cancels`);
+    // OMP runs under a per-seat HOME. A HOME-dependent launcher on PATH (a mise
+    // shim) cannot find its target there, so resolve the real binary first,
+    // with the runner's own environment.
+    let command = runtime;
+    if (runtime === "omp") {
+        const resolved = resolveRuntimeExecutable("omp", process.env);
+        if (!resolved.ok) {
+            console.error(`[omp-runner] ERROR launch: ${resolved.error}`);
+            // Record the exit for this launch so the adapter fails it now instead
+            // of waiting out its readiness timeout. The durable cursor survives.
+            const at = new Date().toISOString();
+            try {
+                const pending = parsePiRunnerState(fs.readFileSync(paths.runnerStatePath, "utf8"));
+                const exitedState = { ready: false, launchId: args.launchId, lastEntryId: pending?.lastEntryId, updatedAt: at, exited: { code: 127, at } };
+                fs.writeFileSync(paths.runnerStatePath, JSON.stringify(exitedState));
+            }
+            catch { /* the pane ERROR marker still fails readiness */ }
+            process.exitCode = 127;
+            return;
+        }
+        command = resolved.path;
+    }
+    const child = spawn(command, childArgs, {
         cwd: args.cwd,
         env: childEnv,
         stdio: ["pipe", "pipe", "pipe"],
@@ -550,12 +792,22 @@ export async function main(argv = process.argv.slice(2)) {
                 return;
             const controller = new AbortController();
             const timeout = setTimeout(() => controller.abort(), 1500);
-            fetch(new URL("/api/activity/hooks", endpoint.baseUrl).toString(), {
+            const request = fetch(new URL("/api/activity/hooks", endpoint.baseUrl).toString(), {
                 method: "POST",
                 headers: { "content-type": "application/json", authorization: `Bearer ${endpoint.token}` },
                 body: JSON.stringify(payload),
                 signal: controller.signal,
-            }).catch(() => { }).finally(() => clearTimeout(timeout));
+            });
+            if (runtime !== "omp") {
+                request.catch(() => { }).finally(() => clearTimeout(timeout));
+                return;
+            }
+            // OMP reads the acknowledgement so identity delivery can retry; null
+            // (transport failure or a non-OK reply) means "not yet persisted".
+            return request
+                .then(async (response) => response.ok ? await response.json() : null)
+                .catch(() => null)
+                .finally(() => clearTimeout(timeout));
         },
         writeSidecar: (state) => {
             try {
@@ -564,30 +816,73 @@ export async function main(argv = process.argv.slice(2)) {
             catch { /* best-effort; adapter falls back to pane markers */ }
         },
         now: () => new Date().toISOString(),
+        stopChild: () => { child.kill(); },
+        sessionFileExists: (path) => fs.existsSync(path),
     };
     const core = new RunnerCore(io, {
         sessionName: args.sessionName, nodeId: process.env.OPENRIG_NODE_ID, launchId: args.launchId,
         // Carry the emitting tenure; never infer it from a later daemon read or Pi event.
         generation: process.env.OPENRIG_OCCUPANT_GENERATION,
-    }, { catchUpSince });
-    readline.createInterface({ input: child.stdout }).on("line", (line) => core.handlePiLine(line));
+    }, { catchUpSince, runtime });
+    let transportUp = runtime === "pi";
+    readline.createInterface({ input: child.stdout }).on("line", (line) => {
+        if (runtime === "omp" && !core.isReady()) {
+            try {
+                const frame = JSON.parse(line);
+                if (frame.type === "ready") {
+                    transportUp = true;
+                    core.start();
+                }
+            }
+            catch { /* surface non-JSON stdout through the core */ }
+        }
+        core.handlePiLine(line);
+    });
+    // Re-deliver OMP identity until the daemon confirms the resume token.
+    const identityRetry = runtime === "omp" ? setInterval(() => core.retrySessionIdentity(), IDENTITY_RETRY_MS) : undefined;
+    identityRetry?.unref();
     readline.createInterface({ input: child.stderr }).on("line", (line) => {
         if (line.trim())
-            process.stdout.write(`[pi:err] ${line}\n`);
+            process.stdout.write(`[${runtime}:err] ${line}\n`);
     });
     const input = createRunnerInput(process.stdin, process.stdout, (block) => core.handleUserBlock(block));
-    child.on("error", (err) => {
-        console.error(`${PI_RUNNER_ERROR_MARKER} failed to spawn pi: ${err.message}`);
-        core.handlePiExit(null);
-        input.close();
-        process.exitCode = 1;
-    });
-    child.on("exit", (code) => {
+    if (runtime === "pi") {
+        child.on("error", (err) => {
+            console.error(`${PI_RUNNER_ERROR_MARKER} failed to spawn pi: ${err.message}`);
+            core.handlePiExit(null);
+            input.close();
+            process.exitCode = 1;
+        });
+        child.on("exit", (code) => {
+            core.handlePiExit(code);
+            input.close();
+            process.exitCode = code ?? 1;
+        });
+        core.start();
+        return;
+    }
+    // OMP: one exit record per launch, with a launch-vs-credential diagnosis
+    // when the RPC session never became resumable.
+    let exited = false;
+    const recordExit = (code) => {
+        if (exited)
+            return;
+        exited = true;
+        clearInterval(identityRetry);
+        if (!core.isReady()) {
+            console.error(transportUp
+                ? "[omp-runner] ERROR OMP did not establish a resumable RPC session. Authenticate this isolated seat using HOME=<seat-root> PI_CODING_AGENT_DIR=<seat-root>/agent omp and /login, or provide its declared model provider key in the OpenRig daemon environment. Default OMP credentials are not shared."
+                : `[omp-runner] ERROR OMP exited before its RPC transport started (${command}, code ${code ?? "unknown"}). This is a launch failure, not a credential problem; see the output above.`);
+        }
         core.handlePiExit(code);
         input.close();
         process.exitCode = code ?? 1;
+    };
+    child.on("error", (err) => {
+        console.error(`[omp-runner] ERROR failed to spawn omp: ${err.message}`);
+        recordExit(null);
     });
-    core.start();
+    child.on("exit", recordExit);
 }
 // Compiled-entry guard: run main() only when executed directly (not imported
 // by tests). import.meta.url === file URL of process.argv[1] when direct.