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

package/src/eval/jl/prelude.jl

@@ -146,221 +146,6 @@ function Base.write(path::AbstractString, content::Any)
     return resolved
 end
 
-function append(path, content)
-    resolved = __omp_resolve_path(string(path))
-    mkpath(dirname(resolved))
-    open(resolved, "a") do f
-        Base.write(f, string(content))
-    end
-    
-    Main.emit_frame(Dict(
-        "type" => "display",
-        "id" => Main.current_rid,
-        "bundle" => Dict(
-            "application/x-omp-status" => Dict(
-                "op" => "append",
-                "path" => resolved,
-                "chars" => length(string(content))
-            )
-        )
-    ))
-    return resolved
-end
-
-function tree(path=".", positional_max_depth=3, positional_show_hidden=false; max_depth=positional_max_depth, show_hidden=positional_show_hidden)
-    base = string(path)
-    resolved = __omp_resolve_path(base)
-    lines = String[]
-    
-    function walk(dir, prefix, depth)
-        if depth > max_depth
-            return
-        end
-        entries = try
-            readdir(dir)
-        catch
-            String[]
-        end
-        if !show_hidden
-            entries = filter(e -> !startswith(e, '.'), entries)
-        end
-        sort!(entries, by = e -> (ispath(joinpath(dir, e)) && isdir(joinpath(dir, e)) ? 0 : 1, lowercase(e)))
-        
-        for (i, name) in enumerate(entries)
-            full = joinpath(dir, name)
-            is_last = i == length(entries)
-            is_dir = isdir(full)
-            push!(lines, "$(prefix)$(is_last ? "└── " : "├── ")$(name)$(is_dir ? "/" : "")")
-            if is_dir
-                walk(full, prefix * (is_last ? "    " : "│   "), depth + 1)
-            end
-        end
-    end
-    
-    walk(resolved, "", 1)
-    out = join(lines, '\n')
-    
-    Main.emit_frame(Dict(
-        "type" => "display",
-        "id" => Main.current_rid,
-        "bundle" => Dict(
-            "application/x-omp-status" => Dict(
-                "op" => "tree",
-                "path" => resolved,
-                "lines" => length(lines)
-            )
-        )
-    ))
-    return out
-end
-
-function __omp_lines_keepends(content::String)
-    parts = split(content, '\n'; keepempty=true)
-    if length(parts) == 1 && isempty(parts[1])
-        return String[]
-    end
-    lines = String[]
-    for i in eachindex(parts)
-        if i < length(parts)
-            push!(lines, string(parts[i], "\n"))
-        elseif !isempty(parts[i])
-            push!(lines, string(parts[i]))
-        end
-    end
-    return lines
-end
-
-function __omp_diff_ops(a::Vector{String}, b::Vector{String})
-    n = length(a)
-    m = length(b)
-    ops = Vector{Tuple{Symbol, Int, Int}}()
-    if n * m > 4_000_000
-        for i in 1:n
-            push!(ops, (:delete, i, 1))
-        end
-        for j in 1:m
-            push!(ops, (:insert, n + 1, j))
-        end
-        return ops
-    end
-
-    dp = [zeros(Int, m + 1) for _ in 1:(n + 1)]
-    for i in n:-1:1
-        for j in m:-1:1
-            dp[i][j] = a[i] == b[j] ? dp[i + 1][j + 1] + 1 : max(dp[i + 1][j], dp[i][j + 1])
-        end
-    end
-
-    i = 1
-    j = 1
-    while i <= n && j <= m
-        if a[i] == b[j]
-            push!(ops, (:equal, i, j))
-            i += 1
-            j += 1
-        elseif dp[i + 1][j] >= dp[i][j + 1]
-            push!(ops, (:delete, i, j))
-            i += 1
-        else
-            push!(ops, (:insert, i, j))
-            j += 1
-        end
-    end
-    while i <= n
-        push!(ops, (:delete, i, j))
-        i += 1
-    end
-    while j <= m
-        push!(ops, (:insert, i, j))
-        j += 1
-    end
-    return ops
-end
-
-function __omp_unified_diff(a::Vector{String}, b::Vector{String}, from_file::String, to_file::String, context::Int=3)
-    ops = __omp_diff_ops(a, b)
-    if !any(op -> op[1] != :equal, ops)
-        return ""
-    end
-
-    entries = [Dict{Symbol, Any}(:tag => tag, :ai => ai, :bi => bi, :text => tag == :insert ? b[bi] : a[ai]) for (tag, ai, bi) in ops]
-    changed = [i for i in eachindex(entries) if entries[i][:tag] != :equal]
-    groups = Vector{Tuple{Int, Int}}()
-    start = nothing
-    prev = nothing
-    for idx in changed
-        if start === nothing
-            start = idx
-            prev = idx
-        elseif idx - prev <= (2 * context) + 1
-            prev = idx
-        else
-            push!(groups, (start, prev))
-            start = idx
-            prev = idx
-        end
-    end
-    if start !== nothing
-        push!(groups, (start, prev))
-    end
-
-    out = IOBuffer()
-    write(out, "--- $from_file\n")
-    write(out, "+++ $to_file\n")
-    for (group_start, group_end) in groups
-        lo = max(group_start - context, 1)
-        hi = min(group_end + context, length(entries))
-        slice = entries[lo:hi]
-        a_start = nothing
-        a_count = 0
-        b_start = nothing
-        b_count = 0
-        for entry in slice
-            if entry[:tag] != :insert
-                if a_start === nothing
-                    a_start = entry[:ai]
-                end
-                a_count += 1
-            end
-            if entry[:tag] != :delete
-                if b_start === nothing
-                    b_start = entry[:bi]
-                end
-                b_count += 1
-            end
-        end
-        write(out, "@@ -$(a_start === nothing ? 1 : a_start),$a_count +$(b_start === nothing ? 1 : b_start),$b_count @@\n")
-        for entry in slice
-            prefix = entry[:tag] == :equal ? " " : (entry[:tag] == :delete ? "-" : "+")
-            text = string(entry[:text])
-            if !endswith(text, "\n")
-                text *= "\n"
-            end
-            write(out, prefix * text)
-        end
-    end
-    return String(take!(out))
-end
-
-function Base.diff(a::AbstractString, b::AbstractString)
-    path_a = __omp_resolve_path(string(a))
-    path_b = __omp_resolve_path(string(b))
-    lines_a = __omp_lines_keepends(open(path_a, "r") do io
-        Base.read(io, String)
-    end)
-    lines_b = __omp_lines_keepends(open(path_b, "r") do io
-        Base.read(io, String)
-    end)
-    out = __omp_unified_diff(lines_a, lines_b, path_a, path_b)
-    __omp_emit_status("diff", Dict{String, Any}(
-        "file_a" => path_a,
-        "file_b" => path_b,
-        "identical" => isempty(out),
-        "preview" => first(out, min(500, length(out)))
-    ))
-    return out
-end
-
 function __omp_apply_query(data, query)
     if query === nothing || isempty(string(query))
         return data
