glm-coding-router 0.3.0 → 0.5.0

package/README.md

@@ -200,6 +200,59 @@ glm-router delegate backend "Task A"   # terminal 1
 glm-router delegate tests "Task B"     # terminal 2
 ```
 
+## benchmark
+
+Measure the Claude Code + GLM stack on built-in coding tasks (spec §54 v0.4).
+Each task runs in a throwaway temp directory: the router writes the task files,
+spawns the standard GLM worker (same env injection, plus `--output-format json`
+to capture the result document), then runs the task's validation command:
+
+```powershell
+glm-router benchmark --yes                 # both built-in tasks, 1 run each
+glm-router benchmark --yes --task fn-reverse --repeat 3
+glm-router benchmark --yes --max-turns 15
+```
+
+Report (per task × run): **duration**, **GLM calls** (assistant turns),
+**retries** (`-` — not exposed by Claude Code yet), **tokens in/out**,
+**tests** (PASS/FAIL of `node test.js`), **success**, **intervention**
+(`needed` when the run did not self-complete). The full JSON report is always
+saved to `%USERPROFILE%\.glm-coding-router\benchmarks\benchmark-<timestamp>.json`
+and `--json` also prints it.
+
+Built-in tasks: `fn-reverse` (implement `reverseWords` until the test passes),
+`fix-bug` (repair an even-length `median` bug).
+
+Notes:
+- Benchmarking makes **real GLM API calls** — interactive runs ask for
+  confirmation; non-interactive runs require `--yes`.
+- Failed tasks are measurements, not errors: the command exits 0 once the
+  suite ran. Missing key/claude or a broken spawn still fail with the usual
+  `ERROR [10]/[20]/[40]`.
+- `--stack codex` is recognized but not supported yet (headless Codex
+  orchestration isn't drivable today); the harness is stack-shaped so it can
+  be added later.
+
+## usage
+
+Provider usage snapshots (spec §54 v0.5) — what is reliably retrievable:
+
+```powershell
+glm-router usage
+```
+
+- **Z.ai Coding Plan quota** (network): queries the Z.ai monitor endpoint
+  (`/api/monitor/usage/quota/limit`) with your key and shows each credit
+  window — consumed/total, percentage, reset time — plus the plan level.
+  Unreachable endpoint or a rejected request renders `✗ <reason>` and exits 1.
+- **Local totals** (offline): aggregates saved benchmark reports — run count
+  and summed input/output tokens (`glm-router benchmark` writes them).
+- **Claude quota / Codex usage**: always shown as "not available" — neither
+  exposes a headless usage API today (and claude.ai quota is irrelevant while
+  traffic is routed to GLM).
+
+`--json` emits the same data machine-readably. No key configured → `ERROR [10]`.
+
 ## CLI reference
 
 ```text
@@ -211,6 +264,8 @@ glm-router key check         key configured? from which source?
 glm-router config show
 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 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/cli.js

@@ -14,6 +14,8 @@ import { projectRemoveCommand } from "./commands/project-remove.js";
 import { skillInstallCommand, skillRemoveCommand } from "./commands/skill.js";
 import { uninstallCommand } from "./commands/uninstall.js";
 import { delegateCommand } from "./commands/delegate.js";
+import { benchmarkCommand } from "./commands/benchmark.js";
+import { usageCommand } from "./commands/usage.js";
 const program = new Command();
 program
     .name("glm-router")
@@ -94,6 +96,18 @@ program
     .option("--profile <name>", "profile overlay (defaults to a profile named <name> if defined)")
     .option("--remove", "remove the worktree after a successful run (branch is always kept)")
     .action((name, prompt, commandOptions) => execute(() => delegateCommand(name, prompt, { ...globalOptions(), ...commandOptions })));
+program
+    .command("benchmark")
+    .description("measure the Claude+GLM stack on built-in coding tasks (makes real GLM calls)")
+    .option("--task <id>", "run only this task (repeatable)", (value, previous) => previous.concat([value]), [])
+    .option("--stack <name>", "orchestration stack (default claude; codex not yet supported)")
+    .option("--max-turns <n>", "worker --max-turns override", (value) => Number(value))
+    .option("--repeat <n>", "run each task N times", (value) => Number(value))
+    .action((commandOptions) => execute(() => benchmarkCommand({ ...globalOptions(), ...commandOptions })));
+program
+    .command("usage")
+    .description("provider usage snapshots: Z.ai Coding Plan quota + local benchmark totals")
+    .action(() => execute(() => usageCommand(globalOptions())));
 program
     .command("uninstall")
     .description("guided removal (keeps ZAI_API_KEY by default)")

