glm-coding-router 0.5.0 → 1.1.0

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/bin/glm-worker.js

@@ -11,8 +11,20 @@ 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";
+/** Same surface minus Bash, used when no Bash command is allowed. */
+export const WORKER_TOOLS_NO_BASH = "Read,Glob,Grep,Edit,Write";
+/**
+ * Build the child arguments (spec §16, specs/worker-bash-permissions.md).
+ *
+ * `--permission-mode acceptEdits` auto-approves file edits but NOT shell
+ * commands, and headless `-p` has no prompt to answer — so without an explicit
+ * `--allowedTools` every Bash call comes back "This command requires
+ * approval". When the allowlist is empty we drop Bash from `--tools` entirely
+ * rather than advertising a tool the worker can never use.
+ */
 export function buildWorkerArgs(prompt, config) {
-    return [
+    const allowedBash = config.worker.allowedBash;
+    const args = [
         "-p",
         prompt,
         "--max-turns",
@@ -20,8 +32,25 @@ export function buildWorkerArgs(prompt, config) {
         "--permission-mode",
         "acceptEdits",
         "--tools",
-        WORKER_TOOLS,
+        allowedBash.length > 0 ? WORKER_TOOLS : WORKER_TOOLS_NO_BASH,
     ];
+    if (allowedBash.length > 0) {
+        args.push("--allowedTools", ...allowedBash.map((pattern) => `Bash(${pattern})`));
+    }
+    return args;
+}
+/** Strip `--no-bash`, which empties the allowlist for one invocation. */
+export function extractNoBashFlag(argv) {
+    const rest = [];
+    let noBash = false;
+    for (const arg of argv) {
+        if (arg === "--no-bash") {
+            noBash = true;
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, noBash };
 }
 /**
  * glm-worker (spec §15, §16): headless implementation worker.
@@ -29,9 +58,13 @@ export function buildWorkerArgs(prompt, config) {
  * --dangerously-skip-permissions.
  */
 export async function runWorker(argv) {
-    const { rest, profile } = extractProfileFlag(argv);
+    const { rest: withoutProfile, profile } = extractProfileFlag(argv);
+    const { rest, noBash } = extractNoBashFlag(withoutProfile);
     const prompt = await resolvePrompt(rest);
-    const config = applyProfile(loadConfig(), profile);
+    const loaded = applyProfile(loadConfig(), profile);
+    const config = noBash
+        ? { ...loaded, worker: { ...loaded.worker, allowedBash: [] } }
+        : loaded;
     const resolved = resolveZaiApiKey();
     if (!resolved) {
         throw Errors.zaiKeyMissing();

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

@@ -2,11 +2,12 @@ import os from "node:os";
 import { execFileSync } from "node:child_process";
 import { defaultConfig, loadConfig } from "../core/config.js";
 import { locateClaude, locateCodex, searchPathFor } from "../core/claude.js";
-import { isWindows, windowsVersionName } from "../core/platform.js";
+import { platformName, platformSupport } from "../core/platform.js";
+import { describeKeyStore, detectUserEnvStore } from "../core/user-env.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 };
@@ -28,8 +29,13 @@ export function runDoctorChecks(options = {}) {
     const results = [];
     const home = options.home ?? os.homedir();
     const env = options.env ?? process.env;
-    // --- System ---
-    results.push(check("System", isWindows() ? windowsVersionName() : `Platform ${process.platform}`, isWindows() ? "ok" : "fail", undefined, isWindows() ? undefined : "v0.1 targets Windows only."));
+    // --- System (specs/cross-platform.md) ---
+    const support = platformSupport();
+    results.push(check("System", platformName(), support === "supported" ? "ok" : support === "experimental" ? "warn" : "fail", undefined, support === "experimental"
+        ? "macOS support is experimental — the suite has not been run on a Mac."
+        : support === "unsupported"
+            ? "Supported: Windows, Linux. macOS is experimental."
+            : undefined));
     const nodeMajor = nodeVersionMajor();
     results.push(check("System", `Node.js ${process.versions.node}`, nodeMajor >= 20 ? "ok" : "fail", undefined, nodeMajor >= 20 ? undefined : "glm-coding-router requires Node.js >= 20."));
     results.push(check("System", "Git", gitFound() ? "ok" : "warn"));
@@ -60,9 +66,19 @@ export function runDoctorChecks(options = {}) {
     const codexPath = locateCodex(config, env);
     results.push(check("Agents", "Codex", codexPath ? "ok" : "warn", codexPath, codexPath ? undefined : "Optional — Claude-only setups are supported."));
     // --- Z.ai key ---
+    const store = options.store ?? detectUserEnvStore();
     const resolved = resolveZaiApiKey({ env, readUserEnv: options.readUserEnv });
-    results.push(check("Z.ai", "ZAI_API_KEY", resolved ? "ok" : "fail", resolved ? `configured (${resolved.source})` : "not found", resolved ? undefined : "Run: glm-router key set"));
+    const sourceLabel = resolved?.source === "process-env" ? "process environment" : describeKeyStore(store);
+    results.push(check("Z.ai", "ZAI_API_KEY", resolved ? "ok" : "fail", resolved ? `configured (${sourceLabel})` : "not found", resolved
+        ? undefined
+        : store === "none"
+            ? 'Set it: export ZAI_API_KEY="<your-key>" (see: glm-router key set)'
+            : "Run: glm-router key set"));
     results.push(check("Z.ai", "Anthropic endpoint", "ok", config.provider.anthropicBaseUrl));
+    // specs/worker-bash-permissions.md — what the worker is allowed to execute.
+    results.push(check("Z.ai", "Worker shell access", "ok", config.worker.allowedBash.length > 0
+        ? `${config.worker.allowedBash.length} allowed Bash patterns`
+        : "disabled (Bash not offered to the worker)"));
     // --- Commands (PATH shims; a dev checkout warns instead of failing) ---
     for (const command of ["glm-chat", "glm-worker", "glm-review"]) {
         const found = searchPathFor(command);
@@ -71,21 +87,22 @@ 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) {
         results.push(check("Environment", "Process environment", "ok", "ZAI_API_KEY visible in current process"));
     }
     else if (resolved) {
-        results.push(check("Environment", "Process environment", "warn", "Current process does not contain ZAI_API_KEY", "This is safe. GLM workers reload the key automatically from the Windows User Environment."));
+        results.push(check("Environment", "Process environment", "warn", "Current process does not contain ZAI_API_KEY", `This is safe. GLM workers reload the key automatically from ${describeKeyStore(store)}.`));
     }
     return { results, config, keySource: resolved?.source };
 }

package/dist/commands/init.js

@@ -6,7 +6,8 @@ import { configPath } from "../core/paths.js";
 import { ExitCode } from "../core/errors.js";
 import { runDoctorChecks } from "./doctor.js";
 import { setWindowsUserEnv, ZAI_API_KEY_ENV } from "../core/zai-key.js";
-import { isWindows } from "../core/platform.js";
+import { detectUserEnvStore } from "../core/user-env.js";
+import { printShellKeyGuidance } from "./key.js";
 import { CodexSkillInstaller, glmDelegationSkill } from "../integrations/skill.js";
 import { version } from "../core/version.js";
 function renderEnvironment(results) {
@@ -84,8 +85,9 @@ export async function initCommand(options, deps = {}) {
         process.stdout.write(`✓ ${ZAI_API_KEY_ENV} already configured (${report.keySource})\n`);
     }
     else if (choices.configureKey) {
-        if (!isWindows()) {
-            process.stdout.write("⚠ Key storage requires Windows in v0.1 — skipped\n");
+        if ((deps.store ?? detectUserEnvStore()) === "none") {
+            // No persistent store here; tell the user the one line that works.
+            printShellKeyGuidance({ env: deps.env });
         }
         else {
             const keyResponse = await prompt({

package/dist/commands/key.js

@@ -1,12 +1,41 @@
 import prompts from "prompts";
-import { assertWindows } from "../core/platform.js";
-import { Errors } from "../core/errors.js";
+import { Errors, formatGlmError } from "../core/errors.js";
 import { logger } from "../core/logging.js";
+import { describeKeyStore, describeShellExport, detectUserEnvStore, } from "../core/user-env.js";
 import { ZAI_API_KEY_ENV, deleteWindowsUserEnv, resolveZaiApiKey, setWindowsUserEnv, } from "../core/zai-key.js";
 import { emitJson } from "./context.js";
+/**
+ * Print the shell-profile guidance used when the platform has no persistent
+ * secret store (the common Linux case: `secret-tool` is not installed by
+ * default). specs/cross-platform.md.
+ */
+export function printShellKeyGuidance(deps = {}) {
+    const { line, profile } = describeShellExport(ZAI_API_KEY_ENV, {
+        env: deps.env,
+        home: deps.home,
+    });
+    process.stdout.write([
+        `This platform has ${describeKeyStore("none")} that ${ZAI_API_KEY_ENV} can be saved to,`,
+        "so set it yourself — it takes one line:",
+        "",
+        `  ${line}`,
+        "",
+        `Add that to ${profile} so new shells inherit it, then run:`,
+        "",
+        "  glm-router key check",
+        "",
+        "The current shell keeps its old environment until you re-source that file",
+        "or open a new terminal.",
+        "",
+    ].join("\n"));
+}
 /** glm-router key set (spec §11): prompt, save to Windows User Environment. */
 export async function keySetCommand(_options, deps = {}) {
-    assertWindows();
+    const store = deps.store ?? detectUserEnvStore();
+    if (store === "none") {
+        printShellKeyGuidance(deps);
+        return 0;
+    }
     const prompt = deps.prompt ?? prompts;
     const setEnv = deps.setEnv ?? setWindowsUserEnv;
     const response = await prompt({
@@ -24,10 +53,10 @@ export async function keySetCommand(_options, deps = {}) {
         setEnv(ZAI_API_KEY_ENV, key);
     }
     catch (error) {
-        logger.error(`Failed to write the Windows User Environment: ${error instanceof Error ? error.message : String(error)}`);
+        logger.error(`Failed to write ${describeKeyStore(store)}: ${error instanceof Error ? error.message : String(error)}`);
         return 1;
     }
-    process.stdout.write(`\n✓ Saved to Windows User Environment:\n  ${ZAI_API_KEY_ENV}\n`);
+    process.stdout.write(`\n✓ Saved to ${describeKeyStore(store)}:\n  ${ZAI_API_KEY_ENV}\n`);
     process.stdout.write("\nOpen a NEW terminal (or restart your Orca terminal) so the current process picks it up.\n");
     return 0;
 }
@@ -42,18 +71,26 @@ export function keyCheckCommand(options, deps = {}) {
         return resolved ? 0 : 10;
     }
     if (!resolved) {
-        // Formatted per spec §36; exit 10 (spec §35).
+        // Formatted per spec §36; exit 10 (spec §35). The hint is platform-aware,
+        // so it never points at a command that cannot finish the job here.
         const error = Errors.zaiKeyMissing();
-        process.stderr.write(`ERROR [${error.codeName}]\n\n${error.message}\n\nRun:\n\n  glm-router key set\n`);
+        process.stderr.write(formatGlmError(error) + "\n");
         return error.exitCode;
     }
-    const sourceLabel = resolved.source === "process-env" ? "process environment" : "Windows User Environment";
+    const sourceLabel = resolved.source === "process-env"
+        ? "process environment"
+        : describeKeyStore(deps.store ?? detectUserEnvStore());
     process.stdout.write(`${ZAI_API_KEY_ENV}: configured\nSource: ${sourceLabel}\n`);
     return 0;
 }
 /** Used by uninstall; keeps the key by default (spec §44). */
 export async function keyRemoveCommand(deps = {}) {
-    assertWindows();
+    const store = deps.store ?? detectUserEnvStore();
+    if (store === "none") {
+        // Nothing this tool owns; the key lives in a shell profile the user wrote.
+        process.stdout.write(`${ZAI_API_KEY_ENV} is not stored by glm-router on this platform — remove the export line from your shell profile.\n`);
+        return;
+    }
     const deleteEnv = deps.deleteEnv ?? deleteWindowsUserEnv;
     deleteEnv(ZAI_API_KEY_ENV);
 }

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/uninstall.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import os from "node:os";
 import { configDir } from "../core/paths.js";
 import { ExitCode } from "../core/errors.js";
+import { describeKeyStore, detectUserEnvStore } from "../core/user-env.js";
 import { CodexSkillInstaller, glmDelegationSkill } from "../integrations/skill.js";
 import { keyRemoveCommand } from "./key.js";
 import { removeClaudeIntegration, removeCodexIntegration } from "../integrations/index.js";
@@ -85,7 +86,7 @@ export async function uninstallCommand(options, deps = {}) {
     }
     if (choices.removeKey) {
         await keyRemoveCommand({ deleteEnv: deps.deleteEnv });
-        process.stdout.write("✓ ZAI_API_KEY removed from Windows User Environment\n");
+        process.stdout.write(`✓ ZAI_API_KEY removed from ${describeKeyStore(detectUserEnvStore())}\n`);
     }
     else {
         process.stdout.write("✓ ZAI_API_KEY kept\n");

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/core/config.js

@@ -6,6 +6,34 @@ import { configDir, configPath } from "./paths.js";
 export const DEFAULT_ANTHROPIC_BASE_URL = "https://api.z.ai/api/anthropic";
 export const DEFAULT_MAIN_MODEL = "glm-5.3";
 export const DEFAULT_FAST_MODEL = "glm-5.3-flash";
+/**
+ * Bash commands the worker may run without an approval prompt
+ * (specs/worker-bash-permissions.md). Headless `-p` has no prompt to answer,
+ * so without this every Bash call is denied and the worker cannot validate its
+ * own work. Validation commands only: no git writes, no rm, no network, no
+ * package installs.
+ */
+export const DEFAULT_ALLOWED_BASH = [
+    "npm test",
+    "npm run *",
+    "npx vitest *",
+    "go test *",
+    "pytest*",
+    "python3 *",
+    "cargo test*",
+    "git status",
+    "git diff*",
+];
+/** Shell metacharacters defeat pattern matching, so they may not appear. */
+const BASH_PATTERN_FORBIDDEN = /[&;|`$><\n]/;
+const AllowedBashSchema = z
+    .array(z
+    .string()
+    .min(1)
+    .refine((value) => !BASH_PATTERN_FORBIDDEN.test(value), {
+    message: "must not contain shell metacharacters (& ; | ` $ > <)",
+}))
+    .default([...DEFAULT_ALLOWED_BASH]);
 /** Named model/maxTurns overlay selected via --profile (specs/glm-fast-profiles.md). */
 export const ProfileSchema = z.object({
     main: z.string().min(1).optional(),
@@ -25,7 +53,8 @@ export const ConfigSchema = z.object({
     }),
     worker: z.object({
         maxTurns: z.number().int().positive(),
-    }).default({ maxTurns: 20 }),
+        allowedBash: AllowedBashSchema,
+    }).default({ maxTurns: 20, allowedBash: [...DEFAULT_ALLOWED_BASH] }),
     review: z.object({
         maxTurns: z.number().int().positive(),
     }).default({ maxTurns: 15 }),
@@ -51,7 +80,7 @@ export function defaultConfig() {
             main: DEFAULT_MAIN_MODEL,
             fast: DEFAULT_FAST_MODEL,
         },
-        worker: { maxTurns: 20 },
+        worker: { maxTurns: 20, allowedBash: [...DEFAULT_ALLOWED_BASH] },
         review: { maxTurns: 15 },
         integrations: {
             claude: true,