@oh-my-pi/pi-coding-agent 16.1.12 → 16.1.14

package/dist/types/config/settings-schema.d.ts

@@ -2886,16 +2886,6 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Prepend line numbers to read tool output by default";
         };
     };
-    readonly readHashLines: {
-        readonly type: "boolean";
-        readonly default: true;
-        readonly ui: {
-            readonly tab: "files";
-            readonly group: "Reading";
-            readonly label: "Hash Lines";
-            readonly description: "Include snapshot-tag headers and line numbers in read output for hashline edit mode ([PATH#TAG] plus LINE:content)";
-        };
-    };
     readonly "read.defaultLimit": {
         readonly type: "number";
         readonly default: 300;
@@ -3152,7 +3142,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly default: true;
         readonly ui: {
             readonly tab: "shell";
-            readonly group: "Eval & Python";
+            readonly group: "Eval & Runtimes";
             readonly label: "Python Eval Backend";
             readonly description: "Allow the eval tool to dispatch Python cells to the IPython kernel";
         };
@@ -3162,18 +3152,38 @@ export declare const SETTINGS_SCHEMA: {
         readonly default: true;
         readonly ui: {
             readonly tab: "shell";
-            readonly group: "Eval & Python";
+            readonly group: "Eval & Runtimes";
             readonly label: "JavaScript Eval Backend";
             readonly description: "Allow the eval tool to dispatch JavaScript cells to the in-process runtime";
         };
     };
+    readonly "eval.rb": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "shell";
+            readonly group: "Eval & Runtimes";
+            readonly label: "Ruby Eval Backend";
+            readonly description: "Allow the eval tool to dispatch Ruby cells to the persistent Ruby kernel";
+        };
+    };
+    readonly "eval.jl": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "shell";
+            readonly group: "Eval & Runtimes";
+            readonly label: "Julia Eval Backend";
+            readonly description: "Allow the eval tool to dispatch Julia cells to the persistent Julia kernel";
+        };
+    };
     readonly "python.kernelMode": {
         readonly type: "enum";
         readonly values: readonly ["session", "per-call"];
         readonly default: "session";
         readonly ui: {
             readonly tab: "shell";
-            readonly group: "Eval & Python";
+            readonly group: "Eval & Runtimes";
             readonly label: "Python Kernel Mode";
             readonly description: "Keep the IPython kernel alive across eval calls or start fresh each time";
         };
@@ -3183,11 +3193,31 @@ export declare const SETTINGS_SCHEMA: {
         readonly default: "";
         readonly ui: {
             readonly tab: "shell";
-            readonly group: "Eval & Python";
+            readonly group: "Eval & Runtimes";
             readonly label: "Python Interpreter";
             readonly description: "Optional path to an exact Python executable. When set, automatic Python runtime discovery is skipped.";
         };
     };
+    readonly "ruby.interpreter": {
+        readonly type: "string";
+        readonly default: "";
+        readonly ui: {
+            readonly tab: "shell";
+            readonly group: "Eval & Runtimes";
+            readonly label: "Ruby Interpreter";
+            readonly description: "Optional path to an exact Ruby executable. When set, automatic Ruby runtime discovery is skipped.";
+        };
+    };
+    readonly "julia.interpreter": {
+        readonly type: "string";
+        readonly default: "";
+        readonly ui: {
+            readonly tab: "shell";
+            readonly group: "Eval & Runtimes";
+            readonly label: "Julia Interpreter";
+            readonly description: "Optional path to an exact Julia executable. When set, automatic Julia runtime discovery is skipped.";
+        };
+    };
     readonly "tools.approval": {
         readonly type: "record";
         readonly default: {};

package/dist/types/cursor.d.ts

@@ -9,14 +9,14 @@ interface CursorExecBridgeOptions {
 export declare class CursorExecHandlers implements ICursorExecHandlers {
     private options;
     constructor(options: CursorExecBridgeOptions);
-    read(args: Parameters<NonNullable<ICursorExecHandlers["read"]>>[0]): Promise<ToolResultMessage<any>>;
-    ls(args: Parameters<NonNullable<ICursorExecHandlers["ls"]>>[0]): Promise<ToolResultMessage<any>>;
-    grep(args: Parameters<NonNullable<ICursorExecHandlers["grep"]>>[0]): Promise<ToolResultMessage<any>>;
-    write(args: Parameters<NonNullable<ICursorExecHandlers["write"]>>[0]): Promise<ToolResultMessage<any>>;
-    delete(args: Parameters<NonNullable<ICursorExecHandlers["delete"]>>[0]): Promise<ToolResultMessage<any>>;
-    shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]): Promise<ToolResultMessage<any>>;
-    shellStream(args: Parameters<NonNullable<ICursorExecHandlers["shellStream"]>>[0], callbacks: CursorShellStreamCallbacks): Promise<ToolResultMessage<any>>;
-    diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]): Promise<ToolResultMessage<any>>;
-    mcp(call: CursorMcpCall): Promise<ToolResultMessage<any>>;
+    read(args: Parameters<NonNullable<ICursorExecHandlers["read"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    ls(args: Parameters<NonNullable<ICursorExecHandlers["ls"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    grep(args: Parameters<NonNullable<ICursorExecHandlers["grep"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    write(args: Parameters<NonNullable<ICursorExecHandlers["write"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    delete(args: Parameters<NonNullable<ICursorExecHandlers["delete"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    shell(args: Parameters<NonNullable<ICursorExecHandlers["shell"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    shellStream(args: Parameters<NonNullable<ICursorExecHandlers["shellStream"]>>[0], callbacks: CursorShellStreamCallbacks): Promise<ToolResultMessage<unknown>>;
+    diagnostics(args: Parameters<NonNullable<ICursorExecHandlers["diagnostics"]>>[0]): Promise<ToolResultMessage<unknown>>;
+    mcp(call: CursorMcpCall): Promise<ToolResultMessage<unknown>>;
 }
 export {};

package/dist/types/eval/__tests__/julia-prelude.test.d.ts

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

package/dist/types/eval/backend-helpers.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Helpers shared by the per-language eval backend definitions (jl/js/py/rb
+ * index modules): session-id namespacing, settings access, and projection of
+ * executor results into the ExecutorBackend result shape.
+ */
+import type { ToolSession } from "../tools";
+import type { ExecutorBackendResult } from "./backend";
+import type { EvalDisplayOutput } from "./types";
+export declare function namespaceSessionId(sessionId: string, prefix: string): string;
+export declare function readSetting<T>(session: ToolSession, key: string): T | undefined;
+export declare function readInterpreterSetting(session: ToolSession, key: string): string | undefined;
+export declare function toExecutorBackendResult(result: {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId?: string | undefined;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: EvalDisplayOutput[];
+}): ExecutorBackendResult;

package/dist/types/eval/executor-base.d.ts

@@ -0,0 +1,118 @@
+import type { ToolSession } from "../tools";
+import type { JsStatusEvent } from "./js/shared/types";
+import type { KernelDisplayOutput } from "./py/display";
+/**
+ * Constructor for a language executor's cancellation error. Each backend
+ * subclasses {@link Error} and carries a `timedOut` flag distinguishing a
+ * deadline expiry from a plain abort.
+ */
+export type CancelledErrorClass = new (timedOut: boolean) => Error & {
+    timedOut: boolean;
+};
+/** Managed-env values a kernel patch may carry (`null` clears, `undefined` skips). */
+export type KernelEnvPatch = Record<string, string | null | undefined>;
+/**
+ * Options every kernel-backed language executor shares. Per-language option
+ * interfaces structurally extend this; the base executor only reads these.
+ */
+export interface KernelExecutorBaseOptions {
+    cwd?: string;
+    timeoutMs?: number;
+    deadlineMs?: number;
+    idleTimeoutMs?: number;
+    onChunk?: (chunk: string) => Promise<void> | void;
+    signal?: AbortSignal;
+    onStatus?: (event: JsStatusEvent) => void;
+    emitStatus?: (event: JsStatusEvent) => void;
+    toolSession?: ToolSession;
+    bridgeSessionId?: string;
+    artifactId?: string;
+    artifactPath?: string;
+}
+/** Normalised execution result produced by {@link executeWithKernelBase}. */
+export interface KernelExecutionResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId: string | undefined;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: KernelDisplayOutput[];
+    stdinRequested: boolean;
+}
+/** Minimal kernel surface the base executor drives, satisfied by every backend kernel. */
+export interface GenericKernel<TEnv> {
+    execute(code: string, options: {
+        cwd?: string;
+        env?: TEnv;
+        id: string;
+        signal?: AbortSignal;
+        timeoutMs?: number;
+        onChunk: (text: string) => Promise<void> | void;
+        onDisplay: (output: KernelDisplayOutput) => Promise<void> | void;
+    }): Promise<{
+        status: "ok" | "error";
+        cancelled: boolean;
+        timedOut: boolean;
+        kernelKilled?: boolean;
+        stdinRequested?: boolean;
+    }>;
+}
+export declare function getExecutionDeadlineMs(options?: {
+    deadlineMs?: number;
+    timeoutMs?: number;
+}): number | undefined;
+export declare function getRemainingTimeoutMs(deadlineMs?: number): number | undefined;
+export declare function isCancellationError(error: unknown, cancelledErrorClass: CancelledErrorClass): boolean;
+export declare function isTimedOutCancellation(error: unknown, cancelledErrorClass: CancelledErrorClass, signal?: AbortSignal): boolean;
+export declare function waitForPromiseWithCancellation<T>(promise: Promise<T>, options: {
+    signal?: AbortSignal;
+    deadlineMs?: number;
+}, cancelledErrorClass: CancelledErrorClass): Promise<T>;
+export declare function createCancelledKernelResult(output: string): KernelExecutionResult;
+export declare const MANAGED_KERNEL_ENV_KEYS: readonly ["PI_SESSION_FILE", "PI_ARTIFACTS_DIR", "PI_TOOL_BRIDGE_URL", "PI_TOOL_BRIDGE_TOKEN", "PI_TOOL_BRIDGE_SESSION", "PI_EVAL_LOCAL_ROOTS"];
+interface ManagedKernelEnvOptions {
+    sessionFile?: string;
+    artifactsDir?: string;
+    bridgeSessionId?: string;
+    bridge?: {
+        url: string;
+        token: string;
+    };
+    localRoots?: Record<string, string>;
+}
+export declare function buildManagedKernelEnvPatch(options: ManagedKernelEnvOptions): Record<string, string | null>;
+export declare function buildManagedKernelEnv(options: ManagedKernelEnvOptions): Record<string, string> | undefined;
+export declare function attachSessionOwner(session: {
+    ownerIds: Set<string>;
+    hasFallbackOwner: boolean;
+}, sessionId: string, ownerId: string | undefined): void;
+export interface ExecuteWithKernelBaseParams<TOptions extends KernelExecutorBaseOptions, TEnv extends KernelEnvPatch = Record<string, string | null>> {
+    kernel: GenericKernel<TEnv>;
+    code: string;
+    options: TOptions | undefined;
+    /** Prefix for the per-execution run id (e.g. `"py"`, `"rb"`, `"jl"`). */
+    runIdPrefix: string;
+    /** Human-readable language label used in the failure log line. */
+    errorLogLabel: string;
+    /**
+     * Julia surfaces eval-timeout control events through its normal status path,
+     * so they must NOT be filtered out the way the JS-status backends do.
+     */
+    isJulia?: boolean;
+    cancelledErrorClass: CancelledErrorClass;
+    buildKernelEnvPatch: (options: TOptions) => TEnv;
+    formatKernelTimeoutAnnotation: (executionTimeoutMs: number | undefined, kernelKilled: boolean) => string;
+    formatTimeoutAnnotation: (executionTimeoutMs: number | undefined) => string | undefined;
+    /**
+     * Override how the wall-clock deadline is derived from options. Defaults to
+     * {@link getExecutionDeadlineMs}; Julia passes the pre-computed `deadlineMs`
+     * straight through instead of re-deriving from `timeoutMs`.
+     */
+    resolveDeadlineMs?: (options: TOptions | undefined) => number | undefined;
+}
+export declare function executeWithKernelBase<TOptions extends KernelExecutorBaseOptions, TEnv extends KernelEnvPatch = Record<string, string | null>>(params: ExecuteWithKernelBaseParams<TOptions, TEnv>): Promise<KernelExecutionResult>;
+export {};

package/dist/types/eval/index.d.ts

@@ -1,4 +1,6 @@
 export * from "./backend";
+export { default as juliaBackend } from "./jl";
 export { default as jsBackend } from "./js";
 export { default as pythonBackend } from "./py";
+export { default as rubyBackend } from "./rb";
 export * from "./types";

package/dist/types/eval/jl/executor.d.ts

@@ -0,0 +1,44 @@
+import type { ToolSession } from "../../tools";
+import { type PyToolBridgeInfo } from "../py/tool-bridge";
+import type { EvalDisplayOutput, EvalStatusEvent } from "../types";
+import { JuliaKernel, type KernelExecuteOptions, type KernelExecuteResult } from "./kernel";
+export interface JuliaExecutorOptions {
+    cwd?: string;
+    sessionId?: string;
+    sessionFile?: string;
+    artifactsDir?: string;
+    localRoots?: Record<string, string>;
+    interpreter?: string;
+    onChunk?: (text: string) => void | Promise<void>;
+    onStatus?: (event: EvalStatusEvent) => void;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    deadlineMs?: number;
+    idleTimeoutMs?: number;
+    kernelOwnerId?: string;
+    reset?: boolean;
+    toolSession?: ToolSession;
+    bridge?: PyToolBridgeInfo;
+    bridgeSessionId?: string;
+    artifactId?: string;
+}
+export interface JuliaKernelExecutor {
+    execute: (code: string, options?: KernelExecuteOptions) => Promise<KernelExecuteResult>;
+}
+export interface JuliaResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId: string | undefined;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: EvalDisplayOutput[];
+    stdinRequested: boolean;
+}
+export declare function disposeAllJuliaKernelSessions(): Promise<void>;
+export declare function disposeJuliaKernelSessionsByOwner(ownerId: string): Promise<void>;
+export declare function executeJuliaWithKernel(kernel: JuliaKernel, code: string, options?: JuliaExecutorOptions): Promise<JuliaResult>;
+export declare function executeJulia(code: string, options?: JuliaExecutorOptions): Promise<JuliaResult>;

package/dist/types/eval/jl/index.d.ts

@@ -0,0 +1,11 @@
+import type { ToolSession } from "../../tools";
+import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
+export declare function namespaceSessionId(sessionId: string): string;
+declare const _default: {
+    id: "julia";
+    label: string;
+    highlightLang: string;
+    isAvailable(session: ToolSession): Promise<boolean>;
+    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+};
+export default _default;

package/dist/types/eval/jl/kernel.d.ts

@@ -0,0 +1,28 @@
+import { BaseKernel, type KernelStartOptions } from "../kernel-base";
+import type { KernelDisplayOutput } from "../py/display";
+import { type JuliaRuntime } from "./runtime";
+export type { KernelExecuteResult, KernelRuntimeEnv } from "../kernel-base";
+export { renderKernelDisplay } from "../py/display";
+export type { KernelDisplayOutput };
+export interface KernelExecuteOptions {
+    id?: string;
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    silent?: boolean;
+    storeHistory?: boolean;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+    onChunk?: (text: string) => void | Promise<void>;
+    onDisplay?: (output: KernelDisplayOutput) => void | Promise<void>;
+}
+export interface JuliaKernelAvailability {
+    ok: boolean;
+    juliaPath?: string;
+    runtime?: JuliaRuntime;
+    reason?: string;
+}
+export declare function checkJuliaKernelAvailability(cwd: string, interpreter?: string): Promise<JuliaKernelAvailability>;
+export declare class JuliaKernel extends BaseKernel<KernelExecuteOptions> {
+    private constructor();
+    static start(options: KernelStartOptions): Promise<JuliaKernel>;
+}

package/dist/types/eval/jl/prelude.d.ts

@@ -0,0 +1 @@
+export declare const JULIA_PRELUDE: string;

package/dist/types/eval/jl/runtime.d.ts

@@ -0,0 +1,22 @@
+export interface JuliaRuntime {
+    /** Path to the julia executable. */
+    juliaPath: string;
+    /** Filtered environment variables. */
+    env: Record<string, string | undefined>;
+}
+export declare const filterEnv: (env: Record<string, string | undefined>) => Record<string, string | undefined>;
+/**
+ * Resolve an explicitly configured interpreter (`julia.interpreter`) into a
+ * runtime, bypassing discovery. Does not probe the executable.
+ * `~` expands to the home directory and relative paths resolve against `cwd`.
+ */
+export declare function resolveExplicitJuliaRuntime(interpreter: string, cwd: string, baseEnv: Record<string, string | undefined>): JuliaRuntime;
+/**
+ * Enumerate candidate Julia runtimes in priority order. With an explicit
+ * interpreter that is the only candidate; otherwise the first `julia` on PATH.
+ */
+export declare function enumerateJuliaRuntimes(cwd: string, baseEnv: Record<string, string | undefined>, interpreter?: string): JuliaRuntime[];
+/**
+ * Resolve the highest-priority Julia runtime. Throws when none exists.
+ */
+export declare function resolveJuliaRuntime(cwd: string, baseEnv: Record<string, string | undefined>, interpreter?: string): JuliaRuntime;

package/dist/types/eval/kernel-base.d.ts

@@ -0,0 +1,105 @@
+import type { Subprocess } from "bun";
+import { type KernelDisplayOutput } from "./py/display";
+export type KernelRuntimeEnv = Record<string, string | null>;
+export interface KernelExecuteOptions {
+    id?: string;
+    /** Runtime working directory applied immediately before this request executes. */
+    cwd?: string;
+    /** Managed runtime environment variables applied immediately before this request executes. */
+    env?: Record<string, string | undefined> | Record<string, string | null>;
+    signal?: AbortSignal;
+    onChunk?: (text: string) => Promise<void> | void;
+    onDisplay?: (output: KernelDisplayOutput) => Promise<void> | void;
+    timeoutMs?: number;
+    silent?: boolean;
+    storeHistory?: boolean;
+    allowStdin?: boolean;
+}
+export interface KernelExecuteResult {
+    status: "ok" | "error";
+    executionCount?: number;
+    error?: {
+        name: string;
+        value: string;
+        traceback: string[];
+    };
+    cancelled: boolean;
+    timedOut: boolean;
+    stdinRequested: boolean;
+    /**
+     * True when the kernel subprocess was killed as part of settling this
+     * execution (e.g. SIGINT was ignored and we escalated to shutdown, or the
+     * kernel died unexpectedly). When false, the kernel remains reusable.
+     */
+    kernelKilled?: boolean;
+}
+export interface KernelShutdownResult {
+    confirmed: boolean;
+}
+export interface KernelShutdownOptions {
+    signal?: AbortSignal;
+    timeoutMs?: number;
+}
+/** Per-language lifecycle configuration consumed by each kernel's `start()`. */
+export interface KernelStartOptions {
+    cwd: string;
+    env?: Record<string, string | undefined>;
+    /** Explicit interpreter path; skips discovery when set. */
+    interpreter?: string;
+    signal?: AbortSignal;
+    deadlineMs?: number;
+}
+/** Per-language configuration handed to {@link BaseKernel} by each subclass. */
+export interface BaseKernelOptions<TExecuteOptions extends KernelExecuteOptions = KernelExecuteOptions> {
+    /** Human-readable language label used in log messages and errors. */
+    languageName: string;
+    /** When true, every IPC frame is logged at debug level. */
+    traceIpc: boolean;
+    /** Wire payload asking the runner to exit cleanly. */
+    exitPayload: string;
+    /** How long to wait after SIGINT before escalating to subprocess termination. */
+    interruptEscalationMs: number;
+    /** Default grace period applied by {@link BaseKernel.shutdown}. */
+    shutdownGraceMs: number;
+    /** Serializes an execution request into the runner's wire protocol. */
+    buildPayload: (code: string, msgId: string, options?: TExecuteOptions) => string;
+}
+export type FrameType = "started" | "stdout" | "stderr" | "display" | "result" | "error" | "done";
+export interface Frame {
+    type: FrameType;
+    id?: string;
+    data?: string;
+    bundle?: Record<string, unknown>;
+    ename?: string;
+    evalue?: string;
+    traceback?: string[];
+    status?: "ok" | "error";
+    executionCount?: number;
+    cancelled?: boolean;
+}
+export declare function getRemainingTimeMs(deadlineMs?: number): number | undefined;
+export declare function createAbortError(name: "AbortError" | "TimeoutError", message: string): Error;
+export declare function throwIfAborted(signal: AbortSignal | undefined, fallbackReason: string): void;
+export declare function isTimeoutReason(reason: unknown): boolean;
+/**
+ * Shared subprocess-backed kernel machinery for the language runners. Each
+ * language subclasses this, supplying its binary/runner via a static `start()`
+ * and its wire protocol via {@link BaseKernelOptions.buildPayload}. The IPC loop
+ * speaks NDJSON: the runner emits one JSON {@link Frame} per line; outbound
+ * requests are serialized by `buildPayload` (which may itself be NDJSON or any
+ * other line-delimited encoding).
+ *
+ * `TExecuteOptions` is the language's own execute-options type so each runner's
+ * `buildPayload` sees its precise option shape (e.g. environment-map variants).
+ */
+export declare abstract class BaseKernel<TExecuteOptions extends KernelExecuteOptions = KernelExecuteOptions> {
+    #private;
+    readonly id: string;
+    constructor(id: string, options: BaseKernelOptions<TExecuteOptions>);
+    setProcess(proc: Subprocess<"pipe", "pipe", "pipe">): void;
+    isAlive(): boolean;
+    execute(code: string, options?: TExecuteOptions): Promise<KernelExecuteResult>;
+    interrupt(): Promise<void>;
+    shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult>;
+    executeWithBudget(code: string, signal: AbortSignal | undefined, timeoutMs: number, label: string): Promise<void>;
+}

package/dist/types/eval/py/kernel.d.ts

@@ -1,60 +1,8 @@
-import { type KernelDisplayOutput } from "./display";
+import { BaseKernel, type KernelStartOptions } from "../kernel-base";
 import { type PythonRuntime } from "./runtime";
+export type { KernelExecuteOptions, KernelExecuteResult, KernelRuntimeEnv, KernelShutdownOptions, KernelShutdownResult, } from "../kernel-base";
 export type { KernelDisplayOutput, PythonStatusEvent } from "./display";
 export { renderKernelDisplay } from "./display";
-export type KernelRuntimeEnv = Record<string, string | null>;
-export interface KernelExecuteOptions {
-    id?: string;
-    /** Runtime working directory applied immediately before this request executes. */
-    cwd?: string;
-    /** Managed runtime environment variables applied immediately before this request executes. */
-    env?: KernelRuntimeEnv;
-    signal?: AbortSignal;
-    onChunk?: (text: string) => Promise<void> | void;
-    onDisplay?: (output: KernelDisplayOutput) => Promise<void> | void;
-    timeoutMs?: number;
-    silent?: boolean;
-    storeHistory?: boolean;
-    allowStdin?: boolean;
-}
-export interface KernelExecuteResult {
-    status: "ok" | "error";
-    executionCount?: number;
-    error?: {
-        name: string;
-        value: string;
-        traceback: string[];
-    };
-    cancelled: boolean;
-    timedOut: boolean;
-    stdinRequested: boolean;
-    /**
-     * True when the kernel subprocess was killed as part of settling this
-     * execution (e.g. SIGINT was ignored and we escalated to shutdown, or the
-     * kernel died unexpectedly). When false, the kernel remains reusable.
-     */
-    kernelKilled?: boolean;
-}
-export interface KernelShutdownResult {
-    confirmed: boolean;
-}
-interface KernelLifecycleOptions {
-    signal?: AbortSignal;
-    deadlineMs?: number;
-}
-interface KernelStartOptions extends KernelLifecycleOptions {
-    cwd: string;
-    env?: Record<string, string | undefined>;
-    /**
-     * Explicit interpreter path (`python.interpreter` from the session's
-     * settings). When set, runtime discovery is skipped entirely.
-     */
-    interpreter?: string;
-}
-interface KernelShutdownOptions {
-    signal?: AbortSignal;
-    timeoutMs?: number;
-}
 export interface PythonKernelAvailability {
     ok: boolean;
     pythonPath?: string;
@@ -63,13 +11,7 @@ export interface PythonKernelAvailability {
     runtime?: PythonRuntime;
 }
 export declare function checkPythonKernelAvailability(cwd: string, interpreter?: string): Promise<PythonKernelAvailability>;
-export declare class PythonKernel {
-    #private;
-    readonly id: string;
+export declare class PythonKernel extends BaseKernel {
     private constructor();
     static start(options: KernelStartOptions): Promise<PythonKernel>;
-    isAlive(): boolean;
-    execute(code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult>;
-    interrupt(): Promise<void>;
-    shutdown(options?: KernelShutdownOptions): Promise<KernelShutdownResult>;
 }

package/dist/types/eval/rb/executor.d.ts

@@ -0,0 +1,77 @@
+import type { ToolSession } from "../../tools";
+import type { JsStatusEvent } from "../js/shared/types";
+import { type KernelDisplayOutput, type KernelExecuteOptions, type KernelExecuteResult } from "./kernel";
+export interface RubyExecutorOptions {
+    /** Working directory for command execution */
+    cwd?: string;
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+    /** Absolute wall-clock deadline in milliseconds since epoch */
+    deadlineMs?: number;
+    /**
+     * Runtime-work budget (ms). Used only for timeout-annotation text when the
+     * caller drives cancellation via the eval watchdog `signal`. Does not arm a timer.
+     */
+    idleTimeoutMs?: number;
+    /** Callback for streaming output chunks (already sanitized) */
+    onChunk?: (chunk: string) => Promise<void> | void;
+    /** AbortSignal for cancellation */
+    signal?: AbortSignal;
+    /** Session identifier for kernel reuse */
+    sessionId?: string;
+    /** Logical owner identifier for retained kernel cleanup */
+    kernelOwnerId?: string;
+    /** Explicit interpreter path (`ruby.interpreter`). Skips discovery when set. */
+    interpreter?: string;
+    /** Restart the kernel before executing */
+    reset?: boolean;
+    /** Session file path for accessing task outputs */
+    sessionFile?: string;
+    /** Effective artifacts directory for the current session. */
+    artifactsDir?: string;
+    /** Artifact path/id for full output storage */
+    artifactPath?: string;
+    artifactId?: string;
+    /**
+     * On-disk roots the prelude helpers substitute for internal-URL schemes
+     * (e.g. `{ local: "/…/artifacts/local" }`). Exported to the kernel as
+     * `PI_EVAL_LOCAL_ROOTS` (JSON).
+     */
+    localRoots?: Record<string, string>;
+    /**
+     * ToolSession used to resolve host-side `tool.<name>(args)` calls. When
+     * omitted, the bridge env vars are not injected and `tool.foo(...)` raises.
+     */
+    toolSession?: ToolSession;
+    /** Callback for status events emitted by tool bridge invocations. */
+    emitStatus?: (event: JsStatusEvent) => void;
+    /** Live status events streamed as they are emitted. */
+    onStatus?: (event: JsStatusEvent) => void;
+    /** @internal Bridge session id, set by `executeRuby` before delegating. */
+    bridgeSessionId?: string;
+    /** @internal Bridge endpoint info, set by `executeRuby` before delegating. */
+    bridge?: {
+        url: string;
+        token: string;
+    };
+}
+export interface RubyKernelExecutor {
+    execute: (code: string, options?: KernelExecuteOptions) => Promise<KernelExecuteResult>;
+}
+export interface RubyResult {
+    output: string;
+    exitCode: number | undefined;
+    cancelled: boolean;
+    truncated: boolean;
+    artifactId?: string;
+    totalLines: number;
+    totalBytes: number;
+    outputLines: number;
+    outputBytes: number;
+    displayOutputs: KernelDisplayOutput[];
+    stdinRequested: boolean;
+}
+export declare function disposeAllRubyKernelSessions(): Promise<void>;
+export declare function disposeRubyKernelSessionsByOwner(ownerId: string): Promise<void>;
+export declare function executeRubyWithKernel(kernel: RubyKernelExecutor, code: string, options?: RubyExecutorOptions): Promise<RubyResult>;
+export declare function executeRuby(code: string, options?: RubyExecutorOptions): Promise<RubyResult>;

package/dist/types/eval/rb/index.d.ts

@@ -0,0 +1,11 @@
+import type { ToolSession } from "../../tools";
+import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
+export declare function namespaceSessionId(sessionId: string): string;
+declare const _default: {
+    id: "ruby";
+    label: string;
+    highlightLang: string;
+    isAvailable(session: ToolSession): Promise<boolean>;
+    execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
+};
+export default _default;