omp-multi-harness 0.1.0

package/src/commands/agents.ts

@@ -0,0 +1,140 @@
+/** `/agents` — availability + auth report, and `/agents auth <codex|claude>`. */
+import type { ExtensionAPI, ExtensionCommandContext } from "@oh-my-pi/pi-coding-agent";
+import { detect, isReady } from "../agents/availability.ts";
+import type { AgentAvailability } from "../agents/types.ts";
+import type { AgentName, MultiHarnessConfig } from "../config/schema.ts";
+import { isWriteLockHeld, writeLockHolder } from "../runs/lock.ts";
+import type { RunRegistry } from "../runs/types.ts";
+
+const DISPLAY: Record<AgentName, string> = { codex: "Codex", claude: "Claude Code" };
+const LOGIN: Record<AgentName, string> = { codex: "codex login", claude: "claude auth login" };
+
+/** Exact remediation text from _spec/10 EXECUTABLE_NOT_FOUND — never paraphrase. */
+const EXECUTABLE_FIX: Record<AgentName, string> = {
+	codex: "Install the Codex CLI, or set multiHarness.codex.executable to its full path.",
+	claude: "Install the Claude Code CLI, or set multiHarness.claude.executable to its full path.",
+};
+
+/** Workspace/write-lock state as already resolved by the caller — kept pure, no fs/lock reads here. */
+export interface WorkspaceStatus {
+	cwd: string;
+	writeLockHeld: boolean;
+	/** Holder label (agent name / run id) — safe to display, never a path or credential. */
+	writeLockHolder?: string;
+}
+
+/** Aggregate run counts from the registry, if one was supplied. */
+export interface RunCounts {
+	running: number;
+	finished: number;
+}
+
+function isExecutableMissing(a: AgentAvailability): boolean {
+	return !a.available && !!a.reason && a.reason.includes("not found on PATH");
+}
+
+function statusWord(a: AgentAvailability): string {
+	if (isExecutableMissing(a)) return "unavailable — executable not found";
+	if (!a.available) return `unavailable — ${a.reason ?? "unknown reason"}`;
+	if (a.auth === "logged-out") return "unavailable — not authenticated";
+	if (a.auth === "unknown") return "installed, auth not checked";
+	return "ready";
+}
+
+/**
+ * Pure renderer for `/agents` — no process spawning, no UI calls. Takes already-resolved
+ * availability plus workspace/run state so it is directly unit-testable (_spec/07 `/agents`,
+ * _spec/12 criterion B: must degrade gracefully, never throw, when an agent is missing).
+ */
+export function renderAgentsReport(items: AgentAvailability[], workspace: WorkspaceStatus, runs?: RunCounts): string {
+	const lines: string[] = [];
+	for (const a of items) {
+		lines.push(DISPLAY[a.agent]);
+		lines.push(`  executable: ${a.executablePath ?? "not found"}`);
+		lines.push(`  version:    ${a.version ?? "-"}`);
+		lines.push(`  auth:       ${a.authDetail}`);
+		lines.push(`  status:     ${statusWord(a)}`);
+		if (isExecutableMissing(a)) lines.push(`  fix:        ${EXECUTABLE_FIX[a.agent]}`);
+		lines.push("");
+	}
+
+	const lockState = workspace.writeLockHeld
+		? `held by ${workspace.writeLockHolder ?? "unknown"}`
+		: "free";
+	lines.push(`Workspace: ${workspace.cwd}   (write lock: ${lockState})`);
+	// Omit the Runs line entirely when we don't have a registry to ask — printing "0 running"
+	// would claim knowledge we don't have.
+	if (runs) lines.push(`Runs: ${runs.running} running, ${runs.finished} finished`);
+
+	const ready = items.filter(isReady).map((a) => DISPLAY[a.agent]);
+	lines.push(ready.length > 0 ? `Ready: ${ready.join(", ")}` : "Ready: none — see the auth hints above");
+	return lines.join("\n");
+}
+
+function renderAuth(items: AgentAvailability[]): string {
+	const lines: string[] = [];
+	for (const a of items) {
+		lines.push(`${DISPLAY[a.agent].padEnd(12)} ${a.authDetail}`);
+	}
+	const loggedOut = items.filter((a) => a.available && a.auth !== "ok");
+	if (loggedOut.length > 0) {
+		lines.push("");
+		lines.push("Run these yourself — this extension never logs in on your behalf:");
+		for (const a of loggedOut) lines.push(`  ${LOGIN[a.agent]}`);
+	}
+	lines.push("");
+	lines.push("Each CLI keeps its own login; OMP's credentials are never shared with them.");
+	return lines.join("\n");
+}
+
+function runCounts(registry: RunRegistry): RunCounts {
+	const all = registry.list();
+	let running = 0;
+	let finished = 0;
+	for (const r of all) {
+		if (r.status === "running" || r.status === "queued") running++;
+		else finished++;
+	}
+	return { running, finished };
+}
+
+/**
+ * `getRegistry` is OPTIONAL and defaults to absent so the existing two-argument call site in
+ * `src/index.ts` (`registerAgentsCommand(pi, getConfig)`) keeps working unchanged. Passing a
+ * third argument turns on the `Runs:` line in the report.
+ */
+export function registerAgentsCommand(
+	pi: ExtensionAPI,
+	getConfig: () => MultiHarnessConfig,
+	getRegistry?: () => RunRegistry,
+): void {
+	pi.registerCommand("agents", {
+		description: "Show Codex / Claude Code availability and authentication",
+		getArgumentCompletions: (prefix: string) =>
+			["auth", "auth codex", "auth claude"]
+				.filter((v) => v.startsWith(prefix))
+				.map((v) => ({ value: v, label: v })),
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const config = getConfig();
+			const argv = args.trim().split(/\s+/).filter(Boolean);
+			const authOnly = argv[0] === "auth";
+			const wanted = argv[1] as AgentName | undefined;
+
+			const names: AgentName[] = wanted === "codex" || wanted === "claude" ? [wanted] : ["codex", "claude"];
+			const items = await Promise.all(names.map((n) => detect(n, config[n], { cwd: ctx.cwd, force: true })));
+
+			if (authOnly) {
+				ctx.ui.notify(renderAuth(items), "info");
+				return;
+			}
+
+			const workspace: WorkspaceStatus = {
+				cwd: ctx.cwd,
+				writeLockHeld: isWriteLockHeld(ctx.cwd),
+				writeLockHolder: writeLockHolder(ctx.cwd),
+			};
+			const runs = getRegistry ? runCounts(getRegistry()) : undefined;
+			ctx.ui.notify(renderAgentsReport(items, workspace, runs), "info");
+		},
+	});
+}

