@pasko70/pibo 2.0.0 → 2.1.1

package/dist/agent-runtimes/omp/history.js

@@ -0,0 +1,108 @@
+import { OMP_ADAPTER_ID } from "./thread.js";
+import { OMP_ADAPTER_VERSION } from "./thread.js";
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function inspectOmpHistory(input, runtimeInstanceId) {
+    const binding = input.binding;
+    return {
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        bindingState: binding.state,
+        available: binding.state === "bound" && Boolean(binding.nativeSessionId),
+        ...(binding.locator ? { locator: binding.locator } : {}),
+        version: OMP_ADAPTER_VERSION,
+        diagnostics: [],
+    };
+}
+function messageEntryRole(message) {
+    if (isRecord(message)) {
+        if (typeof message.role === "string") {
+            const role = message.role;
+            if (role === "user" || role === "assistant" || role === "tool" || role === "system")
+                return role;
+        }
+    }
+    return "system";
+}
+function messageText(message) {
+    if (typeof message === "string")
+        return message;
+    if (!isRecord(message))
+        return "";
+    if (typeof message.text === "string")
+        return message.text;
+    if (typeof message.content === "string")
+        return message.content;
+    if (Array.isArray(message.content)) {
+        const parts = [];
+        for (const part of message.content) {
+            if (isRecord(part) && typeof part.text === "string")
+                parts.push(part.text);
+        }
+        return parts.join("\n");
+    }
+    return "";
+}
+function toHistoryEntry(message, sequence, binding) {
+    const role = messageEntryRole(message);
+    const content = messageText(message);
+    return {
+        id: `${binding.nativeSessionId ?? "omp"}-${sequence}`,
+        type: "message",
+        source: "native",
+        createdAt: isRecord(message) && typeof message.timestamp === "string"
+            ? message.timestamp
+            : new Date().toISOString(),
+        sequence,
+        role,
+        content: content || "[empty message]",
+    };
+}
+export async function readOmpHistory(client, input, runtimeInstanceId, binding) {
+    try {
+        const result = await client.request({
+            type: "get_messages_page",
+            ...(input.cursor ? { cursor: input.cursor } : {}),
+            ...(input.limit ? { limit: input.limit } : {}),
+        }, "get_messages_page");
+        const data = result["data"];
+        if (!isRecord(data) || !Array.isArray(data.messages)) {
+            return emptyPage(runtimeInstanceId);
+        }
+        const entries = [];
+        let sequence = 0;
+        for (const message of data.messages) {
+            entries.push(toHistoryEntry(message, sequence++, binding));
+        }
+        return {
+            runtimeInstanceId,
+            adapterId: OMP_ADAPTER_ID,
+            source: "native",
+            entries,
+            ...(typeof data.nextCursor === "string" ? { nextCursor: data.nextCursor } : {}),
+            hasMore: typeof data.nextCursor === "string" && data.nextCursor.length > 0,
+        };
+    }
+    catch {
+        return emptyPage(runtimeInstanceId);
+    }
+}
+function emptyPage(runtimeInstanceId) {
+    return {
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        source: "native",
+        entries: [],
+        hasMore: false,
+    };
+}
+export function emptyOmpHistoryPage(runtimeInstanceId) {
+    return {
+        runtimeInstanceId,
+        adapterId: OMP_ADAPTER_ID,
+        source: "native",
+        entries: [],
+        hasMore: false,
+    };
+}

package/dist/agent-runtimes/omp/host-tools.js

