@kylecheng3146/agent-ops 0.1.4 → 0.1.6

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`, `guardrails`, and `loop` 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:
@@ -57,10 +64,67 @@ agent-ops update --yes --json
 agent-ops uninstall --dry-run --json
 ```
 
+### Project-local loop
+
+`loop` is an explicit, project-only profile for Codex, Claude Code, or both.
+It requires a POSIX-compatible `bash`; the generated native launchers are
+`.sh` files, so Windows is not currently a supported loop host. Preview it
+first, then install only after reviewing the plan. `loop` also implies the
+`core` baseline, so the project retains the managed rules and routing files:
+
+```bash
+agent-ops init --dry-run --scope project --harness codex,claude --profile loop --json
+agent-ops init --scope project --harness codex,claude --profile loop --yes
+```
+
+It creates one small managed launcher per selected native host:
+
+- Codex: `.codex/hooks/agent-ops-loop.sh`, `.codex/config.toml` when absent,
+  `.codex/loop-goal.md`, `.codex/loop-state.md`, and
+  `.codex/loop-telemetry.jsonl`.
+- Claude Code: `.claude/hooks/agent-ops-loop.sh`, `.claude/loop-goal.md`,
+  `.claude/loop-state.md`, and `.claude/loop-telemetry.jsonl`.
+
+The launchers delegate to one installed Node runtime; agent-ops does not copy
+project-specific policy code into either hook directory. It adds an exact,
+hash-commented `.gitignore` block for the goal, state, and telemetry files.
+Those files and `.codex/config.toml` remain user-owned: update never overwrites
+them, and uninstall keeps them while removing only launchers, hook handlers,
+and the managed ignore block.
+
+The loop registers `SessionStart`, `UserPromptSubmit`, `PreToolUse`,
+`PermissionRequest`, `PostToolUse`, `PreCompact`, `PostCompact`,
+`SubagentStart`, and `SubagentStop`; it intentionally does not register
+`Stop`. On high-confidence matches, it blocks literal credential-shaped user
+prompts or Bash commands, plus dangerous Bash commands such as broad recursive
+deletion or `git reset --hard`. Codex uses its documented exit-code denial path; Claude Code
+uses its documented native JSON denial shapes. Permission and escalation
+requests are never auto-approved or denied by the loop, so the harness's normal
+approval prompt remains authoritative.
+
+Session context is bounded and derives from the redacted goal plus a telemetry
+count. Telemetry records only timestamp, event, outcome, and rule code; it
+never stores raw prompts, Bash commands, or credentials and is byte-rotated.
+Before compaction, the loop writes a bounded, redacted Git-status snapshot into
+its own block inside `loop-state.md`, preserving surrounding user text. This is
+a guardrail, not a complete sandbox or a replacement for each harness's own
+permissions. Review and trust the generated hook configuration in Codex and
+Claude Code before use. An existing Codex `.codex/config.toml` with an explicit
+`[features]` / `hooks = false` setting stops installation before any write.
+
 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 +143,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 +158,104 @@ 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.