package/dist/commands/benchmark.js

@@ -0,0 +1,252 @@
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import prompts from "prompts";
+import { version } from "../core/version.js";
+import { WORKER_TOOLS } from "../bin/glm-worker.js";
+import { loadConfig } from "../core/config.js";
+import { locateClaude } from "../core/claude.js";
+import { createGlmEnv } from "../core/env.js";
+import { Errors } from "../core/errors.js";
+import { configDir } from "../core/paths.js";
+import { spawnAgentCapture } from "../core/process.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+import { BENCHMARK_TASKS, benchmarkTaskById } from "../templates/benchmark-tasks.js";
+import { emitJson } from "./context.js";
+const KNOWN_STACKS = ["claude", "codex"];
+/**
+ * glm-router benchmark (spec §54 v0.4, specs/benchmark.md): run built-in
+ * coding tasks through the Claude+GLM worker path and report §54 metrics.
+ * Failed tasks are measurements, not CLI errors — exits 0 once the suite ran.
+ */
+export async function benchmarkCommand(options, deps = {}) {
+    const stack = options.stack ?? "claude";
+    if (stack === "codex") {
+        throw Errors.invalidArgs("The codex stack is not supported yet: headless Codex orchestration cannot be driven reliably today.", ["v0.4 ships the harness + claude stack; codex slots in later without redesign."]);
+    }
+    if (!KNOWN_STACKS.includes(stack)) {
+        throw Errors.invalidArgs(`Unknown stack "${stack}".`, [`Known stacks: ${KNOWN_STACKS.join(", ")}`]);
+    }
+    const ids = options.task && options.task.length > 0 ? options.task : BENCHMARK_TASKS.map((t) => t.id);
+    const unknown = ids.filter((id) => !benchmarkTaskById(id));
+    if (unknown.length > 0) {
+        throw Errors.invalidArgs(`Unknown task id(s): ${unknown.join(", ")}.`, [`Available tasks: ${BENCHMARK_TASKS.map((t) => t.id).join(", ")}`]);
+    }
+    const tasks = ids.map((id) => benchmarkTaskById(id));
+    const repeat = options.repeat ?? 1;
+    const maxTurns = options.maxTurns;
+    if (!Number.isInteger(repeat) || repeat < 1) {
+        throw Errors.invalidArgs(`--repeat expects a positive integer, got "${repeat}".`);
+    }
+    if (maxTurns !== undefined && (!Number.isInteger(maxTurns) || maxTurns < 1)) {
+        throw Errors.invalidArgs(`--max-turns expects a positive integer, got "${maxTurns}".`);
+    }
+    if (options.dryRun) {
+        if (options.json) {
+            emitJson({ stack, tasks: ids, repeat, maxTurns: maxTurns ?? "(config default)", dryRun: true });
+        }
+        else {
+            const lines = [
+                `would run stack   ${stack}`,
+                `would run tasks   ${ids.join(", ")}`,
+                `would repeat      ${repeat}x`,
+                `would use maxTurns ${maxTurns ?? "(config default)"}`,
+            ];
+            process.stdout.write(lines.join("\n") + "\n");
+        }
+        return 0;
+    }
+    const interactive = deps.interactive ?? process.stdin.isTTY === true;
+    if (!options.yes) {
+        if (!interactive) {
+            throw Errors.invalidArgs(`benchmark makes real GLM API calls; confirm with --yes when running non-interactively.`, [`  glm-router benchmark --yes`]);
+        }
+        const confirm = deps.confirm ?? defaultConfirm;
+        const ok = await confirm();
+        if (!ok) {
+            process.stdout.write("Cancelled.\n");
+            return 1;
+        }
+    }
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const config = loadConfig(home);
+    const resolved = resolveZaiApiKey({ env, readUserEnv: deps.readUserEnv });
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    const claudePath = locateClaude(config, env);
+    const turns = maxTurns ?? config.worker.maxTurns;
+    const now = deps.now ?? Date.now;
+    const mkdtemp = deps.mkdtemp ?? (() => fs.mkdtempSync(path.join(os.tmpdir(), "glm-benchmark-")));
+    const spawn = deps.spawn ?? spawnAgentCapture;
+    const startedAt = new Date(now()).toISOString();
+    const metrics = [];
+    for (const task of tasks) {
+        for (let run = 1; run <= repeat; run++) {
+            metrics.push(await runTask(task, run, { turns, claudePath, config, key: resolved.key, env, now, mkdtemp, spawn }));
+        }
+    }
+    const report = {
+        version,
+        stack,
+        startedAt,
+        finishedAt: new Date(now()).toISOString(),
+        maxTurns: turns,
+        repeat,
+        tasks: metrics,
+    };
+    const savedPath = saveReport(report, home);
+    if (!options.quiet && !options.json) {
+        process.stdout.write(`report saved to ${savedPath}\n`);
+    }
+    if (options.json) {
+        emitJson({ ...report, savedPath });
+    }
+    else {
+        renderTable(metrics, options);
+    }
+    return 0;
+}
+async function runTask(task, run, ctx) {
+    const dir = ctx.mkdtemp();
+    try {
+        for (const [relative, content] of Object.entries(task.files)) {
+            const file = path.join(dir, relative);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, content, "utf8");
+        }
+        const args = [
+            "-p",
+            task.prompt,
+            "--max-turns",
+            String(ctx.turns),
+            "--permission-mode",
+            "acceptEdits",
+            "--tools",
+            WORKER_TOOLS,
+            "--output-format",
+            "json",
+        ];
+        const childEnv = createGlmEnv(ctx.config, ctx.key, ctx.env);
+        const started = ctx.now();
+        let captured;
+        try {
+            captured = await ctx.spawn(ctx.claudePath, { args, cwd: dir, env: childEnv, interactive: false });
+        }
+        catch (error) {
+            throw Errors.childAgentFailed(error instanceof Error ? error.message : String(error));
+        }
+        const durationMs = ctx.now() - started;
+        const parsed = parseClaudeResult(captured.stdout);
+        const validation = await runValidation(task.validate, dir);
+        const selfCompleted = captured.code === 0 && parsed?.isError !== true && !isErrorSubtype(parsed?.subtype);
+        const success = selfCompleted && validation.pass;
+        return {
+            task: task.id,
+            run,
+            durationMs,
+            childDurationMs: parsed?.durationMs ?? null,
+            workerExit: captured.code,
+            glmCalls: parsed?.numTurns ?? null,
+            inputTokens: parsed?.usage?.input_tokens ?? null,
+            outputTokens: parsed?.usage?.output_tokens ?? null,
+            subtype: parsed?.subtype ?? null,
+            testsPass: validation.pass,
+            testsOutput: validation.output,
+            success,
+            interventionNeeded: !selfCompleted,
+            resultParsed: parsed !== null,
+        };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+    }
+}
+/** Parse the child's `--output-format json` result document (last JSON line wins). */
+export function parseClaudeResult(stdout) {
+    const lines = stdout.split(/\r?\n/).filter((line) => line.trim().length > 0);
+    for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+            const parsed = JSON.parse(lines[i]);
+            if (typeof parsed === "object" && parsed !== null) {
+                return {
+                    subtype: typeof parsed.subtype === "string" ? parsed.subtype : undefined,
+                    isError: typeof parsed.is_error === "boolean" ? parsed.is_error : undefined,
+                    numTurns: typeof parsed.num_turns === "number" ? parsed.num_turns : undefined,
+                    durationMs: typeof parsed.duration_ms === "number" ? parsed.duration_ms : undefined,
+                    usage: typeof parsed.usage === "object" && parsed.usage !== null
+                        ? {
+                            input_tokens: numberOrUndefined(parsed.usage.input_tokens),
+                            output_tokens: numberOrUndefined(parsed.usage.output_tokens),
+                        }
+                        : undefined,
+                };
+            }
+        }
+        catch {
+            // Not JSON — keep walking backwards.
+        }
+    }
+    return null;
+}
+function numberOrUndefined(value) {
+    return typeof value === "number" ? value : undefined;
+}
+function isErrorSubtype(subtype) {
+    return subtype !== undefined && subtype.startsWith("error");
+}
+async function runValidation(argv, cwd) {
+    const [bin, ...rest] = argv;
+    return new Promise((resolve) => {
+        execFile(bin, rest, { cwd, windowsHide: true, encoding: "utf8", timeout: 30_000 }, (error, stdout, stderr) => {
+            const output = `${stdout}${stderr}`.trim();
+            resolve({ pass: !error, output: output.length > 0 ? output.slice(-400) : "(no output)" });
+        });
+    });
+}
+function saveReport(report, home) {
+    const dir = path.join(configDir(home), "benchmarks");
+    fs.mkdirSync(dir, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const file = path.join(dir, `benchmark-${stamp}.json`);
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(report, null, 2) + "\n", "utf8");
+    fs.renameSync(tmp, file);
+    return file;
+}
+function renderTable(metrics, options) {
+    if (options.quiet)
+        return;
+    const header = ["task", "run", "duration", "GLM calls", "retries", "tokens i/o", "tests", "success", "intervention"];
+    const rows = metrics.map((m) => [
+        m.task,
+        String(m.run),
+        formatMs(m.durationMs),
+        m.glmCalls === null ? "-" : String(m.glmCalls),
+        "-", // retry count: not exposed by Claude Code (specs/benchmark.md)
+        m.inputTokens === null || m.outputTokens === null ? "-" : `${m.inputTokens}/${m.outputTokens}`,
+        m.testsPass ? "PASS" : "FAIL",
+        m.success ? "yes" : "no",
+        m.interventionNeeded ? "needed" : "none",
+    ]);
+    const widths = header.map((_, column) => Math.max(header[column].length, ...rows.map((row) => row[column].length)));
+    const line = (cells) => cells.map((cell, column) => cell.padEnd(widths[column])).join("  ");
+    process.stdout.write([line(header), ...rows.map(line)].join("\n") + "\n");
+    for (const m of metrics.filter((m) => !m.testsPass)) {
+        process.stdout.write(`\n${m.task} (run ${m.run}) validation output:\n${m.testsOutput}\n`);
+    }
+}
+function formatMs(ms) {
+    return ms >= 10_000 ? `${(ms / 1000).toFixed(1)}s` : `${Math.round(ms / 100) / 10}s`;
+}
+async function defaultConfirm() {
+    const response = await prompts({
+        type: "confirm",
+        name: "ok",
+        message: "Benchmark will make real GLM API calls. Continue?",
+        initial: false,
+    });
+    return response.ok === true;
+}

