@prometheus-ai/agent 0.5.3 → 0.5.8

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

@@ -11,7 +11,7 @@
  *   const isolated = Settings.isolated({ "compaction.enabled": false });
  */
 import { procmgr } from "@prometheus-ai/utils";
-import type { ModelRole } from "../config/model-registry";
+import type { ModelRole } from "../config/model-roles";
 import { AgentStorage } from "../session/agent-storage";
 import { type EditMode } from "../utils/edit-mode";
 import { type BashInterceptorRule, type GroupPrefix, type GroupTypeMap, type SettingPath, type SettingValue } from "./settings-schema";
@@ -30,6 +30,8 @@ export interface SettingsOptions {
     inMemory?: boolean;
     /** Initial overrides */
     overrides?: Partial<Record<SettingPath, unknown>>;
+    /** Extra config.yml-style overlays loaded after global/project settings */
+    configFiles?: string[];
 }
 export declare class Settings {
     #private;
@@ -54,6 +56,11 @@ export declare class Settings {
      * Returns the merged value from global + project + overrides, or the default.
      */
     get<P extends SettingPath>(path: P): SettingValue<P>;
+    /**
+     * Whether `path` has an explicitly configured value (global config, project
+     * config, or runtime override) rather than falling back to the schema default.
+     */
+    isConfigured(path: SettingPath): boolean;
     /**
      * Set a setting value (sync).
      * Updates global settings and queues a background save.
@@ -131,7 +138,12 @@ export declare class Settings {
  * Returns an unsubscribe function. Multiple sessions (main + subagents)
  * can register independently without overwriting each other.
  */
-export declare function onAppendOnlyModeChanged(cb: (value: string) => void): () => void;
+export declare const onAppendOnlyModeChanged: (cb: (value: string) => void) => () => void;
+/**
+ * Subscribe to session-accent setting changes.
+ * Returns an unsubscribe function. Callers should re-read settings in the callback.
+ */
+export declare const onStatusLineSessionAccentChanged: (cb: () => void) => () => void;
 /**
  * Subscribe to changes in the Hindsight bank-scoping settings. Lets the
  * Hindsight backend rebuild the active `HindsightSessionState` when the
@@ -142,7 +154,7 @@ export declare function onAppendOnlyModeChanged(cb: (value: string) => void): ()
  * Returns an unsubscribe function. The callback receives no arguments — the
  * caller is expected to re-read the relevant settings via `Settings.get`.
  */
-export declare function onHindsightScopeChanged(cb: () => void): () => void;
+export declare const onHindsightScopeChanged: (cb: () => void) => () => void;
 export declare function isSettingsInitialized(): boolean;
 /**
  * Reset the global singleton for testing.

package/dist/types/dap/config.d.ts

@@ -2,5 +2,18 @@ import type { DapAdapterConfig, DapResolvedAdapter } from "./types";
 export declare function getAdapterConfigs(): Record<string, DapAdapterConfig>;
 export declare function resolveAdapter(adapterName: string, cwd: string): DapResolvedAdapter | null;
 export declare function getAvailableAdapters(cwd: string): DapResolvedAdapter[];
-export declare function selectLaunchAdapter(program: string, cwd: string, adapterName?: string): DapResolvedAdapter | null;
+export declare function selectLaunchAdapter(program: string, cwd: string, adapterName?: string, programKind?: LaunchProgramKind): DapResolvedAdapter | null;
 export declare function selectAttachAdapter(cwd: string, adapterName?: string, port?: number): DapResolvedAdapter | null;
+/** How the launch `program` resolves on disk. `"missing"` is reserved for
+ *  programs the adapter creates on demand (rare); we treat them like files. */
+export type LaunchProgramKind = "file" | "directory" | "missing";
+/** Compute adapter-specific launch arguments that depend on the resolved
+ *  program. Returned values are spread over `adapter.launchDefaults` so they
+ *  take precedence over the static defaults but can still be overridden by
+ *  the fields `DapSessionManager.launch` sets explicitly (program, cwd, args).
+ *
+ *  Currently scoped to dlv, where `mode` selects how the program path is
+ *  interpreted: directories and `.go` source files debug as a Go package
+ *  (`mode=debug`), anything else is treated as a compiled binary (`mode=exec`).
+ */
+export declare function resolveLaunchOverrides(adapter: DapResolvedAdapter, program: string, programKind: LaunchProgramKind): Record<string, unknown>;

package/dist/types/dap/types.d.ts

@@ -422,6 +422,10 @@ export interface DapAdapterConfig {
      *  On Linux, connects via a unix domain socket.
      *  On macOS, the adapter dials into a local TCP listener (--client-addr). */
     connectMode?: "stdio" | "socket";
+    /** When true, the adapter accepts a directory as the launch `program`
+     *  (e.g. dlv treats it as a Go package path). When false/undefined, the
+     *  debug tool rejects directory programs upfront. */
+    acceptsDirectoryProgram?: boolean;
 }
 export interface DapResolvedAdapter {
     name: string;
@@ -434,6 +438,7 @@ export interface DapResolvedAdapter {
     launchDefaults: Record<string, unknown>;
     attachDefaults: Record<string, unknown>;
     connectMode: "stdio" | "socket";
+    acceptsDirectoryProgram: boolean;
 }
 export interface DapBreakpointRecord {
     id?: number;
@@ -514,6 +519,11 @@ export interface DapLaunchSessionOptions {
     program: string;
     args?: string[];
     cwd: string;
+    /** Per-launch overrides merged over `adapter.launchDefaults`. Used to
+     *  inject adapter-specific values that depend on the resolved program
+     *  (e.g. dlv's `mode` switches between `debug` and `exec` based on
+     *  whether `program` is a Go package path or a compiled binary). */
+    extraLaunchArguments?: Record<string, unknown>;
 }
 export interface DapAttachSessionOptions {
     adapter: DapResolvedAdapter;

package/dist/types/debug/log-viewer.d.ts

@@ -63,6 +63,6 @@ export declare class DebugLogViewerComponent implements Component {
     constructor(options: DebugLogViewerComponentOptions);
     handleInput(keyData: string): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }
 export {};

package/dist/types/debug/raw-sse.d.ts

@@ -14,5 +14,5 @@ export declare class RawSseViewerComponent implements Component {
     constructor(options: RawSseViewerOptions);
     handleInput(keyData: string): void;
     invalidate(): void;
-    render(width: number): string[];
+    render(width: number): readonly string[];
 }

package/dist/types/debug/report-bundle.d.ts

@@ -11,6 +11,8 @@ export interface ReportBundleOptions {
     heapSnapshot?: HeapSnapshot;
     /** Work profile (for work scheduling reports) */
     workProfile?: WorkProfile;
+    /** Raw provider SSE diagnostics captured by the session buffer */
+    rawSseText?: string;
 }
 export interface ReportBundleResult {
     path: string;
@@ -33,6 +35,7 @@ export interface DebugLogSource {
  * - env.json: Sanitized environment variables
  * - config.json: Resolved settings
  * - profile.cpuprofile: CPU profile (performance report only)
+ * - raw-sse.txt: Recent raw provider SSE diagnostics (when captured)
  * - profile.md: Markdown CPU profile (performance report only)
  * - heap.heapsnapshot: Heap snapshot (memory report only)
  * - work.folded: Work profile folded stacks (work report only)

package/dist/types/debug/terminal-info.d.ts

@@ -18,7 +18,6 @@ export interface TerminalStateInfo {
     hyperlinks: boolean;
     deccara: boolean;
     screenToScrollback: boolean;
-    eagerEraseScrollbackRisk: boolean;
     synchronizedOutput: boolean;
     multiplexer: string | null;
     env: {

package/dist/types/discovery/at-imports.d.ts

@@ -0,0 +1,15 @@
+/** Maximum number of recursive `@`-import hops. Matches Claude Code's documented cap. */
+export declare const MAX_AT_IMPORT_DEPTH = 5;
+export interface ExpandAtImportsOptions {
+    /** Maximum hop depth (default: {@link MAX_AT_IMPORT_DEPTH}). */
+    maxDepth?: number;
+    /** Override the home directory used to resolve `~/...` (default: `os.homedir()`). */
+    home?: string;
+}
+/**
+ * Expand `@path/to/file` references in `content` against `filePath`'s directory.
+ *
+ * Returns the expanded text. When no imports match, the original string is
+ * returned unchanged.
+ */
+export declare function expandAtImports(content: string, filePath: string, options?: ExpandAtImportsOptions): Promise<string>;

package/dist/types/discovery/prometheus-extension-roots.d.ts

@@ -1,6 +1,6 @@
 import type { LoadContext } from "../capability/types";
 /** A resolved extension package directory wired into the discovery surfaces. */
-export interface OmpExtensionRoot {
+export interface PrometheusExtensionRoot {
     /** Absolute path to the package directory. */
     path: string;
     /** Stable display name (basename of the package directory). */
@@ -15,20 +15,20 @@ export interface OmpExtensionRoot {
  * entrypoints have no package sub-tree to scan.
  *
  * Call once during startup before any capability load. Repeated calls extend
- * the registered set; {@link clearOmpExtensionCliRoots} resets for tests.
+ * the registered set; {@link clearPrometheusExtensionCliRoots} resets for tests.
  */
-export declare function injectOmpExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void;
+export declare function injectPrometheusExtensionCliRoots(paths: readonly string[], home: string, cwd: string): void;
 /** Drop every CLI-injected root. Tests use this between cases. */
-export declare function clearOmpExtensionCliRoots(): void;
+export declare function clearPrometheusExtensionCliRoots(): void;
 /** Inspect currently-injected CLI roots (read-only). Exposed for diagnostics + tests. */
-export declare function getInjectedOmpExtensionCliRoots(): readonly OmpExtensionRoot[];
+export declare function getInjectedPrometheusExtensionCliRoots(): readonly PrometheusExtensionRoot[];
 /**
  * Resolve every configured extension package directory for the given context.
  *
  * Sources, in order of precedence (later entries with the same absolute path
  * are dropped):
  *
- * 1. CLI roots injected via {@link injectOmpExtensionCliRoots}
+ * 1. CLI roots injected via {@link injectPrometheusExtensionCliRoots}
  * 2. Project `<cwd>/.prometheus/settings.json#extensions`
  * 3. User `~/.prometheus/agent/settings.json#extensions`
  * 4. Enabled plugins installed under `<plugins>/node_modules/` (e.g. via
@@ -40,4 +40,4 @@ export declare function getInjectedOmpExtensionCliRoots(): readonly OmpExtension
  * `package.json`, etc.) are logged at `debug` and degrade gracefully — the
  * other sources still surface.
  */
-export declare function listOmpExtensionRoots(ctx: LoadContext): Promise<OmpExtensionRoot[]>;
+export declare function listPrometheusExtensionRoots(ctx: LoadContext): Promise<PrometheusExtensionRoot[]>;

package/dist/types/edit/diff.d.ts

@@ -1,3 +1,4 @@
+import { type BlockContextSource } from "../utils/block-context";
 export interface DiffResult {
     diff: string;
     firstChangedLine: number | undefined;
@@ -25,7 +26,7 @@ export declare class ApplyPatchError extends Error {
  * Generate a unified diff string with line numbers and context.
  * Returns both the diff string and the first changed line number (in the new file).
  */
-export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number): DiffResult;
+export declare function generateDiffString(oldContent: string, newContent: string, contextLines?: number, source?: BlockContextSource): DiffResult;
 export interface ReplaceOptions {
     /** Allow fuzzy matching */
     fuzzy: boolean;
@@ -44,7 +45,7 @@ export interface ReplaceResult {
  * Generate a unified diff string without file headers.
  * Returns both the diff string and the first changed line number (in the new file).
  */
-export declare function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines?: number): DiffResult;
+export declare function generateUnifiedDiffString(oldContent: string, newContent: string, contextLines?: number, source?: BlockContextSource): DiffResult;
 export declare function normalizeDiff(diff: string): string;
 export declare function normalizeCreateContent(content: string): string;
 export declare function parseDiffHunks(diff: string): DiffHunk[];

package/dist/types/edit/file-snapshot-store.d.ts

@@ -25,6 +25,24 @@ interface FileSnapshotStoreOwner {
  * the session itself.
  */
 export declare function getFileSnapshotStore(session: FileSnapshotStoreOwner): InMemorySnapshotStore;
+/**
+ * Canonicalize an absolute path into the stable key the snapshot store uses.
+ *
+ * Different code paths reach the snapshot store via different path forms:
+ * `read local://foo.md` records under the file's `fs.realpath` (the local
+ * protocol handler resolves symlinks); a subsequent `edit` may address the
+ * same artifact via `local://foo.md`, whose resolver does NOT realpath, or
+ * via the absolute path returned in the `[path#tag]` header. macOS adds the
+ * same hazard at the working-tree level (`/tmp/...` vs `/private/tmp/...`).
+ * Collapsing every key through `realpath` makes those forms fuse onto one
+ * snapshot entry, so a freshly-minted tag is never rejected as stale just
+ * because the lookup spelled the same file differently.
+ *
+ * Non-existent paths (new-file writes) fall back to a realpath of the parent
+ * directory + basename, then to the input. This keeps creates and updates on
+ * the same canonical key.
+ */
+export declare function canonicalSnapshotKey(absolutePath: string): string;
 /**
  * Read the full text of `absolutePath` (within {@link SNAPSHOT_MAX_BYTES}),
  * record it as a version snapshot, and return its content-hash tag. Returns

package/dist/types/edit/hashline/noop-loop-guard.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Per-session guard against subagents looping on byte-identical no-op edits.
+ *
+ * A hashline patch can apply cleanly yet produce no change when the body rows
+ * are already byte-identical to the targeted lines. {@link executeHashlineSingle}
+ * surfaces a soft hint ("re-read the file before issuing another edit"), but in
+ * the wild some models ignore the hint and keep re-issuing the same bytes
+ * (issue #2081 captured 182 such repeats in 205 calls before the user aborted).
+ *
+ * This module tracks consecutive byte-identical no-op edits per canonical file
+ * path within a single session. Once the same payload no-ops {@link NOOP_HARD_LIMIT}
+ * times in a row the caller is expected to escalate from a soft text result to
+ * a thrown {@link ToolError} so the agent loop sees a tool *failure* — empirically
+ * far more effective at breaking the cycle than the soft hint alone.
+ *
+ * A successful (non-noop) commit for a path resets that path's counter; a
+ * different payload on the same path also resets it because the body hash
+ * changed, which is a sign of model progress and deserves another soft hint.
+ */
+interface NoopLoopEntry {
+    /** Hash of the most recent input that no-op'd on this canonical path. */
+    hash: string;
+    /** Consecutive no-op count for the same `hash` on this path. */
+    count: number;
+}
+/** Cross-session-safe state slot held on the `ToolSession`. */
+export interface NoopLoopGuard {
+    entries: Map<string, NoopLoopEntry>;
+}
+/**
+ * After this many consecutive byte-identical no-op edits on the same path,
+ * {@link recordNoopEdit} returns `escalate: true`. Picked deliberately small
+ * so the soft hint still fires once or twice before we escalate — the model
+ * deserves a chance to recover, but a tight bound is what actually breaks
+ * loops in practice.
+ */
+export declare const NOOP_HARD_LIMIT = 3;
+interface NoopLoopGuardOwner {
+    noopLoopGuard?: NoopLoopGuard;
+}
+/** Lazily create the per-session guard, mirroring `getFileSnapshotStore`. */
+export declare function getNoopLoopGuard(session: NoopLoopGuardOwner): NoopLoopGuard;
+/** Result of recording one no-op against the guard. */
+export interface NoopRecordResult {
+    /** Consecutive identical no-op count, including the current one. */
+    count: number;
+    /** True once `count >= NOOP_HARD_LIMIT` and the caller MUST escalate. */
+    escalate: boolean;
+}
+/**
+ * Record a no-op edit for `canonicalPath` keyed by `inputHash` (a stable hash
+ * of the raw patch input bytes). Returns the running consecutive-no-op count
+ * and whether the caller should escalate from a soft text result to a thrown
+ * error.
+ *
+ * `inputHash` is intentionally derived from the raw model-authored bytes
+ * rather than from file content: when the model emits a different payload
+ * (even whitespace-only) that's progress and earns a fresh soft hint, but
+ * re-issuing the same bytes after being warned is what we want to break.
+ */
+export declare function recordNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string, inputHash: string): NoopRecordResult;
+/**
+ * Clear the no-op counter for `canonicalPath`. Call after a non-noop commit
+ * for the same path so a future no-op starts fresh from the soft hint.
+ */
+export declare function resetNoopEdit(session: NoopLoopGuardOwner, canonicalPath: string): void;
+/**
+ * Stable hash of the raw patch input. Bun's `Bun.hash` is xxHash64 — fast,
+ * non-cryptographic, more than adequate for "is this the same payload?".
+ */
+export declare function hashPatchInput(input: string): string;
+export {};

package/dist/types/edit/hashline/params.d.ts

@@ -4,7 +4,7 @@
  * keys without rejection; only `input` is required. `_input` is accepted as a
  * provider-emitted alias for `input`.
  */
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 export declare const hashlineEditParamsSchema: z.ZodPreprocess<z.ZodObject<{
     input: z.ZodString;
 }, z.core.$loose>>;

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

@@ -28,7 +28,6 @@ export declare class EditTool implements AgentTool<TInput> {
     readonly name = "edit";
     readonly label = "Edit";
     readonly loadMode = "essential";
-    readonly nonAbortable = true;
     readonly concurrency = "exclusive";
     readonly strict = true;
     constructor(session: ToolSession);

package/dist/types/edit/modes/apply-patch.d.ts

@@ -7,7 +7,7 @@
  * LSP writethrough, fs-cache invalidation, diagnostics) is shared with
  * the `patch` mode.
  */
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { PatchEditEntry } from "./patch";
 export declare const applyPatchSchema: z.ZodObject<{
     input: z.ZodString;

package/dist/types/edit/modes/patch.d.ts

@@ -5,7 +5,7 @@
  * for robust handling of whitespace and formatting differences.
  */
 import type { AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import { type WritethroughCallback, type WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";

package/dist/types/edit/modes/replace.d.ts

@@ -5,7 +5,7 @@
  * fallback strategies for finding text in files.
  */
 import type { AgentToolResult } from "@prometheus-ai/agent-core";
-import * as z from "zod/v4";
+import { z } from "zod/v4";
 import type { WritethroughCallback, WritethroughDeferredHandle } from "../../lsp";
 import type { ToolSession } from "../../tools";
 import type { EditToolDetails, LspBatchRequest } from "../renderer";

package/dist/types/edit/renderer.d.ts

@@ -93,6 +93,7 @@ export interface EditRenderContext {
 }
 export declare const editToolRenderer: {
     mergeCallAndResult: boolean;
+    provisionalPendingPreview: boolean;
     renderCall(args: EditRenderArgs, options: RenderResultOptions & {
         renderContext?: EditRenderContext;
     }, uiTheme: Theme): Component;

package/dist/types/eval/__tests__/completion-bridge.test.d.ts

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

package/dist/types/eval/__tests__/helpers-local-roots.test.d.ts

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

package/dist/types/eval/__tests__/js-context-manager.test.d.ts

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

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

@@ -18,8 +18,6 @@ export interface ExecutorBackendExecOptions {
      */
     idleTimeoutMs: number;
     reset: boolean;
-    artifactPath: string | undefined;
-    artifactId: string | undefined;
     onChunk: (chunk: string) => void;
     /**
      * Live status events (read/write/agent/…) delivered as they are emitted,
@@ -53,3 +51,10 @@ export interface ExecutorBackend {
     /** Execute one cell. Caller invokes once per cell and aggregates results. */
     execute(code: string, opts: ExecutorBackendExecOptions): Promise<ExecutorBackendResult>;
 }
+/**
+ * Resolve the on-disk roots that the eval helpers substitute for internal-URL
+ * schemes (currently `local://`). Prefers the session's own
+ * {@link LocalProtocolOptions} — the exact mapping `read local://…` uses — so an
+ * eval `write("local://x")` and a later `read local://x` agree on the location.
+ */
+export declare function resolveEvalUrlRoots(session: ToolSession): Record<string, string>;

package/dist/types/eval/bridge-timeout.d.ts

@@ -2,7 +2,7 @@
  * Timeout suspension for in-flight host-side eval bridge calls.
  *
  * The eval watchdog caps a cell's `timeout` as a budget on the cell runtime's
- * own work. Host-side `agent()` / `parallel()` / `llm()` bridge calls hand
+ * own work. Host-side `agent()` / `parallel()` / `completion()` bridge calls hand
  * control to the outer TypeScript process, where the Python kernel or JS VM is
  * only waiting for a result. While that delegated work is in flight, the cell
  * timeout must be ignored completely; once the bridge returns and the runtime is

package/dist/types/eval/completion-bridge.d.ts

@@ -0,0 +1,25 @@
+import type { ToolSession } from "../tools";
+import type { JsStatusEvent } from "./js/shared/types";
+/** Synthetic bridge name reserved for the `completion()` helper across both runtimes. */
+export declare const EVAL_COMPLETION_BRIDGE_NAME = "__completion__";
+type CompletionTier = "smol" | "default" | "slow";
+export interface EvalCompletionBridgeOptions {
+    session: ToolSession;
+    signal?: AbortSignal;
+    emitStatus?: (event: JsStatusEvent) => void;
+}
+export interface EvalCompletionResult {
+    text: string;
+    details: {
+        model: string;
+        tier: CompletionTier;
+        structured: boolean;
+    };
+}
+/**
+ * Run a single stateless completion on behalf of an eval cell's `completion()` call.
+ * Returns a `{ text, details }` value shaped like a {@link callSessionTool}
+ * result so the existing bridge transport carries it to either runtime.
+ */
+export declare function runEvalCompletion(args: unknown, options: EvalCompletionBridgeOptions): Promise<EvalCompletionResult>;
+export {};

package/dist/types/eval/idle-timeout.d.ts

@@ -3,11 +3,9 @@
  *
  * A cell's `timeout` bounds time while the Python kernel or JS VM is in control.
  * Host-side bridge calls can {@link pause} the watchdog so delegated
- * `agent()`/`parallel()`/`llm()` work is ignored completely, then {@link resume}
+ * `agent()`/`parallel()`/`completion()` work is ignored completely, then {@link resume}
  * starts a fresh timeout window once the runtime gets control back.
  *
- * The active timer self-reschedules instead of being torn down on every
- * activity event, so frequent activity costs one timestamp write per event.
  * Pause is reference-counted because `parallel()` can have multiple bridge calls
  * in flight at once.
  */
@@ -18,8 +16,6 @@ export declare class IdleTimeout {
     get signal(): AbortSignal;
     /** Configured active timeout window in milliseconds. */
     get idleMs(): number;
-    /** Record runtime activity, pushing the active deadline forward by `idleMs`. */
-    bump(): void;
     /** Suspend timeout accounting while control is delegated to host-side work. */
     pause(): void;
     /** Resume timeout accounting with a fresh timeout window. */

package/dist/types/eval/js/context-manager.d.ts

@@ -12,6 +12,7 @@ export declare function executeInVmContext(options: {
     sessionId: string;
     cwd: string;
     session: ToolSession;
+    localRoots?: Record<string, string>;
     reset?: boolean;
     code: string;
     filename: string;

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

@@ -20,6 +20,8 @@ export interface JsExecutorOptions {
     artifactPath?: string;
     artifactId?: string;
     session: ToolSession;
+    /** On-disk roots the helpers substitute for internal-URL schemes (e.g. `local://`). */
+    localRoots?: Record<string, string>;
 }
 export interface JsResult {
     output: string;

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

@@ -1,5 +1,5 @@
 import type { ToolSession } from "../../tools";
-import type { ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
 declare const _default: {
     id: "js";
     label: string;

package/dist/types/eval/js/shared/helpers.d.ts

@@ -17,10 +17,16 @@ export interface HelperOptions {
 export interface HelperContext {
     cwd(): string;
     env: Map<string, string>;
+    /**
+     * On-disk roots for internal-URL schemes the helpers accept (e.g.
+     * `{ local: "/…/artifacts/local" }`). A path like `local://x.md` is rewritten
+     * to `<root>/x.md` before any filesystem op; unknown schemes are rejected.
+     */
+    localRoots(): Record<string, string>;
     emitStatus(event: JsStatusEvent): void;
 }
 /**
- * The set of functions exposed to user code via `globalThis.__prometheus_helpers__`. The JS
+ * The set of functions exposed to user code via `globalThis.__omp_helpers__`. The JS
  * prelude reads from this bag and attaches short aliases (`read`, `write`, `tree`, ...)
  * onto the global scope.
  */

package/dist/types/eval/js/shared/rewrite-imports.d.ts

@@ -1,7 +1,7 @@
-export declare function rewriteImports(code: string): string;
-export declare function collectModuleSourceSpecifiers(code: string): string[];
-export declare function rewriteModuleSourceSpecifiers(code: string, replacer: (source: string) => string): string;
-export declare function rewriteDynamicImports(code: string, callee?: string): string;
+export declare function rewriteImports(code: string): Promise<string>;
+export declare function collectModuleSourceSpecifiers(code: string): Promise<string[]>;
+export declare function rewriteModuleSourceSpecifiers(code: string, replacer: (source: string) => string): Promise<string>;
+export declare function rewriteDynamicImports(code: string, callee?: string): Promise<string>;
 /**
  * Strip TypeScript syntax (type annotations, type-only imports/exports, `interface`, `as`,
  * `satisfies`, generics in call expressions, etc.) before the import/lexical rewriters parse
@@ -17,9 +17,9 @@ export declare function stripTypeScriptSyntax(code: string, options?: {
     force?: boolean;
     loader?: TypeScriptStripLoader;
 }): string;
-export declare function wrapCode(code: string): {
+export declare function wrapCode(code: string): Promise<{
     source: string;
     asyncWrapped: boolean;
     finalExpressionReturned: boolean;
-};
+}>;
 export {};

package/dist/types/eval/js/shared/runtime.d.ts

@@ -20,11 +20,16 @@ export interface RuntimeOptions {
     initialCwd: string;
     sessionId: string;
     /**
-     * Extra globals installed alongside `__prometheus_helpers__` / prelude. Use for stable, lifetime-
+     * Extra globals installed alongside `__omp_helpers__` / prelude. Use for stable, lifetime-
      * of-the-worker bindings (e.g. browser's `page`, `browser`). Per-run scope should be set
      * via `setRunScope()` instead.
      */
     extraGlobals?: Record<string, unknown>;
+    /**
+     * On-disk roots the helpers substitute for internal-URL schemes (e.g.
+     * `{ local: "/…/artifacts/local" }`). Stable for the worker's lifetime.
+     */
+    localRoots?: Record<string, string>;
 }
 /**
  * Shared JS runtime for the eval worker and the browser tab worker. Owns the prelude,

package/dist/types/eval/js/worker-protocol.d.ts

@@ -3,6 +3,12 @@ export type { JsDisplayOutput } from "./shared/types";
 export interface SessionSnapshot {
     cwd: string;
     sessionId: string;
+    /**
+     * On-disk roots the helpers substitute for internal-URL schemes
+     * (e.g. `{ local: "/…/artifacts/local" }`). Lets `read`/`write`/`append`
+     * accept `local://…` paths instead of writing a literal `local:/` directory.
+     */
+    localRoots?: Record<string, string>;
 }
 export interface RunErrorPayload {
     name?: string;

package/dist/types/eval/py/__tests__/prelude.test.d.ts

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

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

@@ -25,6 +25,11 @@ export interface PythonExecutorOptions {
     kernelOwnerId?: string;
     /** Kernel mode (session reuse vs per-call) */
     kernelMode?: PythonKernelMode;
+    /**
+     * Explicit interpreter path (`python.interpreter` resolved from the
+     * session's settings). Skips automatic runtime discovery when set.
+     */
+    interpreter?: string;
     /** Restart the kernel before executing */
     reset?: boolean;
     /** Session file path for accessing task outputs */
@@ -39,6 +44,13 @@ export interface PythonExecutorOptions {
     /** Artifact path/id for full output storage */
     artifactPath?: string;
     artifactId?: string;
+    /**
+     * On-disk roots the prelude helpers (`read`/`write`/`append`) substitute for
+     * internal-URL schemes (e.g. `{ local: "/…/artifacts/local" }`). Exported to
+     * the kernel as `PROMETHEUS_EVAL_LOCAL_ROOTS` (JSON) so `write("local://x")` lands
+     * where `read local://x` resolves instead of a literal `local:/` directory.
+     */
+    localRoots?: Record<string, string>;
     /**
      * ToolSession used to resolve host-side `tool.<name>(args)` calls made from
      * the Python prelude's bridge proxy. When omitted, the bridge env vars are

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

@@ -1,5 +1,5 @@
 import type { ToolSession } from "../../tools";
-import type { ExecutorBackendExecOptions, ExecutorBackendResult } from "../backend";
+import { type ExecutorBackendExecOptions, type ExecutorBackendResult } from "../backend";
 export declare function namespaceSessionId(sessionId: string): string;
 declare const _default: {
     id: "python";

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

@@ -45,6 +45,11 @@ interface KernelLifecycleOptions {
 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;
@@ -57,7 +62,7 @@ export interface PythonKernelAvailability {
     /** The probed-working runtime, when one was found. */
     runtime?: PythonRuntime;
 }
-export declare function checkPythonKernelAvailability(cwd: string): Promise<PythonKernelAvailability>;
+export declare function checkPythonKernelAvailability(cwd: string, interpreter?: string): Promise<PythonKernelAvailability>;
 export declare class PythonKernel {
     #private;
     readonly id: string;