glm-coding-router 1.1.1 → 2.0.0

package/dist/commands/watch.js

@@ -0,0 +1,289 @@
+import fs from "node:fs";
+import os from "node:os";
+import { loadConfig } from "../core/config.js";
+import { Errors } from "../core/errors.js";
+import { logger } from "../core/logging.js";
+import { activeRunFile, runDir } from "../core/paths.js";
+import { createEventBus } from "../events/bus.js";
+import { listActive, listHistory } from "../runs/registry.js";
+import { eventsFilePath } from "../runs/store.js";
+import { attachProgress, resolveProgressMode } from "../tui/progress.js";
+/**
+ * fs.watch is the primary follow mechanism but is unreliable on some platforms
+ * (and fires spuriously on others), so a slow interval re-reads from the last
+ * offset as a backstop — never as a tight poll loop.
+ */
+const DEFAULT_FALLBACK_INTERVAL_MS = 1000;
+/** The events that end a run; seeing one means there is nothing left to follow. */
+const TERMINAL_EVENT_TYPES = new Set(["RunCompleted", "RunFailed", "RunCancelled"]);
+/**
+ * glm-router watch [run-id] — attach to a running run and follow it live. The
+ * stored events are re-emitted onto a fresh bus that `attachProgress` renders
+ * through, so a followed run prints exactly what a live one prints. Attaching
+ * reads from the CURRENT end of `events.jsonl` (`--from-start` rewinds to 0):
+ * the user wants what happens from now on, not a replay of what they missed.
+ * Exit 0 on every stop — a run ending, crashing or being interrupted is what
+ * watching is for, not a failure of the command.
+ */
+export function watchCommand(options, deps = {}) {
+    const home = deps.home ?? os.homedir();
+    const target = resolveTarget(home, options.runId);
+    if (target.kind === "none") {
+        // Nothing running is normal, not an error — one clear line, exit 0.
+        process.stdout.write("no active run\n");
+        return Promise.resolve(0);
+    }
+    if (target.kind === "finished") {
+        process.stdout.write(`run ${target.id} already finished (${target.state}) — nothing to follow\n`);
+        return Promise.resolve(0);
+    }
+    const run = target.run;
+    const stream = deps.stderr ?? process.stderr;
+    const intervalMs = deps.intervalMs ?? DEFAULT_FALLBACK_INTERVAL_MS;
+    const file = eventsFilePath(runDir(home, run.date, run.id));
+    const activeFile = activeRunFile(home, run.id);
+    // The registry is the fast path, but the events are the truth: a run whose
+    // last recorded event is terminal is over even while a stale active file
+    // still lists it (a crash between summary and cleanup leaves exactly that).
+    // Following such a file would hang forever, so say so and leave.
+    if (options.fromStart !== true) {
+        const ended = lastTerminalEventType(file);
+        if (ended !== null) {
+            process.stdout.write(`run ${run.id} already ended (${ended}) — nothing to follow\n`);
+            return Promise.resolve(0);
+        }
+    }
+    // Same mode resolution as a live run, so the two views cannot diverge.
+    const mode = resolveProgressMode({
+        quiet: options.quiet,
+        configMode: loadConfig(home).ui.mode,
+        env: process.env,
+        isTTY: streamIsTTY(stream),
+    });
+    const bus = createEventBus(run.id);
+    const progress = attachProgress(bus, { mode, stream });
+    return new Promise((resolve) => {
+        // Bytes below `offset` have been consumed; `pending` holds a torn final
+        // line until its remainder arrives (the store appends whole lines, so a
+        // torn line is the normal mid-append state, not corruption).
+        let offset = options.fromStart === true ? 0 : fileSize(file);
+        let pending = Buffer.alloc(0);
+        let watcher = null;
+        let timer = null;
+        let stopped = false;
+        const stop = (code) => {
+            if (stopped) {
+                return;
+            }
+            stopped = true;
+            if (timer !== null) {
+                clearInterval(timer);
+            }
+            watcher?.close();
+            process.removeListener("SIGINT", onSigint);
+            progress.detach(); // restores the cursor in rich mode
+            bus.close();
+            resolve(code);
+        };
+        const onSigint = () => {
+            stop(0);
+        };
+        /** A transient fs error inside a timer/watch callback must not kill node. */
+        const pump = () => {
+            if (stopped) {
+                return;
+            }
+            try {
+                pumpOnce();
+            }
+            catch (error) {
+                logger.debug(`watch: pumping ${file} failed: ${errorMessage(error)}`);
+            }
+        };
+        const pumpOnce = () => {
+            // A stat failure (file not created yet by a very fresh run, or a prune
+            // racing the watch) reads as "nothing new" — the active-file check below
+            // is the only authority on whether the run itself ended.
+            const size = fileSize(file);
+            if (size > offset) {
+                const chunk = readRange(file, offset, size - offset);
+                offset = size;
+                pending = Buffer.concat([pending, chunk]);
+            }
+            // Only newline-terminated lines are parsed; anything else waits for the
+            // next pump, which is what makes a mid-append read harmless.
+            for (;;) {
+                const newline = pending.indexOf(10);
+                if (newline === -1) {
+                    break;
+                }
+                const line = pending.subarray(0, newline).toString("utf8").trim();
+                pending = pending.subarray(newline + 1);
+                const event = parseStoredEvent(line);
+                if (event === null) {
+                    continue;
+                }
+                // The bus re-stamps seq/ts on replay; nothing downstream of a watch
+                // renders those fields, and a single emit authority stays simpler
+                // than a bypass that would let two writers disagree.
+                bus.emit(event);
+                if (TERMINAL_EVENT_TYPES.has(event.type)) {
+                    stop(0);
+                    return;
+                }
+            }
+            // Every terminal event is appended before the active file is deleted,
+            // so at this point a missing active file means the run died without
+            // one (crash) — the pump above already delivered its last events.
+            if (!fs.existsSync(activeFile)) {
+                process.stdout.write(`run ${run.id} is no longer active — no terminal event was recorded\n`);
+                stop(0);
+            }
+        };
+        const tryStartFsWatch = () => {
+            if (watcher !== null || stopped) {
+                return;
+            }
+            try {
+                watcher = fs.watch(file, () => {
+                    pump();
+                });
+            }
+            catch (error) {
+                // A run so fresh that events.jsonl does not exist yet — the backstop
+                // tick retries until the store creates it.
+                logger.debug(`watch: fs.watch on ${file} failed: ${errorMessage(error)}`);
+            }
+        };
+        process.on("SIGINT", onSigint);
+        if (options.fromStart === true) {
+            pump();
+        }
+        if (!stopped) {
+            if (deps.watchImpl !== undefined) {
+                watcher = deps.watchImpl(file, pump);
+            }
+            else {
+                tryStartFsWatch();
+            }
+            timer = setInterval(() => {
+                if (deps.watchImpl === undefined) {
+                    tryStartFsWatch();
+                }
+                pump();
+            }, intervalMs);
+            // fs.watch keeps the loop alive on its own; the interval is only a
+            // backstop and must not become a second reason to stay alive. When it
+            // IS the mechanism (watchImpl injected, or fs.watch never started), it
+            // stays referenced — otherwise node would exit mid-follow.
+            if (deps.watchImpl === undefined && watcher !== null) {
+                timer.unref();
+            }
+        }
+    });
+}
+/**
+ * Full id or unique suffix, exact match first, ambiguity named — the same
+ * rule as `runs show`. A suffix can also hit history: a finished run is
+ * reported as such rather than "not found" (which would be false) — and
+ * watching one would hang forever, so the caller prints and exits instead.
+ */
+function resolveTarget(home, input) {
+    const activeRuns = listActive(home); // newest first
+    if (input === undefined) {
+        return activeRuns.length > 0 ? { kind: "active", run: activeRuns[0] } : { kind: "none" };
+    }
+    const exact = activeRuns.find((run) => run.id === input);
+    if (exact !== undefined) {
+        return { kind: "active", run: exact };
+    }
+    const suffix = activeRuns.filter((run) => run.id.endsWith(input));
+    if (suffix.length === 1) {
+        return { kind: "active", run: suffix[0] };
+    }
+    if (suffix.length > 1) {
+        throw Errors.invalidArgs(`run id "${input}" is ambiguous — ${suffix.length} active runs end with it:`, suffix.map((run) => run.id));
+    }
+    const refs = listHistory(home);
+    const refExact = refs.find((ref) => ref.id === input);
+    const refSuffix = refs.filter((ref) => ref.id.endsWith(input));
+    const match = refExact ?? (refSuffix.length === 1 ? refSuffix[0] : undefined);
+    if (refExact === undefined && refSuffix.length > 1) {
+        throw Errors.invalidArgs(`run id "${input}" is ambiguous — ${refSuffix.length} recorded runs end with it:`, refSuffix.map((candidate) => candidate.id));
+    }
+    if (match !== undefined) {
+        return { kind: "finished", id: match.id, state: match.state };
+    }
+    throw Errors.invalidArgs(`no run found with id "${input}"`, [`Run "glm-router runs" to list recorded runs.`]);
+}
+/**
+ * The runtime check mirrors `readEvents`: "parses and has a `type` string".
+ * History written by a future version must degrade to an ignored line, not
+ * crash the watcher.
+ */
+function parseStoredEvent(line) {
+    if (line === "") {
+        return null;
+    }
+    try {
+        const parsed = JSON.parse(line);
+        if (typeof parsed === "object" && parsed !== null && typeof parsed.type === "string") {
+            return parsed;
+        }
+    }
+    catch {
+        // A malformed newline-terminated line is skipped, like readEvents skips it.
+    }
+    return null;
+}
+/** Reads exactly [offset, offset+length) — a follow must never re-read bytes. */
+function readRange(file, offset, length) {
+    const fd = fs.openSync(file, "r");
+    try {
+        const buffer = Buffer.alloc(length);
+        const read = fs.readSync(fd, buffer, 0, length, offset);
+        return read === length ? buffer : buffer.subarray(0, read);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}
+function fileSize(file) {
+    try {
+        return fs.statSync(file).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The `type` of the last COMPLETE line, when that type is terminal — null
+ * otherwise (including "file missing" and "last line torn", which both mean
+ * "keep following"). Only the file's tail is read; one event line is far
+ * smaller than the 8 KiB window.
+ */
+function lastTerminalEventType(file) {
+    const size = fileSize(file);
+    if (size === 0) {
+        return null;
+    }
+    const length = Math.min(size, 8192);
+    const body = readRange(file, size - length, length).toString("utf8");
+    const terminated = body.endsWith("\n") ? body.slice(0, -1) : body;
+    const lastNewline = terminated.lastIndexOf("\n");
+    if (lastNewline !== -1 || length === size) {
+        const line = (lastNewline === -1 ? terminated : terminated.slice(lastNewline + 1)).trim();
+        const event = parseStoredEvent(line);
+        if (event !== null && TERMINAL_EVENT_TYPES.has(event.type)) {
+            return event.type;
+        }
+    }
+    return null;
+}
+/** NodeJS.WritableStream has no terminal members; narrow structurally. */
+function streamIsTTY(stream) {
+    return stream.isTTY === true;
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/core/agent-args.js

@@ -0,0 +1,20 @@
+/**
+ * Arguments shared by every headless agent we spawn
+ * (specs/review-mcp-isolation.md).
+ */
+/**
+ * Keep the user's MCP servers out of the children we construct.
+ *
+ * `--tools` only restricts Claude Code's **built-in** set, so MCP tools
+ * registered at user/project scope are additive and survive it. With our own
+ * server registered (`glm-router mcp install`), that handed every `glm-review`
+ * session an `mcp__glm-coding-router__glm_worker` — write access and recursion
+ * from a surface documented as read-only.
+ *
+ * `--strict-mcp-config` uses only the servers given by `--mcp-config`. We pass
+ * none, so the set is empty and the child's tool surface is exactly the one we
+ * asked for. Security setting: not configurable, not overridable by a profile.
+ * Interactive sessions (`glm-chat`, `glm-fast`) are deliberately excluded —
+ * the user's own servers are theirs.
+ */
+export const STRICT_MCP_ARGS = ["--strict-mcp-config"];

package/dist/core/config.js

@@ -68,6 +68,53 @@ export const ConfigSchema = z.object({
     codexPath: z.string().min(1).optional(),
     // Named overlays selected via --profile (specs/glm-fast-profiles.md).
     profiles: z.record(z.string(), ProfileSchema).default({}),
+    // Run-history retention (specs/v2-architecture.md, Phase B / Config v2).
+    // The whole section is defaulted so every v1 config still validates.
+    history: z.object({
+        retentionDays: z.number().int().positive(),
+        maxRuns: z.number().int().positive(),
+    }).default({ retentionDays: 30, maxRuns: 1000 }),
+    // Progress renderer defaults (specs/v2-architecture.md, Phase C / Config v2).
+    // Defaulted exactly like `history` so every v1 config still validates and
+    // schemaVersion stays 1; `mode: "auto"` means rich on a TTY, nested otherwise.
+    ui: z.object({
+        mode: z.enum(["auto", "rich", "nested", "off"]),
+        color: z.boolean(),
+    }).default({ mode: "auto", color: true }),
+    // Quota-aware routing (specs/v2-architecture.md, Phase E / Config v2).
+    // Defaulted exactly like `history` so every v1 config still validates and
+    // schemaVersion stays 1.
+    routing: z.object({
+        quotaAware: z.boolean(),
+        refuseOnCritical: z.boolean(),
+        handoffOnLowQuota: z.boolean(),
+        reserveRatio: z.number().gt(0).lt(1),
+        safetyFactor: z.number().gte(1),
+        preferFlashBelow: z.number().gt(0).lt(1),
+        handoffReadyBelow: z.number().gt(0).lt(1),
+        criticalBelow: z.number().gt(0).lt(1),
+        pollIntervalSec: z.number().int().positive(),
+        quotaCacheTtlSec: z.number().int().positive(),
+    })
+        .refine((routing) => routing.criticalBelow < routing.handoffReadyBelow &&
+        routing.handoffReadyBelow < routing.preferFlashBelow, { message: "routing zones must be ordered criticalBelow < handoffReadyBelow < preferFlashBelow" })
+        .default({
+        quotaAware: true,
+        // D3 (specs/v2-architecture.md, Decisions): refuseOnCritical and
+        // handoffOnLowQuota ship OFF in 2.0.0. Both act on an unmeasured cost
+        // baseline, and a wrong refusal/kill blocks real work behind a --force
+        // escape hatch; a wrong downgrade costs almost nothing. Observe and
+        // downgrade only until the routingAdvice evidence justifies flipping.
+        refuseOnCritical: false,
+        handoffOnLowQuota: false,
+        reserveRatio: 0.10,
+        safetyFactor: 1.3,
+        preferFlashBelow: 0.30,
+        handoffReadyBelow: 0.15,
+        criticalBelow: 0.08,
+        pollIntervalSec: 60,
+        quotaCacheTtlSec: 60,
+    }),
 });
 export function defaultConfig() {
     return {
@@ -88,6 +135,20 @@ export function defaultConfig() {
             codexSkill: true,
         },
         profiles: {},
+        history: { retentionDays: 30, maxRuns: 1000 },
+        ui: { mode: "auto", color: true },
+        routing: {
+            quotaAware: true,
+            refuseOnCritical: false, // D3: observe in 2.0.0, refuse only on 2.1 evidence
+            handoffOnLowQuota: false, // D3: never kill a live child by default
+            reserveRatio: 0.10,
+            safetyFactor: 1.3,
+            preferFlashBelow: 0.30,
+            handoffReadyBelow: 0.15,
+            criticalBelow: 0.08,
+            pollIntervalSec: 60,
+            quotaCacheTtlSec: 60,
+        },
     };
 }
 /**

package/dist/core/errors.js

@@ -22,6 +22,8 @@ export const ExitCode = {
     ProjectRootNotFound: 30,
     ManagedFileWriteFailed: 31,
     ChildAgentFailed: 40,
+    QuotaInsufficient: 41,
+    HandoffRequired: 42,
     UnsupportedPlatform: 50,
 };
 /** Base error for all expected failures. Printed as `ERROR [NAME]` (spec §36). */
@@ -102,6 +104,28 @@ export const Errors = {
         message: `The child agent process failed: ${cause}`,
         exitCode: ExitCode.ChildAgentFailed,
     }),
+    // 41 and 42 (specs/v2-architecture.md Phase E/F, decision D2) both mean
+    // "unfinished, work preserved" — orchestrators read them as a handoff, not
+    // a crash, which is why their hints point at resuming rather than retrying.
+    quotaInsufficient: (estimatedCost, usableBudget) => new GlmRouterError({
+        name: "QUOTA_INSUFFICIENT",
+        // Both numbers are plan credits (H7), never currency.
+        message: `Estimated cost ${estimatedCost} credits does not fit the usable budget of ${usableBudget} credits.`,
+        // 41 is the preflight refusal: nothing was spawned yet, so the only
+        // moves are wait for a reset or explicitly accept the risk.
+        hint: ["Wait for the quota window to reset, or re-run with --force to run anyway."],
+        exitCode: ExitCode.QuotaInsufficient,
+    }),
+    handoffRequired: (reason, bundlePath) => new GlmRouterError({
+        name: "HANDOFF_REQUIRED",
+        message: `The run stopped unfinished: ${reason}.`,
+        // 42 is the mid-run handoff: the work is never lost, only moved.
+        hint: [
+            "The work is unfinished but preserved.",
+            ...(bundlePath !== undefined ? [`Pick it up from: ${bundlePath}`] : []),
+        ],
+        exitCode: ExitCode.HandoffRequired,
+    }),
     unsupportedPlatform: (platform) => new GlmRouterError({
         name: "UNSUPPORTED_PLATFORM",
         message: `This platform is not supported (detected: ${platform}).`,

package/dist/core/paths.js

@@ -11,3 +11,35 @@ export function configPath(home = os.homedir()) {
 export function ownershipPath(home = os.homedir()) {
     return path.join(configDir(home), "ownership.json");
 }
+/** Run history root: <configDir>/runs (specs/v2-architecture.md, Phase B). */
+export function runsDir(home = os.homedir()) {
+    return path.join(configDir(home), "runs");
+}
+/** Registry of still-running workers; a run graduates to history on finish. */
+export function activeRunsDir(home = os.homedir()) {
+    return path.join(runsDir(home), "active");
+}
+/**
+ * History partitioned per day so retention can prune whole date directories
+ * (doc §6). `date` (YYYY-MM-DD) comes from the caller — no clock inside the
+ * path helpers, so the store decides when the day flips.
+ */
+export function runHistoryDir(home = os.homedir(), date) {
+    return path.join(runsDir(home), "history", date);
+}
+/** One directory per run: events.jsonl, summary.json, checkpoint, handoff bundle. */
+export function runDir(home = os.homedir(), date, id) {
+    return path.join(runHistoryDir(home, date), id);
+}
+/** The registry entry for an active run, deleted when the run moves to history. */
+export function activeRunFile(home = os.homedir(), id) {
+    return path.join(activeRunsDir(home), `${id}.json`);
+}
+/** Cached quota snapshot (specs/v2-architecture.md, Phase E) — a cache, never truth. */
+export function quotaCachePath(home = os.homedir()) {
+    return path.join(configDir(home), "cache", "quota.json");
+}
+/** Cost-history samples, one JSON line per cleanly measured run (doc §13, Phase E). */
+export function costSamplesPath(home = os.homedir()) {
+    return path.join(configDir(home), "cost-samples.jsonl");
+}

package/dist/core/process.js

@@ -1,5 +1,6 @@
 import { spawn } from "node:child_process";
 import { Errors } from "./errors.js";
+import { logger } from "./logging.js";
 /**
  * Spawn a child agent process (spec §18, §32, §39):
  * - argument array, never a shell string
@@ -64,6 +65,88 @@ export function spawnAgentCapture(binPath, options) {
         });
     });
 }
+/**
+ * Like spawnAgentCapture, but delivers every complete stdout/stderr line the
+ * moment it arrives (v2 spec Phase D) instead of buffering the whole output
+ * until exit — that buffering is exactly what makes live progress impossible.
+ * Same no-shell argv rule and signal forwarding. A chunk boundary can fall
+ * inside a JSON object, so each stream carries its own partial-line buffer;
+ * blank lines are dropped, and a trailing line without a newline is flushed
+ * before the promise resolves — a crashed agent's last line is still evidence.
+ * A throwing callback is reported at debug level and never kills the run.
+ */
+export function spawnAgentStream(binPath, options) {
+    const { args, cwd, env, onStdoutLine, onStderrLine, onSpawn } = options;
+    return new Promise((resolve, reject) => {
+        const child = spawn(binPath, args, {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+            windowsHide: false,
+        });
+        if (onSpawn) {
+            try {
+                onSpawn(child);
+            }
+            catch (error) {
+                logger.debug(`spawnAgentStream: onSpawn callback failed: ${errorMessage(error)}`);
+            }
+        }
+        const stdout = createLineSplitter(onStdoutLine);
+        const stderr = createLineSplitter(onStderrLine);
+        child.stdout?.setEncoding("utf8");
+        child.stderr?.setEncoding("utf8");
+        child.stdout?.on("data", (chunk) => stdout.push(chunk));
+        child.stderr?.on("data", (chunk) => stderr.push(chunk));
+        const handlers = forwardSignals(child);
+        child.on("error", (error) => {
+            removeSignals(handlers);
+            reject(Errors.childAgentFailed(errorMessage(error)));
+        });
+        // "close", not "exit": it fires once the stdio streams are drained, so the
+        // trailing-line flush below cannot race data still sitting in the pipe.
+        child.on("close", (code) => {
+            removeSignals(handlers);
+            stdout.flush();
+            stderr.flush();
+            resolve({ code: code ?? 1 });
+        });
+    });
+}
+/** Per-stream line buffer for spawnAgentStream: emits each complete line (\n or \r\n) as it arrives. */
+function createLineSplitter(deliver) {
+    let buffer = "";
+    const emit = (line) => {
+        if (line.length === 0)
+            return;
+        try {
+            deliver(line);
+        }
+        catch (error) {
+            logger.debug(`spawnAgentStream: line callback failed: ${errorMessage(error)}`);
+        }
+    };
+    return {
+        push(chunk) {
+            buffer += chunk;
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+                const line = buffer.slice(0, newline);
+                buffer = buffer.slice(newline + 1);
+                emit(line.endsWith("\r") ? line.slice(0, -1) : line);
+                newline = buffer.indexOf("\n");
+            }
+        },
+        flush() {
+            if (buffer.length > 0) {
+                const line = buffer;
+                buffer = "";
+                emit(line);
+            }
+        },
+    };
+}
 /** Install SIGINT/SIGTERM forwarding; returns the handlers for cleanup. */
 function forwardSignals(child) {
     const handlers = new Map();

package/dist/core/prompt.js

@@ -17,16 +17,29 @@ export function readStdin() {
 }
 /**
  * Resolve the task prompt (spec §15, §40):
- *   stdin text → joined arguments → error
+ *   arguments → stdin text → error
+ *
+ * Arguments are checked FIRST, and when they carry a prompt stdin is never
+ * awaited. The original order was stdin-first, which hangs forever whenever
+ * stdin is an open pipe that never reaches EOF — the normal shape under an
+ * agent harness, a CI runner or `nohup`. Measured on Windows: with stdin held
+ * open, `glm-worker "Reply exactly with X"` did nothing at all — no run
+ * directory, no API call, no output — until the pipe closed 25 s later, then
+ * completed in 7 s. A prompt in argv is an explicit instruction and must not
+ * wait on a stream that may never close.
+ *
+ * Piping a task packet still works exactly as before: with no arguments,
+ * blocking until EOF is the correct thing to do, because there is nothing
+ * else to run.
  */
 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;
     }
+    const stdinText = await readStdinFn();
+    if (stdinText !== undefined && stdinText.trim().length > 0) {
+        return stdinText;
+    }
     throw Errors.promptRequired(command);
 }

package/dist/core/routing-flags.js

@@ -0,0 +1,59 @@
+import { Errors } from "./errors.js";
+/** The only two values `--model` takes; the router routes between config slots, not model names. */
+const MODEL_SLOTS = ["main", "fast"];
+/**
+ * Remove the router's Phase E flags from argv (specs/v2-architecture.md).
+ *
+ * Every occurrence is consumed, including repeats, because whatever is left in
+ * `rest` becomes the PROMPT — `resolvePrompt` joins it — so a flag that
+ * survives this function does not reach Claude as a flag, it silently becomes
+ * task text. That is why an unknown `--model` value is an error rather than a
+ * pass-through: quietly appending "--model gpt-4" to someone's prompt is worse
+ * than telling them the flag takes main or fast.
+ *
+ * Like `--profile` (specs/glm-fast-profiles.md), our `--model` deliberately
+ * shadows Claude Code's own flag of that name inside these binaries; callers
+ * who need Claude's version can call `claude` directly.
+ */
+export function extractRoutingFlags(argv) {
+    const rest = [];
+    let model;
+    let force = false;
+    let refreshQuota = false;
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--force") {
+            force = true;
+            continue;
+        }
+        if (arg === "--refresh-quota") {
+            refreshQuota = true;
+            continue;
+        }
+        if (arg === "--model") {
+            // The first occurrence wins, but later ones are still consumed so they
+            // cannot leak into the prompt.
+            model ??= parseSlot(argv[i + 1]);
+            i++;
+            continue;
+        }
+        if (arg.startsWith("--model=")) {
+            model ??= parseSlot(arg.slice("--model=".length));
+            continue;
+        }
+        rest.push(arg);
+    }
+    return { rest, model, force, refreshQuota };
+}
+function parseSlot(value) {
+    if (value === undefined || !MODEL_SLOTS.includes(value)) {
+        throw Errors.invalidArgs(`--model expects "main" or "fast"${value === undefined ? "" : `, got "${value}"`}.`, [
+            "Pick the configured slot, not a model name:",
+            "",
+            "  glm-worker --model fast \"<task>\"",
+            "",
+            "The names behind the slots come from models.main / models.fast in config.",
+        ]);
+    }
+    return value;
+}