@@ -734,10 +519,10 @@ function completion(prompt::String; model="default", system=nothing, schema=noth
     return schema === nothing ? text : Main.json_parse(string(text))
 end
 
-function agent(prompt::String; agent_type="task", model=nothing, label=nothing, schema=nothing, return_handle=false, kwargs...)
+function agent(prompt::String; agent="task", model=nothing, label=nothing, schema=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
     args_dict = Dict{String, Any}("prompt" => prompt)
-    if agent_type !== nothing
-        args_dict["agentType"] = agent_type
+    if agent !== nothing
+        args_dict["agent"] = agent
     end
     if model !== nothing
         args_dict["model"] = model
@@ -748,16 +533,24 @@ function agent(prompt::String; agent_type="task", model=nothing, label=nothing,
     if schema !== nothing
         args_dict["schema"] = schema
     end
-    handle_result = return_handle
+    # Isolation knobs mirror the `task` tool: strict opt-in via `isolated`,
+    # with `apply`/`merge` controlling the post-run patch/branch merge.
+    if isolated !== nothing
+        args_dict["isolated"] = Bool(isolated)
+    end
+    if apply !== nothing
+        args_dict["apply"] = Bool(apply)
+    end
+    if merge !== nothing
+        args_dict["merge"] = Bool(merge)
+    end
+    handle_result = handle
     for (k, v) in kwargs
-        key = string(k)
-        if key == "agent_type" || key == "agentType"
-            args_dict["agentType"] = v
-        elseif key == "return_handle" || key == "returnHandle"
-            handle_result = Bool(v)
-        else
-            args_dict[key] = v
-        end
+        args_dict[string(k)] = v
+    end
+    # Tell the bridge a handle is wanted so it preserves the backing artifacts.
+    if handle_result
+        args_dict["handle"] = true
     end
     res = __omp_call_bridge("__agent__", args_dict)
     text = res isa AbstractDict ? get(res, "text", res) : res
@@ -779,6 +572,18 @@ function agent(prompt::String; agent_type="task", model=nothing, label=nothing,
     if schema !== nothing
         node["data"] = parsed
     end
+    for (src_key, dst_key) in (
+        ("isolated", "isolated"),
+        ("patchPath", "patch_path"),
+        ("branchName", "branch_name"),
+        ("nestedPatches", "nested_patches"),
+        ("changesApplied", "changes_applied"),
+        ("isolationSummary", "isolation_summary"),
+    )
+        if haskey(details, src_key)
+            node[dst_key] = details[src_key]
+        end
+    end
     return node
 end
 

package/src/eval/jl/runner.jl

@@ -3,6 +3,12 @@
 
 using Base64
 
+# Force GR (the default Plots.jl backend) into a headless workstation so a plot
+# never pops up a native gksqt GUI window — the harness renders the inline PNG
+# from `show(io, MIME"image/png", plt)` itself. `get!` keeps an explicit
+# user-provided value, mirroring the Python runner's MPLBACKEND=Agg default.
+get!(ENV, "GKSwstype", "100")
+
 const ORIGINAL_STDOUT = stdout
 const ORIGINAL_STDERR = stderr
 const ORIGINAL_STDIN = stdin
@@ -441,24 +447,38 @@ end
 
 function build_mime_bundle(value)
     bundle = Dict{String, Any}()
-    
-    # text/plain
-    io_plain = IOBuffer()
-    show(io_plain, MIME"text/plain"(), value)
-    bundle["text/plain"] = String(take!(io_plain))
-    
+
+    # text/plain — every mime probe below uses `Base.invokelatest` because this
+    # function runs from the frozen-world `main()` loop: `show`/`showable`
+    # methods that a package adds when it is `using`-ed *inside* a cell (e.g.
+    # Plots/Makie/GraphRecipes registering rich `show` for their plot types) are
+    # invisible to direct dispatch here and fall back to the default struct show,
+    # which can itself throw. Guard text/plain too so a failing repr never aborts
+    # the whole bundle before the image mime is reached.
+    try
+        io_plain = IOBuffer()
+        Base.invokelatest(show, io_plain, MIME"text/plain"(), value)
+        bundle["text/plain"] = String(take!(io_plain))
+    catch
+        bundle["text/plain"] = try
+            summary(value)
+        catch
+            string(typeof(value))
+        end
+    end
+
     # rich mime types
     for mime_str in ["text/html", "text/markdown", "image/png", "image/jpeg"]
         m = MIME(Symbol(mime_str))
-        if showable(m, value)
+        if Base.invokelatest(showable, m, value)
             try
                 io = IOBuffer()
                 if mime_str in ["image/png", "image/jpeg"]
                     b64_io = Base64EncodePipe(io)
-                    show(b64_io, m, value)
+                    Base.invokelatest(show, b64_io, m, value)
                     close(b64_io)
                 else
-                    show(io, m, value)
+                    Base.invokelatest(show, io, m, value)
                 end
                 bundle[mime_str] = String(take!(io))
             catch
@@ -466,7 +486,7 @@ function build_mime_bundle(value)
             end
         end
     end
-    
+
     if value isa AbstractDict || value isa AbstractVector
         try
             bundle["application/json"] = value
@@ -474,7 +494,7 @@ function build_mime_bundle(value)
             # ignore
         end
     end
-    
+
     return bundle
 end
 
@@ -493,7 +513,13 @@ pushdisplay(OmpDisplay())
 
 function emit_error(rid, err, bt)
     io = IOBuffer()
-    showerror(io, err)
+    # invokelatest + guard: custom error types from packages loaded inside the
+    # cell define `showerror` methods invisible to this frozen-world function.
+    try
+        Base.invokelatest(showerror, io, err)
+    catch
+        print(io, string(err))
+    end
     err_str = String(take!(io))
     
     tb = String[]

package/src/eval/js/shared/helpers.ts

@@ -1,19 +1,11 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
 
-import * as Diff from "diff";
 import { ToolError } from "../../../tools/tool-errors";
 import type { JsStatusEvent } from "./types";
 
 export interface HelperOptions {
-	path?: string;
-	hidden?: boolean;
-	maxDepth?: number;
 	limit?: number;
 	offset?: number;
-	reverse?: boolean;
-	unique?: boolean;
-	count?: boolean;
 }
 
 /**
@@ -35,18 +27,12 @@ export interface HelperContext {
 
 /**
  * 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`, ...)
+ * prelude reads from this bag and attaches short aliases (`read`, `write`, `env`, ...)
  * onto the global scope.
  */
 export interface HelperBundle {
 	read(rawPath: string, options?: HelperOptions): Promise<string>;
 	writeFile(rawPath: string, data: unknown): Promise<string>;
-	append(rawPath: string, content: string): Promise<string>;
-	sortText(text: string, options?: HelperOptions): string;
-	uniqText(text: string, options?: HelperOptions): string | Array<[number, string]>;
-	counter(items: string | string[], options?: HelperOptions): Array<[number, string]>;
-	diff(rawA: string, rawB: string): Promise<string>;
-	tree(searchPath?: string, options?: HelperOptions): Promise<string>;
 	env(key?: string, value?: string): string | Record<string, string> | undefined;
 }
 
@@ -81,105 +67,6 @@ export function createHelpers(ctx: HelperContext): HelperBundle {
 			ctx.emitStatus({ op: "write", path: filePath, bytes: getDataSize(data) });
 			return filePath;
 		},
-		append: async (rawPath, content) => {
-			const target = resolveHelperPath(ctx, rawPath, "write");
-			// O(1) append; read-all+rewrite both raced concurrent writers and went
-			// quadratic when called in a loop. Bun.write creates parent dirs, so
-			// keep that behavior for the append path too.
-			await fs.promises.mkdir(path.dirname(target), { recursive: true });
-			await fs.promises.appendFile(target, content, "utf-8");
-			ctx.emitStatus({
-				op: "append",
-				path: target,
-				chars: content.length,
-				bytes: utf8Encoder.encode(content).byteLength,
-			});
-			return target;
-		},
-		sortText: (text, options = {}) => {
-			const lines = String(text).split(/\r?\n/);
-			const deduped = options.unique ? Array.from(new Set(lines)) : lines;
-			const sorted = deduped.sort((a, b) => a.localeCompare(b));
-			if (options.reverse) sorted.reverse();
-			const result = sorted.join("\n");
-			ctx.emitStatus({
-				op: "sort",
-				lines: sorted.length,
-				reverse: options.reverse === true,
-				unique: options.unique === true,
-			});
-			return result;
-		},
-		uniqText: (text, options = {}) => {
-			const lines = String(text)
-				.split(/\r?\n/)
-				.filter(line => line.length > 0);
-			const groups: Array<[number, string]> = [];
-			for (const line of lines) {
-				const last = groups.at(-1);
-				if (last && last[1] === line) {
-					last[0] += 1;
-					continue;
-				}
-				groups.push([1, line]);
-			}
-			ctx.emitStatus({ op: "uniq", groups: groups.length, count_mode: options.count === true });
-			if (options.count) return groups;
-			return groups.map(([, line]) => line).join("\n");
-		},
-		counter: (items, options = {}) => {
-			const values = Array.isArray(items) ? items : String(items).split(/\r?\n/).filter(Boolean);
-			const counts = new Map<string, number>();
-			for (const item of values) counts.set(item, (counts.get(item) ?? 0) + 1);
-			const entries = Array.from(counts.entries())
-				.map(([item, count]) => [count, item] as [number, string])
-				.sort((a, b) => (options.reverse === false ? a[0] - b[0] : b[0] - a[0]) || a[1].localeCompare(b[1]));
-			const limited = entries.slice(0, options.limit ?? entries.length);
-			ctx.emitStatus({ op: "counter", unique: counts.size, total: values.length, top: limited.slice(0, 10) });
-			return limited;
-		},
-		diff: async (rawA, rawB) => {
-			const fileA = resolvePath(ctx, rawA);
-			const fileB = resolvePath(ctx, rawB);
-			const [a, b] = await Promise.all([Bun.file(fileA).text(), Bun.file(fileB).text()]);
-			const result = Diff.createTwoFilesPatch(fileA, fileB, a, b, "", "", { context: 3 });
-			ctx.emitStatus({
-				op: "diff",
-				file_a: fileA,
-				file_b: fileB,
-				identical: a === b,
-				preview: result.slice(0, 500),
-			});
-			return result;
-		},
-		tree: async (searchPath = ".", options = {}) => {
-			const root = resolvePath(ctx, searchPath);
-			const maxDepth = options.maxDepth ?? 3;
-			const showHidden = options.hidden ?? false;
-			const lines: string[] = [`${root}/`];
-			let entryCount = 0;
-			const walk = async (dir: string, prefix: string, depth: number): Promise<void> => {
-				if (depth > maxDepth) return;
-				const entries = (await fs.promises.readdir(dir, { withFileTypes: true }))
-					.filter(entry => showHidden || !entry.name.startsWith("."))
-					.sort((a, b) => a.name.localeCompare(b.name));
-				for (let index = 0; index < entries.length; index++) {
-					const entry = entries[index];
-					const isLast = index === entries.length - 1;
-					const connector = isLast ? "└── " : "├── ";
-					const suffix = entry.isDirectory() ? "/" : "";
-					lines.push(`${prefix}${connector}${entry.name}${suffix}`);
-					entryCount += 1;
-					if (entry.isDirectory()) {
-						await walk(path.join(dir, entry.name), `${prefix}${isLast ? "    " : "│   "}`, depth + 1);
-					}
-				}
-			};
-			await walk(root, "", 1);
-			const result = lines.join("\n");
-			ctx.emitStatus({ op: "tree", path: root, entries: entryCount, preview: result.slice(0, 1000) });
-			return result;
-		},
 		env: (key, value) => {
 			if (!key) {
 				const merged = Object.fromEntries(Object.entries(getMergedEnv(ctx)).sort(([a], [b]) => a.localeCompare(b)));

package/src/eval/js/shared/prelude.txt

@@ -63,23 +63,6 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 		return callHelper("read", path, options);
 	};
 	const write = async (path, data) => callHelper("writeFile", path, data);
-	const append = (path, content) => callHelper("append", path, content);
-	const sort = (text, opts, ...rest) =>
-		callHelper("sortText", text, optionsArg("sort", opts, rest, ["reverse", "unique"], "{ reverse, unique }"));
-	const uniq = (text, opts, ...rest) => callHelper("uniqText", text, optionsArg("uniq", opts, rest, ["count"], "{ count }"));
-	const counter = (items, opts, ...rest) =>
-		callHelper("counter", items, optionsArg("counter", opts, rest, ["limit", "reverse"], "{ limit, reverse }"));
-	const diff = (a, b) => callHelper("diff", a, b);
-	const tree = (path = ".", opts, ...rest) => {
-		if (isPlainObject(path) && opts === undefined && rest.length === 0) {
-			return callHelper("tree", ".", path);
-		}
-		return callHelper(
-			"tree",
-			isNil(path) ? "." : path,
-			optionsArg("tree", opts, rest, ["maxDepth", "showHidden"], "{ maxDepth, showHidden }"),
-		);
-	};
 	const env = (key, value) => callHelper("env", key, value);
 
 	const tool = new Proxy(
@@ -117,18 +100,27 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	};
 
 	const agent = async (prompt, opts, ...rest) => {
-		const o = optionsArg("agent", opts, rest, ["agentType", "model", "label", "schema"], "{ agentType, model, label, schema, returnHandle }");
-		const { returnHandle, ...callArgs } = o;
-		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...callArgs });
+		const o = optionsArg(
+			"agent",
+			opts,
+			rest,
+			["agent", "model", "label", "schema", "isolated", "apply", "merge"],
+			"{ agent, model, label, schema, isolated, apply, merge, handle }",
+		);
+		const { handle, ...callArgs } = o;
+		const res = await globalThis.__omp_call_tool__("__agent__", { prompt, ...callArgs, handle: Boolean(handle) });
 		const text = res && typeof res === "object" ? res.text : res;
 		const parsed = hasOwn(callArgs, "schema") ? JSON.parse(text) : text;
-		if (!returnHandle) return parsed;
+		if (!handle) return parsed;
 		const details = res && typeof res === "object" ? res.details : undefined;
 		if (!details || typeof details !== "object" || details.id == null) {
 			return { text, output: text, handle: null, id: null, agent: null };
 		}
 		const node = { text, output: text, handle: `agent://${details.id}`, id: details.id, agent: details.agent ?? null };
 		if (hasOwn(callArgs, "schema")) node.data = parsed;
+		for (const key of ["isolated", "patchPath", "branchName", "nestedPatches", "changesApplied", "isolationSummary"]) {
+			if (details[key] !== undefined) node[key] = details[key];
+		}
 		return node;
 	};
 
@@ -297,11 +289,5 @@ if (!globalThis.__omp_js_prelude_loaded__) {
 	globalThis.__pool = __pool;
 	globalThis.read = read;
 	globalThis.write = write;
-	globalThis.append = append;
-	globalThis.sort = sort;
-	globalThis.uniq = uniq;
-	globalThis.counter = counter;
-	globalThis.diff = diff;
-	globalThis.tree = tree;
 	globalThis.env = env;
 }

package/src/eval/js/shared/runtime.ts

@@ -72,12 +72,6 @@ const PRELUDE_GLOBAL_KEYS = [
 	"__pool",
 	"read",
 	"write",
-	"append",
-	"sort",
-	"uniq",
-	"counter",
-	"diff",
-	"tree",
 	"env",
 ];
 

package/src/eval/js/shared/types.ts

@@ -1,5 +1,5 @@
 /**
- * Structured status payload emitted by helpers (`read`, `write`, `tree`, etc.) and the
+ * Structured status payload emitted by helpers (`read`, `write`, `env`, etc.) and the
  * tool-call bridge. Surfaces to the model as part of `displays` so it has machine-readable
  * context about what side effects happened.
  */

package/src/eval/js/worker-protocol.ts

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

package/src/eval/py/__tests__/prelude.test.ts

@@ -16,4 +16,17 @@ describe("python prelude", () => {
 		expect(signature).toContain("offset");
 		expect(signature).toContain("limit");
 	});
+
+	it("exposes isolation artifacts on the agent() handle node", () => {
+		// agent(..., handle=True) is the only escape hatch for
+		// recovering apply=False patch/branch/nested artifacts (the bare
+		// schema return is just the parsed object), so the helper MUST
+		// translate the bridge's camelCase details onto the node — otherwise
+		// an isolated apply=False workflow loses captured nested patches.
+		expect(PYTHON_PRELUDE).toContain('("patchPath", "patch_path")');
+		expect(PYTHON_PRELUDE).toContain('("branchName", "branch_name")');
+		expect(PYTHON_PRELUDE).toContain('("nestedPatches", "nested_patches")');
+		expect(PYTHON_PRELUDE).toContain('("changesApplied", "changes_applied")');
+		expect(PYTHON_PRELUDE).toContain('("isolationSummary", "isolation_summary")');
+	});
 });

package/src/eval/py/executor.ts

@@ -71,7 +71,7 @@ export interface PythonExecutorOptions {
 	artifactPath?: string;
 	artifactId?: string;
 	/**
-	 * On-disk roots the prelude helpers (`read`/`write`/`append`) substitute for
+	 * On-disk roots the prelude helpers (`read`/`write`) substitute for
 	 * internal-URL schemes (e.g. `{ local: "/…/artifacts/local" }`). Exported to
 	 * the kernel as `PI_EVAL_LOCAL_ROOTS` (JSON) so `write("local://x")` lands
 	 * where `read local://x` resolves instead of a literal `local:/` directory.