@oh-my-pi/pi-coding-agent 15.3.2 → 15.4.2

package/CHANGELOG.md

@@ -2,6 +2,114 @@
 
 ## [Unreleased]
 
+## [15.4.2] - 2026-05-26
+
+### Fixed
+
+- Fixed plan-mode subagents being unable to terminate because `yield` was registered but missing from the active tool set when `requireYieldTool` was combined with an explicit `toolNames` list ([#1408](https://github.com/can1357/oh-my-pi/issues/1408))
+
+## [15.4.1] - 2026-05-26
+
+### Breaking Changes
+
+- The `vim` edit mode option is no longer available; configurations using `edit.mode: vim` will be automatically mapped to `hashline` mode
+- Hashline payload semantics are now strictly inline-first: the first payload line is whatever follows the sigil on the op line itself, and subsequent lines append after it. A newline immediately after `↑`/`↓`/`:` is no longer a free separator — it produces a blank first payload line. Use `LINE↓content` for a one-line insert, `LINE↓firstline\nsecondline` for two lines; bare `LINE↓` / `LINE↑` / `LINE:` (no inline payload) still insert/replace with one blank line as before.
+
+### Added
+
+- Added `irc.timeoutMs` setting to configure IRC message timeout duration with a default of 120 seconds
+- Added timeout enforcement for IRC send operations to prevent indefinite hangs when recipients are unresponsive
+- Added evaluator state inheritance for `task`-spawned subagents so JavaScript and Python variables are visible between a parent agent and its child sessions
+- Added `hashline-per` edit mode to restore the legacy per-line hashline dialect alongside the default file-hash dialect
+- Added file-hash computation and validation for hashline sections to detect stale edits
+- Added file-read snapshot caching with multi-snapshot ring per path for recovery from agent's own writes
+- Added delete operation (`!`) support to hashline grammar for explicit line deletion
+- Added structural bracket/brace balance warnings when deleting lines with unclosed constructs
+- Added file-hash computation and validation for hashline sections to detect stale edits
+- Added file-read snapshot caching with multi-snapshot ring per path for recovery from agent's own writes
+- Added delete operation (`!`) support to hashline grammar for explicit line deletion
+- Added structural bracket/brace balance warnings when deleting lines with unclosed constructs
+
+### Changed
+
+- Changed Python shared eval sessions to be keyed by `sessionId` and `cwd` so code state no longer leaks across different directories when reusing a session
+- Changed shared JavaScript and Python startup to deduplicate concurrent first-time session initialization so parallel first calls share one warm session
+- Changed shared JavaScript and Python execution output handling so interleaved async runs keep their `display` output scoped to the originating run
+- Changed Python tool bridge to use per-run identifiers alongside session IDs for correct routing of tool responses and output in concurrent evaluations
+- Changed JavaScript and Python `eval` execution to allow overlapping asynchronous cells on the same session ID to run concurrently instead of being strictly queued
+- Updated the edit mode option set to support `replace`, `patch`, `hashline`, and `apply_patch` variants
+- Bare `A:` / `A-B:` (no payload, no inline body) now replaces the line/range with a single blank line, symmetric with bare `A↑` / `A↓` inserting a blank line; previously rejected as ambiguous
+- Simplified hashline anchor format from `LINE+HASH` to bare `LINE` numbers in edit operations
+- Updated hashline file headers to include 4-hex file hash: `¶PATH#HASH` format for anchored edits
+- Changed hashline line separator from `|` to `:` in editable output (e.g., `42:content` instead of `42ab|content`)
+- Removed per-line hash validation; file-level hash now validates entire section integrity
+- Updated read/search output to emit file-hash headers (`¶PATH#HASH`) followed by numbered lines for hashline mode
+- Modified hashline grammar to accept optional file hash in headers and removed hash requirements from line anchors
+- Changed hashline diff preview format to use `LINE:content` instead of `LINE+HASH|content`
+- Updated prompt documentation to reflect new `¶PATH#HASH` header and bare line-number syntax
+- Bare `A:` / `A-B:` (no payload, no inline body) now replaces the line/range with a single blank line, symmetric with bare `A↑` / `A↓` inserting a blank line; previously rejected as ambiguous
+- Simplified hashline anchor format from `LINE+HASH` to bare `LINE` numbers in edit operations
+- Updated hashline file headers to include 4-hex file hash: `¶PATH#HASH` format for anchored edits
+- Changed hashline line separator from `|` to `:` in editable output (e.g., `42:content` instead of `42ab|content`)
+- Removed per-line hash validation; file-level hash now validates entire section integrity
+- Updated read/search output to emit file-hash headers (`¶PATH#HASH`) followed by numbered lines for hashline mode
+- Modified hashline grammar to accept optional file hash in headers and removed hash requirements from line anchors
+- Changed hashline diff preview format to use `LINE:content` instead of `LINE+HASH|content`
+- Updated prompt documentation to reflect new `¶PATH#HASH` header and bare line-number syntax
+
+### Removed
+
+- Removed the `installH2Fetch()` activation from CLI startup; HTTPS fetches now use Bun's default transport
+- Removed the `vim` edit mode along with the `VimTool` module, prompt, and supporting buffer/engine/renderer stack
+- Removed per-line hash anchors (2-letter bigram hashes) from hashline format
+- Removed `RANGE_INTERIOR_HASH` constant; multi-line ranges no longer use `**` filler
+- Removed `HashMismatch` type and hash mismatch error reporting; replaced with file-level validation
+- Removed per-line hash anchors (2-letter bigram hashes) from hashline format
+- Removed `RANGE_INTERIOR_HASH` constant; multi-line ranges no longer use `**` filler
+- Removed `HashMismatch` type and hash mismatch error reporting; replaced with file-level validation
+
+### Fixed
+
+- Fixed JavaScript module reloading to refresh local re-exports when transitive dependency files are edited
+- Fixed Python tool calls in warm kernels to initialize once bridge environment variables appear after startup and to return a clear `tool bridge is unavailable` error when missing
+- Fixed IRC `send` handling to preserve recipient incoming messages when auto-reply timeouts instead of dropping them
+- Fixed Python session disposal to cancel all concurrent active executions in a shared kernel
+- Fixed JavaScript `eval` imports to preserve module-level singletons across re-imports of unchanged local files and reload them only after edits
+- Fixed concurrent Python evaluator tool calls to use per-run identifiers so tool responses and output are routed to the correct execution
+- Fixed the `search` tool argument validation to accept a single string `paths` value as a one-path search.
+
+## [15.4.0] - 2026-05-26
+
+### Breaking Changes
+
+- Replaced the hashline patch format from `§`, `«`, `»`, `≔`, and `..` to `¶`, `↑`, `↓`, `→` with range separators written as `A-B`, requiring users to migrate hashline edit inputs
+
+### Added
+
+- Added `codex` and `gemini` to the web search provider settings so users can configure OpenAI and Gemini web search directly from provider selection
+- Added OpenAI (`codex`) and Gemini web search options with updated setup descriptions for `omp /login openai-codex` and Gemini OAuth login
+- Added pretty-printing for wide JSON `data:` payloads in the raw provider-stream debug viewer so streamed event bodies expand across multiple `data:` lines instead of getting clipped by the per-line truncator, and updated the viewer header to read `raw provider stream (SSE + WS)` now that Codex WebSocket frames also flow through the buffer
+
+### Changed
+
+- Updated hashline operation syntax to support inline payload text on the same op line for insert and replace (`ANCHOR↑/↓/...→`) while still accepting payload lines that follow
+- Updated hashline anchor parsing so copied `|TEXT` decorations remain cosmetic and payload must be provided on or after the operator
+- Unified subagent output-schema validation into a single shared module (`tools/output-schema-validator.ts`) used by both the in-process `yield` tool (validates before the subagent yields) and the executor's post-mortem `finalizeSubprocessOutput` path (validates after subprocess exit). Previously each side ran its own `normalizeSchema` → `jtdToJsonSchema` → `validateJsonSchemaValue` chain in parallel, which was semantically equivalent but invited drift: a future tweak on one side could silently disagree with the other and cause yields that pass in-tool to fail post-mortem (or vice versa). The unification preserves both call sites' existing behavior (yield throws an actionable per-issue error for the model; executor produces a `schema_violation` outcome with the first issue and missing-required fields) by exposing two output formatters (`formatAllValidationIssues` for retries, `formatValidationIssueHeadline` for headlines).
+- Changed web search provider credential lookup to use the shared `AuthStorage` pipeline (`getApiKey`/`getOAuthAccess`) for API-key and OAuth auth instead of direct `AgentStorage` access
+- Changed the `codex` web search provider display label from `Codex` to `OpenAI`
+- Updated `anthropic` and `openai`/`gemini` web search option descriptions to reflect their native `web_search`/OAuth requirements
+
+### Fixed
+
+- Fixed hashline inline payload parsing so same-line payloads containing whitespace, including tab-indented text, are preserved instead of being rejected
+- Fixed Bun HTTP/2 transport errors (`HTTP2StreamReset`, `HTTP2RefusedStream`, and `HTTP2EnhanceYourCalm`) to be treated as transient so the assistant now retries automatically instead of stopping on these recoverable failures
+- Fixed web search OAuth-backed providers (including Codex and Gemini) to use broker-managed token retrieval and account metadata, avoiding direct token-store refresh behavior that could cause search authentication failures
+- Updated Tavily missing-credential feedback to prompt users to configure an API-key provider setting instead of referencing `agent.db` directly
+- Refreshed expired OpenAI Codex OAuth tokens during `web_search` execution and persisted the updated credentials so searches continue working after token expiry
+- Fixed built-in `explore` agent failing every invocation with `schema_violation: files.0.ref: must not be present` on releases prior to 15.3.2 by renaming the `files[].ref` property to `files[].path` in the agent's output schema; `ref` is a JTD-reserved keyword (RFC 8927) and collides with JSON Type Definition's schema-reference form, so the converter previously dropped it from the generated JSON Schema. Defense-in-depth alongside the 15.3.2 converter fix ([#1379](https://github.com/can1357/oh-my-pi/issues/1379)).
+- Increased the `yield` tool's schema-validation retry budget from 1 to 3 so subagents whose first structured-output attempt mismatches the declared output schema get up to three retries before the parent's post-mortem `schema_violation` check hard-fails the task. The tool now also surfaces remaining retry attempts and an explicit "call yield again with the corrected shape" directive in each rejection message, giving the model the context it needs to converge — particularly helpful for models like GLM that tend to invent per-element field names instead of following the declared schema.
+- Fixed CLI PDF file arguments being decoded as raw bytes for local vision models; `.pdf` and other supported document files now go through the same Markit conversion path as the `read` tool before entering the prompt ([#1401](https://github.com/can1357/oh-my-pi/issues/1401)).
+
 ## [15.3.2] - 2026-05-25
 ### Added
 
@@ -22,6 +130,8 @@
 - Added `OMP_NO_WEBP` environment variable to disable WebP encoding in image resize, fixing HTTP 400 errors when attaching browser snapshots to vision models running on local llama.cpp (which uses STB library that lacks WebP support)
 - Fixed loop mode submitting the next prompt while a background async-job delivery turn (idle flush) was still pending, which could cause the job result to be silently dropped and make the session appear to keep firing while work was ongoing ([#1294](https://github.com/can1357/oh-my-pi/issues/1294))
 - Fixed clipboard image paste (Ctrl+V) silently failing on WSL2 by routing image reads through a `powershell.exe` bridge when WSL interop is detected, since `arboard` returns `ContentNotAvailable` under WSLg ([#1280](https://github.com/can1357/oh-my-pi/issues/1280))
+- Fixed `bash` tool timeout and ESC cancellation getting stuck when native shell cleanup stalls; the JavaScript-side deadline now returns the tool result on schedule while native cleanup continues in the background ([#1347](https://github.com/can1357/oh-my-pi/issues/1347))
+- Fixed reviewer agent always failing JTD validation with `findings.0.priority: expected number, received string` whenever `report_finding` surfaced a finding; the tool's `"P0"`-`"P3"` priority is now coerced to its numeric ordinal before populating the auto-injected `findings[]` ([#1350](https://github.com/can1357/oh-my-pi/issues/1350))
 - Fixed config-only marketplace LSP plugins such as `csharp-lsp` not registering servers with the CLI when the plugin cache has only marketplace metadata and no package code ([#1352](https://github.com/can1357/oh-my-pi/issues/1352)).
 - Fixed JTD-to-JSON-Schema conversion treating user-named properties as nested JTD forms when their keys collided with JTD keywords like `ref`, which broke the built-in explore agent's output validator with `schema_violation: files.0.ref: must not be present` ([#1345](https://github.com/can1357/oh-my-pi/issues/1345))
 - Fixed extension `ctx.ui.notify()` messages emitted during `session_start` being cleared before the first interactive render ([#1316](https://github.com/can1357/oh-my-pi/issues/1316)).

package/dist/types/cli/file-processor.d.ts

@@ -7,5 +7,5 @@ export interface ProcessFileOptions {
     /** Whether to auto-resize images to 2000x2000 max. Default: true */
     autoResizeImages?: boolean;
 }
-/** Process @file arguments into text content and image attachments */
+/** Process @file arguments into text, document content, and image attachments */
 export declare function processFileArguments(fileArgs: string[], options?: ProcessFileOptions): Promise<ProcessedFiles>;

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

@@ -1871,7 +1871,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "editing";
             readonly label: "Edit Mode";
-            readonly description: "Select the edit tool variant (replace, patch, hashline, vim, or apply_patch)";
+            readonly description: "Select the edit tool variant (replace, patch, hashline, or apply_patch)";
         };
     };
     readonly "edit.fuzzyMatch": {
@@ -1951,7 +1951,7 @@ export declare const SETTINGS_SCHEMA: {
         readonly ui: {
             readonly tab: "editing";
             readonly label: "Hash Lines";
-            readonly description: "Include line hashes in read output for hashline edit mode (LINE+ID|content)";
+            readonly description: "Include file-hash headers and line numbers in read output for hashline edit mode (\u00B6PATH#hash plus LINE:content)";
         };
     };
     readonly "read.defaultLimit": {
@@ -2282,6 +2282,31 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Enable agent-to-agent IRC messaging via the irc tool";
         };
     };
+    readonly "irc.timeoutMs": {
+        readonly type: "number";
+        readonly default: 120000;
+        readonly ui: {
+            readonly tab: "tools";
+            readonly label: "IRC Timeout";
+            readonly description: "Drop IRC messages whose recipient does not respond within this many milliseconds (0 disables the timeout)";
+            readonly options: readonly [{
+                readonly value: "0";
+                readonly label: "Disabled";
+            }, {
+                readonly value: "30000";
+                readonly label: "30 seconds";
+            }, {
+                readonly value: "60000";
+                readonly label: "1 minute";
+            }, {
+                readonly value: "120000";
+                readonly label: "2 minutes";
+            }, {
+                readonly value: "300000";
+                readonly label: "5 minutes";
+            }];
+        };
+    };
     readonly "renderMermaid.enabled": {
         readonly type: "boolean";
         readonly default: false;
@@ -2762,6 +2787,15 @@ export declare const SETTINGS_SCHEMA: {
             }];
         };
     };
+    readonly "task.enableLsp": {
+        readonly type: "boolean";
+        readonly default: false;
+        readonly ui: {
+            readonly tab: "tasks";
+            readonly label: "LSP in Subagents";
+            readonly description: "Allow subagents spawned via the task tool to use the lsp tool. Off by default to keep subagents cheap; enable when LSP-aware delegation is worth the extra tokens.";
+        };
+    };
     readonly "task.maxRecursionDepth": {
         readonly type: "number";
         readonly default: 2;
@@ -2978,7 +3012,15 @@ export declare const SETTINGS_SCHEMA: {
             }, {
                 readonly value: "anthropic";
                 readonly label: "Anthropic";
-                readonly description: "Uses Anthropic web search";
+                readonly description: "Claude's native web_search tool (uses Anthropic OAuth or ANTHROPIC_API_KEY)";
+            }, {
+                readonly value: "codex";
+                readonly label: "OpenAI";
+                readonly description: "OpenAI's native web_search (uses ChatGPT OAuth via /login openai-codex)";
+            }, {
+                readonly value: "gemini";
+                readonly label: "Gemini";
+                readonly description: "Google Search grounding via Gemini (uses google-gemini-cli or google-antigravity OAuth)";
             }, {
                 readonly value: "zai";
                 readonly label: "Z.AI";

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

@@ -88,7 +88,7 @@ export declare class Settings {
     getGroup<G extends GroupPrefix>(prefix: G): GroupTypeMap[G];
     /**
      * Get the edit variant for a specific model.
-     * Returns "patch", "replace", "hashline", "vim", "apply_patch", or null (use global default).
+     * Returns "patch", "replace", "hashline", "apply_patch", or null (use global default).
      */
     getEditVariantForModel(model: string | undefined): EditMode | null;
     /**

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

@@ -1,5 +1,7 @@
 import { type Component } from "@oh-my-pi/pi-tui";
 import { type RawSseDebugBuffer } from "./raw-sse-buffer";
+/** @internal Exported for tests. */
+export declare function expandPrettyDataLines(raw: readonly string[]): string[];
 export interface RawSseViewerOptions {
     buffer: RawSseDebugBuffer;
     terminalRows: number;

package/dist/types/edit/file-read-cache.d.ts

@@ -2,19 +2,29 @@ import type { ToolSession } from "../tools";
 export interface FileReadSnapshot {
     /** 1-indexed line number → exact line content as observed by `read`/`search`. */
     lines: Map<number, string>;
+    /** Full normalized text when the read path observed the whole file. */
+    fullText?: string;
+    /** 4-hex hash of `fullText`, or a sparse snapshot hash supplied by search. */
+    fileHash?: string;
     recordedAt: number;
 }
+interface FileReadSnapshotMetadata {
+    fullText?: string;
+    fileHash?: string;
+}
 export declare class FileReadCache {
     #private;
     /** Look up the most recent snapshot for `absPath`, or `null` if absent. */
     get(absPath: string): FileReadSnapshot | null;
+    /** Look up the most recent snapshot for `absPath` whose file hash matches. */
+    getByHash(absPath: string, fileHash: string): FileReadSnapshot | null;
     /** Record a contiguous run of lines (e.g. from a `read` tool). `startLine` is 1-indexed. */
-    recordContiguous(absPath: string, startLine: number, lines: readonly string[]): void;
+    recordContiguous(absPath: string, startLine: number, lines: readonly string[], metadata?: FileReadSnapshotMetadata): void;
     /** Record sparse `(lineNumber, content)` pairs (e.g. `search` matches plus context). */
-    recordSparse(absPath: string, entries: Iterable<readonly [number, string]>): void;
-    /** Drop the snapshot for a single path. */
+    recordSparse(absPath: string, entries: Iterable<readonly [number, string]>, metadata?: FileReadSnapshotMetadata): void;
+    /** Drop the snapshot history for a single path. */
     invalidate(absPath: string): void;
-    /** Drop every snapshot. */
+    /** Drop every snapshot history. */
     clear(): void;
 }
 /**
@@ -23,3 +33,4 @@ export declare class FileReadCache {
  * the session itself.
  */
 export declare function getFileReadCache(session: ToolSession): FileReadCache;
+export {};

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

@@ -1,10 +1,7 @@
 import type { AgentTool, AgentToolContext, AgentToolResult, AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
-import type * as z from "zod/v4";
 import { type HashlineParams, hashlineEditParamsSchema } from "../hashline";
 import type { ToolSession } from "../tools";
-import { vimSchema } from "../tools/vim";
 import { type EditMode } from "../utils/edit-mode";
-import type { VimToolDetails } from "../vim/types";
 import { type ApplyPatchParams, applyPatchSchema } from "./modes/apply-patch";
 import { type PatchParams, patchEditSchema } from "./modes/patch";
 import { type ReplaceParams, replaceEditSchema } from "./modes/replace";
@@ -20,10 +17,8 @@ export * from "./modes/replace";
 export * from "./normalize";
 export * from "./renderer";
 export * from "./streaming";
-type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditParamsSchema | typeof vimSchema | typeof applyPatchSchema;
-type VimParams = z.infer<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
-type EditToolResultDetails = EditToolDetails | VimToolDetails;
+type TInput = typeof replaceEditSchema | typeof patchEditSchema | typeof hashlineEditParamsSchema | typeof applyPatchSchema;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | ApplyPatchParams;
 export declare class EditTool implements AgentTool<TInput> {
     #private;
     private readonly session;
@@ -54,5 +49,5 @@ export declare class EditTool implements AgentTool<TInput> {
      * internal `name` and `customWireName`, so returned calls route correctly.
      */
     get customWireName(): string | undefined;
-    execute(_toolCallId: string, params: EditParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<EditToolResultDetails, TInput>, context?: AgentToolContext): Promise<AgentToolResult<EditToolResultDetails, TInput>>;
+    execute(_toolCallId: string, params: EditParams, signal?: AbortSignal, onUpdate?: AgentToolUpdateCallback<EditToolDetails, TInput>, context?: AgentToolContext): Promise<AgentToolResult<EditToolDetails, TInput>>;
 }

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

@@ -7,7 +7,6 @@ import type { FileDiagnosticsResult } from "../lsp";
 import { type Theme } from "../modes/theme/theme";
 import type { OutputMeta } from "../tools/output-meta";
 import { getLspBatchRequest, type LspBatchRequest } from "../tools/render-utils";
-import { type VimRenderArgs } from "../tools/vim";
 import type { EditMode } from "../utils/edit-mode";
 import type { DiffError, DiffResult } from "./diff";
 import type { Operation } from "./modes/patch";
@@ -94,7 +93,7 @@ export interface EditRenderContext {
 }
 export declare const editToolRenderer: {
     mergeCallAndResult: boolean;
-    renderCall(args: EditRenderArgs | VimRenderArgs, options: RenderResultOptions & {
+    renderCall(args: EditRenderArgs, options: RenderResultOptions & {
         renderContext?: EditRenderContext;
     }, uiTheme: Theme): Component;
     renderResult(result: {

package/dist/types/eval/__tests__/shared-executors.test.d.ts

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

package/dist/types/eval/js/shared/local-module-loader.d.ts

@@ -0,0 +1,16 @@
+export type LocalImportResolution = {
+    mode: "local";
+    value: unknown;
+} | {
+    mode: "external";
+    target: string;
+};
+export declare class LocalModuleLoader {
+    #private;
+    constructor(sessionId: string);
+    resolveForRun(cwd: string, source: string): Promise<LocalImportResolution>;
+    resolveForModule(moduleUrl: string, source: string, cwd: string): Promise<LocalImportResolution>;
+    requireForFile(moduleUrlOrPath: string | undefined, cwd: string): NodeJS.Require;
+    filenameForUrl(moduleUrlOrPath: string | undefined): string | null;
+    dirnameForUrl(moduleUrlOrPath: string | undefined, cwd: string): string;
+}

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

@@ -1,4 +1,8 @@
 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 stripTypeScriptSyntax(code: string): string;
 export declare function wrapCode(code: string): {
     source: string;
     asyncWrapped: boolean;

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

@@ -1,21 +1,24 @@
 import { type HelperBundle } from "./helpers";
 import type { JsDisplayOutput } from "./types";
 /**
- * Per-run callbacks. Returned by `getHooks()` on each helper/tool/display invocation so
- * the embedding worker can route emissions to the currently active run. Returning `null`
- * makes status/display/tool calls reject with an error — useful for guarding against
- * helpers being invoked outside a run window.
+ * Per-run callbacks. Runtime globals resolve these from AsyncLocalStorage so
+ * overlapping async cells can route output/tool calls back to their own run.
  */
 export interface RuntimeHooks {
     onText(chunk: string): void;
     onDisplay(output: JsDisplayOutput): void;
     callTool(name: string, args: unknown): Promise<unknown>;
 }
+export interface RunContext {
+    runId: string;
+    hooks: RuntimeHooks;
+    cwd: string;
+    finalExpressionSet: boolean;
+    finalExpressionValue: unknown;
+}
 export interface RuntimeOptions {
     initialCwd: string;
     sessionId: string;
-    /** Resolve hooks for the run currently in flight, or `null` if nothing is active. */
-    getHooks(): RuntimeHooks | null;
     /**
      * 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
@@ -42,6 +45,9 @@ export declare class JsRuntime {
      * cleanup it wants.
      */
     setRunScope(scope: Record<string, unknown>): void;
-    run(code: string, filename?: string): Promise<unknown>;
-    displayValue(value: unknown): void;
+    run(code: string, filename: string | undefined, hooks: RuntimeHooks, options?: {
+        runId?: string;
+        cwd?: string;
+    }): Promise<unknown>;
+    displayValue(value: unknown, hooks?: RuntimeHooks | undefined): void;
 }

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

@@ -1,7 +1,6 @@
 import type { ToolSession } from "../../tools";
 import type { JsStatusEvent } from "../js/shared/types";
-import type { KernelDisplayOutput } from "./display";
-import { type KernelExecuteOptions, type KernelExecuteResult } from "./kernel";
+import { type KernelDisplayOutput, type KernelExecuteOptions, type KernelExecuteResult } from "./kernel";
 export type PythonKernelMode = "session" | "per-call";
 export interface PythonExecutorOptions {
     /** Working directory for command execution */

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

@@ -1,7 +1,13 @@
 import { type KernelDisplayOutput } from "./display";
 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;

package/dist/types/eval/py/tool-bridge.d.ts

@@ -11,10 +11,6 @@ export interface PyToolBridgeInfo {
 }
 /** Starts the bridge server lazily and returns its connection info. */
 export declare function ensurePyToolBridge(): Promise<PyToolBridgeInfo>;
-/**
- * Register a tool session for the duration of one execution. The returned
- * function MUST be called to remove the entry once execution finishes.
- */
-export declare function registerPyToolBridge(sessionId: string, entry: PyToolBridgeEntry): () => void;
+export declare function registerPyToolBridge(sessionId: string, runId: string, entry: PyToolBridgeEntry): () => void;
 /** Stop the bridge and clear registrations. Test-only / shutdown helper. */
 export declare function disposePyToolBridge(): Promise<void>;

package/dist/types/eval/session-id.d.ts

@@ -0,0 +1,3 @@
+import type { ToolSession } from "../tools";
+export type EvalSessionSource = Pick<ToolSession, "cwd" | "getSessionFile">;
+export declare function defaultEvalSessionId(session: EvalSessionSource): string;

package/dist/types/extensibility/extensions/types.d.ts

@@ -179,8 +179,6 @@ export interface ExtensionContext {
     shutdown(): void;
     /** Get the current effective system prompt. */
     getSystemPrompt(): string[];
-    /** @deprecated Use hasPendingMessages() instead */
-    hasQueuedMessages(): boolean;
 }
 /**
  * Extended context for command handlers.
@@ -605,7 +603,7 @@ export interface ExtensionAPI {
         triggerTurn?: boolean;
         deliverAs?: "steer" | "followUp" | "nextTurn";
     }): void;
-    /** Send a user message to the agent. Always triggers a turn. */
+    /** Send a user message to the agent, or queue it when deliverAs is set. */
     sendUserMessage(content: string | (TextContent | ImageContent)[], options?: {
         deliverAs?: "steer" | "followUp";
     }): void;

package/dist/types/hashline/anchors.d.ts

@@ -1,20 +1,26 @@
-import type { HashMismatch } from "./types";
 export declare function formatFullAnchorRequirement(raw?: string): string;
 export declare function parseTag(ref: string): {
     line: number;
-    hash: string;
 };
+export interface HashlineMismatchDetails {
+    path?: string;
+    expectedFileHash: string;
+    actualFileHash: string;
+    fileLines: string[];
+    anchorLines?: readonly number[];
+}
 export declare class HashlineMismatchError extends Error {
-    readonly mismatches: HashMismatch[];
+    readonly path: string | undefined;
+    readonly expectedFileHash: string;
+    readonly actualFileHash: string;
     readonly fileLines: string[];
-    readonly remaps: ReadonlyMap<string, string>;
-    constructor(mismatches: HashMismatch[], fileLines: string[]);
+    readonly anchorLines: readonly number[];
+    constructor(details: HashlineMismatchDetails);
     get displayMessage(): string;
-    private static rejectionHeader;
-    static formatDisplayMessage(mismatches: HashMismatch[], fileLines: string[]): string;
-    static formatMessage(mismatches: HashMismatch[], fileLines: string[]): string;
+    static rejectionHeader(details: HashlineMismatchDetails): string[];
+    static formatDisplayMessage(details: HashlineMismatchDetails): string;
+    static formatMessage(details: HashlineMismatchDetails): string;
 }
 export declare function validateLineRef(ref: {
     line: number;
-    hash: string;
 }, fileLines: string[]): void;

package/dist/types/hashline/constants.d.ts

@@ -1,7 +1,5 @@
 /** Lines of context shown either side of a hash mismatch. */
 export declare const MISMATCH_CONTEXT = 2;
-/** Filler hash used for the interior of a multi-line range; not validated. */
-export declare const RANGE_INTERIOR_HASH = "**";
 /** Optional patch envelope start marker; silently consumed when present. */
 export declare const BEGIN_PATCH_MARKER = "*** Begin Patch";
 /** Optional patch envelope end marker; terminates parsing when encountered. */

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

@@ -1,5 +1,4 @@
-import { type HashlineInputSection } from "./input";
-import type { HashlineApplyOptions } from "./types";
+import type { HashlineApplyOptions, HashlineInputSection } from "./types";
 export declare function computeHashlineSectionDiff(section: HashlineInputSection, cwd: string, options?: HashlineApplyOptions): Promise<{
     diff: string;
     firstChangedLine: number | undefined;

package/dist/types/hashline/executor.d.ts

@@ -0,0 +1,52 @@
+import { type HashlineToken } from "./tokenizer";
+import type { HashlineEdit } from "./types";
+/**
+ * Token-driven state machine that turns a stream of {@link HashlineToken}s
+ * into the flat list of {@link HashlineEdit}s applied downstream by the
+ * apply/diff layers.
+ *
+ * The executor owns:
+ *   - the running edit index (kept monotonic across pending flushes),
+ *   - the pending-payload buffer (lines accumulated for the most recently
+ *     opened insert/replace op),
+ *   - all parse-time diagnostics (range order, "delete with payload",
+ *     orphan payload, unrecognized op),
+ *   - the {@link terminated} flag set by `envelope-end`/`abort`.
+ *
+ * Tokens are dispatched in the order they arrive; the matching tokenizer
+ * supplies the line numbers carried inside each token so diagnostics line
+ * up with the source.
+ */
+export declare class HashlineExecutor {
+    #private;
+    /** True once an `envelope-end` or `abort` token has been observed. */
+    get terminated(): boolean;
+    /**
+     * Consume one token. After `terminated` flips true subsequent feeds
+     * are silently ignored so callers can keep draining their tokenizer
+     * without explicit early-exit guards.
+     */
+    feed(token: HashlineToken): void;
+    /**
+     * Flush any open pending op (including its trailing blank lines, which
+     * are payload-significant) and return the accumulated edits and
+     * warnings. The executor is single-use; reset() is required for reuse.
+     */
+    end(): {
+        edits: HashlineEdit[];
+        warnings: string[];
+    };
+    /** Reset to a fresh state so the same instance can drive another parse. */
+    reset(): void;
+}
+/**
+ * Drive a full hashline diff through the tokenizer + executor pipeline and
+ * return the resulting edits plus any parse-time warnings. This is the
+ * convenience entry point most callers want; reach for {@link
+ * HashlineTokenizer}/{@link HashlineExecutor} directly only when you need
+ * streaming feeds, cross-section state, or custom token handling.
+ */
+export declare function parseHashline(diff: string): {
+    edits: HashlineEdit[];
+    warnings: string[];
+};