glm-coding-router 0.5.0 → 1.0.0

package/README.md

@@ -253,6 +253,39 @@ glm-router usage
 
 `--json` emits the same data machine-readably. No key configured → `ERROR [10]`.
 
+## Agent skills (Claude Code + Codex)
+
+`glm-router skill install` writes the `glm-delegation` SKILL.md into **both**
+agent homes — `~/.claude/skills/` and `~/.codex/skills/` — so either
+orchestrator natively knows how to delegate to GLM workers. Missing homes are
+skipped with a note (optional enhancement, never fatal); `skill remove`
+cleans both. `status` shows one skill row per agent.
+
+## MCP server (optional)
+
+`glm-mcp` (installed with the package) exposes the router as MCP tools over
+stdio — any MCP client can delegate without shell syntax:
+
+| Tool | What it does |
+|---|---|
+| `glm_worker(prompt, profile?)` | implementation worker, returns output |
+| `glm_review(prompt, profile?)` | read-only review/exploration |
+| `glm_delegate(name, prompt)` | worker in an isolated git worktree |
+| `glm_usage()` | Z.ai quota windows + local benchmark totals |
+
+Register it with Claude Code (we never edit `~/.claude.json` ourselves — it
+goes through Claude's own CLI):
+
+```powershell
+glm-router mcp             # prints the snippet + the exact command
+glm-router mcp install     # claude mcp add -s user glm-coding-router -- node .../glm-mcp.js
+glm-router mcp remove      # claude mcp remove -s user glm-coding-router
+```
+
+Tool-level failures return `isError` results (missing key, no claude, outside
+a git repo, unreachable endpoint); the server never prints anything to stdout
+except JSON-RPC frames.
+
 ## CLI reference
 
 ```text
@@ -266,6 +299,7 @@ glm-router config set models.main glm-5.3
 glm-router delegate <name>   run a GLM worker in an isolated git worktree
 glm-router benchmark         measure the Claude+GLM stack on built-in tasks
 glm-router usage             Z.ai quota snapshot + local benchmark totals
+glm-router mcp               optional MCP server registration (glm-mcp)
 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

package/dist/bin/glm-mcp.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import readline from "node:readline";
+import { isMainModule } from "../core/main-guard.js";
+import { createMcpServer } from "../mcp/server.js";
+/**
+ * glm-mcp (specs/v1-architecture.md): MCP server over stdio. Responses are
+ * serialized through a write queue so concurrent tool calls can never
+ * interleave frames. Stderr stays free for anything unexpected.
+ */
+if (isMainModule(import.meta.url)) {
+    const server = createMcpServer();
+    const rl = readline.createInterface({ input: process.stdin, terminal: false });
+    let queue = Promise.resolve();
+    rl.on("line", (line) => {
+        queue = queue.then(async () => {
+            const frame = await server.handleLine(line);
+            if (frame !== null) {
+                process.stdout.write(`${frame}\n`);
+            }
+        });
+    });
+    rl.on("close", () => {
+        void queue.then(() => process.exit(0));
+    });
+}

package/dist/cli.js

@@ -16,6 +16,7 @@ import { uninstallCommand } from "./commands/uninstall.js";
 import { delegateCommand } from "./commands/delegate.js";
 import { benchmarkCommand } from "./commands/benchmark.js";
 import { usageCommand } from "./commands/usage.js";
+import { mcpCommand } from "./commands/mcp.js";
 const program = new Command();
 program
     .name("glm-router")
@@ -108,6 +109,18 @@ program
     .command("usage")
     .description("provider usage snapshots: Z.ai Coding Plan quota + local benchmark totals")
     .action(() => execute(() => usageCommand(globalOptions())));
+const mcp = program
+    .command("mcp")
+    .description("optional glm-mcp MCP server: snippet, install, remove")
+    .action(() => execute(() => mcpCommand(globalOptions(), "info")));
+mcp
+    .command("install")
+    .description("register glm-mcp with Claude Code (claude mcp add -s user)")
+    .action(() => execute(() => mcpCommand(globalOptions(), "install")));
+mcp
+    .command("remove")
+    .description("unregister glm-mcp from Claude Code (claude mcp remove -s user)")
+    .action(() => execute(() => mcpCommand(globalOptions(), "remove")));
 program
     .command("uninstall")
     .description("guided removal (keeps ZAI_API_KEY by default)")

package/dist/commands/doctor.js

@@ -6,7 +6,7 @@ import { isWindows, windowsVersionName } from "../core/platform.js";
 import { resolveZaiApiKey } from "../core/zai-key.js";
 import { configPath } from "../core/paths.js";
 import fs from "node:fs";
-import { CodexSkillInstaller } from "../integrations/skill.js";
+import { skillTargets } from "../integrations/skill.js";
 import { GLM_DELEGATION_SKILL_NAME } from "../templates/glm-delegation-skill.js";
 function check(section, name, status, detail, note) {
     return { section, name, status, detail, note };
@@ -71,14 +71,15 @@ export function runDoctorChecks(options = {}) {
     // --- Claude / Codex integrations ---
     results.push(check("Claude", "Integration", config.integrations.claude ? "ok" : "warn", config.integrations.claude ? "enabled" : "disabled in config"));
     results.push(check("Codex", "AGENTS.md integration", config.integrations.codex ? "ok" : "warn", config.integrations.codex ? "enabled" : "disabled in config"));
-    const skillInstaller = new CodexSkillInstaller(home);
-    const skillDetected = skillInstaller.detect() !== null;
-    const skillInstalled = skillDetected && skillInstaller.isInstalled(GLM_DELEGATION_SKILL_NAME);
-    results.push(check("Codex", "Delegation skill", skillInstalled ? "ok" : "warn", skillInstalled
-        ? "installed"
-        : skillDetected
-            ? "not installed (optional)"
-            : "Codex home not detected — skill skipped (optional)"));
+    for (const { agent, installer } of skillTargets(home)) {
+        const homeDetected = installer.detect() !== null;
+        const skillInstalled = homeDetected && installer.isInstalled(GLM_DELEGATION_SKILL_NAME);
+        results.push(check(agent, "Delegation skill", skillInstalled ? "ok" : "warn", skillInstalled
+            ? "installed"
+            : homeDetected
+                ? "not installed (optional)"
+                : `${agent} home not detected — skill skipped (optional)`));
+    }
     // --- Environment: the Orca stale-env case (spec §9, §10) ---
     const hasProcessKey = Boolean(env.ZAI_API_KEY && env.ZAI_API_KEY.trim());
     if (hasProcessKey) {

package/dist/commands/mcp.js

@@ -0,0 +1,72 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import os from "node:os";
+import { loadConfig } from "../core/config.js";
+import { locateClaude } from "../core/claude.js";
+import { Errors } from "../core/errors.js";
+export const MCP_SERVER_NAME = "glm-coding-router";
+/** Absolute path to the compiled glm-mcp entry next to this module. */
+export function mcpServerScript() {
+    const here = path.dirname(fileURLToPath(import.meta.url)); // …/commands (dist or src)
+    const compiled = path.resolve(here, "..", "bin", "glm-mcp.js");
+    if (fs.existsSync(compiled)) {
+        return compiled;
+    }
+    return path.resolve(here, "..", "bin", "glm-mcp.ts"); // dev checkout via tsx
+}
+function defaultRunClaude(binPath, args) {
+    return new Promise((resolve) => {
+        execFile(binPath, args, { windowsHide: true, encoding: "utf8", timeout: 60_000 }, (error, stdout, stderr) => {
+            const code = error && typeof error.code === "number" ? error.code : 0;
+            resolve({ code, stdout: stdout ?? "", stderr: stderr ?? "" });
+        });
+    });
+}
+/**
+ * glm-router mcp (specs/v1-architecture.md): opt-in registration of the
+ * glm-mcp server. We never edit ~/.claude.json ourselves — install/remove go
+ * through Claude Code's own `claude mcp add/remove` CLI.
+ */
+export async function mcpCommand(options, action = "info", deps = {}) {
+    const script = mcpServerScript();
+    const node = process.execPath;
+    if (action === "info") {
+        const snippet = JSON.stringify({ mcpServers: { [MCP_SERVER_NAME]: { command: node, args: [script] } } }, null, 2);
+        process.stdout.write([
+            "Optional MCP server: glm-mcp exposes glm_worker, glm_review, glm_delegate, glm_usage as MCP tools.",
+            "",
+            "Register it with Claude Code:",
+            "",
+            `  claude mcp add -s user ${MCP_SERVER_NAME} -- "${node}" "${script}"`,
+            "",
+            "Or add this to your MCP client config:",
+            "",
+            snippet,
+            "",
+            "Remove again with:",
+            "",
+            `  claude mcp remove -s user ${MCP_SERVER_NAME}`,
+            "",
+        ].join("\n"));
+        return 0;
+    }
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const config = loadConfig(home);
+    const claudePath = locateClaude(config, env); // ERROR [20] when missing
+    const runClaude = deps.runClaude ?? defaultRunClaude;
+    const args = action === "install"
+        ? ["mcp", "add", "-s", "user", MCP_SERVER_NAME, "--", node, script]
+        : ["mcp", "remove", "-s", "user", MCP_SERVER_NAME];
+    const result = await runClaude(claudePath, args);
+    if (result.code !== 0) {
+        throw Errors.childAgentFailed(`claude mcp ${action} exited ${result.code}${result.stderr.trim() ? `: ${result.stderr.trim()}` : ""}`);
+    }
+    process.stdout.write(`✓ ${MCP_SERVER_NAME} MCP server ${action === "install" ? "registered" : "removed"} (claude -s user scope)\n`);
+    if (result.stdout.trim() && !options.quiet) {
+        process.stdout.write(`${result.stdout.trim()}\n`);
+    }
+    return 0;
+}

package/dist/commands/skill.js

@@ -1,43 +1,55 @@
 import os from "node:os";
-import { CodexSkillInstaller, glmDelegationSkill } from "../integrations/skill.js";
-function installer() {
-    return new CodexSkillInstaller(os.homedir());
-}
-/** glm-router skill install (spec §27): optional enhancement; warn+skip when unsupported. */
-export function skillInstallCommand(options) {
-    const skillInstaller = installer();
-    const location = skillInstaller.detect();
-    if (!location) {
-        process.stdout.write("⚠ Codex skill directory not detected (~/.codex not found).\n" +
-            "  Skipping optional skill — AGENTS.md integration keeps working.\n");
-        return 0;
-    }
+import { glmDelegationSkill, skillTargets } from "../integrations/skill.js";
+function runForEach(options, action, home) {
     const skill = glmDelegationSkill();
-    if (skillInstaller.isInstalled(skill.name) && !options.force) {
-        process.stdout.write(`✓ Skill "${skill.name}" already installed\n`);
-        return 0;
+    const results = [];
+    for (const { agent, installer } of skillTargets(home)) {
+        const location = installer.detect();
+        if (!location) {
+            results.push({ agent, outcome: "skipped", detail: "home not detected — skipping optional skill" });
+            continue;
+        }
+        if (action === "install") {
+            if (installer.isInstalled(skill.name) && !options.force) {
+                results.push({ agent, outcome: "already", detail: `already installed at ${location.skillsDir}` });
+                continue;
+            }
+            if (options.dryRun) {
+                results.push({ agent, outcome: "skipped", detail: `[dry-run] would install to ${location.skillsDir}` });
+                continue;
+            }
+            installer.install(skill);
+            results.push({ agent, outcome: "installed", detail: `installed at ${location.skillsDir}` });
+        }
+        else {
+            if (!installer.isInstalled(skill.name)) {
+                results.push({ agent, outcome: "absent", detail: "not installed" });
+                continue;
+            }
+            if (options.dryRun) {
+                results.push({ agent, outcome: "skipped", detail: "[dry-run] would remove skill" });
+                continue;
+            }
+            installer.remove(skill.name);
+            results.push({ agent, outcome: "removed", detail: "removed" });
+        }
     }
-    if (options.dryRun) {
-        process.stdout.write(`[dry-run] would install skill "${skill.name}" to ${location.skillsDir}\n`);
-        return 0;
-    }
-    skillInstaller.install(skill);
-    process.stdout.write(`✓ Skill "${skill.name}" installed at ${location.skillsDir}\n`);
-    return 0;
+    return results;
 }
-/** glm-router skill remove. */
-export function skillRemoveCommand(options) {
-    const skillInstaller = installer();
-    const skill = glmDelegationSkill();
-    if (!skillInstaller.isInstalled(skill.name)) {
-        process.stdout.write(`✓ Skill "${skill.name}" is not installed\n`);
-        return 0;
-    }
-    if (options.dryRun) {
-        process.stdout.write(`[dry-run] would remove skill "${skill.name}"\n`);
-        return 0;
+function render(results) {
+    for (const result of results) {
+        process.stdout.write(`✓ ${result.agent}: ${result.detail}\n`);
     }
-    skillInstaller.remove(skill.name);
-    process.stdout.write(`✓ Skill "${skill.name}" removed\n`);
     return 0;
 }
+/**
+ * glm-router skill install (spec §27, specs/v1-architecture.md): optional
+ * enhancement for BOTH agents; per-agent warn+skip, never fatal.
+ */
+export function skillInstallCommand(options, deps = {}) {
+    return render(runForEach(options, "install", deps.home ?? os.homedir()));
+}
+/** glm-router skill remove — removes from both agents. */
+export function skillRemoveCommand(options, deps = {}) {
+    return render(runForEach(options, "remove", deps.home ?? os.homedir()));
+}

package/dist/commands/status.js

@@ -3,7 +3,7 @@ import { loadConfig } from "../core/config.js";
 import { locateClaude, locateCodex } from "../core/claude.js";
 import { version } from "../core/version.js";
 import { resolveZaiApiKey } from "../core/zai-key.js";
-import { CodexSkillInstaller } from "../integrations/skill.js";
+import { skillTargets } from "../integrations/skill.js";
 import { GLM_DELEGATION_SKILL_NAME } from "../templates/glm-delegation-skill.js";
 import { emitJson } from "./context.js";
 /** Fast, fully offline summary (spec §41) — no API requests, no key values. */
@@ -22,8 +22,17 @@ export function statusCommand(options, deps = {}) {
         }
     })();
     const codexInstalled = Boolean(locateCodex(config, env));
-    const skillInstaller = new CodexSkillInstaller(home);
-    const skillInstalled = skillInstaller.detect() !== null && skillInstaller.isInstalled(GLM_DELEGATION_SKILL_NAME);
+    const skillState = (() => {
+        const rows = [];
+        for (const { agent, installer } of skillTargets(home)) {
+            rows.push({
+                agent,
+                homeDetected: installer.detect() !== null,
+                installed: installer.isInstalled(GLM_DELEGATION_SKILL_NAME),
+            });
+        }
+        return rows;
+    })();
     if (options.json) {
         emitJson({
             version,
@@ -33,7 +42,10 @@ export function statusCommand(options, deps = {}) {
             integrations: {
                 claude: config.integrations.claude,
                 codex: config.integrations.codex,
-                codexSkill: config.integrations.codexSkill && skillInstalled,
+                skills: skillState.map((row) => ({
+                    agent: row.agent,
+                    enabled: row.homeDetected && row.installed,
+                })),
             },
             models: config.models,
         });
@@ -48,11 +60,12 @@ export function statusCommand(options, deps = {}) {
         "",
         `Claude policy   ${config.integrations.claude ? "enabled" : "disabled"}`,
         `Codex policy    ${config.integrations.codex ? "enabled" : "disabled"}`,
-        `Codex skill     ${skillInstalled ? "enabled" : "disabled"}`,
-        "",
-        `Main model      ${config.models.main}`,
-        `Fast model      ${config.models.fast}`,
     ];
+    for (const row of skillState) {
+        const enabled = row.homeDetected && row.installed;
+        lines.push(`${row.agent} skill     ${enabled ? "enabled" : "disabled"}`);
+    }
+    lines.push("", `Main model      ${config.models.main}`, `Fast model      ${config.models.fast}`);
     process.stdout.write(lines.join("\n") + "\n");
     return 0;
 }

package/dist/commands/usage.js

@@ -19,7 +19,7 @@ function describeWindow(limit) {
     return `window unit=${String(limit.unit)} x ${String(limit.number)}`;
 }
 /** Fetch and validate the Z.ai quota snapshot. Never logs the Authorization header. */
-async function fetchZaiQuota(key, fetchImpl) {
+export async function fetchZaiQuota(key, fetchImpl) {
     let response;
     try {
         response = await fetchImpl(ZAI_QUOTA_URL, {

package/dist/integrations/skill.js

@@ -3,33 +3,52 @@ import path from "node:path";
 import { atomicWriteFile } from "../project/atomic-write.js";
 import { GLM_DELEGATION_SKILL_MD, GLM_DELEGATION_SKILL_NAME, } from "../templates/glm-delegation-skill.js";
 /**
- * Installs SKILL.md-based skills into the Codex home (~/.codex/skills).
- * Detection is conservative: if ~/.codex does not exist there is no
- * supported Codex installation to enhance — return null and let callers warn+skip.
+ * Shared SKILL.md-folder mechanics; subclasses only pick the agent home dir
+ * (specs/v1-architecture.md). Detection stays conservative: a missing home
+ * means no supported installation to enhance — return null, callers warn+skip.
  */
-export class CodexSkillInstaller {
-    codexHome;
-    constructor(home) {
-        this.codexHome = path.join(home, ".codex");
+class HomeDirSkillInstaller {
+    agentHome;
+    constructor(agentHome) {
+        this.agentHome = agentHome;
     }
     detect() {
-        if (!fs.existsSync(this.codexHome)) {
+        if (!fs.existsSync(this.agentHome)) {
             return null;
         }
-        return { skillsDir: path.join(this.codexHome, "skills") };
+        return { skillsDir: path.join(this.agentHome, "skills") };
     }
     install(skill) {
-        const skillDir = path.join(this.codexHome, "skills", skill.name);
+        const skillDir = path.join(this.agentHome, "skills", skill.name);
         atomicWriteFile(path.join(skillDir, "SKILL.md"), skill.content);
     }
     remove(name) {
-        const skillDir = path.join(this.codexHome, "skills", name);
+        const skillDir = path.join(this.agentHome, "skills", name);
         fs.rmSync(skillDir, { recursive: true, force: true });
     }
     isInstalled(name) {
-        return fs.existsSync(path.join(this.codexHome, "skills", name, "SKILL.md"));
+        return fs.existsSync(path.join(this.agentHome, "skills", name, "SKILL.md"));
+    }
+}
+/** Installs skills into the Codex home (~/.codex/skills). */
+export class CodexSkillInstaller extends HomeDirSkillInstaller {
+    constructor(home) {
+        super(path.join(home, ".codex"));
     }
 }
+/** Installs skills into the Claude Code home (~/.claude/skills, specs/v1-architecture.md). */
+export class ClaudeSkillInstaller extends HomeDirSkillInstaller {
+    constructor(home) {
+        super(path.join(home, ".claude"));
+    }
+}
+/** Every agent the delegation skill supports, in stable display order. */
+export function skillTargets(home) {
+    return [
+        { agent: "Claude", installer: new ClaudeSkillInstaller(home) },
+        { agent: "Codex", installer: new CodexSkillInstaller(home) },
+    ];
+}
 export function glmDelegationSkill() {
     return { name: GLM_DELEGATION_SKILL_NAME, content: GLM_DELEGATION_SKILL_MD };
 }

package/dist/mcp/server.js

@@ -0,0 +1,232 @@
+import os from "node:os";
+import { buildWorkerArgs } from "../bin/glm-worker.js";
+import { buildReviewArgs } from "../bin/glm-review.js";
+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 { gitTopLevel } from "../core/git.js";
+import { spawnAgentCapture } from "../core/process.js";
+import { applyProfile } from "../core/profile.js";
+import { version } from "../core/version.js";
+import { createDelegateWorktree, delegateBranch, removeDelegateWorktree, rollbackDelegateBranch, validateDelegateName, } from "../core/worktree.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+import { aggregateLocalUsage, fetchZaiQuota } from "../commands/usage.js";
+const PROMPT_PROPERTY = { type: "string", description: "The task prompt for the GLM agent." };
+export const MCP_TOOLS = [
+    {
+        name: "glm_worker",
+        description: "Run a GLM implementation worker (claude.exe + Z.ai env; tools Read,Glob,Grep,Edit,Write,Bash; acceptEdits). Returns the worker's output.",
+        inputSchema: {
+            type: "object",
+            properties: { prompt: PROMPT_PROPERTY, profile: { type: "string", description: "Config profile overlay (optional)." } },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "glm_review",
+        description: "Run a read-only GLM review/exploration worker (tools Read,Glob,Grep only — cannot edit or run commands).",
+        inputSchema: {
+            type: "object",
+            properties: { prompt: PROMPT_PROPERTY, profile: { type: "string", description: "Config profile overlay (optional)." } },
+            required: ["prompt"],
+        },
+    },
+    {
+        name: "glm_delegate",
+        description: "Run a GLM worker in an isolated git worktree (branch glm/delegate/<name> from HEAD). Worktree and branch are kept afterwards — nothing is committed or merged automatically.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: { type: "string", description: "Delegate slug, e.g. backend or tests." },
+                prompt: PROMPT_PROPERTY,
+            },
+            required: ["name", "prompt"],
+        },
+    },
+    {
+        name: "glm_usage",
+        description: "Usage snapshot: Z.ai Coding Plan credit windows (5h/weekly) and local benchmark totals.",
+        inputSchema: { type: "object", properties: {} },
+    },
+];
+function requiredString(args, key) {
+    const value = args[key];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`"${key}" is required and must be a non-empty string.`);
+    }
+    return value;
+}
+function optionalString(args, key) {
+    const value = args[key];
+    return typeof value === "string" && value.trim().length > 0 ? value : undefined;
+}
+function errorText(error) {
+    if (error instanceof GlmRouterError) {
+        return { text: formatGlmError(error), isError: true };
+    }
+    return { text: error instanceof Error ? error.message : String(error), isError: true };
+}
+function tail(text, max = 400) {
+    return text.length > max ? `…${text.slice(-max)}` : text;
+}
+async function runAgent(prompt, profile, kind, deps) {
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const config = applyProfile(loadConfig(home), profile);
+    const resolved = resolveZaiApiKey({ env, readUserEnv: deps.readUserEnv });
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    const claudePath = locateClaude(config, env);
+    const args = kind === "worker" ? buildWorkerArgs(prompt, config) : buildReviewArgs(prompt, config);
+    const spawn = deps.spawn ?? spawnAgentCapture;
+    const captured = await spawn(claudePath, {
+        args,
+        cwd: deps.cwd ?? process.cwd(),
+        env: createGlmEnv(config, resolved.key, env),
+        interactive: false,
+    });
+    const text = captured.stdout.trim() || "(no output)";
+    if (captured.code !== 0) {
+        return { text: `${text}\n[worker exited ${captured.code}]${captured.stderr ? `\n${tail(captured.stderr.trim())}` : ""}`, isError: true };
+    }
+    return { text, isError: false };
+}
+async function delegate(name, prompt, deps) {
+    validateDelegateName(name);
+    const cwd = deps.cwd ?? process.cwd();
+    const repoRoot = await gitTopLevel(cwd, deps.runGit);
+    if (!repoRoot) {
+        return { text: `Not inside a git repository (cwd: ${cwd}) — glm_delegate needs a repo root.`, isError: true };
+    }
+    const worktree = await createDelegateWorktree(repoRoot, name, { runGit: deps.runGit });
+    const branch = delegateBranch(name);
+    const summary = (exitCode, output) => ({
+        text: [
+            output.trim() || "(no output)",
+            "",
+            `worker exited ${exitCode}`,
+            `worktree kept: ${worktree}`,
+            `branch kept:   ${branch}`,
+            `next: inspect ${worktree}, then merge ${branch} (or discard with git worktree remove)`,
+        ].join("\n"),
+        isError: exitCode !== 0,
+    });
+    try {
+        const result = await runAgent(prompt, undefined, "worker", { ...deps, cwd: worktree });
+        return summary(result.isError ? 1 : 0, result.text);
+    }
+    catch (error) {
+        // Worker never started — roll back the pristine worktree + branch (specs/delegate-worktrees.md).
+        await removeDelegateWorktree(repoRoot, worktree, { runGit: deps.runGit });
+        await rollbackDelegateBranch(repoRoot, branch, { runGit: deps.runGit });
+        return errorText(error);
+    }
+}
+async function usage(deps) {
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const resolved = resolveZaiApiKey({ env, readUserEnv: deps.readUserEnv });
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    const lines = [];
+    let isError = false;
+    try {
+        const quota = await fetchZaiQuota(resolved.key, deps.fetchImpl ?? fetch);
+        lines.push(`Z.ai Coding Plan${quota.level ? ` (level: ${quota.level})` : ""}`);
+        for (const limit of quota.limits ?? []) {
+            const resets = typeof limit.nextResetTime === "number" ? ` — resets ${new Date(limit.nextResetTime).toISOString()}` : "";
+            lines.push(`  ${String(limit.number ?? "?")}x unit ${String(limit.unit ?? "?")}: ${String(limit.currentValue ?? "?")} / ${String(limit.usage ?? "?")} credits (${String(limit.percentage ?? "?")}%)${resets}`);
+        }
+    }
+    catch (error) {
+        isError = true;
+        lines.push(`Z.ai Coding Plan: ✗ ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const local = aggregateLocalUsage(home);
+    lines.push("");
+    lines.push(local.runs === 0
+        ? "Local (benchmark reports): (none yet)"
+        : `Local (benchmark reports): runs ${local.runs} · tokens ${local.tokensIn} in / ${local.tokensOut} out · last ${local.lastFinishedAt}`);
+    return { text: lines.join("\n"), isError };
+}
+/** Execute one MCP tool call. Tool-level failures return isError, never throw. */
+export async function callMcpTool(name, args, deps = {}) {
+    try {
+        switch (name) {
+            case "glm_worker":
+                return await runAgent(requiredString(args, "prompt"), optionalString(args, "profile"), "worker", deps);
+            case "glm_review":
+                return await runAgent(requiredString(args, "prompt"), optionalString(args, "profile"), "review", deps);
+            case "glm_delegate":
+                return await delegate(requiredString(args, "name"), requiredString(args, "prompt"), deps);
+            case "glm_usage":
+                return await usage(deps);
+            default:
+                return { text: `Unknown tool "${name}". Available: ${MCP_TOOLS.map((tool) => tool.name).join(", ")}.`, isError: true };
+        }
+    }
+    catch (error) {
+        return errorText(error);
+    }
+}
+/**
+ * One MCP server instance: `handleLine` takes a stdin line and resolves the
+ * JSON-RPC response frame to write back, or null (nothing to send —
+ * notifications, blank or malformed lines). Pure with respect to stdio.
+ */
+export function createMcpServer(deps = {}) {
+    return {
+        async handleLine(line) {
+            const trimmed = line.trim();
+            if (trimmed.length === 0)
+                return null;
+            let message;
+            try {
+                message = JSON.parse(trimmed);
+            }
+            catch {
+                return null;
+            }
+            if (message.jsonrpc !== "2.0" || typeof message.method !== "string")
+                return null;
+            const id = message.id;
+            if (id === undefined || id === null)
+                return null; // notification
+            const params = (typeof message.params === "object" && message.params !== null ? message.params : {});
+            let body;
+            try {
+                switch (message.method) {
+                    case "initialize":
+                        body = {
+                            result: {
+                                protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : "2024-11-05",
+                                capabilities: { tools: {} },
+                                serverInfo: { name: "glm-coding-router", version },
+                            },
+                        };
+                        break;
+                    case "ping":
+                        body = { result: {} };
+                        break;
+                    case "tools/list":
+                        body = { result: { tools: MCP_TOOLS } };
+                        break;
+                    case "tools/call": {
+                        const result = await callMcpTool(String(params.name ?? ""), (params.arguments ?? {}), deps);
+                        body = { result: { content: [{ type: "text", text: result.text }], isError: result.isError } };
+                        break;
+                    }
+                    default:
+                        body = { error: { code: -32601, message: `Method not found: ${message.method}` } };
+                }
+            }
+            catch (error) {
+                body = { error: { code: -32603, message: `Internal error: ${error instanceof Error ? error.message : String(error)}` } };
+            }
+            return JSON.stringify({ jsonrpc: "2.0", id, ...body });
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "glm-coding-router",
-  "version": "0.5.0",
+  "version": "1.0.0",
   "description": "GLM Coding Plan workers for Claude Code and Codex",
   "type": "module",
   "license": "MIT",
@@ -14,7 +14,8 @@
     "glm-chat": "./dist/bin/glm-chat.js",
     "glm-worker": "./dist/bin/glm-worker.js",
     "glm-review": "./dist/bin/glm-review.js",
-    "glm-fast": "./dist/bin/glm-fast.js"
+    "glm-fast": "./dist/bin/glm-fast.js",
+    "glm-mcp": "./dist/bin/glm-mcp.js"
   },
   "files": [
     "dist"