@@ -0,0 +1,201 @@
+const DEFAULT_MAX_TOOL_CALL_TIMEOUT_MS = 5 * 60_000;
+// Test hook: lets unit tests exercise the abort-on-timeout path quickly.
+function maxToolCallTimeoutMs() {
+    if (typeof process !== "undefined" && process.env?.PIBO_OMP_TOOL_TIMEOUT_MS) {
+        const parsed = Number(process.env.PIBO_OMP_TOOL_TIMEOUT_MS);
+        if (Number.isFinite(parsed) && parsed > 0)
+            return parsed;
+    }
+    return DEFAULT_MAX_TOOL_CALL_TIMEOUT_MS;
+}
+const MAX_RESULT_BYTES = 8 * 1024 * 1024;
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === "string" ? value : JSON.stringify(value ?? "");
+}
+/** Resolve the input-schema JSON Schema from a Pibo tool definition. */
+function toolInputSchema(definition) {
+    if (isRecord(definition.inputSchema)) {
+        return definition.inputSchema;
+    }
+    if (isRecord(definition.parameters)) {
+        return definition.parameters;
+    }
+    return { type: "object", properties: {} };
+}
+/** Flatten a Pibo tool result's content parts into host-tool text content. */
+function flattenToolResult(result) {
+    const parts = [];
+    for (const item of result.content ?? []) {
+        if (item.type === "text") {
+            parts.push(item.text);
+        }
+        else if (item.type === "image") {
+            parts.push("[image content]");
+        }
+        else if ("text" in item) {
+            parts.push(String(item.text ?? ""));
+        }
+        else {
+            parts.push(JSON.stringify(item));
+        }
+    }
+    const content = parts.join("\n");
+    return result.isError ? { content, isError: true } : { content };
+}
+/**
+ * Bridges Pibo's portable tool session over OMP's host-tool RPC protocol.
+ *
+ * - `install` sends Pibo's tool definitions via `set_host_tools` so OMP mounts
+ *   them directly (matching by name).
+ * - `handleFrame` processes `host_tool_call` / `host_tool_cancel` frames from
+ *   OMP, executes the underlying Pibo tool (same contract the Pi direct
+ *   compiler uses), and replies with `host_tool_result`.
+ *
+ * OMP preserves its native tools and base prompt; Pibo adds only its own
+ * portable tools, and only Pibo-hosted tools are governed by Pibo.
+ */
+export class OmpHostToolBridge {
+    client;
+    portableTools;
+    executionContext;
+    emitWarning;
+    tools = new Map();
+    activeCalls = new Map();
+    dispossed = false;
+    constructor(client, portableTools, executionContext, emitWarning) {
+        this.client = client;
+        this.portableTools = portableTools;
+        this.executionContext = executionContext;
+        this.emitWarning = emitWarning;
+    }
+    get installedNames() {
+        return [...this.tools.keys()];
+    }
+    /** Send the current Pibo portable tool definitions to OMP via set_host_tools. */
+    async install() {
+        if (!this.portableTools || this.dispossed) {
+            await this.client.request({ type: "set_host_tools", tools: [] }, "set_host_tools");
+            return [];
+        }
+        const definitions = this.portableTools.createDefinitions();
+        this.tools.clear();
+        const wire = [];
+        for (const def of definitions) {
+            if (typeof def.name !== "string" || def.name.length === 0 || def.portable === false)
+                continue;
+            this.tools.set(def.name, def);
+            wire.push({
+                name: def.name,
+                description: typeof def.description === "string" ? def.description : "",
+                inputSchema: toolInputSchema(def),
+            });
+        }
+        const result = await this.client.request({ type: "set_host_tools", tools: wire }, "set_host_tools");
+        const data = result["data"];
+        const toolNames = isRecord(data) && Array.isArray(data.toolNames)
+            ? data.toolNames.filter((n) => typeof n === "string")
+            : [];
+        return toolNames;
+    }
+    /**
+     * Handle a host tool frame from OMP. Returns true when the frame was a host
+     * tool call/cancel (consumed); false otherwise.
+     */
+    handleFrame(frame) {
+        if (!isRecord(frame))
+            return false;
+        if (frame.type === "host_tool_call") {
+            void this.handleToolCall(frame);
+            return true;
+        }
+        if (frame.type === "host_tool_cancel") {
+            void this.handleToolCancel(frame);
+            return true;
+        }
+        return false;
+    }
+    async handleToolCall(frame) {
+        const toolName = typeof frame.toolName === "string" ? frame.toolName : "unknown";
+        const toolCallId = stringValue(frame.toolCallId);
+        const definition = this.tools.get(toolName);
+        if (!definition) {
+            await this.client
+                .sendSideChannel({ type: "host_tool_result", toolCallId, result: { content: `error: unknown host tool "${toolName}"`, isError: true } }, "host_tool_result")
+                .catch(() => { });
+            return;
+        }
+        const controller = new AbortController();
+        this.activeCalls.set(toolCallId, controller);
+        let timeoutHandle;
+        // Forward incremental Pibo tool progress as host_tool_update when the tool
+        // callback provides it.
+        const onUpdate = definition.portable === false ? undefined : (update) => {
+            void this.client
+                .sendSideChannel({ type: "host_tool_update", toolCallId, partialResult: update }, "host_tool_update")
+                .catch(() => { });
+        };
+        try {
+            const prepared = definition.prepareInput ? definition.prepareInput(frame.arguments) : frame.arguments;
+            const result = await Promise.race([
+                definition.execute(toolCallId, prepared, controller.signal, onUpdate, this.executionContext),
+                new Promise((_, reject) => {
+                    timeoutHandle = setTimeout(() => {
+                        // Abort the underlying Pibo tool so timeout doesn't leak a
+                        // still-running background execution.
+                        controller.abort();
+                        reject(new Error(`OMP host tool "${toolName}" timed out.`));
+                    }, maxToolCallTimeoutMs());
+                }),
+            ]);
+            clearTimeout(timeoutHandle);
+            const wire = this.sanitize(flattenToolResult(result));
+            await this.client.sendSideChannel({ type: "host_tool_result", toolCallId, result: wire }, "host_tool_result");
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.emitWarning(`OMP host tool "${toolName}" failed: ${message}`);
+            try {
+                await this.client.sendSideChannel({ type: "host_tool_result", toolCallId, result: { content: `error: ${message}`, isError: true } }, "host_tool_result");
+            }
+            catch {
+                // best-effort; the client may already be closing
+            }
+        }
+        finally {
+            if (timeoutHandle)
+                clearTimeout(timeoutHandle);
+            this.activeCalls.delete(toolCallId);
+        }
+    }
+    async handleToolCancel(frame) {
+        const toolCallId = stringValue(frame.toolCallId);
+        const active = this.activeCalls.get(toolCallId);
+        if (active)
+            active.abort();
+        this.activeCalls.delete(toolCallId);
+    }
+    sanitize(result) {
+        const serialized = JSON.stringify(result.content ?? "");
+        if (Buffer.byteLength(serialized, "utf8") > MAX_RESULT_BYTES) {
+            return { content: "[result truncated by Pibo]", isError: result.isError };
+        }
+        return result;
+    }
+    /** Cancel all in-flight host tool calls (used on abort/dispose). */
+    async cancelAll() {
+        for (const controller of this.activeCalls.values())
+            controller.abort();
+        this.activeCalls.clear();
+    }
+    dispose() {
+        if (this.dispossed)
+            return;
+        this.dispossed = true;
+        for (const controller of this.activeCalls.values())
+            controller.abort();
+        this.activeCalls.clear();
+    }
+}

