@microck/canonfig 2.0.0 → 2.1.0

package/dist/harness-configuration/adapters/shared-mcp.js

@@ -0,0 +1,214 @@
+export function secretValue(value) {
+    return typeof value === "string" ? value : `\${${value.fromEnv}}`;
+}
+export function enabledMcpServerEntries(context) {
+    return Object.entries(context.config.mcp.servers).filter(([, server]) => server.enabled);
+}
+export function hasEnabledMcpServers(context) {
+    return enabledMcpServerEntries(context).length > 0;
+}
+export function standardMcpProjectionDiagnostics(context, target, includeType = true) {
+    const diagnostics = [];
+    for (const [name, server] of enabledMcpServerEntries(context)) {
+        const omitted = [];
+        if (server.timeoutMs !== undefined)
+            omitted.push("timeoutMs");
+        if (server.enabledTools?.length)
+            omitted.push("enabledTools");
+        if (server.disabledTools?.length)
+            omitted.push("disabledTools");
+        if (!includeType && server.transport === "sse")
+            omitted.push("sse transport discriminator");
+        if (omitted.length > 0) {
+            diagnostics.push({
+                level: "warning",
+                code: "MCP_OPTION_UNSUPPORTED",
+                target,
+                message: `${target} cannot represent ${omitted.join(", ")} for MCP server ${name} in its standard JSON projection; those options were omitted.`,
+            });
+        }
+    }
+    return diagnostics;
+}
+export function codexMcpDiagnostics(context) {
+    return enabledMcpServerEntries(context).flatMap(([name, server]) => server.transport === "sse"
+        ? [{
+                level: "warning",
+                code: "MCP_TRANSPORT_UNSUPPORTED",
+                target: "codex",
+                message: `Codex project MCP config supports streamable HTTP URLs but cannot preserve legacy SSE transport for server ${name}; the URL is emitted as streamable HTTP.`,
+            }]
+        : []);
+}
+export function standardMcpServer(server, includeType = true) {
+    if (server.transport === "stdio") {
+        return {
+            ...(includeType ? { type: "stdio" } : {}),
+            command: server.command,
+            args: server.args,
+            ...(Object.keys(server.env).length > 0
+                ? { env: Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])) }
+                : {}),
+            ...(server.cwd ? { cwd: server.cwd } : {}),
+        };
+    }
+    return {
+        ...(includeType ? { type: server.transport === "sse" ? "sse" : "http" } : {}),
+        url: server.url,
+        ...(Object.keys(server.headers).length > 0
+            ? { headers: Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])) }
+            : {}),
+    };
+}
+export function standardMcpMap(context, includeType = true) {
+    return Object.fromEntries(enabledMcpServerEntries(context)
+        .map(([name, server]) => [name, standardMcpServer(server, includeType)]));
+}
+export function piMcpMap(context) {
+    return Object.fromEntries(enabledMcpServerEntries(context)
+        .map(([name, server]) => {
+        if (server.transport === "stdio") {
+            return [name, {
+                    command: server.command,
+                    args: server.args,
+                    ...(server.cwd ? { cwd: server.cwd } : {}),
+                    ...(Object.keys(server.env).length
+                        ? { env: Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])) }
+                        : {}),
+                }];
+        }
+        return [name, {
+                transport: server.transport,
+                url: server.url,
+                ...(Object.keys(server.headers).length
+                    ? { headers: Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])) }
+                    : {}),
+            }];
+    }));
+}
+export function antigravityMcpMap(context) {
+    return Object.fromEntries(enabledMcpServerEntries(context)
+        .map(([name, server]) => {
+        if (server.transport === "stdio") {
+            return [name, {
+                    command: server.command,
+                    args: server.args,
+                    ...(Object.keys(server.env).length
+                        ? { env: Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])) }
+                        : {}),
+                }];
+        }
+        return [name, {
+                serverUrl: server.url,
+                ...(Object.keys(server.headers).length
+                    ? { headers: Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])) }
+                    : {}),
+            }];
+    }));
+}
+export function openCodeMcpMap(context) {
+    return Object.fromEntries(Object.entries(context.config.mcp.servers).map(([name, server]) => {
+        if (server.transport === "stdio") {
+            return [name, {
+                    type: "local",
+                    command: [server.command, ...server.args],
+                    enabled: server.enabled,
+                    ...(Object.keys(server.env).length
+                        ? { environment: Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])) }
+                        : {}),
+                    ...(server.timeoutMs ? { timeout: server.timeoutMs } : {}),
+                }];
+        }
+        return [name, {
+                type: "remote",
+                url: server.url,
+                enabled: server.enabled,
+                ...(Object.keys(server.headers).length
+                    ? { headers: Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])) }
+                    : {}),
+                ...(server.timeoutMs ? { timeout: server.timeoutMs } : {}),
+            }];
+    }));
+}
+function tomlString(value) {
+    return JSON.stringify(value);
+}
+function tomlKey(value) {
+    return /^[A-Za-z0-9_-]+$/.test(value) ? value : JSON.stringify(value);
+}
+function tomlArray(values) {
+    return `[${values.map(tomlString).join(", ")}]`;
+}
+function tomlInlineTable(entries) {
+    return `{ ${Object.entries(entries).map(([key, value]) => `${tomlKey(key)} = ${tomlString(value)}`).join(", ")} }`;
+}
+export function mcpToml(context, remoteHeadersKey = "http_headers") {
+    const sections = [];
+    for (const [name, server] of enabledMcpServerEntries(context)) {
+        const lines = [`[mcp_servers.${tomlKey(name)}]`];
+        if (server.transport === "stdio") {
+            lines.push(`command = ${tomlString(server.command)}`);
+            if (server.args.length)
+                lines.push(`args = ${tomlArray(server.args)}`);
+            if (server.cwd)
+                lines.push(`cwd = ${tomlString(server.cwd)}`);
+            if (Object.keys(server.env).length) {
+                lines.push(`env = ${tomlInlineTable(Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])))}`);
+            }
+        }
+        else {
+            lines.push(`url = ${tomlString(server.url)}`);
+            if (Object.keys(server.headers).length) {
+                lines.push(`${remoteHeadersKey} = ${tomlInlineTable(Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])))}`);
+            }
+        }
+        if (server.enabledTools?.length)
+            lines.push(`enabled_tools = ${tomlArray(server.enabledTools)}`);
+        if (server.disabledTools?.length)
+            lines.push(`disabled_tools = ${tomlArray(server.disabledTools)}`);
+        sections.push(lines.join("\n"));
+    }
+    return sections.join("\n\n");
+}
+export function jsonMcpArtifact(pathname, owner, context, pathSegments = ["mcpServers"], includeType = true) {
+    return {
+        kind: "json",
+        path: pathname,
+        owner,
+        operations: [{
+                kind: "managed-map",
+                path: pathSegments,
+                entries: standardMcpMap(context, includeType),
+                collision: "error",
+            }],
+    };
+}
+export function grokMcpToml(context) {
+    const sections = [];
+    for (const [name, server] of enabledMcpServerEntries(context)) {
+        const lines = [`[mcp_servers.${tomlKey(name)}]`];
+        if (server.transport === "stdio") {
+            lines.push(`command = ${tomlString(server.command)}`);
+            if (server.args.length)
+                lines.push(`args = ${tomlArray(server.args)}`);
+            if (server.cwd)
+                lines.push(`cwd = ${tomlString(server.cwd)}`);
+            if (Object.keys(server.env).length) {
+                lines.push(`env = ${tomlInlineTable(Object.fromEntries(Object.entries(server.env).map(([key, value]) => [key, secretValue(value)])))}`);
+            }
+        }
+        else {
+            lines.push(`url = ${tomlString(server.url)}`);
+            if (Object.keys(server.headers).length) {
+                lines.push(`headers = ${tomlInlineTable(Object.fromEntries(Object.entries(server.headers).map(([key, value]) => [key, secretValue(value)])))}`);
+            }
+        }
+        if (server.timeoutMs) {
+            const seconds = Math.max(1, Math.ceil(server.timeoutMs / 1000));
+            lines.push(`startup_timeout_sec = ${seconds}`);
+            lines.push(`tool_timeout_sec = ${seconds}`);
+        }
+        sections.push(lines.join("\n"));
+    }
+    return sections.join("\n\n");
+}

