@code-yeongyu/senpi 2026.7.11 → 2026.7.13

package/node_modules/@code-yeongyu/senpi-codemode/src/index.ts

@@ -1,26 +1,59 @@
 import type { ExtensionContext } from "@code-yeongyu/senpi";
 import type { KernelToHostMessage } from "./bridge/protocol.ts";
+import type { AgentExecuteTool } from "./bridges/agent-bridge.ts";
 import { type CompletionRequest, type CompletionResult, createCompletionHandler } from "./completion/handler.ts";
-import { type CodemodeSettings, loadCodemodeSettings } from "./config/settings.ts";
 import {
+	type CodemodeSettings,
+	defaultCodemodeSettings,
+	loadCodemodeSettings,
+	type ResolvedCodemodeSettings,
+	resolveEnabledLanguages,
+} from "./config/settings.ts";
+import {
+	CodemodeSessionDisposedError,
 	type CodemodeSessionManager,
 	type CreateCodemodeSessionManagerOptions,
 	createCodemodeSessionManager,
+	type EvalExecutionTracker,
 } from "./extension/session-manager.ts";
 import {
 	createInterpreterDetector,
 	getInterpreterAvailability,
 	type InterpreterAvailability,
 } from "./interpreters/detect.ts";
+import { resolveSessionArtifactsDir } from "./output/streaming-output.ts";
 import { createEvalTool } from "./tool/eval-tool.ts";
-import type { EvalKernel, EvalLanguage, ExecuteTool } from "./tool/types.ts";
+import { renderEvalCall, renderEvalResult } from "./tool/render.ts";
+import type { EnabledEvalLanguages, EvalKernel, EvalLanguage } from "./tool/types.ts";
+
+const SESSION_LIFECYCLE_EVENTS = [
+	"session_start",
+	"session_shutdown",
+	"session_before_switch",
+	"session_before_fork",
+] as const;
+
+type SessionLifecycleEvent = (typeof SESSION_LIFECYCLE_EVENTS)[number];
+
+type TrackedExecution = {
+	readonly promise: Promise<unknown>;
+	readonly controller: AbortController;
+};
 