package/dist/commands/usage.js

@@ -0,0 +1,162 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { Errors } from "../core/errors.js";
+import { configDir } from "../core/paths.js";
+import { version } from "../core/version.js";
+import { resolveZaiApiKey } from "../core/zai-key.js";
+import { emitJson } from "./context.js";
+/** Z.ai monitor API used by their own dashboard (specs/usage.md). */
+const ZAI_QUOTA_URL = "https://api.z.ai/api/monitor/usage/quota/limit";
+/** Window labels for the observed enum values (specs/usage.md); unknown values stay generic. */
+function describeWindow(limit) {
+    if (limit.unit === 3 && typeof limit.number === "number") {
+        return `${limit.number}-hour window`;
+    }
+    if (limit.unit === 6 && limit.number === 1) {
+        return "weekly";
+    }
+    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) {
+    let response;
+    try {
+        response = await fetchImpl(ZAI_QUOTA_URL, {
+            method: "GET",
+            headers: { Authorization: `Bearer ${key}`, "Content-Type": "application/json" },
+            signal: AbortSignal.timeout(10_000),
+        });
+    }
+    catch (error) {
+        throw new Error(`Z.ai monitor endpoint unreachable (${error instanceof Error ? error.message : "network error"})`);
+    }
+    if (!response.ok) {
+        throw new Error(`Z.ai monitor endpoint returned HTTP ${response.status}`);
+    }
+    let body;
+    try {
+        body = (await response.json());
+    }
+    catch {
+        throw new Error("Z.ai monitor endpoint returned a non-JSON body");
+    }
+    if (body.code !== 200 || typeof body.data !== "object" || body.data === null) {
+        throw new Error(`Z.ai monitor endpoint rejected the request (${body.msg ?? `code ${String(body.code)}`})`);
+    }
+    return body.data;
+}
+/** Aggregate saved benchmark reports (specs/benchmark.md) into one local summary. */
+export function aggregateLocalUsage(home) {
+    const dir = path.join(configDir(home), "benchmarks");
+    let runs = 0;
+    let tokensIn = 0;
+    let tokensOut = 0;
+    let lastFinishedAt = null;
+    if (!fs.existsSync(dir)) {
+        return { runs, tokensIn, tokensOut, lastFinishedAt };
+    }
+    for (const name of fs.readdirSync(dir)) {
+        if (!name.endsWith(".json"))
+            continue;
+        try {
+            const report = JSON.parse(fs.readFileSync(path.join(dir, name), "utf8"));
+            for (const run of report.tasks ?? []) {
+                runs += 1;
+                tokensIn += run.inputTokens ?? 0;
+                tokensOut += run.outputTokens ?? 0;
+            }
+            if (typeof report.finishedAt === "string" && (!lastFinishedAt || report.finishedAt > lastFinishedAt)) {
+                lastFinishedAt = report.finishedAt;
+            }
+        }
+        catch {
+            // Malformed report files are skipped — usage must never crash on bad data.
+        }
+    }
+    return { runs, tokensIn, tokensOut, lastFinishedAt };
+}
+/**
+ * glm-router usage (spec §54 v0.5, specs/usage.md): provider usage snapshots
+ * where APIs allow reliable retrieval. Z.ai quota via the monitor endpoint;
+ * Claude/Codex have no headless usage surface and say so; local totals come
+ * from saved benchmark reports.
+ */
+export async function usageCommand(options, deps = {}) {
+    const home = deps.home ?? os.homedir();
+    const env = deps.env ?? process.env;
+    const fetchImpl = deps.fetchImpl ?? fetch;
+    const resolved = resolveZaiApiKey({ env, readUserEnv: deps.readUserEnv });
+    if (!resolved) {
+        throw Errors.zaiKeyMissing();
+    }
+    let quota;
+    let quotaError;
+    try {
+        quota = await fetchZaiQuota(resolved.key, fetchImpl);
+    }
+    catch (error) {
+        quotaError = error instanceof Error ? error.message : String(error);
+    }
+    const local = aggregateLocalUsage(home);
+    const limits = quota?.limits ?? [];
+    const json = {
+        version,
+        zai: quotaError
+            ? { ok: false, error: quotaError }
+            : {
+                ok: true,
+                level: quota?.level ?? null,
+                limits: limits.map((limit) => ({
+                    window: describeWindow(limit),
+                    consumed: limit.currentValue ?? null,
+                    total: limit.usage ?? null,
+                    remaining: limit.remaining ?? null,
+                    percentage: limit.percentage ?? null,
+                    resetsAt: typeof limit.nextResetTime === "number" ? new Date(limit.nextResetTime).toISOString() : null,
+                })),
+            },
+        local,
+        claude: "not available — Claude Code exposes no headless usage API",
+        codex: "not available — Codex exposes no plan-usage API",
+    };
+    if (options.json) {
+        emitJson(json);
+        return quotaError ? 1 : 0;
+    }
+    const lines = [`GLM Coding Router v${version} — usage snapshot`, ""];
+    if (quotaError) {
+        lines.push(`Z.ai Coding Plan`);
+        lines.push(`  ✗ ${quotaError}`);
+    }
+    else {
+        lines.push(`Z.ai Coding Plan${quota?.level ? ` (level: ${quota.level})` : ""}`);
+        if (limits.length === 0) {
+            lines.push("  (no quota windows reported)");
+        }
+        for (const limit of limits) {
+            const consumed = limit.currentValue ?? "?";
+            const total = limit.usage ?? "?";
+            const percentage = typeof limit.percentage === "number"
+                ? limit.percentage
+                : typeof limit.currentValue === "number" && typeof limit.usage === "number" && limit.usage > 0
+                    ? Math.round((limit.currentValue / limit.usage) * 100)
+                    : "?";
+            const resets = typeof limit.nextResetTime === "number" ? ` — resets ${new Date(limit.nextResetTime).toISOString()}` : "";
+            lines.push(`  ${describeWindow(limit).padEnd(15)} ${consumed} / ${total} credits (${percentage}%)${resets}`);
+        }
+    }
+    lines.push("");
+    lines.push("Local (benchmark reports)");
+    if (local.runs === 0) {
+        lines.push("  (none yet — run glm-router benchmark)");
+    }
+    else {
+        lines.push(`  runs ${local.runs} · tokens ${local.tokensIn} in / ${local.tokensOut} out · last ${local.lastFinishedAt}`);
+    }
+    lines.push("");
+    lines.push(`Claude quota   ${json.claude}`);
+    lines.push(`Codex usage    ${json.codex}`);
+    process.stdout.write(lines.join("\n") + "\n");
+    return quotaError ? 1 : 0;
+}

