github-router 0.3.249 → 0.3.255

package/dist/check-usage-6PB5IUFb.js

@@ -0,0 +1,43 @@
+import { i as ensurePaths } from "./paths-C1cLZ7Ga.js";
+import { r as setupGitHubToken } from "./token-R2ocFC3M.js";
+import { t as getCopilotUsage } from "./get-copilot-usage-DD1N0Xlh.js";
+import { defineCommand } from "citty";
+import consola from "consola";
+//#region src/check-usage.ts
+const checkUsage = defineCommand({
+	meta: {
+		name: "check-usage",
+		description: "Show current GitHub Copilot usage/quota information"
+	},
+	async run() {
+		await ensurePaths();
+		await setupGitHubToken();
+		try {
+			const usage = await getCopilotUsage();
+			const premium = usage.quota_snapshots.premium_interactions;
+			const premiumTotal = premium.entitlement;
+			const premiumUsed = premiumTotal - premium.remaining;
+			const premiumPercentUsed = premiumTotal > 0 ? premiumUsed / premiumTotal * 100 : 0;
+			const premiumPercentRemaining = premium.percent_remaining;
+			function summarizeQuota(name, snap) {
+				if (!snap) return `${name}: N/A`;
+				const total = snap.entitlement;
+				const used = total - snap.remaining;
+				const percentUsed = total > 0 ? used / total * 100 : 0;
+				const percentRemaining = snap.percent_remaining;
+				return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
+			}
+			const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`;
+			const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat);
+			const completionsLine = summarizeQuota("Completions", usage.quota_snapshots.completions);
+			consola.box(`Copilot Usage (plan: ${usage.copilot_plan})\nQuota resets: ${usage.quota_reset_date}\n\nQuotas:\n  ${premiumLine}\n  ${chatLine}\n  ${completionsLine}`);
+		} catch (err) {
+			consola.error("Failed to fetch Copilot usage:", err);
+			process.exit(1);
+		}
+	}
+});
+//#endregion
+export { checkUsage };
+
+//# sourceMappingURL=check-usage-6PB5IUFb.js.map

package/dist/check-usage-6PB5IUFb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-usage-6PB5IUFb.js","names":[],"sources":["../src/check-usage.ts"],"sourcesContent":["import { defineCommand } from \"citty\"\nimport consola from \"consola\"\n\nimport { ensurePaths } from \"./lib/paths\"\nimport { setupGitHubToken } from \"./lib/token\"\nimport {\n  getCopilotUsage,\n  type QuotaDetail,\n} from \"./services/github/get-copilot-usage\"\n\nexport const checkUsage = defineCommand({\n  meta: {\n    name: \"check-usage\",\n    description: \"Show current GitHub Copilot usage/quota information\",\n  },\n  async run() {\n    await ensurePaths()\n    await setupGitHubToken()\n    try {\n      const usage = await getCopilotUsage()\n      const premium = usage.quota_snapshots.premium_interactions\n      const premiumTotal = premium.entitlement\n      const premiumUsed = premiumTotal - premium.remaining\n      const premiumPercentUsed =\n        premiumTotal > 0 ? (premiumUsed / premiumTotal) * 100 : 0\n      const premiumPercentRemaining = premium.percent_remaining\n\n      // Helper to summarize a quota snapshot\n      function summarizeQuota(name: string, snap: QuotaDetail | undefined) {\n        if (!snap) return `${name}: N/A`\n        const total = snap.entitlement\n        const used = total - snap.remaining\n        const percentUsed = total > 0 ? (used / total) * 100 : 0\n        const percentRemaining = snap.percent_remaining\n        return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`\n      }\n\n      const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`\n      const chatLine = summarizeQuota(\"Chat\", usage.quota_snapshots.chat)\n      const completionsLine = summarizeQuota(\n        \"Completions\",\n        usage.quota_snapshots.completions,\n      )\n\n      consola.box(\n        `Copilot Usage (plan: ${usage.copilot_plan})\\n`\n          + `Quota resets: ${usage.quota_reset_date}\\n`\n          + `\\nQuotas:\\n`\n          + `  ${premiumLine}\\n`\n          + `  ${chatLine}\\n`\n          + `  ${completionsLine}`,\n      )\n    } catch (err) {\n      consola.error(\"Failed to fetch Copilot usage:\", err)\n      process.exit(1)\n    }\n  },\n})\n"],"mappings":";;;;;;AAUA,MAAa,aAAa,cAAc;CACtC,MAAM;EACJ,MAAM;EACN,aAAa;CACf;CACA,MAAM,MAAM;EACV,MAAM,YAAY;EAClB,MAAM,iBAAiB;EACvB,IAAI;GACF,MAAM,QAAQ,MAAM,gBAAgB;GACpC,MAAM,UAAU,MAAM,gBAAgB;GACtC,MAAM,eAAe,QAAQ;GAC7B,MAAM,cAAc,eAAe,QAAQ;GAC3C,MAAM,qBACJ,eAAe,IAAK,cAAc,eAAgB,MAAM;GAC1D,MAAM,0BAA0B,QAAQ;GAGxC,SAAS,eAAe,MAAc,MAA+B;IACnE,IAAI,CAAC,MAAM,OAAO,GAAG,KAAK;IAC1B,MAAM,QAAQ,KAAK;IACnB,MAAM,OAAO,QAAQ,KAAK;IAC1B,MAAM,cAAc,QAAQ,IAAK,OAAO,QAAS,MAAM;IACvD,MAAM,mBAAmB,KAAK;IAC9B,OAAO,GAAG,KAAK,IAAI,KAAK,GAAG,MAAM,SAAS,YAAY,QAAQ,CAAC,EAAE,UAAU,iBAAiB,QAAQ,CAAC,EAAE;GACzG;GAEA,MAAM,cAAc,YAAY,YAAY,GAAG,aAAa,SAAS,mBAAmB,QAAQ,CAAC,EAAE,UAAU,wBAAwB,QAAQ,CAAC,EAAE;GAChJ,MAAM,WAAW,eAAe,QAAQ,MAAM,gBAAgB,IAAI;GAClE,MAAM,kBAAkB,eACtB,eACA,MAAM,gBAAgB,WACxB;GAEA,QAAQ,IACN,wBAAwB,MAAM,aAAa,mBACtB,MAAM,iBAAiB,iBAEnC,YAAY,MACZ,SAAS,MACT,iBACX;EACF,SAAS,KAAK;GACZ,QAAQ,MAAM,kCAAkC,GAAG;GACnD,QAAQ,KAAK,CAAC;EAChB;CACF;AACF,CAAC"}

package/dist/claude-BiZxoNWq.js

@@ -0,0 +1,593 @@
+import { $ as scoutModel, C as buildToolbeltAwareness, Ct as shouldUseInsecureTls, Et as DEFAULT_CLAUDE_MODEL_FALLBACKS, G as brainstormModel, J as browserToolsEnabled, K as browseAgentEnabled, Nt as pickClaudeDefault, Q as reviewerModel, S as availableToolCommands, U as agentToolsEnabled, W as artifactToolsEnabled, X as geminiAvailable, Y as fleetToolsEnabled, Z as nativeSubagentModel, _t as provisionAndIndexColbert, a as buildPeerAwarenessSnippet, bt as warmTreeSitterPool, et as scribeModel, ht as provisionBrowserAssets, nt as workerToolsEnabled, o as buildPeerAwarenessSummary, q as browserCompoundToolsEnabled, tt as standInToolEnabled, w as toolbeltEnabled } from "./peer-mcp-personas-BDet588n.js";
+import { o as removeOwnClaudeConfigMirror, r as ensureClaudeConfigMirror, t as PATHS, u as writeArtifactCredsToMirror } from "./paths-C1cLZ7Ga.js";
+import { O as state, d as resolveModel } from "./token-R2ocFC3M.js";
+import { r as parseBoolEnv } from "./exec-DTO2oin0.js";
+import { a as sharedServerArgs, c as listModelsForEndpoint, d as updateClaude, i as setupAndServe, l as runSelfUpdate, o as startKeepAwake, r as parseSharedArgs, s as stopKeepAwake, t as getClaudeCodeEnvVars, u as checkClaudeVersion } from "./server-setup-DcO9qvN3.js";
+import { i as launchChild, r as getCodexVersion, t as provisionToolbelt } from "./provision-DSkPa5hY.js";
+import { i as captureLaunchBaseline, l as stopGateDisabled, n as buildSessionBindHookCommand, r as buildStopHookCommand, s as injectStopHookIntoSettingsFile, t as buildArtifactOpenHookCommand, u as stopGateId } from "./stop-gate-hook-DQc2KV7B.js";
+import { t as liveExec } from "./orchestration-hRU4TdWr.js";
+import { c as repoRoot, d as trustRepo, l as stopGateEnabledForRepo, s as repoFingerprint, t as fileBaselineStore } from "./stop-gate-policy-CHwWbuF_.js";
+import { l as guardToolMatcher, n as activeDispatchModes, r as buildWorkerGuardHookCommand } from "./worker-dispatch-Bj1uYyG9.js";
+import { _ as injectPeerMcpIntoMirror, b as workersKeyOf, c as prependArtifactPanelDirectiveToMirroredClaudeMd, i as OPERATING_DEFAULTS_DIGEST, l as prependOperatingDefaultsToMirroredClaudeMd, m as planModeAllowRules, n as INJECTED_SKILLS, o as appendPeerAwarenessToMirroredClaudeMd, p as injectAllowRules, r as writeInjectedSkill, s as appendToolbeltAwarenessToMirroredClaudeMd, t as injectAttributionSuppressionIntoSettingsFile, u as prependStyleDirectiveToMirroredClaudeMd, v as resolveCodexCliBackend, x as writePeerMcpRuntimeFiles, y as resolveGroupKeysFromMirror } from "./attribution-settings-CegtE0TY.js";
+import { t as enableFileLogging } from "./file-log-reporter-IFQcL5IK.js";
+import { r as hookMcpRuntimeFromEnv } from "./hook-mcp-client-DBvm9608.js";
+import { i as planReviewEnabled, t as buildPlanReviewHookCommand } from "./plan-review-hook-C8x0uKPf.js";
+import { a as checksForDescriptor, i as writeDiscoveredGate, n as readDiscoveredGate, o as descriptorHash, r as sourcesHash, s as parseGateDescriptor, t as discoverGateCommands } from "./gate-discovery-CepmbZnc.js";
+import { t as buildPromptSubmitHookCommand } from "./prompt-submit-hook-BrkkLAAB.js";
+import { i as assertShapingInstalled, n as buildFirstMateGuardHookCommand, t as FIRST_MATE_GUARD_MATCHER } from "./internal-first-mate-guard-La0tIjTU.js";
+import { defineCommand } from "citty";
+import consola from "consola";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { tmpdir } from "node:os";
+import process from "node:process";
+//#region src/lib/injected-skills/artifact-review-skill.ts
+const ARTIFACT_REVIEW_SKILL = {
+	name: "gh-artifact-review",
+	md: `---
+name: gh-artifact-review
+description: Reviews plans and artifacts in the ai-or-die panel. Defaults to authoring a self-contained HTML artifact (rich, annotatable, optionally interactive) and opening THAT for the human, then drains feedback with artifact_await, revises, and ends the loop. Use when running inside an ai-or-die tab and there is a plan, comparison, diagram, table, diff, or report the user should see before proceeding.
+user-invocable: true
+---
+
+# gh-artifact-review: human review in the ai-or-die panel
+
+Use this when you finish a plan or produce something a user should review and you are inside an ai-or-die tab (the \`mcp__peers__artifact_*\` tools drive a live panel). The human can click any block or select text to attach a comment, and can click declarative action controls you emit — both come back to you as typed events.
+
+## Default: present HTML, not raw markdown
+
+HTML is the canonical review artifact — it renders richly and is annotatable element-by-element. When the content is anything visual or structured (a comparison, table, diagram, diff, dashboard, or a plan you want to look polished), **author a self-contained \`.html\` file** (inline CSS, no external deps, readable typography) and open THAT.
+
+- Plan-mode plans: the panel auto-opens them already rendered to HTML — you do not need to convert them by hand.
+- Do not paste raw markdown into an \`.html\`; write real HTML (headings, lists, tables, \`<pre>\` for code). Opening a raw \`.md\` still renders, but a purpose-built HTML artifact reads better and annotates cleanly.
+
+## When to reach for an artifact
+
+Default to one for anything easier to grasp visually than as terminal prose: plans, design proposals, comparisons / trade-offs, decisions that need the user's input, diagrams / architecture, tables, code diffs, reports. Skip it only for trivial one-line answers.
+
+## Playbooks (what a good artifact of each type contains)
+
+- **plan**: goal, current state, the proposed approach (high-level decisions, not every line), then risks and open questions at the end.
+- **comparison**: options as columns, trade-offs as rows, current-vs-target where relevant, and an explicit recommendation. Do not make the reader infer the winner.
+- **table**: scannable rows, a sticky header, aligned numeric columns; group/section dense records rather than one flat wall.
+- **diagram**: boxes + arrows. Mermaid when automatic layout matters; positioned SVG/CSS when each node needs prose, code, or controls.
+- **code / diff**: \`<pre>\` with before/after or unified-diff styling; keep line context tight; call out the changed lines.
+- **report / dashboard**: lead with the headline number / verdict, then supporting detail; keep one idea per section.
+
+## Design system
+
+Artifacts stay portable (they must render identically opened standalone), so do not depend on a server-injected theme. Pick the look in priority order: (1) a look the user named; (2) the **subject project's** own design system, its Tailwind / theme config, CSS variables / tokens, component library, or existing styled pages, especially when the artifact previews that app's UI; (3) only when both come up empty, clean readable defaults (system font stack, generous spacing, a single accent).
+
+## Loop
+
+1. Open: \`mcp__peers__artifact_open\` with the absolute path of the \`.html\` (or the file). Pass \`mode:"interactive"\` when the HTML carries \`data-aod-*\` action controls (below). Relay the returned \`viewUrl\` and tell the user to review in the panel.
+2. Drain: \`mcp__peers__artifact_await\`. It long-holds for the human's next events and returns \`{events, status, cursor}\`. **Pass the returned \`cursor\` on your next call** so you only receive newer events; if \`events\` is empty, call again with that cursor.
+3. Act on each event by \`kind\`:
+   - \`comment\` — a free-text note anchored to the artifact (\`selector\`, quoted \`text\`, \`sourceLine\`); apply the requested change at that exact spot.
+   - \`action\` — the human clicked a control you emitted (\`action\` verb, \`elementId\`, optional \`value\`; a multi-select submit arrives as one action carrying the selected set). Do what the verb means (approve a step, choose an option, apply a toggle set).
+4. Reply: \`mcp__peers__artifact_reply\` with a concise summary of what you changed. Optionally \`mcp__peers__artifact_update({file})\` or \`({html})\` to replace the artifact content in place, or \`mcp__peers__artifact_refresh\` to reload it from disk.
+5. Repeat 2-4 until the user is satisfied; then \`mcp__peers__artifact_end\`. Use \`mcp__peers__artifact_dismiss\` to hide the panel while keeping the review alive (queued feedback preserved) if the user wants it out of the way without ending.
+
+### Push arrival (you do not have to be polling)
+
+When you are idle at the prompt, panel feedback can arrive on its own as a new turn (the tab injects it). Structured actions that answer a pending decision are routed to you directly. Either way, the durable record is the \`artifact_await\` drain, so when in doubt call \`artifact_await\` (with your last cursor) to reconcile — it replays anything you missed.
+
+### \`artifact_poll\` (frozen legacy)
+
+\`mcp__peers__artifact_poll\` still resolves for back-compat but returns the OLD payload (human comments only, no structured actions). Prefer \`artifact_await\`.
+
+## Interactive controls (data-aod-* authoring)
+
+To let the human act on the artifact (not just comment), emit declarative controls; the panel wires them and delivers a typed \`action\` event. No JS in the artifact.
+
+- **choose-one (fires immediately):** each option is a button that posts the moment it is clicked.
+  \`<button data-aod-action="choose" data-aod-group="decision-1" data-aod-id="opt-jwt" data-aod-value="jwt">JWT</button>\`
+- **multi-select (toggle then submit):** checkboxes sharing a \`data-aod-group\`, plus one submit button with the same group. The submit delivers ONE action carrying \`{group, selected:[{elementId, value?}]}\`.
+  \`<input type="checkbox" data-aod-action="check" data-aod-group="opts" data-aod-id="a" data-aod-value="a">\` … \`<button data-aod-action="submit" data-aod-group="opts" data-aod-id="opts-submit">Apply</button>\`
+- **plan steps:** \`<li class="aod-step" data-aod-id="plan-step-3" data-source-line="14">\` with per-step \`data-aod-action="approve"/"skip"\` buttons.
+- **Required attrs:** \`data-aod-action\` (verb), \`data-aod-id\` (stable, echoed back as \`elementId\`; a control missing it is ignored), optional \`data-aod-value\`. Keep \`data-source-line\` for comment mapping.
+
+## Honest limits
+
+- If a tool errors (e.g. \`NOT_IN_AIORDIE_TAB\`, \`UNREACHABLE\`, \`INVALID_REQUEST\`), report the code/message verbatim; do not claim the panel opened.
+- The panel is a review surface, not an approver: outward/irreversible actions still need explicit user confirmation.
+`
+};
+//#endregion
+//#region src/claude.ts
+function isFirstMateSkillName(name) {
+	return name === "gh-first-mate" || name === "gh-first-mate-scaffold" || name === "gh-first-mate-operate" || name === "gh-first-mate-conduct";
+}
+const claudeArgs = {
+	...sharedServerArgs,
+	model: {
+		alias: "m",
+		type: "string",
+		description: "Override the default model for Claude Code. Accepts a full slug (e.g. claude-opus-4-7) or an Opus family shorthand (e.g. 4.7, 4.8, 4.6) which expands to the best variant for that family — adding the [1m] suffix when a 1M-context backend is in the catalog."
+	},
+	"codex-mcp": {
+		type: "boolean",
+		default: true,
+		description: "Wire peer-model MCP personas (codex-critic, codex-reviewer, gemini-critic) into the spawned Claude Code session"
+	},
+	"codex-cli": {
+		type: "boolean",
+		default: false,
+		description: "Add a `codex mcp-server` stdio backend so codex-implementer can mutate files. Requires codex CLI 0.129+; gracefully falls back to HTTP-only if absent."
+	},
+	"codex-mcp-only": {
+		type: "boolean",
+		default: false,
+		description: "Pass --strict-mcp-config to claude code so only github-router's MCP servers are loaded (hides user's existing MCP servers)"
+	},
+	stealth: {
+		type: "boolean",
+		default: false,
+		description: "Opt back into VS Code-only beta header filtering. Loses leverage features (task budgets, token-efficient tools, prompt caching, etc.) but minimizes the wire-fingerprint difference from VS Code Copilot Chat. By default the `claude` subcommand enables extended/leverage betas because the spawned Claude Code already identifies itself via UA and other headers — partial stealth doesn't buy much."
+	},
+	"trust-gate": {
+		type: "boolean",
+		default: false,
+		description: "Explicitly record consent for the structural Stop-gate in THIS repo (pinned to the repo's root-commit). The gate is ON BY DEFAULT when a harness is detected (consent-by-launching), so this is now mostly redundant; it stays for explicit/scripted use. Disable the gate entirely with GH_ROUTER_DISABLE_STOP_GATE=1."
+	},
+	"no-stop-gate": {
+		type: "boolean",
+		default: false,
+		description: "Disable the structural Stop-gate for THIS session (same effect as GH_ROUTER_DISABLE_STOP_GATE=1). Intended for driven/automated sessions where a blocking Stop hook would hang the turn-end while a fleet driver waits."
+	},
+	"auto-update": {
+		type: "boolean",
+		default: true,
+		description: "Check for and install the latest Claude Code on launch via `claude update` (throttled to once per hour via ~/.local/share/github-router/last-update-check). `claude update` respects the real install method (native installer or npm), so it never creates a conflicting second install; builds too old to support it fall back to `npm install -g @anthropic-ai/claude-code@latest`. Set to false (--no-auto-update) to check and warn only. Falls back gracefully if claude/npm/network unavailable."
+	},
+	"update-check": {
+		type: "boolean",
+		default: true,
+		description: "Check the npm registry for a newer Claude Code version on launch and warn if stale (non-blocking ~500ms cost). Set to false (--no-update-check) to skip the check entirely (useful for offline/CI). Independent from --auto-update: --no-update-check implies no auto-install (nothing to install since we never check)."
+	}
+};
+/**
+* Build the argv to forward to the spawned `claude` child from citty's
+* rawArgs (every token after the `claude` subcommand). citty is non-strict,
+* so an unknown flag such as `--print`/`-p`… `--output-format` is absorbed
+* into the parsed `args` object AND its value swallowed, instead of landing
+* in `args._`; forwarding only `args._` therefore drops headless flags unless
+* the user wrapped them in `--`. Here we walk rawArgs and forward every token
+* that is NOT one of github-router's OWN declared flags (or that flag's
+* consumed value). Everything after a literal `--` is forwarded verbatim,
+* preserving the prior explicit-passthrough behavior.
+*
+* A child flag whose NAME collides with a github-router flag (`-p`/`--port`,
+* `-v`/`--verbose`, `-m`/`--model`, `-a`/`--account-type`, `-r`/`--rate-limit`,
+* `-g`/`--github-token`) is owned by github-router; forward it to the child
+* explicitly after `--` (e.g. `github-router claude -- -p`). Every other Claude
+* flag (`--print`, `--output-format`, `--resume`, `--continue`, …) flows
+* through automatically.
+*/
+function collectChildPassthroughArgs(rawArgs, argsDef) {
+	const known = /* @__PURE__ */ new Set();
+	const stringTyped = /* @__PURE__ */ new Set();
+	for (const [name, def] of Object.entries(argsDef)) {
+		const rawAlias = "alias" in def ? def.alias : void 0;
+		const aliases = rawAlias === void 0 ? [] : Array.isArray(rawAlias) ? rawAlias : [rawAlias];
+		for (const n of [name, ...aliases]) {
+			known.add(n);
+			if (def.type === "string") stringTyped.add(n);
+		}
+	}
+	const forwarded = [];
+	for (let i = 0; i < rawArgs.length; i++) {
+		const tok = rawArgs[i];
+		if (tok === "--") {
+			forwarded.push(...rawArgs.slice(i + 1));
+			break;
+		}
+		if (tok === "-" || !tok.startsWith("-")) {
+			forwarded.push(tok);
+			continue;
+		}
+		const doubleDash = tok.startsWith("--");
+		const afterDashes = tok.slice(doubleDash ? 2 : 1);
+		const eq = afterDashes.indexOf("=");
+		const rawName = eq >= 0 ? afterDashes.slice(0, eq) : afterDashes;
+		const hasInlineValue = eq >= 0;
+		const negated = doubleDash && rawName.startsWith("no-");
+		const baseName = negated ? rawName.slice(3) : rawName;
+		if (!(known.has(rawName) || negated && known.has(baseName))) {
+			forwarded.push(tok);
+			continue;
+		}
+		if (!negated && !hasInlineValue && stringTyped.has(rawName) && i + 1 < rawArgs.length && rawArgs[i + 1] !== "--" && !rawArgs[i + 1].startsWith("-")) i++;
+	}
+	return forwarded;
+}
+const claude = defineCommand({
+	meta: {
+		name: "claude",
+		description: "Start the proxy server and launch Claude Code"
+	},
+	args: claudeArgs,
+	async run({ args, rawArgs }) {
+		if (!process.stdout.isTTY) {
+			consola.error("The claude subcommand requires a TTY (interactive terminal).");
+			process.exit(1);
+		}
+		const parsed = parseSharedArgs(args);
+		if (args.stealth) {
+			parsed.extendedBetas = false;
+			consola.info("Stealth mode: VS Code-only beta filtering. Leverage features disabled.");
+		} else if (!args["extended-betas"]) parsed.extendedBetas = true;
+		if (args["update-check"] !== false) try {
+			const versionCheck = await checkClaudeVersion({ noCheck: false });
+			if (versionCheck.skipped && versionCheck.skipReason === "no-claude") consola.debug("claude --version probe failed; skipping auto-update.");
+			else if (versionCheck.skipped && versionCheck.skipReason === "no-npm") consola.debug("npm view @anthropic-ai/claude-code failed; skipping auto-update check (likely offline).");
+			else if (versionCheck.needsUpdate && versionCheck.installedVersion && versionCheck.latestVersion) if (args["auto-update"] !== false) try {
+				await updateClaude(versionCheck.latestVersion);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				consola.warn(`Auto-update of Claude Code from ${versionCheck.installedVersion} to ${versionCheck.latestVersion} failed (${msg}); continuing with installed version. Run \`claude update\` (or \`npm install -g @anthropic-ai/claude-code@latest\`) manually to retry.`);
+			}
+			else consola.warn(`Claude Code v${versionCheck.installedVersion} is installed; v${versionCheck.latestVersion} is available. Run with --auto-update (the default) to install on launch, or \`claude update\` manually.`);
+		} catch (err) {
+			consola.debug("Claude version check failed:", err);
+		}
+		let server;
+		let serverUrl;
+		try {
+			const result = await setupAndServe({
+				...parsed,
+				port: parsed.port,
+				silent: true
+			});
+			server = result.server;
+			serverUrl = result.serverUrl;
+		} catch (error) {
+			consola.error("Failed to start server:", error instanceof Error ? error.message : error);
+			process.exit(1);
+		}
+		runSelfUpdate({ selfUpdate: args["self-update"] !== false });
+		try {
+			await ensureClaudeConfigMirror();
+		} catch (err) {
+			consola.error(`Failed to provision CLAUDE_CONFIG_DIR mirror: ${err instanceof Error ? err.message : String(err)}. Spawned Claude Code would not be able to authenticate.`);
+			process.exit(1);
+		}
+		enableFileLogging();
+		const usingDefault = !args.model;
+		const opusFamilyShorthand = args.model?.match(/^(\d+\.\d+)$/)?.[1];
+		let chosenSlug = opusFamilyShorthand ? pickClaudeDefault(opusFamilyShorthand) : args.model ?? pickClaudeDefault();
+		let resolvedSlug = resolveModel(chosenSlug);
+		if (usingDefault && state.models) {
+			const inCache = (slug) => state.models?.data.some((m) => m.id === resolveModel(slug)) ?? false;
+			if (!inCache(chosenSlug)) {
+				for (const fallback of DEFAULT_CLAUDE_MODEL_FALLBACKS) if (inCache(fallback)) {
+					const fallbackSlug = pickClaudeDefault(fallback.replace(/^claude-opus-/, ""));
+					consola.info(`Default model "${chosenSlug}" not in your Copilot model list; falling back to "${fallbackSlug}".`);
+					chosenSlug = fallbackSlug;
+					resolvedSlug = resolveModel(fallbackSlug);
+					break;
+				}
+			}
+		}
+		if (resolvedSlug !== chosenSlug) consola.info(`Model "${chosenSlug}" resolved to "${resolvedSlug}"`);
+		if (!state.models?.data.find((m) => m.id === resolvedSlug)) {
+			const available = listModelsForEndpoint("/v1/messages");
+			consola.warn(`Model "${resolvedSlug}" not found. Available claude models: ${available.join(", ")}`);
+		}
+		const banner = chosenSlug === resolvedSlug ? chosenSlug : `${chosenSlug} → ${resolvedSlug}`;
+		process.stderr.write(`Server ready on ${serverUrl}, launching Claude Code (${banner})...\n`);
+		const envVars = getClaudeCodeEnvVars(serverUrl, chosenSlug);
+		const extraArgs = collectChildPassthroughArgs(rawArgs, claudeArgs);
+		if (toolbeltEnabled()) {
+			provisionToolbelt().catch((err) => consola.debug("Toolbelt provisioning failed:", err));
+			const toolbeltLine = buildToolbeltAwareness(availableToolCommands());
+			if (toolbeltLine) try {
+				await appendToolbeltAwarenessToMirroredClaudeMd(toolbeltLine);
+			} catch (err) {
+				consola.warn(`Toolbelt CLAUDE.md append failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		}
+		provisionAndIndexColbert();
+		warmTreeSitterPool();
+		startKeepAwake();
+		if (browserToolsEnabled()) provisionBrowserAssets().catch((err) => consola.debug("Browser extension provisioning failed:", err));
+		const baseShutdown = async () => {
+			await stopKeepAwake();
+			await removeOwnClaudeConfigMirror();
+		};
+		let onShutdown = baseShutdown;
+		let peerAwarenessSnippet;
+		let peerAwarenessSummary;
+		if (args["codex-mcp"] !== false) try {
+			const requestedCli = args["codex-cli"] ?? false;
+			const backend = resolveCodexCliBackend({
+				requested: requestedCli,
+				codexInfo: requestedCli ? getCodexVersion() : null
+			});
+			const geminiModelsAvailable = geminiAvailable();
+			if (!geminiModelsAvailable) consola.info("gemini-3.1-pro-preview not found in your Copilot model catalog; gemini-critic persona will not be registered.");
+			const enabledGroups = [
+				"peers",
+				"search",
+				"orchestrate"
+			];
+			if (workerToolsEnabled()) enabledGroups.push("workers");
+			if (standInToolEnabled()) enabledGroups.push("decide");
+			if (browserToolsEnabled()) enabledGroups.push("browser");
+			if (fleetToolsEnabled()) enabledGroups.push("fleet");
+			if (agentToolsEnabled()) enabledGroups.push("first-mate");
+			const { keys: groupKeys, skipped: skippedGroups } = await resolveGroupKeysFromMirror(enabledGroups);
+			const runtime = await writePeerMcpRuntimeFiles(serverUrl, {
+				codexCli: backend === "cli",
+				geminiAvailable: geminiModelsAvailable,
+				groupKeys,
+				workerToolsAvailable: workerToolsEnabled(),
+				browseAvailable: browseAgentEnabled(),
+				nativeSubagentModel: nativeSubagentModel(),
+				reviewerModel: reviewerModel(),
+				brainstormModel: brainstormModel(),
+				scoutModel: scoutModel(),
+				scribeModel: scribeModel()
+			});
+			state.peerMcpNonce = runtime.nonce;
+			envVars.GH_ROUTER_HOOK_MCP_URL = serverUrl;
+			envVars.GH_ROUTER_HOOK_NONCE = runtime.nonce;
+			onShutdown = async () => {
+				await runtime.cleanup();
+				await baseShutdown();
+			};
+			const injected = await injectPeerMcpIntoMirror(serverUrl, {
+				codexCli: backend === "cli",
+				geminiAvailable: geminiModelsAvailable,
+				groupKeys,
+				nonce: runtime.nonce
+			});
+			if (!injected.ok) {
+				extraArgs.push("--mcp-config", runtime.mcpConfigPath);
+				if (args["codex-mcp-only"] === true) extraArgs.push("--strict-mcp-config");
+			} else if (args["codex-mcp-only"] === true) consola.warn("--codex-mcp-only has no effect when peer MCP is wired via the mirrored .claude.json (the user's existing user-scope MCPs in the snapshot are still visible). Pass --no-codex-mcp to skip peer-MCP wiring entirely.");
+			const personaNames = runtime.personas.map((p) => p.agentName).join(", ");
+			const subagentVisibility = injected.ok ? `subagent-visible (mirrored mcpServers: [${injected.serversAdded.join(", ")}])` : `subagent-INVISIBLE (collision on user-side mcpServers: [${injected.conflictingServers.join(", ")}]; parent-only via --mcp-config)`;
+			const skippedNote = skippedGroups.length > 0 ? ` WARNING: groups [${skippedGroups.join(", ")}] skipped — both the bare and \`gh-router-<group>\` keys collide with your own mcpServers; those tools are unavailable this session (rename the user-side server to re-enable).` : "";
+			process.stderr.write(`Peer MCP wired (backend=${backend}, personas=[${personaNames}], subagent .md files=${runtime.agentMdPaths.length}, ${subagentVisibility}).${skippedNote}\n`);
+			const sessionCwd = process.cwd();
+			if (workerToolsEnabled()) {
+				const skillsToWrite = INJECTED_SKILLS.filter((s) => !isFirstMateSkillName(s.name) || agentToolsEnabled());
+				let skillsWritten = 0;
+				for (const s of skillsToWrite) if ((await writeInjectedSkill(s.name, s.md).catch(() => ({ written: false }))).written) skillsWritten++;
+				try {
+					const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+					const cmd = buildPromptSubmitHookCommand(process.execPath, process.argv[1]);
+					await injectStopHookIntoSettingsFile(settingsPath, cmd, "UserPromptSubmit", 45);
+				} catch (err) {
+					consola.warn(`Could not register the UserPromptSubmit hook: ${String(err)}`);
+				}
+				try {
+					const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+					const injectedServerKeys = injected.ok ? injected.serversAdded : [...Object.values(groupKeys).filter((k) => Boolean(k)), ...backend === "cli" ? ["codex-cli"] : []];
+					const res = await injectAllowRules(settingsPath, planModeAllowRules(injectedServerKeys));
+					if (res.added.length) consola.debug(`Auto-approved for plan mode: ${res.added.join(", ")}`);
+				} catch (err) {
+					consola.warn(`Could not auto-approve injected tools: ${String(err)}`);
+				}
+				if (!injected.ok) consola.warn("Workers non-blocking guard NOT registered: subagent MCP injection fell back to parent-only (--mcp-config), so worker-* dispatchers cannot reach the workers server. Raw (blocking) worker tools remain usable on the main thread this session.");
+				else if (process.env.GH_ROUTER_DISABLE_WORKER_GUARD === "1") consola.info("Workers non-blocking guard disabled via GH_ROUTER_DISABLE_WORKER_GUARD=1 — raw mcp__workers__* is callable on the main thread (blocking); the worker-* background agents remain the steered, non-blocking default.");
+				else try {
+					const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+					const workersKey = workersKeyOf(groupKeys);
+					const modes = activeDispatchModes({ browse: browseAgentEnabled() });
+					const cmd = buildWorkerGuardHookCommand(process.execPath, process.argv[1], workersKey, modes);
+					const matcher = guardToolMatcher(workersKey, modes);
+					await injectStopHookIntoSettingsFile(settingsPath, cmd, "PreToolUse", 10, matcher);
+				} catch (err) {
+					consola.warn(`Could not register the workers PreToolUse guard hook: ${String(err)}`);
+				}
+				if (skillsWritten > 0) {
+					const skillNames = skillsToWrite.map((s) => `/${s.name}`).join(", ");
+					process.stderr.write(`Injected skills (${skillsWritten}/${skillsToWrite.length}): ${skillNames}.\n`);
+				}
+			}
+			if (agentToolsEnabled()) {
+				let shapingInstalled = false;
+				try {
+					const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+					const guardCmd = buildFirstMateGuardHookCommand(process.execPath, process.argv[1]);
+					await injectStopHookIntoSettingsFile(settingsPath, guardCmd, "PreToolUse", void 0, FIRST_MATE_GUARD_MATCHER);
+					shapingInstalled = true;
+				} catch (err) {
+					consola.error(`Could not register the operator worker/orchestrate guard hook: ${String(err)}`);
+				}
+				assertShapingInstalled(true, shapingInstalled);
+			}
+			const aiordieSidecar = (process.env.AIORDIE_CLAUDE_BIND ?? "").trim();
+			if (aiordieSidecar.length > 0 && !aiordieSidecar.includes("\"")) try {
+				const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+				const command = buildSessionBindHookCommand(process.execPath, process.argv[1], aiordieSidecar);
+				await injectStopHookIntoSettingsFile(settingsPath, command, "SessionStart");
+				await injectStopHookIntoSettingsFile(settingsPath, command, "SessionEnd");
+			} catch (err) {
+				consola.warn(`Could not register the ai-or-die session-bind hook: ${String(err)}`);
+			}
+			if (artifactToolsEnabled()) {
+				await writeInjectedSkill(ARTIFACT_REVIEW_SKILL.name, ARTIFACT_REVIEW_SKILL.md).catch(() => ({ written: false }));
+				try {
+					await prependArtifactPanelDirectiveToMirroredClaudeMd(groupKeys.peers);
+				} catch (err) {
+					consola.warn(`Artifact-panel directive prepend failed: ${String(err)}`);
+				}
+				try {
+					await writeArtifactCredsToMirror(shouldUseInsecureTls(process.env.AIORDIE_BASE_URL ?? ""));
+					const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+					const cmd = buildArtifactOpenHookCommand(process.execPath, process.argv[1]);
+					await injectStopHookIntoSettingsFile(settingsPath, cmd, "PostToolUse", void 0, "ExitPlanMode");
+				} catch (err) {
+					consola.warn(`Could not register the artifact auto-open hook: ${String(err)}`);
+				}
+			}
+			if (hookMcpRuntimeFromEnv(envVars) && planReviewEnabled()) try {
+				const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+				const command = buildPlanReviewHookCommand(process.execPath, process.argv[1]);
+				await injectStopHookIntoSettingsFile(settingsPath, command, "PostToolUse", void 0, "ExitPlanMode");
+			} catch (err) {
+				consola.warn(`Could not register the advisory plan-review hook: ${String(err)}`);
+			}
+			if (args["trust-gate"] === true) try {
+				const root = await trustRepo(sessionCwd);
+				process.stderr.write(`Structural gate trusted for this repo (${root}); it will run on launch here from now on.\n`);
+			} catch (err) {
+				consola.warn(`Could not record gate trust: ${String(err)}`);
+			}
+			const gateDisabled = stopGateDisabled(args);
+			const forceEnabled = parseBoolEnv(process.env.GH_ROUTER_ENABLE_STOP_GATE) === true;
+			const includeTests = parseBoolEnv(process.env.GH_ROUTER_STOP_GATE_RUN_TESTS) === true;
+			const gateRoot = await repoRoot(sessionCwd).catch(() => sessionCwd);
+			let descriptor = null;
+			let discovering = false;
+			if (!gateDisabled) {
+				descriptor = await parseGateDescriptor(gateRoot, { includeTests }).catch(() => null);
+				if (!descriptor) {
+					const cached = await readDiscoveredGate(gateRoot).catch(() => null);
+					if (cached) descriptor = {
+						kind: "discovered",
+						checks: cached.checks,
+						ecosystem: cached.ecosystem,
+						workdir: gateRoot,
+						evidence: cached.evidence
+					};
+					else if (!forceEnabled && workerToolsEnabled() && parseBoolEnv(process.env.GH_ROUTER_ENABLE_GATE_DISCOVERY) === true) discovering = true;
+				}
+			}
+			let gateEnabled = gateDisabled ? false : await stopGateEnabledForRepo(sessionCwd).catch(() => false);
+			let autoTrusted = false;
+			if (!gateEnabled && !gateDisabled && (descriptor || discovering)) try {
+				await trustRepo(sessionCwd);
+				gateEnabled = true;
+				autoTrusted = true;
+			} catch (err) {
+				consola.warn(`Could not auto-trust this repo for the structural gate: ${String(err)}`);
+			}
+			if (gateEnabled && !descriptor && !discovering) descriptor = {
+				kind: "sealed",
+				gateId: stopGateId(),
+				workdir: gateRoot
+			};
+			if (gateEnabled && descriptor) {
+				const armed = descriptor;
+				try {
+					const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+					const command = buildStopHookCommand(process.execPath, process.argv[1]);
+					if (armed.kind === "sealed") envVars.GH_ROUTER_STOP_GATE_ID = armed.gateId;
+					else if (armed.kind === "parsed") envVars.GH_ROUTER_STOP_GATE_PARSED = "1";
+					else envVars.GH_ROUTER_STOP_GATE_DISCOVERED = "1";
+					if (includeTests) envVars.GH_ROUTER_STOP_GATE_RUN_TESTS = "1";
+					await injectStopHookIntoSettingsFile(settingsPath, command);
+					if (armed.kind !== "sealed") {
+						const checks = checksForDescriptor(armed);
+						const descriptorKey = descriptorHash(armed);
+						const token = randomBytes(8).toString("hex");
+						envVars.GH_ROUTER_STOP_GATE_BASELINE_TOKEN = token;
+						(async () => {
+							await captureLaunchBaseline({
+								checks,
+								workdir: armed.workdir,
+								exec: liveExec,
+								descriptorKey,
+								token,
+								baseline: fileBaselineStore(path.join(tmpdir(), "gh-router-stopgate-baseline"))
+							});
+						})().catch(() => {});
+					}
+					const tail = "A regression or a gate-weakening diff blocks stopping until fixed (per-prompt, max 2). Opt out with GH_ROUTER_DISABLE_STOP_GATE=1.\n";
+					if (armed.kind === "sealed") process.stderr.write((autoTrusted ? `Structural-gate Stop hook enabled by default for this repo (gate=${armed.gateId}; runs typecheck/test/lint at stop). ` : `Structural-gate Stop hook enabled (gate=${armed.gateId}). `) + tail);
+					else {
+						const ids = checksForDescriptor(armed).map((c) => c.id).join(", ");
+						const testNote = includeTests ? "Full test suite ON. " : "Full test suite off by default (enable with GH_ROUTER_STOP_GATE_RUN_TESTS=1). ";
+						process.stderr.write(`Structural-gate Stop hook armed for this ${armed.ecosystem} repo (checks: ${ids}; from ${armed.evidence.join(", ")}). ${testNote}${tail}`);
+					}
+				} catch (err) {
+					consola.warn(`Could not register the structural-gate Stop hook: ${String(err)}`);
+				}
+			} else if (gateEnabled && discovering) {
+				process.stderr.write("Structural Stop-gate: no checks parsed for this repo — discovering check commands in the background (arms on the next launch). Disable with GH_ROUTER_ENABLE_GATE_DISCOVERY=0.\n");
+				(async () => {
+					try {
+						const disc = await discoverGateCommands(gateRoot, {
+							includeTests,
+							signal: AbortSignal.timeout(12e4)
+						});
+						if (disc) {
+							const [fingerprint, sh] = await Promise.all([repoFingerprint(gateRoot).catch(() => ""), sourcesHash(gateRoot).catch(() => "")]);
+							await writeDiscoveredGate({
+								root: gateRoot,
+								fingerprint,
+								sourcesHash: sh,
+								discoveredAt: (/* @__PURE__ */ new Date()).toISOString(),
+								model: "gemini-3.5-flash",
+								ecosystem: disc.ecosystem,
+								checks: disc.checks,
+								confidence: disc.confidence,
+								evidence: disc.evidence
+							});
+						}
+					} catch {}
+				})().catch(() => {});
+			} else if (!gateDisabled && !descriptor && !discovering) process.stderr.write("Structural Stop-gate not enabled: no checks found in this repo (looked at package.json scripts / CI workflows / Makefile / Cargo.toml / go.mod / pyproject). Force a sealed gate with GH_ROUTER_ENABLE_STOP_GATE=1" + (workerToolsEnabled() ? ", or let a model discover them with GH_ROUTER_ENABLE_GATE_DISCOVERY=1" : "") + ".\n");
+			const peerSnippet = buildPeerAwarenessSnippet({
+				codexCli: backend === "cli",
+				geminiAvailable: geminiModelsAvailable,
+				workerToolsAvailable: workerToolsEnabled(),
+				standInAvailable: standInToolEnabled(),
+				browseAvailable: browserToolsEnabled(),
+				compoundBrowseAvailable: browserCompoundToolsEnabled(),
+				powerBrowseAvailable: state.powerBrowseEnabled,
+				fleetAvailable: fleetToolsEnabled(),
+				agentToolsAvailable: agentToolsEnabled(),
+				scoutAvailable: scoutModel() != null,
+				groupKeys
+			});
+			peerAwarenessSnippet = peerSnippet;
+			peerAwarenessSummary = buildPeerAwarenessSummary({
+				workerToolsAvailable: workerToolsEnabled(),
+				standInAvailable: standInToolEnabled(),
+				browseAvailable: browserToolsEnabled(),
+				fleetAvailable: fleetToolsEnabled(),
+				agentToolsAvailable: agentToolsEnabled(),
+				groupKeys
+			});
+			try {
+				await appendPeerAwarenessToMirroredClaudeMd(peerSnippet);
+			} catch (err) {
+				consola.warn(`Peer-awareness CLAUDE.md append failed (agent keeps tool descriptions via tools/list, loses the inventory overview): ${err instanceof Error ? err.message : String(err)}`);
+			}
+			try {
+				await prependStyleDirectiveToMirroredClaudeMd();
+			} catch (err) {
+				consola.warn(`Style-directive CLAUDE.md prepend failed: ${err instanceof Error ? err.message : String(err)}`);
+			}
+		} catch (err) {
+			consola.warn(`Peer MCP wiring failed (claude will launch without it): ${err instanceof Error ? err.message : String(err)}`);
+		}
+		extraArgs.push("--append-system-prompt", peerAwarenessSnippet && peerAwarenessSummary ? `${OPERATING_DEFAULTS_DIGEST}\n\n${peerAwarenessSummary}` : OPERATING_DEFAULTS_DIGEST);
+		try {
+			await prependOperatingDefaultsToMirroredClaudeMd();
+		} catch (err) {
+			consola.warn(`Operating-defaults CLAUDE.md prepend failed: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		if (process.env.GH_ROUTER_DISABLE_NO_ATTRIBUTION !== "1") try {
+			const settingsPath = path.join(PATHS.CLAUDE_CONFIG_DIR, "settings.json");
+			await injectAttributionSuppressionIntoSettingsFile(settingsPath);
+		} catch (err) {
+			consola.warn(`No-attribution settings backstop skipped: ${err instanceof Error ? err.message : String(err)}`);
+		}
+		launchChild({
+			kind: "claude-code",
+			envVars,
+			extraArgs,
+			model: chosenSlug
+		}, server, { onShutdown });
+	}
+});
+//#endregion
+export { claude };
+
+//# sourceMappingURL=claude-BiZxoNWq.js.map