package/src/commands/delegate-command.ts

@@ -0,0 +1,159 @@
+/** `/codex <task>` and `/claude <task>` — direct delegation, bypassing routing. */
+import type { ExtensionAPI, ExtensionCommandContext } from "@oh-my-pi/pi-coding-agent";
+import { MODE_DEFAULT_READ_ONLY, type AgentMode, type AgentName } from "../agents/types.ts";
+import { isValidModelToken, type MultiHarnessConfig } from "../config/schema.ts";
+import { AgentError } from "../process/process-error.ts";
+import { buildHandoff, summarize, truncateMiddle } from "../routing/handoff.ts";
+import type { RunRegistry } from "../runs/types.ts";
+import { deliverBackgroundResult } from "../tools/ask-agent.ts";
+
+const MODES = new Set<AgentMode>(["analyze", "plan", "implement", "debug", "review", "test"]);
+
+export interface ParsedCommand {
+	task: string;
+	readOnly?: boolean;
+	newSession: boolean;
+	background: boolean;
+	model?: string;
+	mode?: AgentMode;
+	errors: string[];
+}
+
+/** Flags are stripped from the front; everything else is the task, verbatim. */
+export function parseDelegateArgs(args: string): ParsedCommand {
+	const tokens = args.trim().split(/\s+/).filter(Boolean);
+	const result: ParsedCommand = { task: "", newSession: false, background: false, errors: [] };
+	let i = 0;
+
+	for (; i < tokens.length; i++) {
+		const token = tokens[i]!;
+		if (!token.startsWith("--")) break;
+		switch (token) {
+			case "--read-only":
+				result.readOnly = true;
+				break;
+			case "--write":
+				result.readOnly = false;
+				break;
+			case "--new":
+				result.newSession = true;
+				break;
+			case "--bg":
+				result.background = true;
+				break;
+			case "--model": {
+				const value = tokens[++i];
+				if (!value) result.errors.push("--model needs a value");
+				else if (!isValidModelToken(value)) result.errors.push(`--model ${value}: not a valid model token`);
+				else result.model = value;
+				break;
+			}
+			case "--mode": {
+				const value = tokens[++i];
+				if (value && MODES.has(value as AgentMode)) result.mode = value as AgentMode;
+				else result.errors.push(`--mode ${value ?? ""}: expected one of ${[...MODES].join(", ")}`);
+				break;
+			}
+			default:
+				result.errors.push(`unknown flag ${token}`);
+		}
+	}
+
+	result.task = tokens.slice(i).join(" ");
+	return result;
+}
+
+export interface DelegateCommandDeps {
+	pi: ExtensionAPI;
+	agent: AgentName;
+	getConfig: () => MultiHarnessConfig;
+	/** Taken as a getter so this module never imports the registry implementation. */
+	getRegistry: () => RunRegistry;
+}
+
+export function registerDelegateCommand({ pi, agent, getConfig, getRegistry }: DelegateCommandDeps): void {
+	pi.registerCommand(agent, {
+		description: `Delegate a task directly to ${agent === "codex" ? "Codex" : "Claude Code"}`,
+		getArgumentCompletions: (prefix: string) =>
+			["--read-only", "--write", "--new", "--bg", "--model", "--mode"]
+				.filter((f) => f.startsWith(prefix))
+				.map((f) => ({ value: f, label: f })),
+		handler: async (args: string, ctx: ExtensionCommandContext) => {
+			const config = getConfig();
+			const parsed = parseDelegateArgs(args);
+
+			if (parsed.errors.length > 0) {
+				ctx.ui.notify(parsed.errors.join("\n"), "error");
+				return;
+			}
+			if (!parsed.task) {
+				ctx.ui.notify(
+					`Usage: /${agent} [--read-only] [--write] [--new] [--bg] [--mode <mode>] [--model <id>] <task>`,
+					"warning",
+				);
+				return;
+			}
+			if (!config.enabled || !config[agent].enabled) {
+				ctx.ui.notify(`${agent} is disabled in config (multiHarness.${agent}.enabled).`, "error");
+				return;
+			}
+			const readOnly = parsed.readOnly ?? (parsed.mode ? MODE_DEFAULT_READ_ONLY[parsed.mode] : false);
+
+			// Through the registry, not straight to the adapter: that is what gives a slash command
+			// the same write lock, concurrency cap, and `/sessions` row as a tool call.
+			const registry = getRegistry();
+			const started = registry.start({
+				agent,
+				task: buildHandoff({ task: parsed.task, mode: parsed.mode, maxChars: config.limits.maxHandoffChars }),
+				summary: summarize(parsed.task),
+				cwd: ctx.cwd,
+				mode: parsed.mode,
+				readOnly,
+				model: parsed.model,
+				continueSession: !parsed.newSession,
+				background: parsed.background,
+			});
+
+			if (parsed.background) {
+				// Detached by design; `.catch` is mandatory (_spec/01 §2).
+				registry
+					.wait(started.id)
+					.then((finished) => {
+						if (finished) deliverBackgroundResult({ pi, ctx, run: finished, config });
+					})
+					.catch((e) => pi.logger.warn?.(`[multi-harness] background run ${started.id}: ${(e as Error).message}`));
+
+				ctx.ui.notify(`Started ${agent} run ${started.id} in the background. Track it with /sessions.`, "info");
+				return;
+			}
+
+			const unsubscribe = registry.subscribe((run) => {
+				if (run.id === started.id) ctx.ui.setStatus("multi-harness", `${agent}: ${run.phase}`);
+			});
+
+			try {
+				const finished = await registry.wait(started.id);
+				if (!finished) {
+					ctx.ui.notify(`Run ${started.id} disappeared from the registry.`, "error");
+					return;
+				}
+				if (finished.status !== "done") {
+					ctx.ui.notify(`${finished.errorCode ?? finished.status}: ${finished.errorMessage ?? finished.status}`, "error");
+					return;
+				}
+
+				const { text } = truncateMiddle(finished.output ?? "", config.limits.maxOutputChars);
+				// Relayed as `agent` attribution so consumers can tell it from user-typed text,
+				// and so the supervisor can act on it.
+				await pi.sendUserMessage(text, { attribution: "agent" });
+			} catch (e) {
+				const message =
+					e instanceof AgentError ? `${e.code}: ${e.message}` : `Unexpected failure: ${(e as Error).message}`;
+				ctx.ui.notify(message, "error");
+			} finally {
+				unsubscribe();
+				ctx.ui.setStatus("multi-harness", undefined);
+			}
+		},
+	});
+}

