@kylecheng3146/agent-ops 0.1.4 → 0.1.5

package/README.md

@@ -1,7 +1,7 @@
 # Loop Engineering Toolkit
 
 Loop Engineering Toolkit is an evidence-driven development-loop toolkit for
-Codex and Claude Code. It is designed to turn acceptance criteria, explicit
+Codex, Claude Code, and opencode. It is designed to turn acceptance criteria, explicit
 verification, safe lifecycle hooks, and independent review into a repeatable
 engineering workflow.
 
@@ -33,17 +33,24 @@ Use `--help` for the complete command reference or provide explicit options in
 automation. The wizard never writes files until you review and confirm its
 installation plan.
 
+The interactive multi-select screens start with no harness or profile selected.
+Choose at least one of `codex`, `claude`, and `opencode`, and at least one of
+the `core`, `advisory`, and `guardrails` profiles before confirming. For
+scripted use, `--harness all` selects all three harnesses; comma-separated
+selections such as `codex,opencode` are also supported. The legacy `both` value
+remains an alias for `codex,claude`.
+
 Preview a project installation before changing files:
 
 ```bash
 agent-ops init \
-  --dry-run --scope project --harness both --profile core --json
+  --dry-run --scope project --harness all --profile core --json
 ```
 
 After reviewing the plan, apply it explicitly with `--yes`:
 
 ```bash
-agent-ops init --scope project --harness both --profile core --yes
+agent-ops init --scope project --harness all --profile core --yes
 ```
 
 The remaining day-to-day checks are:
@@ -60,7 +67,16 @@ agent-ops uninstall --dry-run --json
 Use `--scope user` with user-home installations. Keep `--dry-run` for any
 operation you want to inspect before applying; non-interactive automation should
 pass `--yes` only after reviewing the plan. Add `--json` when another tool will
-consume the result.
+consume the result. `update` operates on an existing managed installation. Pass
+`--target-version <version>` when the target must be explicit or the command
+must work without a registry lookup, for example:
+
+```bash
+agent-ops update \
+  --harness opencode \
+  --target-version 0.1.4 \
+  --dry-run --json
+```
 
 ## Quick start from a source checkout
 
@@ -79,14 +95,14 @@ Preview a project installation before changing files:
 
 ```bash
 node dist/packages/cli/src/bin.js init \
-  --dry-run --scope project --harness both --profile core --json
+  --dry-run --scope project --harness all --profile core --json
 ```
 
 After reviewing the plan, apply it explicitly with `--yes`. Trust, diagnostics,
 updates, and removal are separate commands:
 
 ```bash
-node dist/packages/cli/src/bin.js init --scope project --harness both --profile core --yes
+node dist/packages/cli/src/bin.js init --scope project --harness all --profile core --yes
 node dist/packages/cli/src/bin.js trust status --json
 node dist/packages/cli/src/bin.js doctor --json
 node dist/packages/cli/src/bin.js config explain --json
@@ -94,17 +110,76 @@ node dist/packages/cli/src/bin.js update --dry-run --json
 node dist/packages/cli/src/bin.js uninstall --dry-run --json
 ```
 
+The `dist/...` path is relative to the source checkout. When testing from a
+throwaway project, run the built CLI with its absolute checkout path (or use the
+published `agent-ops` command); a new project does not contain its own `dist/`
+directory. `update` also requires that the project already has a valid managed
+`.agent-ops/manifest.json` created by `init`.
+
 The commands after `init --yes` are post-apply operations. `doctor` reports
 `UNKNOWN` for a probe that has nothing to verify yet: `repository-trust` until
 `trust grant` runs, and `smoke-availability` until the configuration declares a
 verification command.
 