package/dist/harness-configuration/adapters/shared.js

@@ -0,0 +1,4 @@
+export * from "./shared-common.js";
+export * from "./shared-documents.js";
+export * from "./shared-hooks.js";
+export * from "./shared-mcp.js";

package/dist/harness-configuration/adapters/tools.js

@@ -0,0 +1,24 @@
+const maps = {
+    codex: { read: ["read_file"], write: ["apply_patch"], search: ["grep", "glob"], shell: ["shell"], web: ["web_search"], mcp: ["mcp"], subagent: ["spawn_agent"], test: ["shell"], git: ["shell"] },
+    "claude-code": { read: ["Read"], write: ["Edit", "Write"], search: ["Grep", "Glob"], shell: ["Bash"], web: ["WebFetch", "WebSearch"], mcp: [], subagent: ["Task"], test: ["Bash"], git: ["Bash"] },
+    amp: { read: ["read"], write: ["edit", "write"], search: ["grep", "glob"], shell: ["Bash"], web: ["web"], mcp: ["mcp"], subagent: ["agent"], test: ["Bash"], git: ["Bash"] },
+    "oh-my-pi": { read: ["read"], write: ["edit", "write"], search: ["search", "find"], shell: ["bash"], web: ["web_search"], mcp: ["mcp"], subagent: ["task"], test: ["bash"], git: ["bash"] },
+    pi: { read: ["read"], write: ["edit", "write"], search: ["grep", "find"], shell: ["bash"], web: ["web"], mcp: ["mcp"], subagent: ["task"], test: ["bash"], git: ["bash"] },
+    "factory-droid": { read: ["Read"], write: ["Edit", "Create", "ApplyPatch"], search: ["Grep", "Glob", "LS"], shell: ["Execute"], web: ["FetchUrl", "WebSearch"], mcp: ["mcp__.*"], subagent: ["Task"], test: ["Execute"], git: ["Execute"] },
+    cursor: { read: ["Read"], write: ["Edit", "Write"], search: ["Grep", "Glob"], shell: ["Shell"], web: ["WebFetch", "WebSearch"], mcp: ["MCP"], subagent: ["Agent"], test: ["Shell"], git: ["Shell"] },
+    devin: { read: ["read"], write: ["edit", "write"], search: ["grep", "glob"], shell: ["exec"], web: ["web"], mcp: ["mcp"], subagent: ["subagent"], test: ["exec"], git: ["exec"] },
+    opencode: { read: ["read"], write: ["edit", "write"], search: ["grep", "glob"], shell: ["bash"], web: ["webfetch"], mcp: [], subagent: ["task"], test: ["bash"], git: ["bash"] },
+    "grok-build": { read: ["Read"], write: ["Edit", "Write"], search: ["Grep", "Glob"], shell: ["Bash"], web: ["WebFetch", "WebSearch"], mcp: ["mcp__.*"], subagent: ["Agent"], test: ["Bash"], git: ["Bash"] },
+    antigravity: { read: ["view_file"], write: ["write_to_file", "replace_file_content", "multi_replace_file_content"], search: ["grep_search", "find_by_name", "list_dir"], shell: ["run_command"], web: ["browser_*", "search_web"], mcp: ["mcp_*"], subagent: ["task"], test: ["run_command"], git: ["run_command"] },
+    "copilot-cli": { read: ["Read"], write: ["Edit", "Write"], search: ["Grep", "Glob"], shell: ["Bash"], web: ["WebFetch", "WebSearch"], mcp: ["mcp__*"], subagent: ["Task"], test: ["Bash"], git: ["Bash"] },
+    kimi: { read: ["Read"], write: ["Edit", "Write"], search: ["Grep", "Glob"], shell: ["Bash"], web: ["WebSearch", "FetchURL"], mcp: ["mcp__*"], subagent: ["Agent", "AgentSwarm"], test: ["Bash"], git: ["Bash"] },
+    kilo: { read: ["read"], write: ["edit", "write"], search: ["grep", "glob"], shell: ["bash"], web: ["webfetch"], mcp: [], subagent: ["task"], test: ["bash"], git: ["bash"] },
+    hermes: { read: ["read_file"], write: ["write_file", "patch"], search: ["search_files"], shell: ["terminal"], web: ["web_search", "web_extract"], mcp: ["mcp"], subagent: ["delegate_task"], test: ["terminal"], git: ["terminal"] },
+    qwen: { read: ["read_file"], write: ["edit", "write_file"], search: ["grep_search", "glob", "list_directory"], shell: ["run_shell_command"], web: ["web_fetch", "web_search"], mcp: ["mcp__*"], subagent: ["agent"], test: ["run_shell_command"], git: ["run_shell_command"] },
+};
+export function nativeToolsForCapabilities(target, capabilities) {
+    return [...new Set(capabilities.flatMap((capability) => maps[target][capability]))];
+}
+export function nativeTools(target, agent) {
+    return nativeToolsForCapabilities(target, agent.tools);
+}

