glm-coding-router 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 hieu9721
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,248 @@
+# GLM Coding Router
+
+GLM Coding Plan workers for Claude Code and Codex, on Windows.
+
+Claude Code and Codex stay your orchestrators — they keep responsibility for requirements,
+architecture, review, and integration. `glm-coding-router` delegates well-scoped
+implementation work (exploration, CRUD, boilerplate, tests, mechanical refactoring) to
+GLM workers via Z.ai's Anthropic-compatible endpoint.
+
+One global npm install replaces the manual `.cmd` shim setup:
+
+```text
+Claude / Codex → shell → glm-worker → claude.exe harness → Z.ai endpoint → GLM Coding Plan
+```
+
+## Architecture
+
+```text
+                         Developer
+                             │
+             ┌───────────────┴───────────────┐
+             ▼                               ▼
+       Claude Code                         Codex
+             │                               │
+             └───────────────┬───────────────┘
+                        shell command
+                             │
+             ┌───────────────┼───────────────┐
+             ▼               ▼               ▼
+         glm-chat        glm-worker      glm-review
+             │               │               │
+             └───────────────┼───────────────┘
+                        claude.exe
+              (injected environment only)
+                             │
+                             ▼
+              https://api.z.ai/api/anthropic
+                             │
+                             ▼
+                    GLM Coding Plan
+                    GLM-5.3 / GLM-5.3-Flash
+```
+
+## Requirements
+
+- Windows 10/11 (v0.1; Linux/macOS planned for v0.2)
+- Node.js >= 20
+- Claude Code (`claude.exe`) — the GLM commands run on the Claude Code harness
+- Codex (optional — Claude-only setups are fully supported)
+- A Z.ai Coding Plan API key
+
+No Anthropic pay-as-you-go, no OpenAI API, no LiteLLM, no proxy.
+
+## Installation
+
+```powershell
+npm install -g glm-coding-router
+glm-router init
+```
+
+`npx glm-coding-router init` also works for a one-off check, but the global install is
+what puts `glm-worker` on your PATH long-term.
+
+## Quick start
+
+After `glm-router init`:
+
+```powershell
+glm-chat
+glm-worker "Implement validation and add tests"
+glm-review "Analyze the auth module"
+```
+
+## glm-chat
+
+Interactive GLM-backed Claude Code session. Resolves the Z.ai key, locates `claude.exe`,
+injects the Z.ai environment **into the child process only**, and spawns it with
+pass-through arguments:
+
+```powershell
+glm-chat
+glm-chat --version
+glm-chat --any-claude-flag
+```
+
+Your normal `claude` command and its authentication are untouched.
+
+## glm-worker
+
+Headless implementation worker:
+
+```powershell
+glm-worker "Implement validation and add tests"
+```
+
+Or via stdin (a structured task packet):
+
+```powershell
+@"
+TASK:
+Implement refresh token validation.
+
+SCOPE:
+internal/auth/
+
+VALIDATION:
+go test ./internal/auth/...
+"@ | glm-worker
+```
+
+Input priority: **stdin → arguments → error**. The worker runs with
+`--max-turns 20 --permission-mode acceptEdits --tools Read,Glob,Grep,Edit,Write,Bash`.
+It never uses `--dangerously-skip-permissions`.
+
+## glm-review
+
+Read-only worker for repository exploration, call-graph discovery, duplicate detection,
+dependency inspection, and preliminary review:
+
+```powershell
+glm-review "Inspect this repository"
+```
+
+Runs with `--tools Read,Glob,Grep` — it cannot edit files or run commands.
+
+## CLI reference
+
+```text
+glm-router init              guided setup
+glm-router doctor [--network]  full runtime diagnosis
+glm-router status            quick offline overview
+glm-router key set           store ZAI_API_KEY (Windows User Environment)
+glm-router key check         key configured? from which source?
+glm-router config show
+glm-router config set models.main glm-5.3
+glm-router project init      CLAUDE.md / AGENTS.md managed blocks (--dry-run supported)
+glm-router project remove
+glm-router skill install     optional Codex delegation skill
+glm-router skill remove
+glm-router uninstall         guided removal (keeps ZAI_API_KEY by default)
+```
+
+Global flags: `--json --quiet --verbose --dry-run --force --yes`
+
+## Claude integration
+
+`glm-router project init` adds a **managed block** to `CLAUDE.md` at the project root
+(`git rev-parse --show-toplevel`, falling back to cwd):
+
+```text
+<!-- glm-coding-router:start -->
+... delegation policy ...
+<!-- glm-coding-router:end -->
+```
+
+- Everything outside the markers is preserved; existing blocks are replaced in place;
+  runs are idempotent and never duplicate.
+- Files are updated atomically (tmp file → fsync → rename).
+- On a malformed marker pair the file is left untouched with an actionable error.
+- CRLF/LF and UTF-8 are preserved.
+- `glm-router project remove` deletes only the managed block. A file the router
+  created entirely is deleted only when it would otherwise be empty.
+
+## Codex integration
+
+The same command updates `AGENTS.md` (Codex's repository instruction file) with an
+equivalent managed block. Additionally, `glm-router skill install` installs the optional
+`glm-delegation` skill to `~/.codex/skills/glm-delegation/SKILL.md`. If Codex is not
+detected, the skill step warns and skips — AGENTS.md integration and the core tool are
+unaffected.
+
+## Orca behavior (stale environments)
+
+Terminals embedded in Orca snapshot the Windows environment at startup. A key added
+after Orca starts is invisible to those terminals. Every GLM command therefore resolves
+the key in this order:
+
+1. `process.env.ZAI_API_KEY`
+2. Windows User Environment (via PowerShell)
+3. fail with an actionable error
+
+The key is never cached to disk.
+
+## Security model
+
+- The key lives only in the Windows User Environment; it is never written to
+  `config.json`, the repo, logs, or stack traces. Debug output redacts
+  `ZAI_API_KEY`, `ANTHROPIC_AUTH_TOKEN`, and Authorization headers.
+- Z.ai routing environment variables (`ANTHROPIC_AUTH_TOKEN`,
+  `ANTHROPIC_BASE_URL`, model overrides) are injected **only** into the spawned
+  `claude.exe` child process. `ANTHROPIC_API_KEY` is blanked in the child so your
+  normal Claude auth is never in play. `ANTHROPIC_BASE_URL` is never persisted globally.
+- Claude Code and Codex global authentication are never modified.
+- Child processes are spawned with argument arrays (`shell: false`) — prompts with
+  quotes, pipes, ampersands, or newlines are passed verbatim, never through a shell.
+- No telemetry, no automatic git commits.
+
+## Troubleshooting
+
+| Symptom | Fix |
+| --- | --- |
+| `ERROR [ZAI_KEY_MISSING]` | `glm-router key set`, then open a **new** terminal |
+| `ERROR [CLAUDE_NOT_FOUND]` | Install Claude Code, or `glm-router config set claudePath C:\path\to\claude.exe` |
+| Key works in a new terminal but not inside Orca | Expected — workers re-read the Windows User Environment automatically; run `glm-router doctor` to confirm |
+| `glm-*` not on PATH after install | Reopen the terminal; check `npm config get prefix` is on PATH |
+| `ERROR [MANAGED_BLOCK_CORRUPT]` | Fix the marker pair in the named file manually, then re-run |
+
+Run `glm-router doctor` (add `--network` to probe the Z.ai endpoint) for a full diagnosis.
+
+## Uninstall
+
+```powershell
+glm-router uninstall
+```
+
+The wizard removes the config, the Codex skill, and optionally the current project
+integration. `ZAI_API_KEY` is **kept** by default — removing credentials requires
+explicit consent. Finish with `npm uninstall -g glm-coding-router`.
+
+## Development
+
+```powershell
+npm install
+npm run build      # tsc → dist/
+npm test           # vitest run
+npm run lint       # eslint src tests
+npm run dev        # tsx src/cli.ts <args>
+```
+
+Integration tests spawn `tests/fixtures/fake-agent.mjs` (via `node.exe`) to verify
+argument passing, environment injection, and exit-code propagation without spending
+API quota. See the `GLM Coding Router — Technical Specification v0.1.md` for the full
+v0.1 contract (exit codes, managed-block test matrix, acceptance criteria).
+
+## Publishing
+
+```powershell
+npm run build
+npm test
+npm publish
+```
+
+`prepublishOnly` runs build + tests. The package ships only `dist/`; the four binaries
+(`glm-router`, `glm-chat`, `glm-worker`, `glm-review`) are declared in `bin`.
+
+## License
+
+MIT

package/dist/bin/glm-chat.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { loadConfig } from "../core/config.js";
+import { locateClaude } from "../core/claude.js";
+import { createGlmEnv } from "../core/env.js";
+import { Errors, formatGlmError, GlmRouterError } from "../core/errors.js";
+import { isMainModule } from "../core/main-guard.js";
+import { logger, redact } from "../core/logging.js";
+import { spawnAgent } from "../core/process.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+/**
+ * glm-chat (spec §14): resolve key → detect claude.exe → inject Z.ai env →
+ * spawn claude interactively with pass-through arguments.
+ */
+export async function runChat(argv) {
+    const config = loadConfig();
+    const resolved = resolveZaiApiKey();
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    const claudePath = locateClaude(config);
+    const env = createGlmEnv(config, resolved.key);
+    logger.debug(`spawning ${claudePath}`);
+    logger.debug(redact(`env ANTHROPIC_BASE_URL=${env.ANTHROPIC_BASE_URL}`, [resolved.key]));
+    return spawnAgent(claudePath, {
+        args: [...argv],
+        cwd: process.cwd(),
+        env,
+        interactive: true,
+    });
+}
+if (isMainModule(import.meta.url)) {
+    runChat(process.argv.slice(2)).then((code) => process.exit(code), (error) => {
+        if (error instanceof GlmRouterError) {
+            process.stderr.write(formatGlmError(error) + "\n");
+            process.exit(error.exitCode);
+        }
+        process.stderr.write(String(error) + "\n");
+        process.exit(1);
+    });
+}

package/dist/bin/glm-review.js

@@ -0,0 +1,47 @@
+#!/usr/bin/env node
+import { loadConfig } from "../core/config.js";
+import { locateClaude } from "../core/claude.js";
+import { createGlmEnv } from "../core/env.js";
+import { Errors, formatGlmError, GlmRouterError } from "../core/errors.js";
+import { isMainModule } from "../core/main-guard.js";
+import { logger, redact } from "../core/logging.js";
+import { readStdin, resolvePrompt } from "../core/prompt.js";
+import { spawnAgent } from "../core/process.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+/** Read-only review surface (spec §17) — no Edit, Write, or Bash. */
+export const REVIEW_TOOLS = "Read,Glob,Grep";
+export function buildReviewArgs(prompt, config) {
+    return ["-p", prompt, "--max-turns", String(config.review.maxTurns), "--tools", REVIEW_TOOLS];
+}
+/**
+ * glm-review (spec §17): read-only worker for exploration, call-graph
+ * discovery, duplicate detection, dependency inspection, and review.
+ */
+export async function runReview(argv) {
+    const prompt = await resolvePrompt(argv, readStdin, "glm-review");
+    const config = loadConfig();
+    const resolved = resolveZaiApiKey();
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    const claudePath = locateClaude(config);
+    const args = buildReviewArgs(prompt, config);
+    const env = createGlmEnv(config, resolved.key);
+    logger.debug(redact(`spawning ${claudePath} ${args.join(" ")}`, [resolved.key]));
+    return spawnAgent(claudePath, {
+        args,
+        cwd: process.cwd(),
+        env,
+        interactive: false,
+    });
+}
+if (isMainModule(import.meta.url)) {
+    runReview(process.argv.slice(2)).then((code) => process.exit(code), (error) => {
+        if (error instanceof GlmRouterError) {
+            process.stderr.write(formatGlmError(error) + "\n");
+            process.exit(error.exitCode);
+        }
+        process.stderr.write(String(error) + "\n");
+        process.exit(1);
+    });
+}

package/dist/bin/glm-worker.js

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+import { loadConfig } from "../core/config.js";
+import { locateClaude } from "../core/claude.js";
+import { createGlmEnv } from "../core/env.js";
+import { Errors, formatGlmError, GlmRouterError } from "../core/errors.js";
+import { isMainModule } from "../core/main-guard.js";
+import { logger, redact } from "../core/logging.js";
+import { resolvePrompt } from "../core/prompt.js";
+import { spawnAgent } from "../core/process.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+/** Worker tool surface (spec §16). */
+export const WORKER_TOOLS = "Read,Glob,Grep,Edit,Write,Bash";
+export function buildWorkerArgs(prompt, config) {
+    return [
+        "-p",
+        prompt,
+        "--max-turns",
+        String(config.worker.maxTurns),
+        "--permission-mode",
+        "acceptEdits",
+        "--tools",
+        WORKER_TOOLS,
+    ];
+}
+/**
+ * glm-worker (spec §15, §16): headless implementation worker.
+ * Prompt priority: stdin → arguments → error. Never uses
+ * --dangerously-skip-permissions.
+ */
+export async function runWorker(argv) {
+    const prompt = await resolvePrompt(argv);
+    const config = loadConfig();
+    const resolved = resolveZaiApiKey();
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    const claudePath = locateClaude(config);
+    const args = buildWorkerArgs(prompt, config);
+    const env = createGlmEnv(config, resolved.key);
+    logger.debug(redact(`spawning ${claudePath} ${args.join(" ")}`, [resolved.key]));
+    return spawnAgent(claudePath, {
+        args,
+        cwd: process.cwd(),
+        env,
+        interactive: false,
+    });
+}
+if (isMainModule(import.meta.url)) {
+    runWorker(process.argv.slice(2)).then((code) => process.exit(code), (error) => {
+        if (error instanceof GlmRouterError) {
+            process.stderr.write(formatGlmError(error) + "\n");
+            process.exit(error.exitCode);
+        }
+        process.stderr.write(String(error) + "\n");
+        process.exit(1);
+    });
+}

package/dist/cli.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { version } from "./core/version.js";
+import { ExitCode } from "./core/errors.js";
+import { isMainModule } from "./core/main-guard.js";
+import { applyGlobalOptions, reportError } from "./commands/context.js";
+import { initCommand } from "./commands/init.js";
+import { doctorCommand } from "./commands/doctor-command.js";
+import { statusCommand } from "./commands/status.js";
+import { keyCheckCommand, keySetCommand } from "./commands/key.js";
+import { configSetCommand, configShowCommand } from "./commands/config.js";
+import { projectInitCommand } from "./commands/project-init.js";
+import { projectRemoveCommand } from "./commands/project-remove.js";
+import { skillInstallCommand, skillRemoveCommand } from "./commands/skill.js";
+import { uninstallCommand } from "./commands/uninstall.js";
+const program = new Command();
+program
+    .name("glm-router")
+    .description("GLM Coding Plan workers for Claude Code and Codex")
+    .version(version);
+program
+    .option("--json", "machine-readable JSON output")
+    .option("--quiet", "suppress non-error output")
+    .option("--verbose", "debug-level output")
+    .option("--dry-run", "preview file modifications without writing")
+    .option("--force", "apply actions even when already done")
+    .option("--yes", "assume defaults for all prompts");
+/** Shared action wrapper: apply global flags, catch errors, set the exit code. */
+async function execute(action) {
+    applyGlobalOptions(globalOptions());
+    try {
+        process.exitCode = await action();
+    }
+    catch (error) {
+        process.exitCode = reportError(error);
+    }
+}
+function globalOptions() {
+    return program.opts();
+}
+program
+    .command("init")
+    .description("guided setup: environment check, key, config, integrations")
+    .action(() => execute(() => initCommand(globalOptions())));
+program
+    .command("doctor")
+    .description("diagnose the full runtime")
+    .option("--network", "also probe Z.ai endpoint reachability")
+    .action((commandOptions) => execute(() => doctorCommand({ ...globalOptions(), ...commandOptions })));
+program
+    .command("status")
+    .description("quick offline status overview")
+    .action(() => execute(() => Promise.resolve(statusCommand(globalOptions()))));
+const key = program.command("key").description("manage the Z.ai Coding Plan API key");
+key
+    .command("set")
+    .description("prompt for and store the key in the Windows User Environment")
+    .action(() => execute(() => keySetCommand(globalOptions())));
+key
+    .command("check")
+    .description("report whether the key is configured and from which source")
+    .action(() => execute(() => Promise.resolve(keyCheckCommand(globalOptions()))));
+const config = program.command("config").description("show or change configuration");
+config
+    .command("show")
+    .description("print the effective configuration")
+    .action(() => execute(() => Promise.resolve(configShowCommand(globalOptions()))));
+config
+    .command("set <key> <value>")
+    .description("set a dotted config value, e.g. models.main glm-5.3")
+    .action((keyPath, value) => execute(() => Promise.resolve(configSetCommand(keyPath, value, globalOptions()))));
+const project = program.command("project").description("per-project CLAUDE.md / AGENTS.md integration");
+project
+    .command("init")
+    .description("create or update the GLM delegation managed blocks")
+    .action(() => execute(() => Promise.resolve(projectInitCommand(globalOptions()))));
+project
+    .command("remove")
+    .description("remove the managed blocks, preserving user content")
+    .action(() => execute(() => Promise.resolve(projectRemoveCommand(globalOptions()))));
+const skill = program.command("skill").description("manage the optional Codex delegation skill");
+skill
+    .command("install")
+    .description("install the glm-delegation skill for Codex")
+    .action(() => execute(() => Promise.resolve(skillInstallCommand(globalOptions()))));
+skill
+    .command("remove")
+    .description("remove the glm-delegation skill")
+    .action(() => execute(() => Promise.resolve(skillRemoveCommand(globalOptions()))));
+program
+    .command("uninstall")
+    .description("guided removal (keeps ZAI_API_KEY by default)")
+    .action(() => execute(() => uninstallCommand(globalOptions())));
+export async function main(argv) {
+    try {
+        // argv is the full process.argv; commander's default "node" origin strips
+        // the executable and script path itself.
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        process.stderr.write(error instanceof Error ? `${error.message}\n` : `${String(error)}\n`);
+        process.exitCode = ExitCode.InvalidArgs;
+    }
+    return Number(process.exitCode ?? ExitCode.Success);
+}
+if (isMainModule(import.meta.url)) {
+    void main(process.argv).then((code) => process.exit(code));
+}

package/dist/commands/config.js

@@ -0,0 +1,39 @@
+import { loadConfig, saveConfig, setConfigValue } from "../core/config.js";
+import { configPath } from "../core/paths.js";
+import { emitJson } from "./context.js";
+/** glm-router config show (spec §28). */
+export function configShowCommand(options) {
+    const config = loadConfig();
+    if (options.json) {
+        emitJson({ path: configPath(), config });
+        return 0;
+    }
+    const lines = [
+        `Provider: Z.ai`,
+        `Main model: ${config.models.main}`,
+        `Fast model: ${config.models.fast}`,
+        "",
+        "Worker:",
+        `  max turns: ${config.worker.maxTurns}`,
+        "",
+        "Review:",
+        `  max turns: ${config.review.maxTurns}`,
+        "",
+        "Integrations:",
+        `  Claude: ${config.integrations.claude ? "enabled" : "disabled"}`,
+        `  Codex: ${config.integrations.codex ? "enabled" : "disabled"}`,
+        `  Codex skill: ${config.integrations.codexSkill ? "enabled" : "disabled"}`,
+        "",
+        `Config file: ${configPath()}`,
+    ];
+    process.stdout.write(lines.join("\n") + "\n");
+    return 0;
+}
+/** glm-router config set <dotted.key> <value> (spec §28). */
+export function configSetCommand(key, value, _options) {
+    const config = loadConfig();
+    const updated = setConfigValue(config, key, value);
+    saveConfig(updated);
+    process.stdout.write(`✓ ${key} = ${value}\n`);
+    return 0;
+}

package/dist/commands/context.js

@@ -0,0 +1,20 @@
+import { ExitCode, formatGlmError, GlmRouterError } from "../core/errors.js";
+import { logger } from "../core/logging.js";
+/** Configure the shared logger from global flags (spec §8, §37). */
+export function applyGlobalOptions(options) {
+    const level = options.verbose ? "debug" : "info";
+    logger.setLevel(level, options.quiet ?? false);
+}
+/** Uniform error reporting for command actions. */
+export function reportError(error) {
+    if (error instanceof GlmRouterError) {
+        process.stderr.write(formatGlmError(error) + "\n");
+        return error.exitCode;
+    }
+    const message = error instanceof Error ? error.stack ?? error.message : String(error);
+    process.stderr.write(`ERROR [INTERNAL]\n\n${message}\n`);
+    return ExitCode.GenericFailure;
+}
+export function emitJson(value) {
+    process.stdout.write(JSON.stringify(value, null, 2) + "\n");
+}

package/dist/commands/doctor-command.js

@@ -0,0 +1,64 @@
+import { runDoctorChecks, doctorHasFailures } from "./doctor.js";
+import { emitJson } from "./context.js";
+import { logger } from "../core/logging.js";
+const SYMBOL = {
+    ok: "✓",
+    warn: "⚠",
+    fail: "✗",
+};
+function renderText(results, networkResult) {
+    const lines = ["GLM Coding Router Doctor", ""];
+    let currentSection = "";
+    for (const result of results) {
+        if (result.section !== currentSection) {
+            currentSection = result.section;
+            lines.push(currentSection);
+        }
+        lines.push(`  ${SYMBOL[result.status]} ${result.name}`);
+        if (result.detail) {
+            lines.push(`      ${result.detail}`);
+        }
+        if (result.note) {
+            lines.push(`      ${result.note}`);
+        }
+    }
+    if (networkResult) {
+        lines.push("Network");
+        lines.push(`  ${networkResult === "reachable" ? "✓" : "⚠"} Z.ai endpoint ${networkResult}`);
+    }
+    const failures = doctorHasFailures(results);
+    lines.push("");
+    lines.push(`Status: ${failures ? "ISSUES DETECTED" : "HEALTHY"}`);
+    return lines.join("\n");
+}
+/** Lightweight endpoint reachability probe (spec §42). Never consumes coding quota. */
+export async function probeEndpoint(baseUrl) {
+    try {
+        const response = await fetch(baseUrl, {
+            method: "GET",
+            signal: AbortSignal.timeout(10_000),
+        });
+        // Any HTTP response proves reachability; auth errors are expected without a key.
+        return response.status < 500 ? "reachable" : `reachable with errors (HTTP ${response.status})`;
+    }
+    catch {
+        return "not reachable";
+    }
+}
+export async function doctorCommand(options) {
+    const report = runDoctorChecks();
+    if (options.json) {
+        emitJson({
+            status: doctorHasFailures(report.results) ? "ISSUES" : "HEALTHY",
+            checks: report.results,
+            keySource: report.keySource,
+        });
+        return doctorHasFailures(report.results) ? 1 : 0;
+    }
+    const networkResult = options.network
+        ? await probeEndpoint(report.config.provider.anthropicBaseUrl)
+        : undefined;
+    process.stdout.write(renderText(report.results, networkResult) + "\n");
+    logger.debug(`anthropic base url: ${report.config.provider.anthropicBaseUrl}`);
+    return doctorHasFailures(report.results) ? 1 : 0;
+}