omp-multi-harness 0.1.0

package/scripts/setup/omp.ts

@@ -0,0 +1,167 @@
+/** OMP host setup: CLI, agent directory, its own provider auth, router model, extension install. */
+import { appendFileSync, existsSync, lstatSync, mkdirSync, readFileSync, symlinkSync } from "node:fs";
+import { join } from "node:path";
+import { REPO, type SetupGroup, agentDir, executableStep, sh, which } from "./types.ts";
+
+function models(): string[] | null {
+	const r = sh("omp", ["models", "ls", "--json"], 30_000);
+	if (!r.ok) return null;
+	try {
+		return ((JSON.parse(r.out) as { models?: { id?: string }[] }).models ?? []).map((m) => m.id ?? "");
+	} catch {
+		return null;
+	}
+}
+
+export const ompSetup: SetupGroup = {
+	id: "omp",
+	title: "OMP host",
+	steps: [
+		{
+			...executableStep({
+				id: "omp-cli",
+				title: "OMP CLI",
+				bin: "omp",
+				install: { description: "Install OMP", command: "bun add -g @oh-my-pi/pi-coding-agent" },
+			}),
+			// Wrap so we can flag the repo-local copy `bun run` puts on PATH.
+			run() {
+				const p = which("omp");
+				if (!p) {
+					return {
+						status: "fail",
+						detail: "not found",
+						fix: { description: "Install OMP", command: "bun add -g @oh-my-pi/pi-coding-agent" },
+					};
+				}
+				const local = p.startsWith(join(REPO, "node_modules"));
+				return {
+					status: "ok",
+					detail: `${sh("omp", ["--version"]).out} (${p})${local ? " — repo-local copy shadowing your global omp" : ""}`,
+				};
+			},
+		},
+		{
+			id: "omp-dir",
+			title: "OMP agent directory",
+			run() {
+				const dir = agentDir();
+				if (existsSync(dir)) return { status: "ok", detail: dir };
+				return {
+					status: "warn",
+					detail: `${dir} does not exist — OMP creates it on first run`,
+					fix: { description: "Run OMP once so it initializes its agent directory", command: "omp" },
+				};
+			},
+		},
+		{
+			id: "omp-auth",
+			title: "OMP provider auth (supervisor + router)",
+			run() {
+				if (!which("omp")) return { status: "skip", detail: "omp not installed" };
+				const ids = models();
+				if (ids === null) return { status: "warn", detail: "could not query `omp models ls --json`" };
+				if (ids.length === 0) {
+					return {
+						status: "fail",
+						detail: "no authenticated models — OMP cannot take a supervisor turn",
+						fix: {
+							description: "Authenticate OMP with your own provider (separate from the worker logins)",
+							command: "omp   # then use /login",
+						},
+					};
+				}
+				return { status: "ok", detail: `${ids.length} model(s) available` };
+			},
+		},
+		{
+			id: "omp-router",
+			title: "Router model (auto mode)",
+			run() {
+				if (!which("omp")) return { status: "skip", detail: "omp not installed" };
+				const ids = models();
+				if (!ids || ids.length === 0) {
+					return { status: "warn", detail: "cannot verify — OMP has no authenticated models; auto falls back to rules" };
+				}
+				const preferred = ["claude-haiku", "gpt-5.2-mini", "gemini-2.5-flash", "haiku", "mini", "flash"];
+				const hit = ids.find((id) => preferred.some((p) => id.toLowerCase().includes(p)));
+				return hit
+					? { status: "ok", detail: `${hit} available for routing.model` }
+					: { status: "warn", detail: "no small/fast model found — set multiHarness.routing.model explicitly" };
+			},
+		},
+		{
+			id: "omp-link",
+			title: "Extension linked into OMP",
+			run() {
+				const target = join(agentDir(), "extensions", "multi-harness");
+				const exists = (() => {
+					try {
+						return !!lstatSync(target);
+					} catch {
+						return false;
+					}
+				})();
+				if (exists) return { status: "ok", detail: target };
+				return {
+					status: "warn",
+					detail: "not linked (fine during development — use `omp -e ./src/index.ts`)",
+					fix: {
+						description: "Symlink this repo into the OMP extensions directory",
+						command: `ln -s "${REPO}" "${target}"`,
+						auto: () => {
+							mkdirSync(join(agentDir(), "extensions"), { recursive: true });
+							symlinkSync(REPO, target, "dir");
+						},
+					},
+				};
+			},
+		},
+		{
+			id: "omp-config",
+			title: "multiHarness config block",
+			run() {
+				const cfg = join(agentDir(), "config.yml");
+				if (!existsSync(cfg)) {
+					return {
+						status: "warn",
+						detail: `${cfg} not found — run OMP once first`,
+						fix: { description: "Run OMP once so it writes its config", command: "omp" },
+					};
+				}
+				if (/^multiHarness:/m.test(readFileSync(cfg, "utf8"))) return { status: "ok", detail: cfg };
+				return {
+					status: "warn",
+					detail: "no multiHarness block (defaults will be used)",
+					fix: {
+						description: `Append a commented default multiHarness block to ${cfg}`,
+						auto: () => {
+							appendFileSync(
+								cfg,
+								[
+									"",
+									"# Added by omp-multi-harness setup. Every option: _spec/09-config.md",
+									"multiHarness:",
+									"  enabled: true",
+									"  codex:",
+									"    enabled: true",
+									"    model: null      # null → your ~/.codex/config.toml decides",
+									"  claude:",
+									"    enabled: true",
+									"    model: null      # null → your Claude Code config decides",
+									"  routing:",
+									"    mode: model      # model | rules",
+									'    model: "@smol"   # router model for agent: "auto"',
+									"  concurrency:",
+									"    maxConcurrentRuns: 4",
+									"  debug: false",
+									"",
+								].join("\n"),
+							);
+						},
+					},
+				};
+			},
+		},
+	],
+};