package/src/commands/harness-setup.ts

@@ -0,0 +1,94 @@
+/** `/harness-setup` — the setup checklist from _spec/14, rendered inside a session. */
+import type { ExtensionAPI, ExtensionCommandContext } from "@oh-my-pi/pi-coding-agent";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { detect } from "../agents/availability.ts";
+import { agentDir, configPaths } from "../config/load.ts";
+import type { MultiHarnessConfig } from "../config/schema.ts";
+
+type Row = { ok: boolean | null; label: string; detail: string; fix?: string };
+
+function render(rows: Row[]): string {
+	const glyph = (ok: boolean | null) => (ok === null ? "!" : ok ? "✔" : "✘");
+	const body = rows.map((r) => `  ${glyph(r.ok)} ${r.label.padEnd(30)} ${r.detail}`);
+	const fixes = rows.filter((r) => r.ok !== true && r.fix);
+	if (fixes.length > 0) {
+		body.push("");
+		body.push("Fixes:");
+		for (const r of fixes) body.push(`  · ${r.fix}`);
+	}
+	body.push("");
+	body.push("Full checklist outside a session: `bun run doctor`");
+	return body.join("\n");
+}
+
+export function registerHarnessSetupCommand(
+	pi: ExtensionAPI,
+	getConfig: () => MultiHarnessConfig,
+	getSources: () => string[],
+): void {
+	pi.registerCommand("harness-setup", {
+		description: "Check multi-harness setup: CLIs, authentication, config, install",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const config = getConfig();
+			const [codex, claude] = await Promise.all([
+				detect("codex", config.codex, { cwd: ctx.cwd, force: true }),
+				detect("claude", config.claude, { cwd: ctx.cwd, force: true }),
+			]);
+
+			const link = join(agentDir(), "extensions", "multi-harness");
+			const sources = getSources();
+			const { user } = configPaths(ctx.cwd);
+			const models = ctx.models.list().length;
+
+			const rows: Row[] = [
+				{
+					ok: models > 0,
+					label: "OMP provider auth",
+					detail: models > 0 ? `${models} model(s) available` : "no authenticated models",
+					fix: models > 0 ? undefined : "run `omp` and use /login (OMP's own login, never shared with the workers)",
+				},
+				{
+					ok: config.routing.mode === "rules" ? true : models > 0,
+					label: "Router model (auto)",
+					detail:
+						config.routing.mode === "rules"
+							? "rules mode — no router model needed"
+							: models > 0
+								? `${config.routing.model} (falls back to rules on failure)`
+								: "unavailable — auto routing falls back to rules",
+				},
+				{
+					ok: codex.available && codex.auth === "ok",
+					label: "Codex",
+					detail: codex.available ? `${codex.version ?? "?"} · ${codex.authDetail}` : (codex.reason ?? "unavailable"),
+					fix: codex.available && codex.auth !== "ok" ? "codex login" : codex.available ? undefined : "install the Codex CLI",
+				},
+				{
+					ok: claude.available && claude.auth === "ok",
+					label: "Claude Code",
+					detail: claude.available ? `${claude.version ?? "?"} · ${claude.authDetail}` : (claude.reason ?? "unavailable"),
+					fix:
+						claude.available && claude.auth !== "ok"
+							? "claude auth login"
+							: claude.available
+								? undefined
+								: "install Claude Code",
+				},
+				{
+					ok: sources.length > 0 ? true : null,
+					label: "Config",
+					detail: sources.length > 0 ? sources.join(", ") : `no config file — defaults in use (${user})`,
+				},
+				{
+					ok: existsSync(link) ? true : null,
+					label: "Installed into OMP",
+					detail: existsSync(link) ? link : "not linked — running from -e or a project path",
+					fix: existsSync(link) ? undefined : `ln -s <repo> "${link}"`,
+				},
+			];
+
+			ctx.ui.notify(render(rows), "info");
+		},
+	});
+}