@kylecheng3146/agent-ops 0.1.6 → 0.1.8

package/dist/runtime/src/install/doctor.js

@@ -338,6 +338,46 @@ async function checkRegistrationDrift(root, manifest, config) {
         return check("registration-drift", "UNKNOWN", "Hook registration drift could not be assessed safely.");
     }
 }
+/**
+ * Guidance lives in `message` rather than a `remediation` field: as of this
+ * check, `remediation` does not exist on DoctorCheck. Because target
+ * authentication failures surface as one unexplained review failure — the
+ * chain deliberately does not sniff stderr for "not logged in" — this text is
+ * the operator's only route out, so it names the exact command.
+ */
+async function checkReviewTargets(config, probe, checkAuth) {
+    const targets = config?.reviewRoles?.find((role) => role.role === "independent-review")?.targets ?? [];
+    if (targets.length === 0) {
+        return check("review-targets", "PASS", "External review disabled. Re-run agent-ops init to enable.");
+    }
+    if (probe === undefined) {
+        return check("review-targets", "PASS", `External review targets: ${targets.join(", ")}. ` +
+            "Login state unverified; run: agent-ops doctor --check-auth");
+    }
+    for (const target of targets) {
+        const result = await probe(target, checkAuth);
+        if (result === "missing-executable") {
+            return check("review-targets", "FAIL", `${target} not found. Install it, or remove "${target}" from ` +
+                "reviewRoles[].targets.", "UPDATE_REQUIRED");
+        }
+        if (result === "ineligible") {
+            return check("review-targets", "FAIL", `${target} has no read-only mode and cannot review. Remove ` +
+                `"${target}" from reviewRoles[].targets.`, "UPDATE_REQUIRED");
+        }
+        if (result === "timeout") {
+            return check("review-targets", "FAIL", `${target} did not answer in time. Re-run: ` +
+                "agent-ops doctor --check-auth", "UPDATE_REQUIRED");
+        }
+        if (checkAuth && result !== "ok") {
+            return check("review-targets", "FAIL", `${target} is installed but not authenticated, or it rejected the ` +
+                `call. Run: ${target} login`, "UPDATE_REQUIRED");
+        }
+    }
+    return check("review-targets", "PASS", checkAuth
+        ? `External review targets authenticated: ${targets.join(", ")}.`
+        : `External review targets: ${targets.join(", ")}. ` +
+            "Login state unverified; run: agent-ops doctor --check-auth");
+}
 export async function doctorInstallation(options) {
     const manifest = await checkManifest(options.root);
     const config = await checkConfig(options.root);
@@ -355,7 +395,8 @@ export async function doctorInstallation(options) {
         await checkProbe("hook-registration", options.probes?.hookRegistration),
         checkLifecycleSummary(manifest.manifest, config.config),
         await checkProbe("repository-trust", options.probes?.repositoryTrust),
-        await checkProbe("smoke-availability", options.probes?.smokeAvailability)
+        await checkProbe("smoke-availability", options.probes?.smokeAvailability),
+        await checkReviewTargets(config.config, options.probes?.reviewTarget, options.checkReviewTargetAuth === true)
     ];
     return {
         checks,

package/dist/runtime/src/install/plan.js

@@ -40,7 +40,12 @@ async function readCurrentFile(root, path) {
         throw error;
     }
 }
-function formatConfig(profiles, existing) {
+function formatConfig(profiles, existing, reviewTargets = []) {
+    // Absent reviewRoles means external review is disabled; an empty selection
+    // must therefore omit the field rather than write an empty array.
+    const reviewRoles = reviewTargets.length > 0
+        ? [{ role: "independent-review", targets: [...reviewTargets] }]
+        : existing?.reviewRoles;
     return `${JSON.stringify({
         schemaVersion: CONFIG_SCHEMA_VERSION,
         profiles,
@@ -51,10 +56,11 @@ function formatConfig(profiles, existing) {
             }
         },
         pathMappings: existing?.pathMappings ?? [],
-        securityExceptions: existing?.securityExceptions ?? []
+        securityExceptions: existing?.securityExceptions ?? [],
+        ...(reviewRoles === undefined ? {} : { reviewRoles })
     }, null, 2)}\n`;
 }
-async function planConfig(root, profiles, existingManifest, suppliedConfig) {
+async function planConfig(root, profiles, existingManifest, suppliedConfig, reviewTargets = []) {
     const current = await readCurrentFile(root, CONFIG_PATH);
     const owned = findOwnedArtifact(existingManifest, CONFIG_PATH);
     if (current !== null && owned === undefined) {
@@ -86,7 +92,7 @@ async function planConfig(root, profiles, existingManifest, suppliedConfig) {
         }
         existingConfig = result.value;
     }
-    const content = formatConfig(profiles, existingConfig);
+    const content = formatConfig(profiles, existingConfig, reviewTargets);
     return {
         operation: {
             kind: "write",
@@ -413,7 +419,7 @@ export async function createInstallPlan(options) {
         : [];
     const operations = [];
     const artifacts = [];
-    const config = await planConfig(options.root, resolved.profiles, existing?.manifest ?? null, options.existingConfig);
+    const config = await planConfig(options.root, resolved.profiles, existing?.manifest ?? null, options.existingConfig, options.reviewTargets ?? []);
     operations.push(config.operation);
     artifacts.push(config.record);
     for (const artifact of contribution.artifacts) {

package/dist/runtime/src/review/execute.js

@@ -0,0 +1,180 @@
+import { mkdtemp, realpath, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { runVerificationCommand } from "../verify/spawn.js";
+import { extractReviewObject } from "./extract.js";
+import { buildTargetInvocation } from "./invocation.js";
+import { reviewReportResults, reviewReportStatus, validateReviewReport } from "./report.js";
+import { detectHostTarget, orderChain } from "./roles.js";
+import { buildReviewPrompt } from "./runner.js";
+/**
+ * Deliberately below the five-minute `spawn.ts` default: a timeout advances the
+ * chain, so the worst case is targets x timeout.
+ */
+export const DEFAULT_REVIEW_TIMEOUT_MS = 120_000;
+const EXECUTION_ENV = [
+    "PATH", "PATHEXT", "SystemRoot", "SYSTEMROOT", "WINDIR", "COMSPEC",
+    "LANG", "LC_ALL", "TERM", "TMPDIR", "TEMP", "TMP"
+];
+const AUTH_ENV = {
+    claude: ["ANTHROPIC_API_KEY", "CLAUDE_CODE_OAUTH_TOKEN"],
+    codex: ["OPENAI_API_KEY"],
+    agy: ["AGY_API_KEY"]
+};
+export function isolatedReviewEnvironment(target, directory, source) {
+    const env = {};
+    for (const key of [...EXECUTION_ENV, ...AUTH_ENV[target]]) {
+        const value = source[key];
+        if (value !== undefined) {
+            env[key] = value;
+        }
+    }
+    env.HOME = directory;
+    env.USERPROFILE = directory;
+    env.XDG_CONFIG_HOME = join(directory, "config");
+    env.XDG_CACHE_HOME = join(directory, "cache");
+    return env;
+}
+/** Codex and agy currently lack documented instruction/customization isolation. */
+export function hasRequiredReviewIsolation(target) {
+    return target === "claude";
+}
+const REQUIRED_HELP_FLAGS = {
+    claude: [
+        "--add-dir", "--permission-mode", "--no-session-persistence",
+        "--safe-mode", "--disable-slash-commands", "--json-schema"
+    ],
+    codex: [],
+    agy: []
+};
+/**
+ * Failure classes that mean no review happened, so trying the next target is
+ * not review shopping. Everything else — including FAIL — is terminal.
+ */
+const ADVANCING = new Set([
+    "missing-executable",
+    "spawn-failed",
+    "timeout"
+]);
+/**
+ * Builds the `execute` callback `runIndependentReview` expects: walk the
+ * configured targets in order and return the first real verdict.
+ */
+export function createReviewExecutor(options) {
+    const report = options.onProgress ?? (() => { });
+    const host = detectHostTarget(options.env ?? process.env);
+    const chain = orderChain(options.targets, host);
+    return async (request) => {
+        const expected = request.invocation.packet.criteria.map((criterion) => criterion.id);
+        const prompt = buildReviewPrompt(request.invocation);
+        const repositoryRoot = await realpath(options.cwd);
+        let unavailable = false;
+        for (const [index, target] of chain.entries()) {
+            if (!hasRequiredReviewIsolation(target)) {
+                unavailable = true;
+                report(`${target}: required context-isolation controls unavailable → skipping`);
+                continue;
+            }
+            const attemptDirectory = await mkdtemp(join(tmpdir(), "agent-ops-review-"));
+            try {
+                const invocation = buildTargetInvocation({
+                    target,
+                    prompt,
+                    repositoryRoot,
+                    ...(options.model === undefined ? {} : { model: options.model }),
+                    ...(options.effort === undefined ? {} : { effort: options.effort })
+                });
+                if (invocation === undefined) {
+                    unavailable = true;
+                    report(`${target}: no read-only mode available → skipping`);
+                    continue;
+                }
+                if (target === host) {
+                    report(`${target}: reviewer == host; no independent target configured`);
+                }
+                const environment = isolatedReviewEnvironment(target, attemptDirectory, options.env ?? process.env);
+                const capability = await runVerificationCommand({
+                    id: `review-capability-${target}-${index}`,
+                    command: invocation.command,
+                    args: ["--help"],
+                    cwd: attemptDirectory,
+                    required: true,
+                    evidence: { kind: "exit-code" },
+                    timeoutMs: Math.min(options.timeoutMs ?? DEFAULT_REVIEW_TIMEOUT_MS, 10_000)
+                }, {
+                    cwd: attemptDirectory,
+                    ...(options.runner === undefined ? {} : { runner: options.runner }),
+                    env: environment,
+                    replaceEnv: true
+                });
+                if (capability.status !== "PASS" ||
+                    capability.stdoutTruncated ||
+                    capability.stderrTruncated ||
+                    REQUIRED_HELP_FLAGS[target].some((flag) => !capability.stdout.includes(flag))) {
+                    unavailable = true;
+                    report(`${target}: required CLI capabilities unavailable → skipping`);
+                    continue;
+                }
+                const spawned = await runVerificationCommand({
+                    id: `review-${target}-${index}`,
+                    command: invocation.command,
+                    args: [...invocation.args],
+                    cwd: attemptDirectory,
+                    required: true,
+                    evidence: { kind: "exit-code" },
+                    timeoutMs: options.timeoutMs ?? DEFAULT_REVIEW_TIMEOUT_MS
+                }, {
+                    cwd: attemptDirectory,
+                    ...(options.runner === undefined ? {} : { runner: options.runner }),
+                    ...(options.outputLimitBytes === undefined
+                        ? {}
+                        : { outputLimitBytes: options.outputLimitBytes }),
+                    stdin: invocation.stdin,
+                    env: environment,
+                    replaceEnv: true
+                });
+                if (ADVANCING.has(spawned.failureClass)) {
+                    report(`${target}: ${spawned.failureClass} → trying next target`);
+                    continue;
+                }
+                if (spawned.stdoutTruncated || spawned.stderrTruncated) {
+                    return { status: "NOT_RUN", reason: "output-too-large", harness: target };
+                }
+                const payload = extractReviewObject(target, spawned.stdout);
+                const parsed = payload === undefined
+                    ? undefined
+                    : validateReviewReport(payload, expected, request.invocation.scope?.changedFiles);
+                if (parsed === undefined || !parsed.ok) {
+                    return {
+                        status: "NOT_RUN",
+                        reason: parsed?.errors.some((error) => error.code === "INCOMPLETE_SCOPE")
+                            ? "incomplete-scope"
+                            : "unparseable-output",
+                        harness: target,
+                        ...(parsed === undefined ? {} : { validationErrors: parsed.errors })
+                    };
+                }
+                const reportValue = parsed.value;
+                const results = reviewReportResults(reportValue);
+                return {
+                    status: reviewReportStatus(reportValue),
+                    results,
+                    report: reportValue,
+                    harness: target,
+                    independence: host === undefined
+                        ? "unknown"
+                        : host === target
+                            ? "same-target"
+                            : "different-target"
+                };
+            }
+            finally {
+                await rm(attemptDirectory, { recursive: true, force: true });
+            }
+        }
+        return {
+            status: "NOT_RUN",
+            reason: unavailable ? "capability-unavailable" : "missing-cli"
+        };
+    };
+}

package/dist/runtime/src/review/extract.js

@@ -0,0 +1,69 @@
+/**
+ * The key holding the model's answer differs in every envelope, so every
+ * target gets its own branch. Verified against tests/fixtures/review/.
+ */
+const ENVELOPE_KEYS = {
+    agy: "response",
+    claude: "result"
+};
+function parseObject(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+        ? parsed
+        : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+ * The model's answer as text, before any JSON contract is applied. Returns
+ * undefined rather than throwing so the caller can report
+ * `unparseable-output` for every transport failure through one path.
+ */
+export function extractFinalMessage(target, stdout) {
+    const key = ENVELOPE_KEYS[target];
+    if (key === undefined) {
+        // codex: stdout is the final message itself.
+        const trimmed = stdout.trim();
+        return trimmed.length === 0 ? undefined : trimmed;
+    }
+    const envelope = parseObject(stdout);
+    const value = envelope?.[key];
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length === 0 ? undefined : trimmed;
+}
+/**
+ * The last balanced JSON object in a block of model text. Scanning backwards
+ * matters: models often restate the schema before answering, and the answer is
+ * what comes last. This only ever runs on the extracted final message, never on
+ * raw stdout, so it cannot capture a transport envelope.
+ */
+export function extractJsonObject(text) {
+    return parseObject(text.trim());
+}
+/**
+ * Review results use a strict native structured-output transport. Unlike the
+ * legacy probe parser above, this path neither recovers fenced JSON nor accepts
+ * a provider's generic text result field.
+ */
+export function extractReviewObject(target, stdout) {
+    if (target === "codex") {
+        return extractJsonObject(stdout);
+    }
+    const envelope = parseObject(stdout);
+    const key = target === "claude" ? "structured_output" : "response";
+    const value = envelope?.[key];
+    if (isRecord(value)) {
+        return value;
+    }
+    return typeof value === "string" ? extractJsonObject(value) : undefined;
+}

package/dist/runtime/src/review/invocation.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+function reviewSchemaPath() {
+    const packaged = fileURLToPath(new URL("../../../../schemas/review-report.schema.json", import.meta.url));
+    if (existsSync(packaged)) {
+        return packaged;
+    }
+    const source = fileURLToPath(new URL("../../../schemas/review-report.schema.json", import.meta.url));
+    return existsSync(source)
+        ? source
+        : resolve(process.cwd(), "schemas", "review-report.schema.json");
+}
+function reviewSchemaText() {
+    return readFileSync(reviewSchemaPath(), "utf8");
+}
+/**
+ * Read-only enforcement per target, verified against each CLI's own help
+ * output. A target absent from this table is ineligible: review never runs an
+ * agent that can edit the code it is reviewing. This is what excludes
+ * opencode, whose `--agent plan` is rejected as a subagent and silently falls
+ * back to a writable agent.
+ */
+export const READ_ONLY_ARGS = {
+    agy: ["--sandbox", "--mode", "plan"],
+    claude: ["--permission-mode", "plan"],
+    codex: ["-s", "read-only"]
+};
+function modelArgs(target, model) {
+    if (model === undefined) {
+        return [];
+    }
+    return target === "codex" ? ["-m", model] : ["--model", model];
+}
+function effortArgs(target, effort) {
+    if (effort === undefined) {
+        return [];
+    }
+    // codex has no --effort flag; reasoning effort is a config override.
+    return target === "codex"
+        ? ["-c", `model_reasoning_effort=${effort}`]
+        : ["--effort", effort];
+}
+export function buildTargetInvocation(request) {
+    const readOnly = READ_ONLY_ARGS[request.target];
+    if (readOnly === undefined || readOnly.length === 0) {
+        return undefined;
+    }
+    const shared = [
+        ...readOnly,
+        ...modelArgs(request.target, request.model),
+        ...effortArgs(request.target, request.effort)
+    ];
+    if (request.target === "codex") {
+        // codex writes progress to stderr and leaves stdout as the bare final
+        // message, so it needs no output-format flag and no scratch file.
+        // Without --skip-git-repo-check it refuses to run outside a trusted git
+        // directory, which a caller would otherwise read as "not authenticated".
+        return {
+            command: "codex",
+            args: [
+                "exec",
+                "-",
+                "--skip-git-repo-check",
+                "--output-schema",
+                reviewSchemaPath(),
+                ...(request.repositoryRoot === undefined
+                    ? []
+                    : ["--add-dir", request.repositoryRoot, "--ephemeral", "--ignore-rules"]),
+                ...shared
+            ],
+            stdin: request.prompt
+        };
+    }
+    const isolation = request.target === "claude"
+        ? ["--no-session-persistence", "--safe-mode", "--disable-slash-commands"]
+        : [];
+    return {
+        command: request.target,
+        args: [
+            "-p",
+            "--output-format",
+            "json",
+            "--json-schema",
+            reviewSchemaText(),
+            ...(request.repositoryRoot === undefined
+                ? []
+                : ["--add-dir", request.repositoryRoot]),
+            ...isolation,
+            ...shared
+        ],
+        stdin: request.prompt
+    };
+}
+/** A deep doctor probe uses stdin but keeps its simple text response contract. */
+export function buildProbeInvocation(request) {
+    const readOnly = READ_ONLY_ARGS[request.target];
+    if (readOnly === undefined || readOnly.length === 0) {
+        return undefined;
+    }
+    if (request.target === "codex") {
+        return {
+            command: "codex",
+            args: ["exec", "-", "--skip-git-repo-check", ...readOnly],
+            stdin: request.prompt
+        };
+    }
+    const isolation = request.target === "claude"
+        ? ["--no-session-persistence", "--safe-mode", "--disable-slash-commands"]
+        : [];
+    return {
+        command: request.target,
+        args: ["-p", "--output-format", "json", ...isolation, ...readOnly],
+        stdin: request.prompt
+    };
+}

package/dist/runtime/src/review/packet.js

@@ -1,10 +1,47 @@
+const MAX_PACKET_BYTES = 64 * 1024;
+function safe(value) {
+    return safeTaskText(redactSecrets(value));
+}
+function checkSensitive(value) {
+    const decision = evaluateGuardrail({
+        kind: "content",
+        content: value,
+        scope: "review-packet"
+    });
+    if (decision.action === "block") {
+        throw new AgentOpsError("REVIEW_SENSITIVE_INPUT", "Review input contains credential-shaped content.");
+    }
+}
 export function buildReviewPacket(input) {
-    return {
-        request: input.request,
-        criteria: input.criteria.map((criterion) => ({ ...criterion })),
-        artifactRefs: [...input.artifactRefs],
+    for (const value of [
+        input.request,
+        ...input.criteria.flatMap((criterion) => [criterion.id, criterion.description, ...(criterion.verifierIds ?? [])]),
+        ...input.artifactRefs,
+        ...input.evidenceRequirements.flatMap((requirement) => [requirement.criterionId, requirement.requirement])
+    ]) {
+        checkSensitive(value);
+    }
+    const packet = {
+        request: safe(input.request),
+        criteria: input.criteria.map((criterion) => ({
+            id: safe(criterion.id),
+            description: safe(criterion.description),
+            ...(criterion.verifierIds === undefined
+                ? {}
+                : { verifierIds: criterion.verifierIds.map(safe) })
+        })),
+        artifactRefs: input.artifactRefs.map(safe),
         evidenceRequirements: input.evidenceRequirements.map((requirement) => ({
-            ...requirement
+            criterionId: safe(requirement.criterionId),
+            requirement: safe(requirement.requirement)
         }))
     };
+    if (Buffer.byteLength(JSON.stringify(packet), "utf8") > MAX_PACKET_BYTES) {
+        throw new AgentOpsError("REVIEW_SCOPE_TOO_LARGE", "Review packet exceeds the 64 KiB limit.");
+    }
+    return packet;
 }
+import { evaluateGuardrail } from "../guardrails/evaluate.js";
+import { AgentOpsError } from "../fs/paths.js";
+import { redactSecrets } from "../security/redact.js";
+import { safeTaskText } from "../task/render.js";

package/dist/runtime/src/review/probe.js

@@ -0,0 +1,72 @@
+import { runVerificationCommand } from "../verify/spawn.js";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { extractFinalMessage } from "./extract.js";
+import { hasRequiredReviewIsolation, isolatedReviewEnvironment } from "./execute.js";
+import { buildProbeInvocation } from "./invocation.js";
+const PROBE_PROMPT = "Reply with the single word OK and nothing else.";
+/**
+ * Matches the review timeout rather than being "quick": codex at high
+ * reasoning effort answers a trivial prompt in ~20s, and a probe that times out
+ * would otherwise be reported as an authentication failure.
+ */
+const PROBE_TIMEOUT_MS = 120_000;
+/**
+ * The only check that actually proves a target is usable: ask it something
+ * trivial and see whether an answer comes back. A credential-file check can
+ * pass while the token is expired, and self-declaration ("already logged in?")
+ * is not evidence at all.
+ */
+export async function probeReviewTarget(target, options) {
+    const deep = options.deep === true;
+    if (deep && !hasRequiredReviewIsolation(target)) {
+        return "ineligible";
+    }
+    const invocation = buildProbeInvocation({ target, prompt: PROBE_PROMPT });
+    if (invocation === undefined) {
+        return "ineligible";
+    }
+    const directory = deep
+        ? await mkdtemp(join(tmpdir(), "agent-ops-review-probe-"))
+        : options.cwd;
+    try {
+        const spawned = await runVerificationCommand({
+            id: `review-probe-${target}`,
+            command: invocation.command,
+            args: deep ? [...invocation.args] : ["--version"],
+            cwd: directory,
+            required: true,
+            evidence: { kind: "exit-code" },
+            timeoutMs: options.timeoutMs ?? PROBE_TIMEOUT_MS
+        }, {
+            cwd: directory,
+            ...(options.runner === undefined ? {} : { runner: options.runner }),
+            ...(deep
+                ? {
+                    stdin: invocation.stdin,
+                    env: isolatedReviewEnvironment(target, directory, process.env),
+                    replaceEnv: true
+                }
+                : {})
+        });
+        if (spawned.failureClass === "missing-executable") {
+            return "missing-executable";
+        }
+        if (spawned.timedOut) {
+            return "timeout";
+        }
+        if (!deep) {
+            return spawned.status === "PASS" ? "ok" : "unauthenticated";
+        }
+        return spawned.status === "PASS" &&
+            extractFinalMessage(target, spawned.stdout) !== undefined
+            ? "ok"
+            : "unauthenticated";
+    }
+    finally {
+        if (deep) {
+            await rm(directory, { recursive: true, force: true });
+        }
+    }
+}

package/dist/runtime/src/review/render.js

@@ -0,0 +1,62 @@
+import { redactSecrets } from "../security/redact.js";
+import { safeTaskText } from "../task/render.js";
+function safe(value) {
+    return safeTaskText(redactSecrets(value));
+}
+function lineList(values) {
+    return values.length === 0 ? ["- none"] : values.map((value) => `- ${safe(value)}`);
+}
+export function renderReviewResult(result) {
+    const lines = [
+        `Independent review: ${result.status}`,
+        `Reviewer: ${result.harness}; model: ${safe(result.model)}; effort: ${safe(result.effort)}.`
+    ];
+    if (result.scope !== undefined) {
+        lines.push(result.scope.mode === "base"
+            ? `Scope: ${result.scope.mode} ${safe(result.scope.baseRef)} (${safe(result.scope.resolvedBase)}).`
+            : "Scope: worktree.");
+    }
+    if (result.independence !== undefined) {
+        lines.push(`Independence: ${result.independence}.`);
+    }
+    if (result.verification !== undefined) {
+        lines.push("Machine verification:");
+        for (const command of result.verification.commands) {
+            lines.push(`- ${safe(command.criterionId)}/${safe(command.commandId)}: ${command.status}` +
+                `${command.required ? " (required)" : " (optional)"}` +
+                `${command.evidenceReference === undefined ? "" : ` — ${safe(command.evidenceReference)}`}`);
+        }
+    }
+    if (result.report === undefined) {
+        lines.push(`Reason: ${result.reason ?? "unknown"}.`);
+        for (const error of result.validationErrors ?? []) {
+            lines.push(`- ${safe(error.path)}: ${safe(error.code)} — ${safe(error.message)}`);
+        }
+        lines.push("Run: agent-ops doctor --check-auth to verify target authentication.");
+        return `${lines.join("\n")}\n`;
+    }
+    const report = result.report;
+    const nonBlocking = report.findings.filter((finding) => !finding.blocking).length;
+    lines.push(`Non-blocking findings: ${nonBlocking}.`, "", "Summary:", safe(report.summary), "", "Criteria:");
+    for (const item of report.results) {
+        lines.push(`- ${safe(item.criterionId)}: ${item.status} — ${safe(item.summary)}`);
+        lines.push(...item.evidence.map((evidence) => `  - ${safe(evidence)}`));
+    }
+    lines.push("", "Findings:");
+    if (report.findings.length === 0) {
+        lines.push("- none");
+    }
+    else {
+        for (const finding of report.findings) {
+            lines.push(`- [${finding.severity}] ${finding.blocking ? "blocking" : "non-blocking"}: ${safe(finding.title)}`);
+            lines.push(`  ${safe(finding.details)}`);
+            lines.push(`  Recommendation: ${safe(finding.recommendation)}`);
+            lines.push(...finding.locations.map((location) => `  Location: ${safe(location.path)}${location.line === undefined ? "" : `:${location.line}`}`));
+            lines.push(...finding.evidence.map((evidence) => `  Evidence: ${safe(evidence)}`));
+        }
+    }
+    lines.push("", "Residual risks:", ...lineList(report.residualRisks));
+    lines.push("", "Changed files inspected:", ...lineList(report.changedFilesInspected));
+    lines.push("", "Supporting files inspected:", ...lineList(report.supportingFilesInspected));
+    return `${lines.join("\n")}\n`;
+}