package/scripts/setup/toolchain.ts

@@ -0,0 +1,81 @@
+/** Toolchain and repository hygiene — everything that is not provider-specific. */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { REPO, type SetupGroup, sh, which } from "./types.ts";
+
+export const toolchainSetup: SetupGroup = {
+	id: "toolchain",
+	title: "Toolchain",
+	steps: [
+		{
+			id: "bun",
+			title: "Bun runtime",
+			run() {
+				const p = which("bun");
+				if (!p) {
+					return {
+						status: "fail",
+						detail: "not found — OMP loads extensions with Bun",
+						fix: { description: "Install Bun", command: "curl -fsSL https://bun.sh/install | bash" },
+					};
+				}
+				return { status: "ok", detail: `${sh("bun", ["--version"]).out} (${p})` };
+			},
+		},
+		{
+			id: "git",
+			title: "Git repository",
+			run() {
+				if (!which("git")) return { status: "fail", detail: "git not found" };
+				const inRepo = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd: REPO, encoding: "utf8" }).status === 0;
+				if (inRepo) return { status: "ok", detail: "initialized" };
+				return {
+					status: "warn",
+					detail: "not a git repository",
+					fix: {
+						description: "Initialize the repository",
+						command: "git init",
+						auto: () => {
+							spawnSync("git", ["init"], { cwd: REPO, stdio: "inherit" });
+						},
+					},
+				};
+			},
+		},
+		{
+			id: "deps",
+			title: "Project dependencies",
+			run() {
+				if (existsSync(join(REPO, "node_modules"))) return { status: "ok", detail: "node_modules present" };
+				return {
+					status: "warn",
+					detail: "node_modules missing",
+					fix: {
+						description: "Install dependencies",
+						command: "bun install",
+						auto: () => {
+							spawnSync("bun", ["install"], { cwd: REPO, stdio: "inherit" });
+						},
+					},
+				};
+			},
+		},
+		{
+			id: "editor",
+			title: "Editor config",
+			run() {
+				const missing = [
+					".vscode/settings.json",
+					".vscode/extensions.json",
+					".vscode/launch.json",
+					".vscode/tasks.json",
+					".editorconfig",
+				].filter((f) => !existsSync(join(REPO, f)));
+				return missing.length === 0
+					? { status: "ok", detail: ".vscode/* and .editorconfig present" }
+					: { status: "warn", detail: `missing: ${missing.join(", ")}` };
+			},
+		},
+	],
+};

package/scripts/setup/types.ts

