glm-coding-router 0.1.0

package/dist/core/config.js

@@ -0,0 +1,150 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { Errors } from "./errors.js";
+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";
+export const ConfigSchema = z.object({
+    schemaVersion: z.literal(1),
+    provider: z.object({
+        name: z.literal("zai"),
+        anthropicBaseUrl: z.string().url(),
+    }),
+    models: z.object({
+        main: z.string().min(1),
+        fast: z.string().min(1),
+    }),
+    worker: z.object({
+        maxTurns: z.number().int().positive(),
+    }).default({ maxTurns: 20 }),
+    review: z.object({
+        maxTurns: z.number().int().positive(),
+    }).default({ maxTurns: 15 }),
+    integrations: z.object({
+        claude: z.boolean(),
+        codex: z.boolean(),
+        codexSkill: z.boolean(),
+    }).default({ claude: true, codex: true, codexSkill: true }),
+    // Optional executable overrides used by discovery (spec §33, §34).
+    claudePath: z.string().min(1).optional(),
+    codexPath: z.string().min(1).optional(),
+});
+export function defaultConfig() {
+    return {
+        schemaVersion: 1,
+        provider: {
+            name: "zai",
+            anthropicBaseUrl: DEFAULT_ANTHROPIC_BASE_URL,
+        },
+        models: {
+            main: DEFAULT_MAIN_MODEL,
+            fast: DEFAULT_FAST_MODEL,
+        },
+        worker: { maxTurns: 20 },
+        review: { maxTurns: 15 },
+        integrations: {
+            claude: true,
+            codex: true,
+            codexSkill: true,
+        },
+    };
+}
+/**
+ * Load config from %USERPROFILE%\.glm-coding-router\config.json.
+ * A missing file yields defaults; anything present must validate (spec §29).
+ */
+export function loadConfig(home) {
+    const file = configPath(home);
+    if (!fs.existsSync(file)) {
+        return defaultConfig();
+    }
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (error) {
+        throw Errors.configInvalid(`cannot read ${file}: ${errorMessage(error)}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw Errors.configInvalid(`invalid JSON in ${file}: ${errorMessage(error)}`);
+    }
+    const result = ConfigSchema.safeParse(parsed);
+    if (!result.success) {
+        const detail = result.error.issues
+            .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+            .join("; ");
+        throw Errors.configInvalid(detail);
+    }
+    return result.data;
+}
+export function saveConfig(config, home) {
+    const dir = configDir(home);
+    fs.mkdirSync(dir, { recursive: true });
+    const file = configPath(home);
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, JSON.stringify(config, null, 2) + "\n", "utf8");
+    fs.renameSync(tmp, file);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Set a dotted config key, e.g. `models.main glm-5.3` (spec §28).
+ * Existing numbers/booleans coerce the incoming string; result must re-validate.
+ */
+export function setConfigValue(config, dottedKey, rawValue) {
+    const keys = dottedKey.split(".");
+    if (keys.length === 0 || keys.some((k) => k.length === 0)) {
+        throw Errors.configInvalid(`invalid config key "${dottedKey}"`);
+    }
+    const draft = structuredClone(config);
+    let target = draft;
+    for (const key of keys.slice(0, -1)) {
+        const next = target[key];
+        if (typeof next !== "object" || next === null) {
+            throw Errors.configInvalid(`config key "${dottedKey}" does not exist`);
+        }
+        target = next;
+    }
+    const leafKey = keys[keys.length - 1];
+    if (!(leafKey in target)) {
+        throw Errors.configInvalid(`config key "${dottedKey}" does not exist`);
+    }
+    const current = target[leafKey];
+    let value = rawValue;
+    if (typeof current === "number") {
+        const numeric = Number(rawValue);
+        if (Number.isNaN(numeric)) {
+            throw Errors.configInvalid(`"${dottedKey}" expects a number, got "${rawValue}"`);
+        }
+        value = numeric;
+    }
+    else if (typeof current === "boolean") {
+        if (rawValue !== "true" && rawValue !== "false") {
+            throw Errors.configInvalid(`"${dottedKey}" expects true or false, got "${rawValue}"`);
+        }
+        value = rawValue === "true";
+    }
+    target[leafKey] = value;
+    const result = ConfigSchema.safeParse(draft);
+    if (!result.success) {
+        const detail = result.error.issues
+            .map((issue) => `${issue.path.join(".") || "(root)"}: ${issue.message}`)
+            .join("; ");
+        throw Errors.configInvalid(detail);
+    }
+    return result.data;
+}
+/** Config path for messages, independent of home override (used by status/doctor). */
+export function describeConfigPath(home) {
+    return configPath(home);
+}
+export function configDirFor(home) {
+    return path.dirname(configPath(home));
+}

package/dist/core/env.js

@@ -0,0 +1,22 @@
+/** Per-child-process timeout injected alongside the Z.ai env (spec §12). */
+export const API_TIMEOUT_MS = "3000000";
+/**
+ * Environment injected into the claude.exe child process only (spec §12).
+ * Never applied to the parent shell and never persisted globally.
+ */
+export function createGlmEnv(config, zaiKey, baseEnv = process.env) {
+    return {
+        ...baseEnv,
+        ANTHROPIC_API_KEY: "",
+        ANTHROPIC_AUTH_TOKEN: zaiKey,
+        ANTHROPIC_BASE_URL: config.provider.anthropicBaseUrl,
+        API_TIMEOUT_MS,
+        ENABLE_CLAUDEAI_MCP_SERVERS: "false",
+        ANTHROPIC_DEFAULT_OPUS_MODEL: config.models.main,
+        ANTHROPIC_DEFAULT_SONNET_MODEL: config.models.main,
+        ANTHROPIC_DEFAULT_HAIKU_MODEL: config.models.fast,
+        // GLM models are not in Claude Code's model catalog; without this it
+        // enforces its assumed 200k context window on unknown models.
+        CLAUDE_CODE_DISABLE_UNKNOWN_MODEL_WINDOW_ENFORCEMENT: "1",
+    };
+}

package/dist/core/errors.js

@@ -0,0 +1,121 @@
+/** Standard exit codes (spec §35). */
+export const ExitCode = {
+    Success: 0,
+    GenericFailure: 1,
+    InvalidArgs: 2,
+    ZaiKeyMissing: 10,
+    ConfigInvalid: 11,
+    ClaudeNotFound: 20,
+    CodexNotFound: 21,
+    ProjectRootNotFound: 30,
+    ManagedFileWriteFailed: 31,
+    ChildAgentFailed: 40,
+    UnsupportedPlatform: 50,
+};
+/** Base error for all expected failures. Printed as `ERROR [NAME]` (spec §36). */
+export class GlmRouterError extends Error {
+    codeName;
+    hint;
+    exitCode;
+    constructor(options) {
+        super(options.message);
+        this.name = `GlmRouterError:${options.name}`;
+        this.codeName = options.name;
+        this.hint = options.hint ?? [];
+        this.exitCode = options.exitCode;
+    }
+}
+export const Errors = {
+    zaiKeyMissing: () => new GlmRouterError({
+        name: "ZAI_KEY_MISSING",
+        message: "ZAI_API_KEY was not found.",
+        hint: ["Run:", "", "  glm-router key set"],
+        exitCode: ExitCode.ZaiKeyMissing,
+    }),
+    configInvalid: (detail) => new GlmRouterError({
+        name: "CONFIG_INVALID",
+        message: `Configuration is invalid: ${detail}`,
+        hint: [
+            "Fix or remove the config file:",
+            "",
+            "  %USERPROFILE%\\.glm-coding-router\\config.json",
+        ],
+        exitCode: ExitCode.ConfigInvalid,
+    }),
+    claudeNotFound: (detail) => new GlmRouterError({
+        name: "CLAUDE_NOT_FOUND",
+        message: detail ??
+            "Claude Code executable was not found in PATH.",
+        hint: [
+            "Expected:",
+            "",
+            "  claude.exe",
+            "",
+            "Install Claude Code or set an override:",
+            "",
+            "  glm-router config set claudePath C:\\path\\to\\claude.exe",
+        ],
+        exitCode: ExitCode.ClaudeNotFound,
+    }),
+    codexNotFound: () => new GlmRouterError({
+        name: "CODEX_NOT_FOUND",
+        message: "Codex executable was not found in PATH.",
+        hint: ["Codex is optional; Claude-only setups are supported."],
+        exitCode: ExitCode.CodexNotFound,
+    }),
+    projectRootNotFound: () => new GlmRouterError({
+        name: "PROJECT_ROOT_NOT_FOUND",
+        message: "Could not determine the project root.",
+        exitCode: ExitCode.ProjectRootNotFound,
+    }),
+    managedFileWriteFailed: (file, cause) => new GlmRouterError({
+        name: "MANAGED_FILE_WRITE_FAILED",
+        message: `Failed to update ${file}: ${cause}`,
+        hint: ["The file was left unmodified."],
+        exitCode: ExitCode.ManagedFileWriteFailed,
+    }),
+    childAgentFailed: (cause) => new GlmRouterError({
+        name: "CHILD_AGENT_FAILED",
+        message: `The child agent process failed: ${cause}`,
+        exitCode: ExitCode.ChildAgentFailed,
+    }),
+    unsupportedPlatform: (platform) => new GlmRouterError({
+        name: "UNSUPPORTED_PLATFORM",
+        message: `This command requires Windows (detected: ${platform}).`,
+        hint: ["Linux and macOS support is planned for v0.2."],
+        exitCode: ExitCode.UnsupportedPlatform,
+    }),
+    promptRequired: (command = "glm-worker") => new GlmRouterError({
+        name: "PROMPT_REQUIRED",
+        message: "No task prompt was provided.",
+        hint: [
+            "Usage:",
+            "",
+            `  ${command} "Implement validation and add tests"`,
+            `  Get-Content task.md | ${command}`,
+        ],
+        exitCode: ExitCode.InvalidArgs,
+    }),
+    managedBlockCorrupt: (file, cause) => new GlmRouterError({
+        name: "MANAGED_BLOCK_CORRUPT",
+        message: `Managed block in ${file} is malformed: ${cause}`,
+        hint: [
+            "Fix or remove the markers manually:",
+            "",
+            "  <!-- glm-coding-router:start -->",
+            "  ...",
+            "  <!-- glm-coding-router:end -->",
+            "",
+            "The file was not modified.",
+        ],
+        exitCode: ExitCode.ManagedFileWriteFailed,
+    }),
+};
+/** Print a GlmRouterError in the spec §36 format. Never print secret values. */
+export function formatGlmError(error) {
+    const lines = [`ERROR [${error.codeName}]`, "", error.message];
+    if (error.hint.length > 0) {
+        lines.push("", ...error.hint);
+    }
+    return lines.join("\n");
+}

package/dist/core/logging.js

@@ -0,0 +1,54 @@
+const LEVEL_ORDER = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+};
+/**
+ * Replace every occurrence of a known secret with `[REDACTED]` (spec §37).
+ * Empty/missing values are ignored; any real secret value is redacted.
+ */
+export function redact(text, secrets) {
+    let output = text;
+    for (const secret of secrets) {
+        if (secret && secret.length > 0) {
+            output = output.split(secret).join("[REDACTED]");
+        }
+    }
+    return output;
+}
+/** Minimal leveled logger honoring --quiet / --verbose. Writes to stderr so stdout stays parseable. */
+export class Logger {
+    level;
+    quiet;
+    constructor(level = "info", quiet = false) {
+        this.level = level;
+        this.quiet = quiet;
+    }
+    setLevel(level, quiet = false) {
+        this.level = level;
+        this.quiet = quiet;
+    }
+    error(message) {
+        this.emit("error", message);
+    }
+    warn(message) {
+        this.emit("warn", message);
+    }
+    info(message) {
+        this.emit("info", message);
+    }
+    debug(message) {
+        this.emit("debug", message);
+    }
+    emit(level, message) {
+        if (this.quiet && level !== "error")
+            return;
+        if (LEVEL_ORDER[level] > LEVEL_ORDER[this.level])
+            return;
+        const prefix = level === "debug" ? "debug:" : "";
+        const line = prefix ? `${prefix} ${message}` : message;
+        process.stderr.write(line + "\n");
+    }
+}
+export const logger = new Logger();

package/dist/core/main-guard.js

@@ -0,0 +1,20 @@
+import { fileURLToPath } from "node:url";
+import fs from "node:fs";
+import path from "node:path";
+/**
+ * True when this module is the entry point (node dist/bin/glm-worker.js).
+ * Robust against URL-encoded characters and symlinks.
+ */
+export function isMainModule(importMetaUrl) {
+    const entry = process.argv[1];
+    if (!entry)
+        return false;
+    try {
+        const self = fs.realpathSync(fileURLToPath(importMetaUrl));
+        const invoked = fs.realpathSync(path.resolve(entry));
+        return self === invoked;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/core/paths.js

@@ -0,0 +1,13 @@
+import os from "node:os";
+import path from "node:path";
+/** Config directory: %USERPROFILE%\.glm-coding-router (spec §13). */
+export function configDir(home = os.homedir()) {
+    return path.join(home, ".glm-coding-router");
+}
+export function configPath(home = os.homedir()) {
+    return path.join(configDir(home), "config.json");
+}
+/** Local metadata tracking which project files this tool created entirely (spec §43). */
+export function ownershipPath(home = os.homedir()) {
+    return path.join(configDir(home), "ownership.json");
+}

package/dist/core/platform.js

@@ -0,0 +1,20 @@
+import os from "node:os";
+import { Errors } from "./errors.js";
+export function isWindows() {
+    return process.platform === "win32";
+}
+/** Human-readable Windows version from os.release() ("10.0.26200" → "Windows 11"). */
+export function windowsVersionName() {
+    if (!isWindows()) {
+        return process.platform;
+    }
+    const release = os.release();
+    const build = Number.parseInt(release.split(".")[2] ?? "0", 10);
+    return build >= 22000 ? "Windows 11" : "Windows 10";
+}
+/** Guard for commands that require Windows-specific machinery (PowerShell user env, etc.). */
+export function assertWindows() {
+    if (!isWindows()) {
+        throw Errors.unsupportedPlatform(process.platform);
+    }
+}

package/dist/core/process.js

@@ -0,0 +1,60 @@
+import { spawn } from "node:child_process";
+import { Errors } from "./errors.js";
+/**
+ * Spawn a child agent process (spec §18, §32, §39):
+ * - argument array, never a shell string
+ * - inherits cwd and stdout/stderr
+ * - forwards SIGINT/SIGTERM so Ctrl+C reaches the child
+ * - resolves with the child's exit code (signals resolve to 1)
+ */
+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);
+            }
+        };
+        child.on("error", (error) => {
+            cleanup();
+            reject(Errors.childAgentFailed(errorMessage(error)));
+        });
+        child.on("exit", (code) => {
+            cleanup();
+            resolve(code ?? 1);
+        });
+    });
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/prompt.js

@@ -0,0 +1,32 @@
+import { Errors } from "./errors.js";
+/** Read all of stdin when it is not a TTY; resolve undefined otherwise (spec §40). */
+export function readStdin() {
+    const stdin = process.stdin;
+    if (stdin.isTTY) {
+        return Promise.resolve(undefined);
+    }
+    return new Promise((resolve) => {
+        let data = "";
+        stdin.setEncoding("utf8");
+        stdin.on("data", (chunk) => {
+            data += chunk;
+        });
+        stdin.on("end", () => resolve(data.length > 0 ? data : undefined));
+        stdin.on("error", () => resolve(undefined));
+    });
+}
+/**
+ * Resolve the task prompt (spec §15, §40):
+ *   stdin text → joined arguments → error
+ */
+export async function resolvePrompt(argv, readStdinFn = readStdin, command = "glm-worker") {
+    const stdinText = await readStdinFn();
+    if (stdinText !== undefined && stdinText.trim().length > 0) {
+        return stdinText;
+    }
+    const argText = argv.join(" ").trim();
+    if (argText.length > 0) {
+        return argText;
+    }
+    throw Errors.promptRequired(command);
+}

package/dist/core/version.js

@@ -0,0 +1,3 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+export const version = require("../../package.json").version;

package/dist/core/zai-key.js

@@ -0,0 +1,84 @@
+import { execFileSync } from "node:child_process";
+export const ZAI_API_KEY_ENV = "ZAI_API_KEY";
+/** Only well-formed variable names may reach powershell.exe (spec §38). */
+function assertEnvVarName(name) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) {
+        throw new Error(`Invalid environment variable name: ${name}`);
+    }
+}
+/**
+ * Read a variable from the Windows User Environment via PowerShell (spec §10).
+ * Returns undefined on any failure — callers fall back or fail with their own error.
+ */
+export function readWindowsUserEnv(name) {
+    assertEnvVarName(name);
+    try {
+        const result = execFileSync("powershell.exe", [
+            "-NoProfile",
+            "-NonInteractive",
+            "-Command",
+            `[Environment]::GetEnvironmentVariable('${name}','User')`,
+        ], {
+            encoding: "utf8",
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        const value = result.trim();
+        return value || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Write a variable to the Windows User Environment (spec §11).
+ * The value is passed through a child-process env var so it never needs
+ * PowerShell string escaping (spec §38: no unescaped user data in commands).
+ */
+export function setWindowsUserEnv(name, value) {
+    assertEnvVarName(name);
+    execFileSync("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `[Environment]::SetEnvironmentVariable('${name}', $env:GLM_ROUTER_VALUE, 'User')`,
+    ], {
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "pipe"],
+        env: { ...process.env, GLM_ROUTER_VALUE: value },
+    });
+}
+export function deleteWindowsUserEnv(name) {
+    assertEnvVarName(name);
+    execFileSync("powershell.exe", [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `[Environment]::SetEnvironmentVariable('${name}', $null, 'User')`,
+    ], {
+        windowsHide: true,
+        stdio: ["ignore", "ignore", "pipe"],
+    });
+}
+/**
+ * Resolve the Z.ai key with the mandatory fallback order (spec §10):
+ *   1. process.env.ZAI_API_KEY
+ *   2. Windows User Environment
+ *   3. fail (undefined)
+ *
+ * The fallback exists because Orca terminals snapshot a stale environment and
+ * cannot see keys added after startup. Never cache the key to disk.
+ */
+export function resolveZaiApiKey(options = {}) {
+    const env = options.env ?? process.env;
+    const readUserEnv = options.readUserEnv ?? readWindowsUserEnv;
+    const fromProcess = env[ZAI_API_KEY_ENV];
+    if (fromProcess && fromProcess.trim()) {
+        return { key: fromProcess.trim(), source: "process-env" };
+    }
+    const fromUserEnv = readUserEnv(ZAI_API_KEY_ENV);
+    if (fromUserEnv && fromUserEnv.trim()) {
+        return { key: fromUserEnv.trim(), source: "windows-user-env" };
+    }
+    return undefined;
+}

package/dist/integrations/claude.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { removeManagedFile, upsertManagedFile } from "../project/managed-file.js";
+import { CLAUDE_MANAGED_BLOCK } from "../templates/claude-block.js";
+export function claudeFilePath(projectRoot) {
+    return path.join(projectRoot, "CLAUDE.md");
+}
+/** Upsert the GLM delegation block into <root>\CLAUDE.md without overwriting user content (spec §19–21). */
+export function installClaudeIntegration(projectRoot, options = {}) {
+    return upsertManagedFile({
+        file: claudeFilePath(projectRoot),
+        block: CLAUDE_MANAGED_BLOCK,
+        home: options.home,
+        dryRun: options.dryRun,
+    });
+}
+export function removeClaudeIntegration(projectRoot, options = {}) {
+    return removeManagedFile(claudeFilePath(projectRoot), options.home, options.dryRun);
+}

package/dist/integrations/codex.js

@@ -0,0 +1,18 @@
+import path from "node:path";
+import { removeManagedFile, upsertManagedFile } from "../project/managed-file.js";
+import { AGENTS_MANAGED_BLOCK } from "../templates/agents-block.js";
+export function agentsFilePath(projectRoot) {
+    return path.join(projectRoot, "AGENTS.md");
+}
+/** Upsert the GLM delegation block into <root>\AGENTS.md for Codex (spec §23, §24). */
+export function installCodexIntegration(projectRoot, options = {}) {
+    return upsertManagedFile({
+        file: agentsFilePath(projectRoot),
+        block: AGENTS_MANAGED_BLOCK,
+        home: options.home,
+        dryRun: options.dryRun,
+    });
+}
+export function removeCodexIntegration(projectRoot, options = {}) {
+    return removeManagedFile(agentsFilePath(projectRoot), options.home, options.dryRun);
+}

package/dist/integrations/index.js

@@ -0,0 +1,3 @@
+export { installClaudeIntegration, removeClaudeIntegration, claudeFilePath } from "./claude.js";
+export { installCodexIntegration, removeCodexIntegration, agentsFilePath } from "./codex.js";
+export { CodexSkillInstaller, glmDelegationSkill } from "./skill.js";

package/dist/integrations/skill.js

@@ -0,0 +1,35 @@
+import fs from "node:fs";
+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.
+ */
+export class CodexSkillInstaller {
+    codexHome;
+    constructor(home) {
+        this.codexHome = path.join(home, ".codex");
+    }
+    detect() {
+        if (!fs.existsSync(this.codexHome)) {
+            return null;
+        }
+        return { skillsDir: path.join(this.codexHome, "skills") };
+    }
+    install(skill) {
+        const skillDir = path.join(this.codexHome, "skills", skill.name);
+        atomicWriteFile(path.join(skillDir, "SKILL.md"), skill.content);
+    }
+    remove(name) {
+        const skillDir = path.join(this.codexHome, "skills", name);
+        fs.rmSync(skillDir, { recursive: true, force: true });
+    }
+    isInstalled(name) {
+        return fs.existsSync(path.join(this.codexHome, "skills", name, "SKILL.md"));
+    }
+}
+export function glmDelegationSkill() {
+    return { name: GLM_DELEGATION_SKILL_NAME, content: GLM_DELEGATION_SKILL_MD };
+}