package/dist/core/errors.js

@@ -96,6 +96,12 @@ export const Errors = {
         ],
         exitCode: ExitCode.InvalidArgs,
     }),
+    invalidArgs: (detail, hint) => new GlmRouterError({
+        name: "INVALID_ARGS",
+        message: detail,
+        hint: hint && hint.length > 0 ? hint : undefined,
+        exitCode: ExitCode.InvalidArgs,
+    }),
     gitNotFound: () => new GlmRouterError({
         name: "GIT_NOT_FOUND",
         message: "git was not found on PATH.",

package/dist/core/process.js

@@ -10,51 +10,84 @@ import { Errors } from "./errors.js";
 export function spawnAgent(binPath, options) {
     const { args, cwd, env, interactive = true } = options;
     return new Promise((resolve, reject) => {
-        let child;
-        try {
-            child = spawn(binPath, args, {
-                cwd,
-                env,
-                stdio: interactive ? "inherit" : ["ignore", "inherit", "inherit"],
-                shell: false,
-                windowsHide: false,
-            });
-        }
-        catch (error) {
-            reject(Errors.childAgentFailed(errorMessage(error)));
-            return;
-        }
-        const signals = ["SIGINT", "SIGTERM"];
-        const handlers = new Map();
-        for (const signal of signals) {
-            const handler = () => {
-                if (child.killed)
-                    return;
-                try {
-                    child.kill(signal);
-                }
-                catch {
-                    // Child already gone; the exit event settles the promise.
-                }
-            };
-            handlers.set(signal, handler);
-            process.on(signal, handler);
-        }
-        const cleanup = () => {
-            for (const [signal, handler] of handlers) {
-                process.removeListener(signal, handler);
-            }
-        };
+        const child = spawn(binPath, args, {
+            cwd,
+            env,
+            stdio: interactive ? "inherit" : ["ignore", "inherit", "inherit"],
+            shell: false,
+            windowsHide: false,
+        });
+        const handlers = forwardSignals(child);
         child.on("error", (error) => {
-            cleanup();
+            removeSignals(handlers);
             reject(Errors.childAgentFailed(errorMessage(error)));
         });
         child.on("exit", (code) => {
-            cleanup();
+            removeSignals(handlers);
             resolve(code ?? 1);
         });
     });
 }
+/**
+ * Like spawnAgent but pipes stdout/stderr instead of inheriting them and
+ * resolves the captured output (specs/benchmark.md) — same no-shell rule and
+ * signal forwarding. Used by `benchmark` to parse the child's result JSON.
+ */
+export function spawnAgentCapture(binPath, options) {
+    const { args, cwd, env } = options;
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, args, {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+            windowsHide: false,
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk;
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk;
+        });
+        const handlers = forwardSignals(child);
+        child.on("error", (error) => {
+            removeSignals(handlers);
+            reject(Errors.childAgentFailed(errorMessage(error)));
+        });
+        child.on("exit", (code) => {
+            removeSignals(handlers);
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+    });
+}
+/** Install SIGINT/SIGTERM forwarding; returns the handlers for cleanup. */
+function forwardSignals(child) {
+    const handlers = new Map();
+    for (const signal of ["SIGINT", "SIGTERM"]) {
+        const handler = () => {
+            if (child.killed)
+                return;
+            try {
+                child.kill(signal);
+            }
+            catch {
+                // Child already gone; the exit event settles the promise.
+            }
+        };
+        handlers.set(signal, handler);
+        process.on(signal, handler);
+    }
+    return handlers;
+}
+function removeSignals(handlers) {
+    for (const [signal, handler] of handlers) {
+        process.removeListener(signal, handler);
+    }
+}
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/templates/benchmark-tasks.js

@@ -0,0 +1,70 @@
+export const BENCHMARK_TASKS = [
+    {
+        id: "fn-reverse",
+        description: "implement reverseWords from a stub until node test.js passes",
+        files: {
+            "src/util.js": [
+                "// Implement reverseWords(str): reverse the ORDER of the words in str.",
+                '// Example: reverseWords("hello world") === "world hello".',
+                "// Collapse extra whitespace between words and trim the ends.",
+                "function reverseWords(str) {",
+                "  // TODO: implement",
+                "}",
+                "",
+                "module.exports = { reverseWords };",
+                "",
+            ].join("\n"),
+            "test.js": [
+                'const assert = require("node:assert");',
+                'const { reverseWords } = require("./src/util.js");',
+                'assert.strictEqual(reverseWords("hello world"), "world hello");',
+                'assert.strictEqual(reverseWords("a"), "a");',
+                'assert.strictEqual(reverseWords("  spaced   out  "), "out spaced");',
+                'assert.strictEqual(reverseWords(""), "");',
+                'console.log("PASS");',
+                "",
+            ].join("\n"),
+        },
+        prompt: [
+            "Implement reverseWords in src/util.js so that `node test.js` passes.",
+            "Words are separated by whitespace; collapse repeats and trim the ends.",
+            "Do not modify test.js. Verify by running `node test.js` with Bash.",
+        ].join(" "),
+        validate: ["node", "test.js"],
+    },
+    {
+        id: "fix-bug",
+        description: "repair an even-length median bug until node test.js passes",
+        files: {
+            "stats.js": [
+                "// median(values) returns the median of a non-empty list of numbers.",
+                "function median(values) {",
+                "  const sorted = [...values].sort((a, b) => a - b);",
+                "  const mid = Math.floor(sorted.length / 2);",
+                "  return sorted[mid]; // BUG: wrong for even-length lists",
+                "}",
+                "",
+                "module.exports = { median };",
+                "",
+            ].join("\n"),
+            "test.js": [
+                'const assert = require("node:assert");',
+                'const { median } = require("./stats.js");',
+                "assert.strictEqual(median([3, 1, 2]), 2);",
+                "assert.strictEqual(median([4, 1, 3, 2]), 2.5);",
+                "assert.strictEqual(median([5]), 5);",
+                'console.log("PASS");',
+                "",
+            ].join("\n"),
+        },
+        prompt: [
+            "stats.js has a bug: median() returns the wrong result for even-length lists.",
+            "Fix it so that `node test.js` passes (even lists return the average of the two middle values).",
+            "Do not modify test.js. Verify by running `node test.js` with Bash.",
+        ].join(" "),
+        validate: ["node", "test.js"],
+    },
+];
+export function benchmarkTaskById(id) {
+    return BENCHMARK_TASKS.find((task) => task.id === id);
+}

package/package.json

@@ -1,47 +1,47 @@
-{
-  "name": "glm-coding-router",
-  "version": "0.3.0",
-  "description": "GLM Coding Plan workers for Claude Code and Codex",
-  "type": "module",
-  "license": "MIT",
-  "author": "hieu9721",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/hieu9721/GLM-coding-router.git"
-  },
-  "bin": {
-    "glm-router": "./dist/cli.js",
-    "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"
-  },
-  "files": [
-    "dist"
-  ],
-  "scripts": {
-    "dev": "tsx src/cli.ts",
-    "build": "tsc",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "lint": "eslint src tests",
-    "prepublishOnly": "npm run build && npm test"
-  },
-  "engines": {
-    "node": ">=20"
-  },
-  "dependencies": {
-    "commander": "^15.0.0",
-    "prompts": "^2.4.2",
-    "zod": "^4.6.5"
-  },
-  "devDependencies": {
-    "@types/node": "^22.20.3",
-    "@types/prompts": "^2.4.9",
-    "eslint": "^9.39.5",
-    "tsx": "^4.23.13",
-    "typescript": "^5.9.3",
-    "typescript-eslint": "^8.70.0",
-    "vitest": "^5.0.1"
-  }
-}
+{
+  "name": "glm-coding-router",
+  "version": "0.5.0",
+  "description": "GLM Coding Plan workers for Claude Code and Codex",
+  "type": "module",
+  "license": "MIT",
+  "author": "hieu9721",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hieu9721/GLM-coding-router.git"
+  },
+  "bin": {
+    "glm-router": "./dist/cli.js",
+    "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"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsx src/cli.ts",
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint src tests",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "commander": "^15.0.0",
+    "prompts": "^2.4.2",
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
+    "@types/node": "^22.20.3",
+    "@types/prompts": "^2.4.9",
+    "eslint": "^9.39.5",
+    "tsx": "^4.23.13",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.70.0",
+    "vitest": "^5.0.1"
+  }
+}