package/dist/agent-runtimes/omp/models.js

@@ -0,0 +1,86 @@
+/** OMP thinking levels (from ai/types.ts ThinkingLevel). */
+export const OMP_REASONING_VALUES = ["none", "low", "medium", "high"];
+export const OMP_MODEL_PROVIDER_ID = "omp";
+export const OMP_MODEL_OPTIONS_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        provider: { type: "string" },
+        modelId: { type: "string" },
+        thinkingLevel: { type: "string", enum: [...OMP_REASONING_VALUES] },
+    },
+};
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function toAgentRuntimeModelCatalog(runtimeInstanceId, models) {
+    return {
+        runtimeInstanceId,
+        models: models.map(toAgentRuntimeModelInfo),
+    };
+}
+export function toAgentRuntimeModelInfo(model) {
+    return {
+        id: model.id,
+        provider: model.provider ?? OMP_MODEL_PROVIDER_ID,
+        displayName: model.name ?? model.id,
+        reasoningOptions: model.reasoning || model.thinking ? [...OMP_REASONING_VALUES] : undefined,
+        options: {
+            provider: model.provider ?? OMP_MODEL_PROVIDER_ID,
+            modelId: model.id,
+        },
+    };
+}
+export async function readOmpModelCatalog(client, runtimeInstanceId) {
+    try {
+        const result = await client.request({ type: "get_available_models" }, "get_available_models");
+        const data = result["data"];
+        if (data && typeof data === "object" && !Array.isArray(data) && "models" in data) {
+            const models = data.models;
+            if (Array.isArray(models)) {
+                const descriptors = [];
+                for (const item of models) {
+                    if (!isRecord(item))
+                        continue;
+                    if (typeof item.id !== "string" || item.id.length === 0)
+                        continue;
+                    descriptors.push({
+                        provider: typeof item.provider === "string" ? item.provider : undefined,
+                        id: item.id,
+                        name: typeof item.name === "string" ? item.name : undefined,
+                        reasoning: item.reasoning === true,
+                        thinking: item.thinking === true,
+                        contextWindow: typeof item.contextWindow === "number" ? item.contextWindow : undefined,
+                    });
+                }
+                return toAgentRuntimeModelCatalog(runtimeInstanceId, descriptors);
+            }
+        }
+    }
+    catch {
+        // Model discovery is best-effort in fixtures; empty catalog is acceptable.
+    }
+    return { runtimeInstanceId, models: [] };
+}
+export async function setOmpModel(client, provider, modelId) {
+    const result = await client.request({ type: "set_model", provider, modelId }, "set_model");
+    const data = result["data"];
+    if (isRecord(data) && typeof data.id === "string") {
+        return toAgentRuntimeModelInfo({
+            provider: typeof data.provider === "string" ? data.provider : provider,
+            id: data.id,
+            name: typeof data.name === "string" ? data.name : undefined,
+        });
+    }
+    return { id: modelId, provider };
+}
+export async function setOmpThinkingLevel(client, level) {
+    await client.request({ type: "set_thinking_level", level }, "set_thinking_level");
+}
+export function parseOmpReasoning(level) {
+    if (typeof level === "string" && level.length > 0) {
+        const normalized = OMP_REASONING_VALUES.includes(level) ? level : "medium";
+        return { value: normalized, availableValues: [...OMP_REASONING_VALUES], supported: true };
+    }
+    return { availableValues: [...OMP_REASONING_VALUES], supported: true };
+}