-type SessionLifecycleEvent = "session_start" | "session_shutdown" | "session_before_switch" | "session_before_fork";
+type SessionRuntime = {
+	readonly manager: CodemodeSessionManager;
+	readonly enabledLanguages: EnabledEvalLanguages;
+	readonly settings: ResolvedCodemodeSettings;
+	readonly artifactsDir: string;
+	readonly executeTool: AgentExecuteTool;
+	readonly spawns: boolean;
+};
 
 export interface CodemodeExtensionAPI {
 	registerTool(tool: ReturnType<typeof createEvalTool>): void;
 	on(event: SessionLifecycleEvent, handler: (event: unknown, ctx: ExtensionContext) => Promise<void> | void): void;
-	executeTool: ExecuteTool;
+	executeTool: AgentExecuteTool;
+	getActiveTools(): string[];
 }
 
 export interface SenpiCodemodeOptions {
@@ -30,60 +63,122 @@ export interface SenpiCodemodeOptions {
 	readonly complete?: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>;
 }
 
+class CodemodeSessionNotStartedError extends Error {
+	readonly name = "CodemodeSessionNotStartedError";
+
+	constructor() {
+		super("codemode session has not started");
+	}
+}
+
 export default function senpiCodemode(pi: CodemodeExtensionAPI, options: SenpiCodemodeOptions = {}): void {
 	const manager = new SessionManagerProxy();
 	const complete = options.complete ?? ((request, ctx) => createCompletionHandler()(ctx)(request));
+	const renderers = { renderCall: renderEvalCall, renderResult: renderEvalResult };
 	pi.registerTool(
 		createEvalTool({
 			enabledLanguages: { py: true, js: true, rb: true, jl: true },
 			kernelManager: manager,
-			cellTimeoutSeconds: 30,
-			executeTool: (toolName, params, executeOptions) => pi.executeTool(toolName, params, executeOptions),
+			cellTimeoutSeconds: defaultCodemodeSettings.cellTimeoutSeconds,
+			executeTool: createExecuteTool(pi),
 			complete,
+			settings: defaultCodemodeSettings,
+			executionTracker: manager,
+			renderers,
 		}),
 	);
 
 	pi.on("session_start", async (event, ctx) => {
 		const generation = manager.beginReplacement();
-		await manager.replace(generation, await createManager(pi, ctx, event, complete, options));
+		const runtime = await createRuntime(pi, ctx, event, complete, options);
+		if (!(await manager.replace(generation, runtime.manager))) return;
+		pi.registerTool(
+			createEvalTool({
+				enabledLanguages: runtime.enabledLanguages,
+				kernelManager: manager,
+				cellTimeoutSeconds: runtime.settings.cellTimeoutSeconds,
+				executeTool: runtime.executeTool,
+				complete,
+				settings: runtime.settings,
+				artifactsDir: runtime.artifactsDir,
+				executionTracker: manager,
+				renderers,
+				spawns: runtime.spawns,
+				spawnDefaultAgent: runtime.settings.taskTools.task,
+			}),
+		);
 	});
 	pi.on("session_shutdown", async () => manager.dispose());
 	pi.on("session_before_switch", async () => manager.dispose());
 	pi.on("session_before_fork", async () => manager.dispose());
 }
 
-class SessionManagerProxy implements CodemodeSessionManager {
+class SessionManagerProxy implements CodemodeSessionManager, EvalExecutionTracker {
 	#current: CodemodeSessionManager | undefined;
 	#generation = 0;
+	#started = false;
+	#acceptingExecutions = false;
+	readonly #executions = new Set<TrackedExecution>();
 
 	beginReplacement(): number {
 		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
 		return this.#generation;
 	}
 
-	async replace(generation: number, next: CodemodeSessionManager): Promise<void> {
+	async replace(generation: number, next: CodemodeSessionManager): Promise<boolean> {
+		if (generation !== this.#generation) {
+			await next.dispose();
+			return false;
+		}
+		await this.#settleExecutions();
 		if (generation !== this.#generation) {
 			await next.dispose();
-			return;
+			return false;
 		}
 		const current = this.#current;
 		this.#current = undefined;
 		await current?.dispose();
 		if (generation !== this.#generation) {
 			await next.dispose();
-			return;
+			return false;
 		}
 		this.#current = next;
+		this.#started = true;
+		this.#acceptingExecutions = true;
+		return true;
+	}
+
+	assertEvalExecutionAllowed(): void {
+		if (this.#acceptingExecutions && this.#current !== undefined) return;
+		if (this.#started) throw new CodemodeSessionDisposedError();
+		throw new CodemodeSessionNotStartedError();
+	}
+
+	async trackEvalExecution<Result>(execution: Promise<Result>, controller: AbortController): Promise<Result> {
+		this.assertEvalExecutionAllowed();
+		const tracked: TrackedExecution = { promise: execution, controller };
+		this.#executions.add(tracked);
+		try {
+			return await execution;
+		} finally {
+			this.#executions.delete(tracked);
+		}
 	}
 
 	async getKernel(language: EvalLanguage, onMessage: (message: KernelToHostMessage) => void): Promise<EvalKernel> {
-		if (!this.#current) throw new Error("codemode session has not started");
-		return await this.#current.getKernel(language, onMessage);
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.getKernel(language, onMessage);
 	}
 
 	async complete(request: CompletionRequest, ctx: ExtensionContext): Promise<CompletionResult> {
-		if (!this.#current) throw new Error("codemode session has not started");
-		return await this.#current.complete(request, ctx);
+		this.assertEvalExecutionAllowed();
+		const current = this.#current;
+		if (current === undefined) throw new CodemodeSessionNotStartedError();
+		return await current.complete(request, ctx);
 	}
 
 	setContext(ctx: ExtensionContext): void {
@@ -92,30 +187,69 @@ class SessionManagerProxy implements CodemodeSessionManager {
 
 	async dispose(): Promise<void> {
 		this.#generation++;
+		this.#acceptingExecutions = false;
+		this.#abortExecutions();
+		await this.#settleExecutions();
 		const current = this.#current;
 		this.#current = undefined;
 		await current?.dispose();
 	}
+
+	#abortExecutions(): void {
+		if (this.#executions.size === 0) return;
+		const error = new CodemodeSessionDisposedError();
+		for (const execution of this.#executions) execution.controller.abort(error);
+	}
+
+	async #settleExecutions(): Promise<void> {
+		if (this.#executions.size === 0) return;
+		await Promise.allSettled([...this.#executions].map((execution) => execution.promise));
+	}
 }
 
-async function createManager(
+async function createRuntime(
 	pi: CodemodeExtensionAPI,
 	ctx: ExtensionContext,
 	event: unknown,
 	complete: (request: CompletionRequest, ctx: ExtensionContext) => Promise<CompletionResult>,
 	options: SenpiCodemodeOptions,
-): Promise<CodemodeSessionManager> {
+): Promise<SessionRuntime> {
 	const loaded = await loadCodemodeSettings({ cwd: ctx.cwd });
-	const availability = await getInterpreterAvailability(loaded.settings, createInterpreterDetector());
+	const settings: ResolvedCodemodeSettings = {
+		...loaded.settings,
+		languages: resolveEnabledLanguages(loaded.settings),
+	};
+	const availability = await getInterpreterAvailability(settings, createInterpreterDetector());
+	const enabledLanguages = enabledLanguagesFrom(settings, availability);
+	const artifacts = resolveSessionArtifactsDir(ctx.sessionManager.getSessionFile());
+	const activeTools = new Set(pi.getActiveTools());
+	const executeTool = createExecuteTool(pi, activeTools);
 	const create = options.createSessionManager ?? createCodemodeSessionManager;
-	return await create({
+	const manager = await create({
 		sessionId: sessionIdFrom(event),
 		cwd: ctx.cwd,
-		settings: loaded.settings,
+		settings,
 		availability,
-		executeTool: (toolName, params, executeOptions) => pi.executeTool(toolName, params, executeOptions),
+		artifactsDir: artifacts.dir,
+		executeTool,
 		complete,
 	});
+	return {
+		manager,
+		enabledLanguages,
+		settings,
+		artifactsDir: artifacts.dir,
+		executeTool,
+		spawns: activeTools.has(settings.taskTools.task),
+	};
+}
+
+function createExecuteTool(pi: CodemodeExtensionAPI, activeTools?: ReadonlySet<string>): AgentExecuteTool {
+	const executeTool: AgentExecuteTool = (toolName, params, executeOptions) =>
+		pi.executeTool(toolName, params, executeOptions);
+	return Object.assign(executeTool, {
+		isToolAvailable: (name: string): boolean => activeTools?.has(name) ?? pi.getActiveTools().includes(name),
+	});
 }
 
 function sessionIdFrom(event: unknown): string {

package/node_modules/@code-yeongyu/senpi-codemode/src/interpreters/detect.ts

@@ -144,7 +144,7 @@ function candidateInvocation(candidate: string): { readonly command: string; rea
 }
 
 function parseVersion(output: string): string | null {
-	const match = /(?:Python|ruby|julia)\s+v?(\d+(?:\.\d+){1,3})/i.exec(output.trim());
+	const match = /(?:Python|ruby|julia)\s+(?:version\s+)?v?(\d+(?:\.\d+){1,3})/i.exec(output.trim());
 	return match?.[1] ?? null;
 }
 

package/node_modules/@code-yeongyu/senpi-codemode/src/kernels/jl/prelude.jl

@@ -1,79 +1,283 @@
-# NOTE: deliberately NO `using Base64`. On a cold Julia depot (a fresh CI runner
-# home) the first `using Base64` triggers a serial package precompile (~1s+ of CPU
-# and disk IO); under an oversubscribed CI runner that spike balloons past the
-# per-cell timeout, so the kernel's first cell would flakily time out, restart, and
-# lose session state. Every other kernel dependency (Sockets in runner.jl, Base) is
-# already in the shipped sysimage and needs no precompile, so base64 is the only
-# precompile trigger — we hand-roll it against Base to keep cold start deterministic.
-# Verified byte-exact against Base64.base64encode (empty / 1-2-3 byte remainders /
-# multibyte UTF-8 / binary / long input).
+# allow: SIZE_OK — this dependency-free kernel prelude is loaded as one runtime asset.
 const SENPI_B64_ALPHABET = collect("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
 
 function senpi_base64(text::AbstractString)
-    # prelude.jl shadows Base `write` within Main, so infrastructure must qualify
-    # Base.write explicitly (see the same policy note in runner.jl).
     bytes = codeunits(text)
     out = IOBuffer()
-    n = length(bytes)
-    i = 1
-    while i <= n
-        b0 = bytes[i]
-        b1 = i + 1 <= n ? bytes[i + 1] : UInt8(0)
-        b2 = i + 2 <= n ? bytes[i + 2] : UInt8(0)
-        Base.write(out, SENPI_B64_ALPHABET[(b0 >> 2) + 1])
-        Base.write(out, SENPI_B64_ALPHABET[(((b0 & 0x03) << 4) | (b1 >> 4)) + 1])
-        Base.write(out, i + 1 <= n ? SENPI_B64_ALPHABET[(((b1 & 0x0f) << 2) | (b2 >> 6)) + 1] : '=')
-        Base.write(out, i + 2 <= n ? SENPI_B64_ALPHABET[(b2 & 0x3f) + 1] : '=')
-        i += 3
+    index = 1
+    while index <= length(bytes)
+        first_byte = bytes[index]
+        second_byte = index + 1 <= length(bytes) ? bytes[index + 1] : UInt8(0)
+        third_byte = index + 2 <= length(bytes) ? bytes[index + 2] : UInt8(0)
+        Base.write(out, SENPI_B64_ALPHABET[(first_byte >> 2) + 1])
+        Base.write(out, SENPI_B64_ALPHABET[(((first_byte & 0x03) << 4) | (second_byte >> 4)) + 1])
+        Base.write(out, index + 1 <= length(bytes) ? SENPI_B64_ALPHABET[(((second_byte & 0x0f) << 2) | (third_byte >> 6)) + 1] : '=')
+        Base.write(out, index + 2 <= length(bytes) ? SENPI_B64_ALPHABET[(third_byte & 0x3f) + 1] : '=')
+        index += 3
     end
-    return String(take!(out))
+    String(take!(out))
+end
+
+function senpi_status_events_enabled()
+    get(senpi_connection, "statusEvents", true) !== false
+end
+
+function senpi_emit_status(op::AbstractString, fields::AbstractDict=Dict{String, Any}(); force::Bool=false)
+    (force || senpi_status_events_enabled()) || return nothing
+    event = Dict{String, Any}("op" => string(op))
+    for (key, value) in fields
+        event[string(key)] = value
+    end
+    senpi_emit(Dict("type" => "status", "event" => event))
+    nothing
+end
+
+function senpi_with_bridge_timeout_pause(operation::Function)
+    senpi_emit_status("timeout-pause"; force=true)
+    try
+        return operation()
+    finally
+        senpi_emit_status("timeout-resume"; force=true)
+    end
+end
+
+function senpi_url_decode(value::AbstractString)
+    out = IOBuffer()
+    index = 1
+    while index <= ncodeunits(value)
+        character = Char(codeunit(value, index))
+        if character == '%' && index + 2 <= ncodeunits(value)
+            hex = value[index + 1:index + 2]
+            parsed = tryparse(UInt8, hex; base=16)
+            if parsed !== nothing
+                Base.write(out, parsed)
+                index += 3
+                continue
+            end
+        end
+        Base.write(out, character)
+        index += 1
+    end
+    String(take!(out))
+end
+
+function senpi_resolve_path(value::AbstractString)
+    raw = string(value)
+    matched = match(r"^([a-z][a-z0-9+.\-]*)://(.*)$"i, raw)
+    matched === nothing && return abspath(raw)
+    scheme = lowercase(string(matched.captures[1]))
+    roots = get(senpi_connection, "localRoots", nothing)
+    root = roots isa AbstractDict ? get(roots, scheme, nothing) : nothing
+    root isa AbstractString && !isempty(root) || error("Protocol paths are not supported by this helper: $raw")
+    relative = senpi_url_decode(replace(string(matched.captures[2]), '\\' => '/'))
+    root_path = abspath(string(root))
+    isempty(relative) && return root_path
+    (startswith(relative, '/') || ".." in split(relative, '/')) && error("Unsafe $scheme:// path (absolute or traversal): $raw")
+    resolved = abspath(joinpath(root_path, relative))
+    (resolved == root_path || startswith(resolved, root_path * string(Base.Filesystem.path_separator))) || error("$scheme:// path escapes its root: $raw")
+    resolved
+end
+
+function senpi_display_payload(value)
+    if value isa AbstractDict
+        kind = get(value, "type", get(value, :type, nothing))
+        text_value = get(value, "text", get(value, :text, nothing))
+        if kind == "markdown" && text_value !== nothing
+            return "text/markdown", string(text_value), false
+        end
+        mime_type = get(value, "mimeType", get(value, :mimeType, nothing))
+        data = get(value, "data", get(value, :data, nothing))
+        if kind == "image" && mime_type isa AbstractString && data !== nothing
+            return string(mime_type), string(data), true
+        end
+        return "application/json", senpi_json(value), false
+    end
+    value isa AbstractVector && return "application/json", senpi_json(value), false
+    "text/plain", string(value), false
 end
 
 function display(value)
-    text = senpi_json(value)
-    senpi_emit(Dict("type" => "display", "mimeType" => "application/json", "dataBase64" => senpi_base64(text)))
-    return nothing
+    mime_type, payload, encoded = senpi_display_payload(value)
+    senpi_emit(Dict("type" => "display", "mimeType" => mime_type, "dataBase64" => encoded ? payload : senpi_base64(payload)))
+    nothing
+end
+
+function display_image(base64_value::AbstractString, mime_type::AbstractString="image/png")
+    senpi_emit(Dict("type" => "display", "mimeType" => string(mime_type), "dataBase64" => string(base64_value)))
+    nothing
+end
+
+function text(value)
+    senpi_emit(Dict("type" => "text", "stream" => "stdout", "data" => string(value)))
+    nothing
 end
 
 function print(values...)
-    senpi_emit(Dict("type" => "text", "stream" => "stdout", "data" => join(string.(values), "")))
-    return nothing
+    text(join(string.(values), ""))
 end
 
-function read(path::AbstractString)
-    return Base.read(path, String)
+function read(path::AbstractString, offset::Integer=1, limit::Union{Integer, Nothing}=nothing)
+    resolved = senpi_resolve_path(path)
+    content = Base.read(resolved, String)
+    if offset > 1 || limit !== nothing
+        lines = split(content, '\n'; keepempty=true)
+        start = max(1, Int(offset))
+        finish = limit === nothing ? length(lines) : min(length(lines), start + Int(limit) - 1)
+        content = start <= length(lines) ? join(lines[start:finish], '\n') : ""
+    end
+    senpi_emit_status("read", Dict("path" => resolved, "chars" => length(content), "preview" => first(content, min(length(content), 500))))
+    content
 end
 
 function write(path::AbstractString, content)
-    Base.write(path, string(content))
-    return path
+    resolved = senpi_resolve_path(path)
+    mkpath(dirname(resolved))
+    data = string(content)
+    open(resolved, "w") do io
+        Base.write(io, data)
+    end
+    senpi_emit_status("write", Dict("path" => resolved, "chars" => length(data)))
+    resolved
 end
 
 function env(key=nothing, value=nothing)
     if key === nothing
-        return Dict(k => v for (k, v) in ENV)
-    elseif value === nothing
-        return get(ENV, string(key), nothing)
-    else
-        ENV[string(key)] = string(value)
-        return value
+        values = Dict{String, String}(string(name) => string(item) for (name, item) in ENV)
+        senpi_emit_status("env", Dict("count" => length(values), "keys" => sort(collect(keys(values)))[1:min(20, length(values))]))
+        return values
     end
+    name = string(key)
+    if value === nothing
+        resolved = get(ENV, name, nothing)
+        senpi_emit_status("env", Dict("key" => name, "value" => resolved, "action" => "get"))
+        return resolved
+    end
+    resolved = string(value)
+    ENV[name] = resolved
+    senpi_emit_status("env", Dict("key" => name, "value" => resolved, "action" => "set"))
+    resolved
 end
 
-function log(message)
-    senpi_emit(Dict("type" => "log", "message" => string(message)))
-    return nothing
+struct SenpiToolProxy end
+
+struct SenpiToolCallable
+    name::String
 end
 
-function phase(title)
-    senpi_emit(Dict("type" => "phase", "title" => string(title)))
-    return nothing
+function (callable::SenpiToolCallable)(args=nothing; kwargs...)
+    values = Dict{String, Any}()
+    if args !== nothing
+        args isa AbstractDict || error("tool.$(callable.name)(...) expects a dictionary of arguments")
+        for (key, value) in args
+            values[string(key)] = value
+        end
+    end
+    for (key, value) in kwargs
+        values[string(key)] = value
+    end
+    senpi_with_bridge_timeout_pause(() -> senpi_call_tool(callable.name, values))
 end
 
-struct SenpiToolProxy end
+Base.getproperty(::SenpiToolProxy, name::Symbol) = SenpiToolCallable(string(name))
+const tool = SenpiToolProxy()
 
-function Base.getproperty(::SenpiToolProxy, name::Symbol)
-    return args -> senpi_call_tool(string(name), args)
+function completion(prompt::AbstractString; model="default", system=nothing, schema=nothing, kwargs...)
+    options = Dict{String, Any}("model" => model)
+    system !== nothing && (options["system"] = system)
+    schema !== nothing && (options["schema"] = schema)
+    for (key, value) in kwargs
+        options[string(key)] = value
+    end
+    response = senpi_with_bridge_timeout_pause(() -> senpi_completion(string(prompt), options))
+    response isa AbstractDict || return response
+    haskey(response, "value") && return response["value"]
+    get(response, "text", response)
 end
 
-const tool = SenpiToolProxy()
+function output(ids...; format="raw", offset=nothing, limit=nothing)
+    isempty(ids) && error("At least one output ID is required")
+    format in ("raw", "tail") || error("output() format must be 'raw' or 'tail'")
+    arguments = Dict{String, Any}("ids" => string.(ids), "format" => format)
+    offset !== nothing && (arguments["offset"] = offset)
+    limit !== nothing && (arguments["limit"] = limit)
+    senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__output__", arguments))
+end
+
+function agent(prompt::AbstractString; agent="task", model=nothing, label=nothing, schema=nothing, isolated=nothing, apply=nothing, merge=nothing, handle=false, kwargs...)
+    arguments = Dict{String, Any}("prompt" => string(prompt), "agent" => agent)
+    for (key, value) in (("model", model), ("label", label), ("schema", schema), ("isolated", isolated), ("apply", apply), ("merge", merge))
+        value !== nothing && (arguments[key] = value)
+    end
+    for (key, value) in kwargs
+        arguments[string(key)] = value
+    end
+    handle && (arguments["handle"] = true)
+    response = senpi_with_bridge_timeout_pause(() -> senpi_call_tool("__agent__", arguments))
+    record = response isa AbstractDict ? response : Dict{String, Any}()
+    text_value = get(record, "text", response)
+    parsed = schema === nothing ? text_value : haskey(record, "data") ? record["data"] : senpi_json_parse(string(text_value))
+    handle || return parsed
+    result = Dict{String, Any}("text" => text_value, "output" => text_value, "id" => get(record, "id", nothing), "agent" => get(record, "agent", agent))
+    result["handle"] = get(record, "handle", result["id"] === nothing ? nothing : "agent://" * string(result["id"]))
+    schema !== nothing && (result["data"] = parsed)
+    result
+end
+
+function senpi_pool_map(items, callback)
+    values = collect(items)
+    isempty(values) && return Any[]
+    configured_width = get(senpi_connection, "parallelPoolWidth", 4)
+    width = configured_width isa Real && isfinite(configured_width) ? Int(floor(configured_width)) : 4
+    workers = min(max(width, 1), length(values))
+    tokens = Channel{Nothing}(workers)
+    for _ in 1:workers
+        put!(tokens, nothing)
+    end
+    results = Vector{Any}(undef, length(values))
+    errors = Dict{Int, Any}()
+    lock = ReentrantLock()
+    @sync for index in eachindex(values)
+        @async begin
+            take!(tokens)
+            try
+                results[index] = callback(values[index])
+            catch error
+                Base.lock(lock) do
+                    errors[index] = error
+                end
+            finally
+                put!(tokens, nothing)
+            end
+        end
+    end
+    isempty(errors) || throw(errors[minimum(keys(errors))])
+    results
+end
+
+function parallel(thunks)
+    values = collect(thunks)
+    for thunk in values
+        applicable(thunk) || error("parallel() expects zero-argument callables")
+    end
+    senpi_pool_map(values, thunk -> thunk())
+end
+
+function pipeline(items, stages...)
+    values = collect(items)
+    for stage in stages
+        isempty(values) && return values
+        applicable(stage, first(values)) || error("pipeline() stages must be callables")
+        values = senpi_pool_map(values, stage)
+    end
+    values
+end
+
+function log(message)
+    senpi_emit(Dict("type" => "log", "message" => string(message)))
+    nothing
+end
+
+function phase(title)
+    senpi_emit(Dict("type" => "phase", "title" => string(title)))
+    nothing
+end