package/dist/harness-configuration/cli-arguments.js

@@ -0,0 +1,105 @@
+import path from "node:path";
+import { parseTargetList } from "./core/config.js";
+import { CanonfigError } from "./core/errors.js";
+export const harnessHelpText = `Canonfig harness configuration
+
+Usage: canonfig harness <command> [options]
+
+Commands:
+  init       Create .canonfig/harness.yaml and canonical source directories
+  validate   Validate canonical sources and selected adapter translations
+  targets    List built-in harness adapters and support levels
+  plan       Show native files that would change
+  apply      Apply the current plan atomically
+  sync       Alias for apply
+  status     Report pending changes, conflicts, and diagnostics
+  diff       Print a unified-style diff for pending changes
+  clean      Remove only configuration currently owned by Canonfig
+  doctor     Probe selected harness executables
+
+Options:
+  --root <path>         Repository root or descendant working directory
+  --target <id>         Select one target; repeatable
+  --targets <ids>       Select comma-separated targets
+  --strict              Reject shim, lossy, and unsupported mappings
+  --force               Take ownership of explicit collisions or managed edits
+  --all                 Include unchanged files in plan output
+  --dry-run             Do not write during apply or clean
+  --no-input            Never prompt; accepted for scheduled invocations
+  --json                Emit the stable canonfig.cli/v1 envelope
+`;
+export const parseHarnessArguments = (arguments_) => {
+    const [command = "help", ...rest] = arguments_;
+    let root = process.cwd();
+    let json = false;
+    let strict = false;
+    let force = false;
+    let all = false;
+    let dryRun = false;
+    const requestedTargets = [];
+    for (let index = 0; index < rest.length; index += 1) {
+        const argument = rest[index];
+        if (argument === "--json") {
+            json = true;
+            continue;
+        }
+        if (argument === "--strict") {
+            strict = true;
+            continue;
+        }
+        if (argument === "--force") {
+            force = true;
+            continue;
+        }
+        if (argument === "--all") {
+            all = true;
+            continue;
+        }
+        if (argument === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        if (argument === "--no-input")
+            continue;
+        if (argument === "--help" || argument === "-h") {
+            return {
+                command: "help",
+                root: path.resolve(root),
+                json,
+                strict,
+                force,
+                all,
+                dryRun,
+            };
+        }
+        if (argument === "--root"
+            || argument === "--cwd"
+            || argument === "--target"
+            || argument === "--targets") {
+            const value = rest[index + 1];
+            if (value === undefined || value.startsWith("-")) {
+                throw new CanonfigError("HARNESS_OPTION_VALUE_REQUIRED", `${argument} requires a value.`);
+            }
+            index += 1;
+            if (argument === "--root" || argument === "--cwd")
+                root = path.resolve(value);
+            else
+                requestedTargets.push(value);
+            continue;
+        }
+        throw new CanonfigError("HARNESS_OPTION_UNKNOWN", `Unknown harness option: ${argument}`);
+    }
+    const targets = requestedTargets.length === 0
+        ? undefined
+        : parseTargetList(requestedTargets.join(","));
+    return {
+        command,
+        root: path.resolve(root),
+        json,
+        strict,
+        force,
+        all,
+        dryRun,
+        ...(targets === undefined ? {} : { targets }),
+    };
+};

package/dist/harness-configuration/cli-output.js

@@ -0,0 +1,77 @@
+import { Schema } from "effect";
+import { CliExitCode } from "../cli/exit-codes.js";
+import { renderCliResult } from "../cli/render.js";
+import { CanonfigError } from "./core/errors.js";
+const actionSymbol = (entry) => {
+    switch (entry.action) {
+        case "create": return "+";
+        case "update": return "~";
+        case "delete": return "-";
+        case "conflict": return "!";
+        case "unchanged": return "=";
+    }
+};
+export const renderHumanPlan = (plan, includeUnchanged) => {
+    const lines = [];
+    for (const entry of plan.entries) {
+        if (!includeUnchanged && entry.action === "unchanged")
+            continue;
+        lines.push(`${actionSymbol(entry)} ${entry.action.padEnd(9)} ${entry.path}`);
+        if (entry.reason !== undefined)
+            lines.push(`  ${entry.reason}`);
+    }
+    for (const diagnostic of plan.diagnostics) {
+        const target = diagnostic.target === undefined ? "" : `[${diagnostic.target}] `;
+        const location = diagnostic.path === undefined ? "" : ` (${diagnostic.path})`;
+        lines.push(`${diagnostic.level.toUpperCase()} ${target}${diagnostic.code}: ${diagnostic.message}${location}`);
+    }
+    const counts = ["create", "update", "delete", "unchanged", "conflict"]
+        .map((action) => `${plan.entries.filter((entry) => entry.action === action).length} ${action}`)
+        .join(", ");
+    lines.push(counts);
+    return `${lines.join("\n")}\n`;
+};
+export const toCliPayload = (value) => Schema.decodeUnknownSync(Schema.MutableJson)(JSON.parse(JSON.stringify(value)));
+export const planPayload = (plan) => toCliPayload({
+    root: plan.root,
+    targets: plan.targets,
+    entries: plan.entries.map(({ content: _content, before: _before, after: _after, nextState: _nextState, ...entry }) => entry),
+    diagnostics: plan.diagnostics,
+});
+export const diagnosticsPayload = (diagnostics) => toCliPayload(diagnostics);
+export const isHarnessPlanBlocked = (plan) => plan.entries.some((entry) => entry.action === "conflict")
+    || plan.diagnostics.some((diagnostic) => diagnostic.level === "error");
+export const renderHarnessResult = (io, input) => {
+    const rendered = input.json
+        ? renderCliResult({
+            command: input.command,
+            message: input.message,
+            data: input.data,
+            exitCode: input.exitCode,
+        }, "json")
+        : (input.human ?? renderCliResult({
+            command: input.command,
+            message: input.message,
+            data: input.data,
+            exitCode: input.exitCode,
+        }, "human"));
+    if (input.exitCode === CliExitCode.success)
+        io.writeStdout(rendered);
+    else
+        io.writeStderr(rendered);
+    io.setExitCode(input.exitCode);
+};
+export const harnessFailureExitCode = (error) => {
+    if (!(error instanceof CanonfigError))
+        return CliExitCode.internal;
+    if (/CONFLICT|COLLISION|EDITED|ESCAPE|STALE/u.test(error.code)) {
+        return CliExitCode.conflictOrDrift;
+    }
+    if (/APPLY|WRITE|ROLLBACK/u.test(error.code)) {
+        return CliExitCode.verificationOrApplyFailure;
+    }
+    if (/INVALID|NOT_FOUND|UNKNOWN|REQUIRED|EMPTY|PARSE/u.test(error.code)) {
+        return CliExitCode.usageOrConfiguration;
+    }
+    return CliExitCode.internal;
+};

package/dist/harness-configuration/cli.js

@@ -0,0 +1,196 @@
+import { CliExitCode } from "../cli/exit-codes.js";
+import { harnessHelpText, parseHarnessArguments, } from "./cli-arguments.js";
+import { diagnosticsPayload, harnessFailureExitCode, isHarnessPlanBlocked, planPayload, renderHarnessResult, renderHumanPlan, toCliPayload, } from "./cli-output.js";
+import { HarnessConfigurationCompiler, createDefaultRegistry, } from "./core/compiler.js";
+import { findRepositoryRoot } from "./core/config.js";
+import { formatPlanDiff } from "./core/diff.js";
+import { doctorTargets } from "./core/doctor.js";
+import { CanonfigError, errorMessage } from "./core/errors.js";
+import { applyPlan, createPlan } from "./core/planner.js";
+import { scaffoldProject } from "./core/scaffold.js";
+import { TARGET_IDS } from "./core/types.js";
+export const isHarnessConfigurationCommand = (arguments_) => arguments_[0] === "harness";
+const renderHelp = (parsed, io) => {
+    renderHarnessResult(io, {
+        command: "harness.help",
+        message: "Harness configuration help",
+        data: {
+            commands: [
+                "init",
+                "validate",
+                "targets",
+                "plan",
+                "apply",
+                "status",
+                "diff",
+                "clean",
+                "doctor",
+            ],
+        },
+        exitCode: CliExitCode.success,
+        json: parsed.json,
+        human: harnessHelpText,
+    });
+};
+export const runHarnessConfigurationCli = async (arguments_, io) => {
+    let parsed;
+    try {
+        parsed = parseHarnessArguments(arguments_);
+        const registry = createDefaultRegistry();
+        const compiler = new HarnessConfigurationCompiler(registry);
+        const commandName = `harness.${parsed.command}`;
+        if (parsed.command === "help") {
+            renderHelp(parsed, io);
+            return;
+        }
+        if (parsed.command === "init") {
+            const written = await scaffoldProject(parsed.root, {
+                targets: parsed.targets,
+                force: parsed.force,
+            });
+            renderHarnessResult(io, {
+                command: commandName,
+                message: written.length === 0
+                    ? "No harness source files changed"
+                    : "Harness source initialized",
+                data: { root: parsed.root, written },
+                exitCode: CliExitCode.success,
+                json: parsed.json,
+                human: written.length === 0
+                    ? "No files changed.\n"
+                    : `${written.map((file) => `+ ${file}`).join("\n")}\n`,
+            });
+            return;
+        }
+        if (parsed.command === "targets") {
+            const descriptors = registry.list().map((adapter) => adapter.descriptor);
+            renderHarnessResult(io, {
+                command: commandName,
+                message: "Harness targets listed",
+                data: toCliPayload(descriptors),
+                exitCode: CliExitCode.success,
+                json: parsed.json,
+                human: `${descriptors.map((descriptor) => [
+                    `${descriptor.id.padEnd(16)} ${descriptor.name}`,
+                    `  ${Object.entries(descriptor.capabilities)
+                        .map(([feature, level]) => `${feature}:${level}`)
+                        .join("  ")}`,
+                ].join("\n")).join("\n")}\n`,
+            });
+            return;
+        }
+        if (parsed.command === "doctor") {
+            const results = doctorTargets(registry, parsed.targets);
+            renderHarnessResult(io, {
+                command: commandName,
+                message: "Harness probes completed",
+                data: toCliPayload(results),
+                exitCode: CliExitCode.success,
+                json: parsed.json,
+                human: `${results.map((result) => `${result.id.padEnd(16)} ${(result.found ? "found" : "missing").padEnd(8)} ${result.executable ?? result.error ?? ""}`).join("\n")}\n`,
+            });
+            return;
+        }
+        const root = await findRepositoryRoot(parsed.root);
+        if (parsed.command === "clean") {
+            const plan = await createPlan(root, [...TARGET_IDS], [], [], { force: parsed.force });
+            const exitCode = isHarnessPlanBlocked(plan)
+                ? CliExitCode.conflictOrDrift
+                : CliExitCode.success;
+            if (exitCode === CliExitCode.success && !parsed.dryRun)
+                await applyPlan(plan);
+            renderHarnessResult(io, {
+                command: commandName,
+                message: exitCode !== CliExitCode.success
+                    ? "Harness cleanup blocked"
+                    : parsed.dryRun
+                        ? "Harness cleanup planned"
+                        : "Harness-owned configuration cleaned",
+                data: planPayload(plan),
+                exitCode,
+                json: parsed.json,
+                human: renderHumanPlan(plan, parsed.all),
+            });
+            return;
+        }
+        const plan = await compiler.plan({
+            root,
+            targets: parsed.targets,
+            strict: parsed.strict,
+            force: parsed.force,
+        });
+        const exitCode = isHarnessPlanBlocked(plan)
+            ? CliExitCode.conflictOrDrift
+            : CliExitCode.success;
+        if (parsed.command === "validate") {
+            renderHarnessResult(io, {
+                command: commandName,
+                message: exitCode === CliExitCode.success
+                    ? "Harness configuration is valid"
+                    : "Harness configuration validation failed",
+                data: diagnosticsPayload(plan.diagnostics),
+                exitCode,
+                json: parsed.json,
+                human: exitCode === CliExitCode.success
+                    ? "Harness configuration is valid.\n"
+                    : renderHumanPlan(plan, false),
+            });
+            return;
+        }
+        if (parsed.command === "plan" || parsed.command === "status") {
+            renderHarnessResult(io, {
+                command: commandName,
+                message: parsed.command === "status"
+                    ? (exitCode === CliExitCode.success
+                        ? "Harness configuration status computed"
+                        : "Harness configuration has conflicts")
+                    : "Harness configuration plan computed",
+                data: planPayload(plan),
+                exitCode,
+                json: parsed.json,
+                human: renderHumanPlan(plan, parsed.all),
+            });
+            return;
+        }
+        if (parsed.command === "diff") {
+            const diff = formatPlanDiff(plan);
+            renderHarnessResult(io, {
+                command: commandName,
+                message: "Harness configuration diff computed",
+                data: planPayload(plan),
+                exitCode,
+                json: parsed.json,
+                human: diff === "" ? "No pending changes.\n" : `${diff}\n`,
+            });
+            return;
+        }
+        if (parsed.command === "apply" || parsed.command === "sync") {
+            if (exitCode === CliExitCode.success && !parsed.dryRun)
+                await applyPlan(plan);
+            renderHarnessResult(io, {
+                command: commandName,
+                message: exitCode !== CliExitCode.success
+                    ? "Harness configuration apply blocked"
+                    : parsed.dryRun
+                        ? "Harness configuration apply planned"
+                        : "Harness configuration applied",
+                data: planPayload(plan),
+                exitCode,
+                json: parsed.json,
+                human: renderHumanPlan(plan, parsed.all),
+            });
+            return;
+        }
+        throw new CanonfigError("HARNESS_COMMAND_UNKNOWN", `Unknown harness command: ${parsed.command}`);
+    }
+    catch (error) {
+        const exitCode = harnessFailureExitCode(error);
+        renderHarnessResult(io, {
+            command: `harness.${parsed?.command ?? "unknown"}`,
+            message: errorMessage(error),
+            data: error instanceof CanonfigError ? { code: error.code } : undefined,
+            exitCode,
+            json: parsed?.json ?? arguments_.includes("--json"),
+        });
+    }
+};