-Installing the `advisory` or `guardrails` profile also registers lifecycle
-hooks in `.claude/settings.json` and `.codex/hooks.json`. Only agent-ops owned
-handlers are added, foreign settings in those files are preserved, and
-`uninstall` removes exactly the handlers it registered. The hooks call
-`agent-ops hook <harness> <event>`, which always exits 0 so a toolkit failure
-can never block the harness.
+Installing the `advisory` or `guardrails` profile registers the lifecycle and
+command-policy hooks implied by those profiles for the selected harnesses.
+Claude Code and Codex use their native JSON settings files; opencode uses the agent-ops-owned
+`.opencode/plugins/agent-ops.js` shim and never changes `opencode.json`. Only
+agent-ops-owned handlers and artifacts are managed, foreign settings are
+preserved, and `uninstall` removes exactly the content it registered. At user
+scope, the opencode plugin is placed under
+`.config/opencode/plugins/agent-ops.js`, or under the configured
+`$XDG_CONFIG_HOME/opencode/` or `$OPENCODE_CONFIG_DIR/` when that location is
+inside the managed user root. The shims call `agent-ops hook <harness> <event>`
+through the installed absolute runtime path. Advisory failures remain
+fail-open; command-policy failures are fail-closed only where the native
+harness can block the tool. Claude and Codex lifecycle summaries are
+`supported`; OpenCode's app-scoped initialization is `degraded` rather than
+per-session coverage. Codex command denial remains `unknown` until native
+blocking is confirmed.
+
+`guardrails` enables command policy only; it does not imply Stop verification.
+Stop verification is an explicit, disabled-by-default config feature. Enable it
+only with confirmed commands, for example the relevant config fragment is:
+
+```json
+{
+  "features": { "stopVerification": { "enabled": true } },
+  "verification": {
+    "commands": [
+      {
+        "id": "unit",
+        "command": "npm",
+        "args": ["test"],
+        "cwd": ".",
+        "required": true,
+        "evidence": { "kind": "test-count", "minimum": 1 }
+      }
+    ]
+  }
+}
+```
+
+After changing Stop configuration, run `agent-ops update` so native
+registrations match the config, then `agent-ops trust grant` to bind the
+current config. Stop is report-only: `PASS`, `FAIL`, and `UNKNOWN` continue
+the harness, emit bounded command evidence, and never complete a task.
+Config v1 migrates to config v2 with Stop disabled; migration invalidates the
+old trust binding, and pre-v1 binaries cannot read the migrated config.
+
+The generated `AGENTS.md` and `CLAUDE.md` routing blocks are supplemental: they
+load the managed baseline while leaving project-specific instructions in those
+files authoritative. Existing installations with the previous canonical
+wording are migrated by `agent-ops update`; changed managed blocks still fail
+closed.
+
+Dry-run plans keep harness settings writes opaque: human and JSON output expose
+only the expected hash, content hash, and a safe summary. Use
+`--hook-target <harness>=<surface-id>` when selecting a non-default discovered
+surface; project-local Claude settings are never selected implicitly. The
+internal plan still retains the complete merged settings for transactional
+apply. The routing migration is one-way once applied; review the release notes
+before attempting a downgrade.
 
 For a full command reference, run `agent-ops --help`. The `task`, `verify`, and
 `review` commands support acceptance tracking and independent verification when
@@ -116,7 +191,7 @@ the project configuration defines those workflows.
 - Treat command output and current filesystem state as evidence.
 - Keep advisory automation separate from blocking guardrails.
 - Preserve user configuration through managed, reversible updates.
-- Support Codex and Claude Code without project-specific assumptions.
+- Support Codex, Claude Code, and opencode without project-specific assumptions.
 - Collect no network telemetry.
 
 ## Project status

package/dist/packages/cli/src/args.js