package/dist/agent-runtimes/omp/process.js

@@ -0,0 +1,283 @@
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { mkdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { OmpRpcClient } from "./client.js";
+const MAX_VERSION_OUTPUT_BYTES = 256 * 1024;
+const PRIVATE_DIRECTORY_MODE = 0o700;
+const PRIVATE_FILE_MODE = 0o600;
+const RESOURCE_ENVIRONMENT_KEY_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export class OmpProcessError extends Error {
+    code;
+    constructor(code, message, options = {}) {
+        super(message, options);
+        this.code = code;
+        this.name = "OmpProcessError";
+    }
+}
+function safeSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+}
+function nodeErrorCode(error) {
+    return error instanceof Error && "code" in error && typeof error.code === "string"
+        ? (error.code ?? undefined)
+        : undefined;
+}
+async function ensurePrivateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+}
+async function ensurePrivateConfig(path) {
+    await mkdir(dirname(path), { recursive: true, mode: PRIVATE_DIRECTORY_MODE });
+    try {
+        await stat(path);
+    }
+    catch {
+        await writeFile(path, "", { mode: PRIVATE_FILE_MODE });
+    }
+}
+export async function prepareOmpInstancePaths(config, runtimeInstanceId) {
+    const root = resolve(config.homeRoot, safeSegment(runtimeInstanceId) || "orp");
+    return {
+        root,
+        agentDir: join(root, "agent"),
+        config: join(root, "agent", "config.yml"),
+        skills: join(root, "agent", "skills"),
+        context: join(root, "agent", "context"),
+    };
+}
+export async function prepareOmpSessionPaths(input) {
+    const instanceKey = safeSegment(input.runtimeInstanceId) || "orp";
+    const sessionKey = safeSegment(input.piboSessionId) || "session";
+    const generationKey = safeSegment(input.sessionGeneration) || "gen";
+    // Instance root is shared/persistent; never delete it on session dispose.
+    const instanceRoot = resolve(input.config.homeRoot, instanceKey);
+    // Config/agent state is per-session (not shared) so one session's dispose can
+    // never destroy another session's config or transcript. agentDir/config live
+    // under a per-piboSessionId directory; sessionDir (OMP's transcript store) is
+    // stable across generations for resume.
+    const sessionRoot = join(instanceRoot, "sessions", sessionKey);
+    const paths = {
+        root: join(sessionRoot, generationKey),
+        agentDir: join(sessionRoot, "agent"),
+        config: join(sessionRoot, "agent", "config.yml"),
+        skills: join(sessionRoot, "agent", "skills"),
+        context: join(sessionRoot, "agent", "context"),
+        piboSessionId: input.piboSessionId,
+        sessionGeneration: input.sessionGeneration,
+        // OMP transcript store: stable across generations so a resumed session
+        // re-attaches to the same native session files.
+        sessionDir: join(sessionRoot, "omp-sessions"),
+    };
+    await ensurePrivateDirectory(instanceRoot);
+    await ensurePrivateDirectory(paths.agentDir);
+    await ensurePrivateDirectory(paths.skills);
+    await ensurePrivateDirectory(paths.context);
+    await ensurePrivateDirectory(paths.sessionDir);
+    await ensurePrivateConfig(paths.config);
+    return paths;
+}
+/**
+ * Release the ephemeral session generation directory. The per-session agent
+ * dir, config.yml, and OMP transcript store are deliberately NOT removed — they
+ * belong to the Pibo Session across generations and are needed for resume.
+ */
+export async function disposeOmpSessionPaths(paths) {
+    await rm(paths.root, { recursive: true, force: true });
+}
+/**
+ * Build the environment for the OMP child. The agent dir is redirected via
+ * `PI_CODING_AGENT_DIR` (and `PI_CONFIG_DIR`) so all OMP user-global state is
+ * isolated under the Pibo-owned home — the real `~/.omp` is never touched.
+ * Only allow-listed keys are inherited; provider API keys are passed through
+ * from the allowlisted key set (model auth is provider-config via models.yml +
+ * env).
+ */
+export function buildOmpProcessEnvironment(input) {
+    const base = input.baseEnvironment ?? process.env;
+    // PI_CODING_AGENT_DIR is the authoritative override for ~/.omp (getAgentDir).
+    // We must NOT set OMP_PROFILE: it relocates getAgentDir() under
+    // <agentDir>/profiles/<name>, which would break the config.yml lookup (config
+    // is written at <agentDir>/config.yml). No PI_CONFIG_DIR either — OMP does not
+    // use it to locate config.
+    const env = {
+        PI_CODING_AGENT_DIR: input.paths.agentDir,
+        PI_NO_TITLE: "1",
+    };
+    const allowlist = new Set([...input.config.environmentAllowlist, ...input.config.apiKeyEnvironment]);
+    for (const [key, value] of Object.entries(base)) {
+        if (allowlist.has(key) && value !== undefined) {
+            env[key] = value;
+        }
+    }
+    return env;
+}
+async function probeOmpVersion(config, environment) {
+    return await new Promise((resolveProbe) => {
+        const command = ["--version"];
+        let child;
+        try {
+            child = spawn(config.bunExecutable, [config.ompEntry, ...command], {
+                env: environment,
+                stdio: ["ignore", "pipe", "pipe"],
+            });
+        }
+        catch (error) {
+            resolveProbe({ status: "failed", errorCode: nodeErrorCode(error) });
+            return;
+        }
+        let settled = false;
+        let bytes = 0;
+        const chunks = [];
+        const settle = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolveProbe(result);
+        };
+        const collect = (chunk) => {
+            bytes += chunk.length;
+            if (bytes > MAX_VERSION_OUTPUT_BYTES) {
+                child?.kill("SIGKILL");
+                settle({ status: "too_large" });
+                return;
+            }
+            chunks.push(Buffer.from(chunk));
+        };
+        child.stdout?.on("data", collect);
+        child.stderr?.on("data", collect);
+        child.once("error", (error) => {
+            settle(error.code === "ENOENT" ? { status: "missing" } : { status: "failed", errorCode: nodeErrorCode(error) });
+        });
+        child.once("close", (code) => {
+            if (settled)
+                return;
+            if (code !== 0) {
+                settle({ status: "failed", exitCode: code });
+                return;
+            }
+            settle({ status: "ok", output: Buffer.concat(chunks).toString("utf8") });
+        });
+        const timer = setTimeout(() => {
+            child?.kill("SIGKILL");
+            settle({ status: "timeout" });
+        }, config.diagnosticTimeoutMs);
+    });
+}
+export async function diagnoseOmpRuntime(config, runtimeInstanceId, options = {}) {
+    const diagnostics = [];
+    if (!config.ompEntry) {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_entry_unset",
+            message: `No OMP CLI entry is configured for runtime instance "${runtimeInstanceId}".`,
+            path: "config.ompEntry",
+        });
+        return diagnostics;
+    }
+    let paths;
+    try {
+        paths = await prepareOmpSessionPaths({
+            config,
+            runtimeInstanceId,
+            piboSessionId: "runtime-diagnostics",
+            sessionGeneration: `version-probe-${randomUUID()}`,
+        });
+    }
+    catch (error) {
+        const errorCode = nodeErrorCode(error);
+        diagnostics.push({
+            severity: "error",
+            code: "omp_home_unavailable",
+            message: `Private OMP state is unavailable for runtime instance "${runtimeInstanceId}".`,
+            path: "config.homeRoot",
+            ...(errorCode ? { details: { errorCode } } : {}),
+        });
+        return diagnostics;
+    }
+    diagnostics.push({
+        severity: "info",
+        code: "omp_home_ready",
+        message: `Private OMP state is ready for runtime instance "${runtimeInstanceId}".`,
+        details: { scope: "configured-instance", private: true },
+    });
+    let probe;
+    try {
+        probe = await probeOmpVersion(config, buildOmpProcessEnvironment({ paths, config, baseEnvironment: options.baseEnvironment ?? process.env }));
+    }
+    finally {
+        await disposeOmpSessionPaths(paths);
+    }
+    if (probe.status === "missing") {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_bun_not_found",
+            message: `Bun executable is not available for runtime instance "${runtimeInstanceId}".`,
+            path: "config.bunExecutable",
+        });
+        return diagnostics;
+    }
+    if (probe.status === "timeout") {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_version_probe_timeout",
+            message: `OMP version inspection timed out for runtime instance "${runtimeInstanceId}".`,
+            path: "config.diagnosticTimeoutMs",
+        });
+        return diagnostics;
+    }
+    if (probe.status === "too_large") {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_version_probe_too_large",
+            message: `OMP version inspection produced too much output for runtime instance "${runtimeInstanceId}".`,
+        });
+        return diagnostics;
+    }
+    if (probe.status === "failed") {
+        diagnostics.push({
+            severity: "error",
+            code: "omp_version_probe_failed",
+            message: `OMP CLI version inspection failed for runtime instance "${runtimeInstanceId}".`,
+            ...(probe.exitCode !== undefined || probe.errorCode
+                ? {
+                    details: {
+                        ...(probe.exitCode !== undefined ? { exitCode: probe.exitCode } : {}),
+                        ...(probe.errorCode ? { errorCode: probe.errorCode } : {}),
+                    },
+                }
+                : {}),
+        });
+        return diagnostics;
+    }
+    const version = probe.output.trim().split("\n").slice(-1)[0] ?? "";
+    diagnostics.push({
+        severity: "info",
+        code: "omp_version_ok",
+        message: `OMP CLI is available for runtime instance "${runtimeInstanceId}".`,
+        details: { version: version || "unknown", private: true },
+    });
+    return diagnostics;
+}
+export async function startOmpProcess(input) {
+    const client = new OmpRpcClient({
+        startupTimeoutMs: input.startupTimeoutMs,
+        requestTimeoutMs: input.requestTimeoutMs,
+    });
+    await client.connect(Array.from(input.ompCommand), {
+        cwd: input.cwd,
+        env: input.environment,
+    });
+    return client;
+}
+/**
+ * Build the OMP child command. ompEntry is validated as an absolute path at
+ * config-parse time (config.ompEntry), so the command is never resolved against
+ * the arbitrary session workspace.
+ */
+export function resolveOmpCommand(config, paths) {
+    if (!config.ompEntry) {
+        throw new Error("OMP CLI entry is not configured; set config.ompEntry to an absolute CLI path.");
+    }
+    return [config.bunExecutable, config.ompEntry, "--mode", "rpc", "--session-dir", paths.sessionDir];
+}