+`artifact-staleness` reports `DEGRADED` with `UPDATE_REQUIRED` when a toolkit
+upgrade or effective profile or capability change makes intact managed rules
+differ from the current baseline. Run `agent-ops update` to regenerate them.
+Missing, altered, or hash-mismatched managed artifacts remain `FAIL` under
+`artifacts`.
+
+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. Runtime-failure enforcement is deliberately narrow: Claude Code can
+emit its documented `PreToolUse` denial shape for a classified invalid installed
+configuration, and the managed OpenCode `tool.execute.before` plugin throws
+its documented command-policy denial or unavailable-runtime error for its
+supported Bash surface. Codex command policy is `unknown` and explicitly
+non-enforcing for the ordinary `guardrails` profile. The project-local `loop`
+profile uses its separate native hook policy described above. These are output
+and plugin contracts, not proof that a host
+honors a denial. Claude and Codex lifecycle summaries are `supported`; OpenCode's
+app-scoped initialization is `degraded` rather than per-session coverage.
+
+Claude's invalid-config fallback has four safeguards: only an invalid (not
+absent) `.agent-ops/config.json` can reach it; a safely read manifest must list
+the current harness; `AGENT_OPS_DISABLE=1` must not be set; and Claude's denial
+reason names the config file with a repair or temporary shell-disable remedy.
+`AGENT_OPS_DISABLE=1` is a human-shell recovery variable only. Agent-ops never
+reads it from configuration, a manifest, or another file it writes. Every
+`SessionStart` and `Stop` failure path remains fail-open.
+
+`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.
+
+### Rejected proposals and deliberate boundaries
+
+The following proposals are deliberately rejected: emitting a model-visible
+`SessionStart` advisory summary, inspecting user-authored Markdown link
+integrity in `doctor`, and creating backups for agent-authored rule edits.
+Transactional backups remain limited to agent-ops apply operations. Agent-ops
+also does not add a git-workflow instruction to the generated baseline, which
+stays project-neutral.
+
+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 +267,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,8 +12,7 @@ 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"]);
+const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
 export class CliArgumentError extends Error {
     code;
     option;
@@ -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)
                     });
                 }
@@ -111,12 +131,12 @@ else {
                     const config = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
                     return await runDoctorCommand({
                         root,
+                        toolkitVersion: CLI_VERSION,
                         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)
@@ -138,7 +158,11 @@ else {
                         adapters: commonHarnessAdapters(),
                         registry: new NpmRegistryClient(),
                         isTTY,
+                        toolkitVersion: CLI_VERSION,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
+                        ...(args.hookTargets === undefined
+                            ? {}
+                            : { hookTargets: args.hookTargets }),
                         confirm: async (plan) => await confirmPlan(formatUpdatePlan(plan)),
                         ...(args.targetVersion === undefined
                             ? {}
@@ -219,7 +243,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,8 +29,9 @@ Commands:
 
 Options:
   --scope <project|user>
-  --harness <both|claude|codex>
-  --profile <core|advisory|guardrails>  Repeatable
+  --harness <all|both|claude|codex|opencode|comma-separated>  Init/update
+  --hook-target <harness=surface-id>  Repeatable advanced init/update option
+  --profile <core|advisory|guardrails|loop>  Repeatable
   --task <id>
   --target-version <version>          Update target version (offline-capable)
   --title <text>
@@ -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/codex-loop-process.js

@@ -0,0 +1,70 @@
+import { PROJECT_LOOP_EVENTS, runProjectLoop } from "../../../runtime/src/hooks/codex-loop.js";
+const MAX_LOOP_INPUT_BYTES = 64 * 1024;
+function isLoopHarness(value) {
+    return value === "claude" || value === "codex";
+}
+function isLoopEvent(value) {
+    return (value !== undefined &&
+        PROJECT_LOOP_EVENTS.includes(value));
+}
+async function readStdin(stream) {
+    const chunks = [];
+    let total = 0;
+    for await (const chunk of stream) {
+        const buffer = Buffer.isBuffer(chunk)
+            ? chunk
+            : Buffer.from(String(chunk), "utf8");
+        total += buffer.byteLength;
+        if (total > MAX_LOOP_INPUT_BYTES) {
+            return null;
+        }
+        chunks.push(buffer);
+    }
+    return Buffer.concat(chunks, total).toString("utf8");
+}
+function parseInput(source) {
+    if (source === null) {
+        return null;
+    }
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Process boundary for the generated Bash launchers. Invalid input stays
+ * fail-open; the runtime owns every policy decision and output shape.
+ */
+export async function runLoopProcess(argv, io, dependencies = {}) {
+    const [harness, event] = argv;
+    if (!isLoopHarness(harness) || !isLoopEvent(event)) {
+        return 0;
+    }
+    try {
+        const result = await runProjectLoop({
+            harness,
+            event,
+            input: parseInput(await readStdin(io.stdin)),
+            root: dependencies.root ?? process.cwd(),
+            ...(dependencies.now === undefined ? {} : { now: dependencies.now }),
+            ...(dependencies.gitStatus === undefined
+                ? {}
+                : { gitStatus: dependencies.gitStatus }),
+            ...(dependencies.telemetryMaxBytes === undefined
+                ? {}
+                : { telemetryMaxBytes: dependencies.telemetryMaxBytes })
+        });
+        if (result.stdout.length > 0) {
+            io.writeStdout(result.stdout);
+        }
+        if (result.stderr.length > 0) {
+            io.writeStderr(result.stderr);
+        }
+        return result.exitCode;
+    }
+    catch {
+        return 0;
+    }
+}

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 }]
+            : []
     };
 }