@@ -1,3 +1,4 @@
+import { isHarnessId, resolveHarnessSelection } from "../../../runtime/src/install/harness.js";
 export const COMMAND_NAMES = [
     "init",
     "config",
@@ -11,7 +12,6 @@ export const COMMAND_NAMES = [
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
-const HARNESSES = new Set(["both", "claude", "codex"]);
 const PROFILES = new Set(["advisory", "core", "guardrails"]);
 export class CliArgumentError extends Error {
     code;
@@ -36,11 +36,30 @@ function duplicate(option) {
 function invalidValue(option, value) {
     throw new CliArgumentError("CLI_INVALID_VALUE", `Invalid value for ${option}: ${value}`, option);
 }
+function parseHarness(option, value) {
+    return resolveHarnessSelection(value) ?? invalidValue(option, value);
+}
+function parseHookTarget(option, value) {
+    const separator = value.indexOf("=");
+    if (separator <= 0 ||
+        separator !== value.lastIndexOf("=") ||
+        separator === value.length - 1) {
+        return invalidValue(option, value);
+    }
+    const harness = value.slice(0, separator);
+    const surfaceId = value.slice(separator + 1);
+    if (!isHarnessId(harness) ||
+        !/^[a-z][a-z0-9-]{0,63}$/u.test(surfaceId)) {
+        return invalidValue(option, value);
+    }
+    return { harness: harness, surfaceId };
+}
 export function parseArgs(argv) {
     let command;
     let action;
     let scope;
     let harness;
+    const hookTargets = [];
     let taskId;
     let targetVersion;
     let title;
@@ -76,10 +95,17 @@ export function parseArgs(argv) {
                     duplicate(token);
                 }
                 const value = readOptionValue(argv, index, token);
-                if (!HARNESSES.has(value)) {
-                    invalidValue(token, value);
+                harness = parseHarness(token, value);
+                index += 1;
+                break;
+            }
+            case "--hook-target": {
+                const value = readOptionValue(argv, index, token);
+                const target = parseHookTarget(token, value);
+                if (hookTargets.some(({ harness: id }) => id === target.harness)) {
+                    duplicate(`${token} ${target.harness}`);
                 }
-                harness = value;
+                hookTargets.push(target);
                 index += 1;
                 break;
             }
@@ -216,6 +242,7 @@ export function parseArgs(argv) {
     if (helpSeen || versionSeen) {
         if (scope !== undefined ||
             harness !== undefined ||
+            hookTargets.length > 0 ||
             profiles.length > 0 ||
             taskId !== undefined ||
             targetVersion !== undefined ||
@@ -252,6 +279,11 @@ export function parseArgs(argv) {
     if (command !== "update" && targetVersion !== undefined) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--target-version may be used only with update.");
     }
+    if (hookTargets.length > 0 &&
+        command !== "init" &&
+        command !== "update") {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--hook-target may be used only with init or update.");
+    }
     if (command === "task") {
         if (harness !== undefined ||
             profiles.length > 0 ||
@@ -300,14 +332,15 @@ export function parseArgs(argv) {
         (title !== undefined || sessionId !== undefined)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Review accepts harness, criteria, evidence, scope, dry-run, json, and yes options.");
     }
-    if (command === "review" && harness === "both") {
-        invalidValue("--harness", harness);
+    if (command === "review" && harness !== undefined && harness.length !== 1) {
+        invalidValue("--harness", harness.join(","));
     }
     return {
         command,
         ...(action === undefined ? {} : { action }),
         ...(scope === undefined ? {} : { scope }),
         ...(harness === undefined ? {} : { harness }),
+        ...(hookTargets.length === 0 ? {} : { hookTargets }),
         profiles,
         ...(taskId === undefined ? {} : { taskId }),
         ...(targetVersion === undefined ? {} : { targetVersion }),

package/dist/packages/cli/src/bin.js

@@ -4,7 +4,7 @@ import { homedir } from "node:os";
 import { join } from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { commonHarnessAdapters } from "../../../runtime/src/install/harness.js";
+import { commonHarnessAdapters, harnessHookPath, HARNESS_IDS } from "../../../runtime/src/install/harness.js";
 import { hookRegistrationSatisfied, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
 import { parseInstallManifest } from "../../../runtime/src/fs/manifest.js";
 import { NpmRegistryClient } from "../../../runtime/src/registry/npm.js";
@@ -12,6 +12,7 @@ import { TaskService } from "../../../runtime/src/task/service.js";
 import { FileTaskStore } from "../../../runtime/src/task/store.js";
 import { FileTrustStore, calculateTrustBinding } from "../../../runtime/src/security/trust.js";
 import { localStatePaths } from "../../../runtime/src/security/permissions.js";
+import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
 import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
 import { VerificationService } from "../../../runtime/src/verify/service.js";
@@ -33,23 +34,39 @@ import { runVerifyCommand } from "./commands/verify.js";
 import { formatUpdatePlan, runUpdateCommand } from "./commands/update.js";
 import { errorEnvelope } from "./output.js";
 const HOOK_RUNTIME_PATH = fileURLToPath(new URL("./hook-entry.js", import.meta.url));
-async function readOptionalJson(path) {
+async function readOptionalText(path) {
     try {
-        return JSON.parse(await readFile(path, "utf8"));
+        return await readFile(path, "utf8");
     }
     catch {
         return null;
     }
 }
-async function installedHarness(root) {
+async function hookSources(root, scope) {
+    const sources = {};
+    const manifest = await installedManifest(root);
+    const recordedOpencodePluginPath = manifest?.artifacts.find(({ id }) => id === "opencode-plugin")?.path;
+    const recordedHookPaths = new Map((manifest?.hooks ?? []).map(({ harness, path }) => [harness, path]));
+    for (const id of HARNESS_IDS) {
+        const path = id === "opencode" && recordedOpencodePluginPath !== undefined
+            ? recordedOpencodePluginPath
+            : recordedHookPaths.get(id) ??
+                harnessHookPath(id, scope, root);
+        sources[id] = await readOptionalText(join(root, path));
+    }
+    return sources;
+}
+async function installedManifest(root) {
     try {
-        return parseInstallManifest(await readFile(join(root, ".agent-ops", "manifest.json"), "utf8")).harness;
+        return parseInstallManifest(await readFile(join(root, ".agent-ops", "manifest.json"), "utf8"));
     }
     catch {
-        // ponytail: no readable manifest means demand hooks for both harnesses.
-        return "both";
+        return null;
     }
 }
+async function installedHarness(root) {
+    return (await installedManifest(root))?.harness ?? [...HARNESS_IDS];
+}
 async function confirmInit(plan) {
     writeBanner({
         isTTY: process.stdout.isTTY === true,
@@ -104,6 +121,9 @@ else {
                         isTTY,
                         toolkitVersion: CLI_VERSION,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
+                        ...(args.hookTargets === undefined
+                            ? {}
+                            : { hookTargets: args.hookTargets }),
                         confirm: async (plan) => await confirmInit(plan)
                     });
                 }
@@ -114,9 +134,8 @@ else {
                         probes: {
                             hookRegistration: async () => hookRegistrationSatisfied({
                                 harness: await installedHarness(root),
-                                profiles: config.profiles,
-                                claudeSettings: await readOptionalJson(join(root, ".claude", "settings.json")),
-                                codexHooks: await readOptionalJson(join(root, ".codex", "hooks.json"))
+                                config,
+                                sources: await hookSources(root, args.scope === "user" ? "user" : "project")
                             }),
                             repositoryTrust: async () => repositoryTrustStatus(await repositoryTrust(root, config, CLI_VERSION)),
                             smokeAvailability: () => smokeAvailabilityStatus(config)
@@ -139,6 +158,9 @@ else {
                         registry: new NpmRegistryClient(),
                         isTTY,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
+                        ...(args.hookTargets === undefined
+                            ? {}
+                            : { hookTargets: args.hookTargets }),
                         confirm: async (plan) => await confirmPlan(formatUpdatePlan(plan)),
                         ...(args.targetVersion === undefined
                             ? {}
@@ -219,7 +241,7 @@ else {
                     const binding = await calculateTrustBinding({
                         repositoryPath: root,
                         remoteUrl: remote,
-                        configHash: sha256(JSON.stringify(config)),
+                        configHash: calculateConfigHash(config),
                         runtimeHash: sha256(CLI_VERSION)
                     });
                     return await runTrustCommand({

package/dist/packages/cli/src/cli.js

@@ -1,4 +1,5 @@
 import { CliArgumentError, parseArgs } from "./args.js";
+import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { errorEnvelope, okEnvelope, writeEnvelope } from "./output.js";
 import { completeInitChoices } from "./wizard.js";
 import { BANNER } from "./ui.js";
@@ -28,7 +29,8 @@ Commands:
 
 Options:
   --scope <project|user>
-  --harness <both|claude|codex>
+  --harness <all|both|claude|codex|opencode|comma-separated>  Init/update
+  --hook-target <harness=surface-id>  Repeatable advanced init/update option
   --profile <core|advisory|guardrails>  Repeatable
   --task <id>
   --target-version <version>          Update target version (offline-capable)
@@ -89,6 +91,9 @@ export async function runCli(argv, io, services) {
         if (error instanceof CliArgumentError) {
             return writeAndReturn(io, errorEnvelope(error.code, error.message), args.json, 2);
         }
+        if (error instanceof AgentOpsError) {
+            return writeAndReturn(io, errorEnvelope(error.code, error.message), args.json, 1);
+        }
         return writeAndReturn(io, errorEnvelope("CLI_INTERNAL_ERROR", "Command execution failed."), args.json, 1);
     }
 }

package/dist/packages/cli/src/commands/doctor.js

@@ -1,32 +1,54 @@
 import { doctorInstallation } from "../../../../runtime/src/install/doctor.js";
 function formatDoctorReport(report) {
+    const surfaces = report.surfaces ?? [];
     return `${[
         "Installation doctor",
-        ...report.checks.map(({ id, status, message }) => `- ${status} ${id}: ${message}`)
+        ...report.checks.map(({ id, status, message, code }) => `- ${status} ${id}${code === undefined ? "" : ` [${code}]`}: ${message}`),
+        ...(surfaces.length === 0
+            ? []
+            : [
+                "Surfaces:",
+                ...surfaces.map(({ harness, surfaceId, path, status, managedHandlerCount, foreignHandlerCount }) => `- ${status} ${harness}/${surfaceId}: ${path} ` +
+                    `(managed ${managedHandlerCount}, foreign ${foreignHandlerCount})`)
+            ])
     ].join("\n")}\n`;
 }
 export async function runDoctorCommand(options) {
     const report = await doctorInstallation(options);
     const hasFailure = report.checks.some(({ status }) => status === "FAIL");
     const hasUnknown = report.checks.some(({ status }) => status === "UNKNOWN");
+    const hasUnsupported = report.checks.some(({ status }) => status === "UNSUPPORTED");
+    const hasDegraded = report.checks.some(({ status }) => status === "DEGRADED");
     const code = hasFailure
         ? "DOCTOR_FAILED"
-        : hasUnknown
-            ? "DOCTOR_UNKNOWN"
-            : "DOCTOR_OK";
+        : hasUnsupported
+            ? "DOCTOR_UNSUPPORTED"
+            : hasUnknown
+                ? "DOCTOR_UNKNOWN"
+                : hasDegraded
+                    ? "DOCTOR_DEGRADED"
+                    : "DOCTOR_OK";
     const message = hasFailure
         ? "Installation diagnostics found failures."
-        : hasUnknown
-            ? "Installation diagnostics contain unknown checks."
-            : "Installation diagnostics passed.";
+        : hasUnsupported
+            ? "Installation diagnostics found unsupported capabilities."
+            : hasUnknown
+                ? "Installation diagnostics contain unknown checks."
+                : hasDegraded
+                    ? "Installation diagnostics found degraded checks."
+                    : "Installation diagnostics passed.";
     return {
         code,
-        status: hasFailure || hasUnknown ? "error" : "ok",
+        status: hasFailure || hasUnsupported || hasUnknown || hasDegraded
+            ? "error"
+            : "ok",
         data: {
             report,
             message,
             text: formatDoctorReport(report)
         },
-        errors: hasFailure || hasUnknown ? [{ code, message }] : []
+        errors: hasFailure || hasUnsupported || hasUnknown || hasDegraded
+            ? [{ code, message }]
+            : []
     };
 }

package/dist/packages/cli/src/commands/hook.js

@@ -1,9 +1,7 @@
-import { normalizeClaudeHookInput } from "../../../../runtime/src/adapters/claude/input.js";
-import { claudeHookOutput } from "../../../../runtime/src/adapters/claude/output.js";
-import { normalizeCodexHookInput } from "../../../../runtime/src/adapters/codex/input.js";
-import { codexHookOutput } from "../../../../runtime/src/adapters/codex/output.js";
+import { runLifecycleAdvisory } from "../../../../runtime/src/hooks/advisory.js";
 import { dispatchHookEvent } from "../../../../runtime/src/hooks/dispatch.js";
-import { resolveProfiles } from "../../../../runtime/src/install/profiles.js";
+import { resolveCapabilities } from "../../../../runtime/src/install/profiles.js";
+import { harnessDescriptor } from "../../../../runtime/src/install/harness.js";
 export const HOOK_EVENTS = [
     "SessionStart",
     "PreToolUse",
@@ -15,7 +13,9 @@ export const HOOK_EVENTS = [
  */
 export async function runHookCommand(options) {
     try {
-        const { capabilities } = resolveProfiles(options.config.profiles);
+        const { capabilities } = options.config.profiles.length === 0
+            ? { capabilities: [] }
+            : resolveCapabilities(options.config);
         let input;
         try {
             input = JSON.parse(options.stdin);
@@ -23,18 +23,20 @@ export async function runHookCommand(options) {
         catch {
             return { exitCode: 0, stdout: "", stderr: "" };
         }
-        const event = options.harness === "claude"
-            ? normalizeClaudeHookInput(input)
-            : normalizeCodexHookInput(input);
-        const result = await dispatchHookEvent(event, {
+        const descriptor = harnessDescriptor(options.harness);
+        const normalized = descriptor.runtime.normalizeInput(input);
+        const stopRegistration = descriptor.control.registrations.find(({ capability }) => capability === "optional-stop-verify");
+        const stopVerification = options.stopVerification !== undefined &&
+            stopRegistration?.support !== "unsupported"
+            ? options.stopVerification
+            : undefined;
+        const result = await dispatchHookEvent(normalized, {
             capabilities,
-            trusted: options.trusted
+            trusted: options.trusted,
+            advisory: options.advisory ?? runLifecycleAdvisory,
+            ...(stopVerification === undefined ? {} : { stopVerification })
         });
-        if (options.harness === "claude") {
-            return claudeHookOutput(options.event, result);
-        }
-        const codex = codexHookOutput(options.event, result);
-        return { exitCode: 0, stdout: codex.stdout, stderr: "" };
+        return descriptor.runtime.formatOutput(options.event, result);
     }
     catch {
         return { exitCode: 0, stdout: "", stderr: "" };

package/dist/packages/cli/src/commands/init.js

@@ -3,6 +3,7 @@ import { createInstallPlan } from "../../../../runtime/src/install/plan.js";
 import { applyInstallPlan } from "../../../../runtime/src/install/apply.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
+import { toPublicInstallPlan } from "../public-plan.js";
 export function formatInstallPlan(plan) {
     const hooks = plan.manifest.hooks ?? [];
     return formatOperationPlan({
@@ -18,7 +19,7 @@ export function formatInstallPlan(plan) {
                     ...hooks.map((hook) => `  - ${hook.harness}: ${hook.path} (${hook.events.join(", ")})`)
                 ])
         ],
-        operations: plan.operations
+        operations: toPublicInstallPlan(plan).operations
     });
 }
 function appliedMessage(plan) {
@@ -36,7 +37,7 @@ function initError(code, message, plan) {
     return {
         code,
         status: "error",
-        data: { applied: false, plan, message },
+        data: { applied: false, plan: toPublicInstallPlan(plan), message },
         errors: [{ code, message }]
     };
 }
@@ -59,12 +60,15 @@ export async function runInitCommand(options) {
             : { toolkitVersion: options.toolkitVersion }),
         ...(options.hookRuntimePath === undefined
             ? {}
-            : { hookRuntimePath: options.hookRuntimePath })
+            : { hookRuntimePath: options.hookRuntimePath }),
+        ...((options.hookTargets ?? args.hookTargets) === undefined
+            ? {}
+            : { hookTargets: options.hookTargets ?? args.hookTargets })
     });
     if (args.dryRun) {
         return okEnvelope("INIT_PLAN_READY", {
             applied: false,
-            plan,
+            plan: toPublicInstallPlan(plan),
             message: "Installation plan calculated; no files were written.",
             text: formatInstallPlan(plan)
         });
@@ -80,7 +84,7 @@ export async function runInitCommand(options) {
     await applyInstallPlan(options.root, plan);
     return okEnvelope("INIT_APPLIED", {
         applied: true,
-        plan,
+        plan: toPublicInstallPlan(plan),
         message: appliedMessage(plan)
     });
 }

package/dist/packages/cli/src/commands/review.js

@@ -2,8 +2,12 @@ import { buildReviewPacket } from "../../../../runtime/src/review/packet.js";
 import { runIndependentReview } from "../../../../runtime/src/review/runner.js";
 import { resolveReviewRole } from "../../../../runtime/src/review/roles.js";
 import { okEnvelope } from "../output.js";
+/**
+ * Review runs against one harness. Argument parsing already rejects a
+ * multi-harness selection here, so the first entry is the whole selection.
+ */
 function harness(value) {
-    return value === "claude" ? "claude" : "codex";
+    return value?.[0] ?? "codex";
 }
 export async function runReviewCommand(options) {
     const ids = options.args.criteria ?? [];

package/dist/packages/cli/src/commands/uninstall.js

@@ -1,6 +1,7 @@
 import { applyUninstallPlan, createUninstallPlan } from "../../../../runtime/src/install/uninstall.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
+import { toPublicUninstallPlan } from "../public-plan.js";
 function formatUninstallPlan(plan) {
     return formatOperationPlan({
         title: "Uninstall plan",
@@ -13,14 +14,14 @@ function formatUninstallPlan(plan) {
                     `Harness: ${plan.manifest.harness}`
                 ])
         ],
-        operations: plan.operations
+        operations: toPublicUninstallPlan(plan).operations
     });
 }
 function uninstallError(code, message, plan) {
     return {
         code,
         status: "error",
-        data: { applied: false, plan, message },
+        data: { applied: false, plan: toPublicUninstallPlan(plan), message },
         errors: [{ code, message }]
     };
 }
@@ -29,14 +30,14 @@ export async function runUninstallCommand(options) {
     if (!plan.installed) {
         return okEnvelope("UNINSTALL_NOT_INSTALLED", {
             applied: false,
-            plan,
+            plan: toPublicUninstallPlan(plan),
             message: "No managed installation exists."
         });
     }
     if (options.args.dryRun) {
         return okEnvelope("UNINSTALL_PLAN_READY", {
             applied: false,
-            plan,
+            plan: toPublicUninstallPlan(plan),
             message: "Uninstall plan calculated; no files were changed.",
             text: formatUninstallPlan(plan)
         });
@@ -51,7 +52,7 @@ export async function runUninstallCommand(options) {
     await applyUninstallPlan(options.root, plan);
     return okEnvelope("UNINSTALL_APPLIED", {
         applied: true,
-        plan,
+        plan: toPublicUninstallPlan(plan),
         message: "Managed installation content was removed."
     });
 }