@@ -0,0 +1,76 @@
+/** Shared plumbing for the per-provider setup modules. */
+import { spawnSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import { join, resolve } from "node:path";
+
+export type Status = "ok" | "warn" | "fail" | "skip";
+
+export interface Fix {
+	/** Shown to the user. */
+	description: string;
+	/** Exact command the user can copy/paste. */
+	command?: string;
+	/** Safe to run unattended (after a prompt). Installs and logins never have one. */
+	auto?: () => void;
+}
+
+export interface Step {
+	id: string;
+	title: string;
+	run(): { status: Status; detail: string; fix?: Fix };
+}
+
+/** One provider's (or one concern's) setup steps. `setup.ts` runs every registered group. */
+export interface SetupGroup {
+	id: string;
+	title: string;
+	steps: Step[];
+}
+
+export const REPO = resolve(import.meta.dir, "..", "..");
+export const IS_MAC = platform() === "darwin";
+export const IS_WINDOWS = platform() === "win32";
+
+export function sh(cmd: string, args: string[], timeout = 15_000) {
+	const r = spawnSync(cmd, args, { encoding: "utf8", timeout, shell: false });
+	return {
+		ok: r.status === 0,
+		code: r.status,
+		out: (r.stdout ?? "").trim(),
+		err: (r.stderr ?? "").trim(),
+		missing: (r.error as NodeJS.ErrnoException | undefined)?.code === "ENOENT",
+	};
+}
+
+export function which(bin: string): string | null {
+	const r = sh(IS_WINDOWS ? "where" : "which", [bin], 5_000);
+	return r.ok && r.out ? (r.out.split("\n")[0]?.trim() ?? null) : null;
+}
+
+/**
+ * Active OMP agent directory. Honors PI_CODING_AGENT_DIR; `omp --profile <name>` shifts it
+ * to ~/.omp/profiles/<name>/agent, so never hard-code this elsewhere.
+ */
+export function agentDir(): string {
+	return process.env.PI_CODING_AGENT_DIR ?? join(homedir(), ".omp", "agent");
+}
+
+/** A CLI presence check shared by every provider module. */
+export function executableStep(opts: {
+	id: string;
+	title: string;
+	bin: string;
+	versionArgs?: string[];
+	install: { description: string; command: string };
+}): Step {
+	return {
+		id: opts.id,
+		title: opts.title,
+		run() {
+			const p = which(opts.bin);
+			if (!p) return { status: "fail", detail: "not found", fix: opts.install };
+			const version = sh(opts.bin, opts.versionArgs ?? ["--version"]).out;
+			return { status: "ok", detail: `${version} (${p})` };
+		},
+	};
+}

package/scripts/setup.ts

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+/**
+ * omp-multi-harness setup — orchestrator.
+ *
+ *   bun scripts/setup.ts            # same as `check`
+ *   bun scripts/setup.ts check      # read-only report of every setup step
+ *   bun scripts/setup.ts fix        # apply the safe automatic fixes (asks first)
+ *   bun scripts/setup.ts fix --yes  # ...without asking
+ *   bun scripts/setup.ts check --json
+ *   bun scripts/setup.ts check --only codex,claude
+ *
+ * Each provider owns its own module under scripts/setup/; this file just runs them all.
+ * Rules (see _spec/10 and _spec/14):
+ *   - never read a credential file, never print a token, never log in for the user
+ *   - auth state comes only from each CLI's own status command
+ *   - installs and logins are printed as commands; they are never auto-run
+ */
+import { createInterface } from "node:readline/promises";
+import { claudeSetup } from "./setup/claude.ts";
+import { codexSetup } from "./setup/codex.ts";
+import { ompSetup } from "./setup/omp.ts";
+import { toolchainSetup } from "./setup/toolchain.ts";
+import type { SetupGroup, Status, Step } from "./setup/types.ts";
+
+/** Registration order = report order. Add a provider by adding its module here. */
+const GROUPS: SetupGroup[] = [toolchainSetup, ompSetup, codexSetup, claudeSetup];
+
+const GLYPH: Record<Status, string> = { ok: "✔", warn: "!", fail: "✘", skip: "–" };
+
+interface Outcome {
+	group: SetupGroup;
+	step: Step;
+	status: Status;
+	detail: string;
+	fix?: { description: string; command?: string; auto?: () => void };
+}
+
+function arg(argv: string[], name: string): string | undefined {
+	const i = argv.indexOf(`--${name}`);
+	return i >= 0 ? argv[i + 1] : undefined;
+}
+
+async function main() {
+	const argv = process.argv.slice(2);
+	const mode = argv.find((a) => !a.startsWith("--")) ?? "check";
+	const yes = argv.includes("--yes") || argv.includes("-y");
+	const asJson = argv.includes("--json");
+	const only = arg(argv, "only")?.split(",").map((s) => s.trim());
+
+	const groups = only ? GROUPS.filter((g) => only.includes(g.id)) : GROUPS;
+	const results: Outcome[] = groups.flatMap((group) =>
+		group.steps.map((step) => ({ group, step, ...step.run() })),
+	);
+
+	if (asJson) {
+		console.log(
+			JSON.stringify(
+				results.map((r) => ({ group: r.group.id, id: r.step.id, status: r.status, detail: r.detail })),
+				null,
+				2,
+			),
+		);
+		process.exit(results.some((r) => r.status === "fail") ? 1 : 0);
+	}
+
+	console.log("\nomp-multi-harness setup\n");
+	for (const group of groups) {
+		console.log(`${group.title}`);
+		for (const r of results.filter((x) => x.group.id === group.id)) {
+			console.log(`  ${GLYPH[r.status]} ${r.step.title.padEnd(36)} ${r.detail}`);
+		}
+		console.log();
+	}
+
+	const actionable = results.filter((r) => r.fix && r.status !== "ok" && r.status !== "skip");
+	if (actionable.length === 0) {
+		console.log("Everything is set up.\n");
+		return;
+	}
+
+	const auto = actionable.filter((r) => r.fix?.auto);
+	const manual = actionable.filter((r) => !r.fix?.auto);
+
+	if (mode === "fix" && auto.length > 0) {
+		const rl = yes ? null : createInterface({ input: process.stdin, output: process.stdout });
+		for (const r of auto) {
+			if (rl) {
+				const a = (await rl.question(`${r.fix!.description}? [y/N] `)).trim().toLowerCase();
+				if (a !== "y" && a !== "yes") continue;
+			}
+			try {
+				r.fix!.auto!();
+				console.log(`  ${GLYPH.ok} ${r.step.title}: fixed`);
+			} catch (e) {
+				console.log(`  ${GLYPH.fail} ${r.step.title}: ${(e as Error).message}`);
+			}
+		}
+		rl?.close();
+		console.log();
+	} else if (auto.length > 0) {
+		console.log("Automatic fixes available — run `bun scripts/setup.ts fix`:");
+		for (const r of auto) console.log(`  · ${r.fix!.description}`);
+		console.log();
+	}
+
+	if (manual.length > 0) {
+		console.log("Run these yourself (installs and logins are never automated):");
+		for (const r of manual) {
+			console.log(`  · [${r.group.title}] ${r.fix!.description}`);
+			if (r.fix!.command) console.log(`      ${r.fix!.command}`);
+		}
+		console.log();
+	}
+}
+
+await main();

package/src/agents/availability.ts

@@ -0,0 +1,106 @@
+/**
+ * Executable + authentication detection, cached per process.
+ *
+ * Auth state comes ONLY from each CLI's own status command. No credential file is read, no
+ * token is printed, and nothing here ever attempts a login (_spec/10, _spec/14).
+ */
+import { spawnAgent } from "../process/spawn-agent.ts";
+import { resolveExecutable } from "../process/executable.ts";
+import type { AgentConfig, AgentName } from "../config/schema.ts";
+import type { AgentAvailability, AuthState } from "./types.ts";
+
+const VERSION_TIMEOUT_MS = 5_000;
+const AUTH_TIMEOUT_MS = 20_000;
+
+const cache = new Map<AgentName, AgentAvailability>();
+
+async function capture(executable: string, args: string[], cwd: string, timeoutMs: number, env?: NodeJS.ProcessEnv) {
+	try {
+		const r = await spawnAgent({ command: executable, args, cwd, timeoutMs, killGraceMs: 1_000, env });
+		return { ok: r.exitCode === 0, stdout: r.stdout.trim(), stderr: r.stderr.trim() };
+	} catch {
+		return { ok: false, stdout: "", stderr: "" };
+	}
+}
+
+async function codexAuth(executable: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<{ auth: AuthState; authDetail: string }> {
+	const r = await capture(executable, ["login", "status"], cwd, AUTH_TIMEOUT_MS, env);
+	// `codex login status` prints to STDERR, not stdout — read both (_spec/14).
+	const line = [r.stdout, r.stderr].join("\n").split("\n").find((l) => /logged in/i.test(l));
+	if (r.ok && line) return { auth: "ok", authDetail: line.trim() };
+	return { auth: "logged-out", authDetail: "not authenticated — run `codex login`" };
+}
+
+async function claudeAuth(executable: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<{ auth: AuthState; authDetail: string }> {
+	const r = await capture(executable, ["auth", "status", "--json"], cwd, AUTH_TIMEOUT_MS, env);
+	if (r.ok && r.stdout) {
+		try {
+			// The payload also carries email, org id and org name. Read only these two fields
+			// and never print or persist the rest.
+			const parsed = JSON.parse(r.stdout) as { loggedIn?: boolean; authMethod?: string };
+			if (parsed.loggedIn) return { auth: "ok", authDetail: `logged in via ${parsed.authMethod ?? "unknown method"}` };
+			return { auth: "logged-out", authDetail: "not authenticated — run `claude auth login`" };
+		} catch {
+			return { auth: "unknown", authDetail: "unexpected `claude auth status` output" };
+		}
+	}
+	return { auth: "logged-out", authDetail: "not authenticated — run `claude auth login`" };
+}
+
+export interface DetectOptions {
+	cwd: string;
+	/** Skip the auth probe (it costs a process spawn each). */
+	skipAuth?: boolean;
+	force?: boolean;
+	env?: NodeJS.ProcessEnv;
+}
+
+export async function detect(agent: AgentName, config: AgentConfig, opts: DetectOptions): Promise<AgentAvailability> {
+	if (!opts.force) {
+		const hit = cache.get(agent);
+		if (hit) return hit;
+	}
+
+	let result: AgentAvailability;
+
+	if (!config.enabled) {
+		result = { agent, available: false, auth: "unknown", authDetail: "-", reason: `disabled in config (multiHarness.${agent}.enabled)` };
+	} else {
+		const executablePath = resolveExecutable(config.executable, opts.env);
+		if (!executablePath) {
+			result = {
+				agent,
+				available: false,
+				auth: "unknown",
+				authDetail: "-",
+				reason: `\`${config.executable}\` not found on PATH`,
+			};
+		} else {
+			const version = await capture(executablePath, ["--version"], opts.cwd, VERSION_TIMEOUT_MS, opts.env);
+			const auth = opts.skipAuth
+				? { auth: "unknown" as AuthState, authDetail: "not checked" }
+				: agent === "codex"
+					? await codexAuth(executablePath, opts.cwd, opts.env)
+					: await claudeAuth(executablePath, opts.cwd, opts.env);
+			result = {
+				agent,
+				available: true,
+				executablePath,
+				version: [version.stdout, version.stderr].find((s) => s.length > 0) ?? undefined,
+				...auth,
+			};
+		}
+	}
+
+	cache.set(agent, result);
+	return result;
+}
+
+/** Ready = installed, enabled, and authenticated. */
+export function isReady(a: AgentAvailability): boolean {
+	return a.available && a.auth === "ok";
+}
+
+export function clearAvailabilityCache(): void {
+	cache.clear();
+}

package/src/agents/claude-events.ts

@@ -0,0 +1,125 @@
+/**
+ * Interpretation of `claude -p --output-format stream-json` output.
+ *
+ * Shapes captured from Claude Code 2.1.274 (2026-09-18):
+ *   {"type":"system","subtype":"init","session_id":"…"}
+ *   {"type":"system","subtype":"hook_started"|"hook_response"|"thinking_tokens"|"post_turn_summary",…}
+ *   {"type":"assistant", …}
+ *   {"type":"rate_limit_event", …}
+ *   {"type":"result","subtype":"success","result":"pong","is_error":false,
+ *    "session_id":"…","num_turns":1,"duration_ms":8243,"total_cost_usd":0.43,
+ *    "usage":{…},"permission_denials":[…]}
+ *
+ * A real run is mostly hook noise, so progress reporting deliberately ignores it.
+ */
+export interface ClaudeStreamState {
+	sessionId?: string;
+	/** Terminal text from the `result` event. */
+	result?: string;
+	/** Set when the result event reports a failure. */
+	failure?: string;
+	lastAssistantText?: string;
+	turns?: number;
+	costUsd?: number;
+	/** Tools Claude asked for and was refused — evidence that read-only actually held. */
+	permissionDenials: number;
+	sawResult: boolean;
+	/**
+	 * Set once the first `result` event has decided success/failure. A real run emits
+	 * exactly one; a duplicate or out-of-order repeat must not flip an already-decided
+	 * outcome (see the matching note on CodexStreamState.settled).
+	 */
+	settled: boolean;
+}
+
+export interface ClaudeProgressEvent {
+	phase: string;
+	detail?: string;
+	raw?: string;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+	return value && typeof value === "object" && !Array.isArray(value) ? (value as Record<string, unknown>) : null;
+}
+
+/** Pull readable text out of an assistant message's content blocks. */
+function assistantText(event: Record<string, unknown>): string | undefined {
+	const message = asRecord(event.message);
+	const content = message?.content ?? event.content;
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return undefined;
+	const parts: string[] = [];
+	for (const block of content) {
+		const b = asRecord(block);
+		if (b && b.type === "text" && typeof b.text === "string") parts.push(b.text);
+	}
+	return parts.length > 0 ? parts.join("") : undefined;
+}
+
+/** Tool names mentioned by an assistant event, for progress display. */
+function toolName(event: Record<string, unknown>): string | undefined {
+	const message = asRecord(event.message);
+	const content = message?.content;
+	if (!Array.isArray(content)) return undefined;
+	for (const block of content) {
+		const b = asRecord(block);
+		if (b && b.type === "tool_use" && typeof b.name === "string") return b.name;
+	}
+	return undefined;
+}
+
+export function newClaudeStreamState(): ClaudeStreamState {
+	return { permissionDenials: 0, sawResult: false, settled: false };
+}
+
+export function applyClaudeEvent(state: ClaudeStreamState, value: unknown): ClaudeProgressEvent | null {
+	const event = asRecord(value);
+	if (!event) return null;
+
+	if (!state.sessionId && typeof event.session_id === "string") state.sessionId = event.session_id;
+
+	const type = typeof event.type === "string" ? event.type : "";
+	const subtype = typeof event.subtype === "string" ? event.subtype : "";
+
+	if (type === "system") {
+		// Hook chatter and token accounting are noise; only `init` is worth a phase.
+		return subtype === "init" ? { phase: "starting", raw: "system:init" } : null;
+	}
+
+	if (type === "assistant") {
+		const text = assistantText(event);
+		if (text) state.lastAssistantText = text;
+		const tool = toolName(event);
+		return tool ? { phase: `using ${tool}`, raw: "assistant:tool_use" } : { phase: "writing response", raw: "assistant" };
+	}
+
+	if (type === "user") return { phase: "reading tool results", raw: "user" };
+
+	if (type === "rate_limit_event") return { phase: "waiting on rate limit", raw: type };
+
+	if (type === "result") {
+		state.sawResult = true;
+		// Informational fields are harmless to keep refreshing even from a stray repeat.
+		if (typeof event.num_turns === "number") state.turns = event.num_turns;
+		if (typeof event.total_cost_usd === "number") state.costUsd = event.total_cost_usd;
+		if (Array.isArray(event.permission_denials)) state.permissionDenials = event.permission_denials.length;
+
+		const isError = event.is_error === true || (subtype !== "" && subtype !== "success");
+		const text = typeof event.result === "string" ? event.result : undefined;
+
+		if (!state.settled) {
+			state.settled = true;
+			if (isError) {
+				state.failure = text && text.length > 0 ? text : `the run ended with "${subtype || "an error"}"`;
+			} else {
+				state.result = text;
+			}
+		}
+
+		return isError
+			? { phase: "failed", detail: text || state.failure, raw: `result:${subtype}` }
+			: { phase: "completed", raw: `result:${subtype}` };
+	}
+
+	return null;
+}