github-router 0.3.313 → 0.3.315

package/dist/hooks.mjs

@@ -6,9 +6,9 @@ import g, { stdin, stdout } from "node:process";
 import * as tty from "node:tty";
 import { WriteStream } from "node:tty";
 import f from "node:readline";
-import { existsSync, mkdirSync, promises, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import fs, { existsSync, mkdirSync, promises, readFileSync, realpathSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
 import os, { homedir, tmpdir } from "node:os";
 import "node:fs/promises";
@@ -34621,6 +34621,120 @@ var init_mcp_workspace_header = __esmMin((() => {
 	MCP_WORKSPACE_HEADER = "X-GH-Workspace";
 }));
 //#endregion
+//#region src/lib/aic-usage.ts
+/** Convert nano-AIU to AI credits. */
+function nanoAiuToCredits(nanoAiu) {
+	if (!Number.isFinite(nanoAiu) || nanoAiu <= 0) return 0;
+	return nanoAiu / NANO_AIU_PER_CREDIT;
+}
+/**
+* Compact display: `12.42` for totals ≥ 0.01, more precision below.
+* Always a plain number string — callers add units/context.
+*/
+function formatAic(credits) {
+	if (!Number.isFinite(credits) || credits <= 0) return "0";
+	if (credits >= 100) return credits.toFixed(1);
+	if (credits >= 1) return credits.toFixed(2);
+	if (credits >= .01) return credits.toFixed(3);
+	return credits.toPrecision(2);
+}
+var NANO_AIU_PER_CREDIT;
+var init_aic_usage = __esmMin((() => {
+	NANO_AIU_PER_CREDIT = 1e9;
+}));
+//#endregion
+//#region src/lib/aic-ledger.ts
+/**
+* Per-launch AIC (AI Credits) ledger.
+*
+* Every route handler records upstream `copilot_usage` here as a side effect
+* (bytes pass through untouched). The totals feed two consumers:
+*
+*   1. `internal-aic-status` — runs as a SEPARATE process on every status-line
+*      tick, so it cannot read in-process memory. Each `record()` therefore
+*      also persists an atomic snapshot file; the ledger path is handed to the
+*      spawned child via `GH_ROUTER_AIC_LEDGER` and baked into the statusLine
+*      command.
+*   2. The `claude` exit summary — reads the in-process snapshot.
+*
+* Keyed per proxy process (one file per PID under `<APP_DIR>/aic-ledger/`),
+* so concurrent launches never mix. Snapshot writes are best-effort and never
+* throw into the request path. Stale files (dead PID, >24h) are swept at
+* startup of the next record and on shutdown.
+*/
+function emptyModelTokens() {
+	return {
+		input: 0,
+		cache_read: 0,
+		cache_write: 0,
+		output: 0,
+		other: 0
+	};
+}
+/**
+* Read a persisted snapshot file (the status-hook path). Returns undefined
+* when missing/unreadable — the hook then prints nothing.
+*/
+function readAicSnapshotFile(file) {
+	try {
+		const raw = fs.readFileSync(file, "utf8");
+		const parsed = JSON.parse(raw);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+		const record = parsed;
+		if (typeof record.totalNanoAiu !== "number" || typeof record.requests !== "number") return;
+		return {
+			totalNanoAiu: Math.max(0, Math.floor(record.totalNanoAiu)),
+			requests: Math.max(0, Math.floor(record.requests)),
+			perModel: record.perModel && typeof record.perModel === "object" ? record.perModel : {},
+			perTokenType: record.perTokenType && typeof record.perTokenType === "object" ? record.perTokenType : {},
+			tokensByModel: sanitizeModelTokens(record.tokensByModel)
+		};
+	} catch {
+		return;
+	}
+}
+/** Best-effort sanitize of persisted per-model token counts; `{}` when absent. */
+function sanitizeModelTokens(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return {};
+	const out = {};
+	for (const [model, counts] of Object.entries(value)) {
+		if (!counts || typeof counts !== "object" || Array.isArray(counts)) continue;
+		const entry = counts;
+		const clean = emptyModelTokens();
+		let ok = true;
+		for (const field of [
+			"input",
+			"cache_read",
+			"cache_write",
+			"output",
+			"other"
+		]) {
+			const n = entry[field];
+			if (n === void 0) continue;
+			if (typeof n !== "number" || !Number.isFinite(n) || n < 0) {
+				ok = false;
+				break;
+			}
+			clean[field] = Math.floor(n);
+		}
+		if (ok) out[model] = clean;
+	}
+	return out;
+}
+/** Total credits for a snapshot. */
+function aicTotalCredits(snapshot) {
+	return nanoAiuToCredits(snapshot.totalNanoAiu);
+}
+/** One-line status fragment: `[AIC 12.42]`. Empty string when nothing recorded. */
+function formatAicStatus(snapshot) {
+	if (snapshot.requests === 0 || snapshot.totalNanoAiu <= 0) return "";
+	return `[AIC ${formatAic(aicTotalCredits(snapshot))}]`;
+}
+var init_aic_ledger = __esmMin((() => {
+	init_paths();
+	init_aic_usage();
+}));
+//#endregion
 //#region src/lib/orchestration/gate-discovery.ts
 /**
 * Evidence-pinned model FALLBACK for the structural Stop-gate — the last resort
@@ -34912,7 +35026,7 @@ var internal_stop_hook_exports = /* @__PURE__ */ __exportAll({
 * no such handle. Hooks always receive piped/redirected stdin, so this never
 * blocks (guarded against an interactive TTY, and any error -> "").
 */
-function readStdin$5() {
+function readStdin$6() {
 	try {
 		if (process.stdin.isTTY) return "";
 		return readFileSync(0, "utf8");
@@ -35099,7 +35213,7 @@ var init_internal_stop_hook = __esmMin((() => {
 			description: "Internal: the structural-gate Stop hook. Reads the Claude Code hook payload on stdin, runs the sealed gate, exits 2 (blocks the stop) on a red gate or gate-weakening diff."
 		},
 		async run() {
-			const stdin = readStdin$5();
+			const stdin = readStdin$6();
 			const reviewEnabled = stopReviewEnabled() && hookMcpRuntimeFromEnv() !== void 0;
 			let transcriptPath = "";
 			let userPrompt = "";
@@ -35267,7 +35381,7 @@ var internal_prompt_submit_exports = /* @__PURE__ */ __exportAll({ internalPromp
 * no such handle. Hooks always receive piped/redirected stdin, so this never
 * blocks (guarded against an interactive TTY, and any error -> "").
 */
-function readStdin$4() {
+function readStdin$5() {
 	try {
 		if (process.stdin.isTTY) return "";
 		return readFileSync(0, "utf8");
@@ -35304,7 +35418,7 @@ var init_internal_prompt_submit = __esmMin((() => {
 		},
 		async run() {
 			try {
-				const stdin = readStdin$4();
+				const stdin = readStdin$5();
 				const steerEnabled = parseBoolEnv(process.env.GH_ROUTER_DISABLE_PROMPT_STEER) !== true;
 				const runtime = hookMcpRuntimeFromEnv();
 				let decision;
@@ -35599,7 +35713,7 @@ var init_plan_review_hook = __esmMin((() => {
 //#endregion
 //#region src/internal-plan-review.ts
 var internal_plan_review_exports = /* @__PURE__ */ __exportAll({ internalPlanReview: () => internalPlanReview });
-function readStdin$3() {
+function readStdin$4() {
 	try {
 		if (process.stdin.isTTY) return "";
 		return readFileSync(0, "utf8");
@@ -35692,7 +35806,7 @@ var init_internal_plan_review = __esmMin((() => {
 					return;
 				}
 				const decision = await decidePlanReviewHook({
-					stdin: readStdin$3(),
+					stdin: readStdin$4(),
 					runtimeAvailable: true,
 					debounce: filePlanReviewDebounce(stopReviewStateDir()),
 					fallbackCwd: process.cwd()
@@ -35715,7 +35829,7 @@ var internal_session_bind_exports = /* @__PURE__ */ __exportAll({
 * teardown and trips a `uv_async_send` assertion; a synchronous read has no such
 * handle. Hooks always receive piped stdin (guarded against a TTY; any error -> "").
 */
-function readStdin$2() {
+function readStdin$3() {
 	try {
 		if (process.stdin.isTTY) return "";
 		return readFileSync(0, "utf8");
@@ -35809,7 +35923,7 @@ var init_internal_session_bind = __esmMin((() => {
 			try {
 				const out = typeof args.out === "string" ? args.out.trim() : "";
 				if (!out) return;
-				const record = decodeSessionBind(readStdin$2());
+				const record = decodeSessionBind(readStdin$3());
 				if (record) writeSidecar(out, record);
 			} catch {}
 			process.exitCode = 0;
@@ -37622,7 +37736,7 @@ var internal_artifact_open_exports = /* @__PURE__ */ __exportAll({
 	internalArtifactOpen: () => internalArtifactOpen,
 	parseExitPlanPayload: () => parseExitPlanPayload
 });
-function readStdin$1() {
+function readStdin$2() {
 	try {
 		if (process.stdin.isTTY) return "";
 		return readFileSync(0, "utf8");
@@ -37722,7 +37836,7 @@ var init_internal_artifact_open = __esmMin((() => {
 		},
 		async run() {
 			try {
-				const raw = readStdin$1();
+				const raw = readStdin$2();
 				let payload;
 				try {
 					payload = JSON.parse(raw);
@@ -37941,7 +38055,7 @@ var internal_worker_guard_exports = /* @__PURE__ */ __exportAll({ internalWorker
 * libuv FS request that races Windows process teardown. Hooks always receive
 * piped stdin (guarded against an interactive TTY; any error → "").
 */
-function readStdin() {
+function readStdin$1() {
 	try {
 		if (process.stdin.isTTY) return "";
 		return readFileSync(0, "utf8");
@@ -37972,7 +38086,7 @@ var init_internal_worker_guard = __esmMin((() => {
 		},
 		run(ctx) {
 			try {
-				const stdin = readStdin();
+				const stdin = readStdin$1();
 				const workersKey = String(ctx.args["workers-key"] ?? "").trim();
 				if (workersKey.length > 0) {
 					const { output } = decideWorkerGuard({
@@ -38429,6 +38543,491 @@ var init_internal_max_dispatch_guard = __esmMin((() => {
 	});
 }));
 //#endregion
+//#region src/lib/copilot-discount.ts
+function row(factor, source) {
+	return {
+		factor,
+		source
+	};
+}
+/**
+* Clamp a factor to usable range. Non-finite or negative factors (corrupt
+* table edit, bad injection) degrade to 1.0 — unfactored but never NaN,
+* never negative on screen.
+*/
+function sanitizeFactor(raw) {
+	return typeof raw === "number" && Number.isFinite(raw) && raw >= 0 ? raw : 1;
+}
+/**
+* Session discounted USD from a ledger snapshot. Total function: never
+* throws (guards non-finite/negative ledger values defensively — a corrupt
+* snapshot must degrade the status line, not crash the hook).
+*/
+function discountedUsdForSnapshot(snapshot) {
+	return discountedUsdWithFactors(snapshot, DISCOUNT_FACTORS);
+}
+/**
+* Factor-injectable core (exported for unit tests — e.g. proving a
+* fat-finger factor can never overstate spend). `factors` falls back to
+* 1.0 per model exactly like the table lookup.
+*/
+function discountedUsdWithFactors(snapshot, factors) {
+	const byModel = {};
+	let sum = 0;
+	for (const [model, entry] of Object.entries(snapshot.perModel)) {
+		const nano = typeof entry.nanoAiu === "number" && Number.isFinite(entry.nanoAiu) ? Math.max(0, entry.nanoAiu) : 0;
+		const factor = sanitizeFactor(factors[model]?.factor);
+		const usd = nano / 1e9 * USD_PER_AIC_CREDIT * factor;
+		byModel[model] = usd;
+		sum += usd;
+	}
+	const cap = aicTotalCredits(snapshot) * USD_PER_AIC_CREDIT;
+	if (!(sum > cap * (1 + 1e-9)) || sum <= 0) return {
+		total: sum,
+		byModel,
+		capped: false
+	};
+	const scale = cap / sum;
+	const scaled = {};
+	for (const [model, usd] of Object.entries(byModel)) scaled[model] = usd * scale;
+	return {
+		total: cap,
+		byModel: scaled,
+		capped: true
+	};
+}
+var USD_PER_AIC_CREDIT, DISCOUNT_FACTORS;
+var init_copilot_discount = __esmMin((() => {
+	init_aic_ledger();
+	USD_PER_AIC_CREDIT = .01;
+	DISCOUNT_FACTORS = Object.freeze({
+		"gpt-5.6-sol": row(.28, "0.27-0.29 across 28d/MTD/7d/pre/9-9; write-mix refuted"),
+		"claude-opus-5": row(.62, "0.61-0.64 across windows; 9/7 1.02 excluded as single-day artifact"),
+		"claude-sonnet-5": row(.66, "0.62-0.71 across windows"),
+		"gpt-5.3-codex": row(.6, "0.59-0.62 across windows"),
+		"gpt-5.4": row(.6, "single snapshot 0.598"),
+		"gemini-3.7-flash": row(.29, "September regime; pre-Sep 1.00x — volatile"),
+		"gpt-5.6-luna": row(1, "long-tier portal + writes, no discount"),
+		"grok-4.6": row(1, "portal default, six windows"),
+		"gemini-3.8-flash": row(1, "portal exact, six windows to the dollar")
+	});
+}));
+//#endregion
+//#region src/lib/default-statusline.ts
+/**
+* Rich default status line for `github-router claude` sessions.
+*
+* Replaces the need for users to maintain their own PowerShell/bash status
+* script: `internal-aic-status` renders these segments natively from the
+* Claude Code stdin JSON, then pins the `[AIC x.xx]` ledger fragment ahead
+* of them. Zero dependencies, cross-platform (Windows 11 is the primary
+* target — no `powershell`/`bash`/`jq` required), and fast (no shell
+* startup; one bounded `git rev-parse` at most).
+*
+* Segment order (left = highest priority; narrow terminals drop from the
+* right, `AIC` is never dropped):
+*
+*   `[AIC] | [ctx bar] % | model | dir (branch) | ~$actual | in/out | dur | +a -r`
+*
+* The `$` segment is the DISCOUNTED actual (`~$` = factor-discounted
+* session total from `copilot-discount.ts`, capped at AIC × $0.01) — NOT
+* Claude's `cost.total_cost_usd`, which prices at Anthropic list rates and
+* reads ~10-100x high against Copilot billing (a 28-day sample: 41.1B tokens
+* for $5,142 ≈ $0.13/1M blended vs $15-75/1M list). Rendering list price
+* next to the real `[AIC]` billing unit would show two contradictory
+* numbers, so list price is deliberately not rendered at all.
+*
+* Width comes from `COLUMNS` (set by Claude Code for status scripts since
+* v2.1.153); fallback is 120 when unset/unparseable so a missing `COLUMNS`
+* never needlessly drops segments.
+*/
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return;
+	return value;
+}
+function finiteNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function nonEmptyString(value) {
+	return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+/**
+* Parse Claude Code's status-line stdin JSON into the fields we render.
+* Total function: malformed JSON or unexpected shapes yield `{}` (every
+* segment then renders its `--` placeholder or is omitted) — never throws.
+*/
+function parseStatusInput(raw) {
+	if (!raw.trim()) return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(raw);
+	} catch {
+		return {};
+	}
+	const root = asRecord(parsed);
+	if (!root) return {};
+	const out = {};
+	const ctx = asRecord(root.context_window);
+	if (ctx) {
+		const pct = finiteNumber(ctx.used_percentage);
+		if (pct !== void 0) out.usedPct = pct;
+		const tIn = finiteNumber(ctx.total_input_tokens);
+		if (tIn !== void 0 && tIn >= 0) out.totalInputTokens = Math.floor(tIn);
+		const tOut = finiteNumber(ctx.total_output_tokens);
+		if (tOut !== void 0 && tOut >= 0) out.totalOutputTokens = Math.floor(tOut);
+	}
+	const cost = asRecord(root.cost);
+	if (cost) {
+		const dur = finiteNumber(cost.total_duration_ms);
+		if (dur !== void 0 && dur >= 0) out.totalDurationMs = dur;
+		const la = finiteNumber(cost.total_lines_added);
+		if (la !== void 0 && la >= 0) out.linesAdded = Math.floor(la);
+		const lr = finiteNumber(cost.total_lines_removed);
+		if (lr !== void 0 && lr >= 0) out.linesRemoved = Math.floor(lr);
+	}
+	const workspace = asRecord(root.workspace);
+	const cwd = (workspace ? nonEmptyString(workspace.current_dir) : void 0) ?? nonEmptyString(root.cwd);
+	if (cwd) out.cwd = cwd;
+	const model = asRecord(root.model);
+	if (model) {
+		const name = nonEmptyString(model.display_name) ?? nonEmptyString(model.id);
+		if (name) out.modelName = name;
+	}
+	return out;
+}
+/** Compact token count: `999` → `999`, `15234` → `15.2k`, `2.1M`. */
+function compactTokens(n) {
+	if (n >= 1e6) return `${(n / 1e6).toFixed(1)}M`;
+	if (n >= 1e3) return `${(n / 1e3).toFixed(1)}k`;
+	return `${n}`;
+}
+/** `45000` → `0m45s`, `198000` → `3m18s`, `3720000` → `1h02m`. */
+function formatDurationMs(ms) {
+	const totalSeconds = Math.floor(ms / 1e3);
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor(totalSeconds % 3600 / 60);
+	const seconds = totalSeconds % 60;
+	if (hours >= 1) return `${hours}h${String(minutes).padStart(2, "0")}m`;
+	return `${minutes}m${String(seconds).padStart(2, "0")}s`;
+}
+/** Basename of a cwd, tolerant of `/` and `\` separators + trailing slash. */
+function dirLeaf(cwd) {
+	const trimmed = cwd.replace(/[/\\]+$/, "");
+	const parts = trimmed.split(/[/\\]/);
+	return parts[parts.length - 1] ?? trimmed;
+}
+function buildCtxSegment(usedPct) {
+	if (usedPct === void 0 || !Number.isFinite(usedPct)) return {
+		text: `${DIM}[----------] --%${RESET}`,
+		plain: "[----------] --%"
+	};
+	const u = Math.max(0, Math.min(100, Math.round(usedPct)));
+	let filled = Math.round(u / 100 * CTX_BAR_LEN);
+	if (filled > CTX_BAR_LEN) filled = CTX_BAR_LEN;
+	if (filled < 0) filled = 0;
+	const bar = `#`.repeat(filled) + `-`.repeat(CTX_BAR_LEN - filled);
+	return {
+		text: `${u < 50 ? GREEN : u < 75 ? YELLOW : RED}[${bar}] ${u}%${RESET}`,
+		plain: `[${bar}] ${u}%`
+	};
+}
+/**
+* Discounted-actual `$` segment. Callers pass the capped total from
+* `discountedUsdForSnapshot` — this function only formats. Placeholder
+* `~$--` until the first priced upstream response lands in the ledger.
+* Thresholds are tuned for ACTUALS scale (a session runs ~$0.10-2.00) —
+* not the old list-price scale.
+*/
+function buildUsdSegment(actualUsd) {
+	if (actualUsd === void 0 || !Number.isFinite(actualUsd) || actualUsd < 0) return {
+		text: `${DIM}~$--${RESET}`,
+		plain: "~$--"
+	};
+	const c = actualUsd;
+	const color = c < 1 ? GREEN : c < 5 ? YELLOW : c < 20 ? ORANGE : RED;
+	const formatted = c < 10 ? c.toFixed(2) : c.toFixed(1);
+	return {
+		text: `${color}~$${formatted}${RESET}`,
+		plain: `~$${formatted}`
+	};
+}
+function buildToksSegment(tIn, tOut) {
+	if (tIn === void 0 || tOut === void 0) return {
+		text: `${DIM}--/--${RESET}`,
+		plain: "--/--"
+	};
+	const cin = compactTokens(tIn);
+	const cout = compactTokens(tOut);
+	return {
+		text: `${CYAN}${cin}${RESET}${DIM}/${RESET}${MAGENTA}${cout}${RESET}`,
+		plain: `${cin}/${cout}`
+	};
+}
+function buildDurSegment(durMs) {
+	if (durMs === void 0 || !Number.isFinite(durMs) || durMs < 0) return {
+		text: `${DIM}--${RESET}`,
+		plain: "--"
+	};
+	const formatted = formatDurationMs(durMs);
+	return {
+		text: `${DIM}${formatted}${RESET}`,
+		plain: formatted
+	};
+}
+function buildLinesSegment(added, removed) {
+	const a = added ?? 0;
+	const r = removed ?? 0;
+	return {
+		text: `${GREEN}+${a}${RESET} ${RED}-${r}${RESET}`,
+		plain: `+${a} -${r}`
+	};
+}
+function buildModelSegment(modelName) {
+	if (!modelName || modelName === "--") return void 0;
+	return {
+		text: `${MAGENTA}${modelName}${RESET}`,
+		plain: modelName
+	};
+}
+function buildDirGitSegment(cwd, branch) {
+	const leaf = cwd ? dirLeaf(cwd) : "";
+	const br = branch && branch !== "HEAD" ? branch : "";
+	if (!leaf && !br) return void 0;
+	if (leaf && br) return {
+		text: `${BLUE}${leaf}${RESET} ${CYAN}(${br})${RESET}`,
+		plain: `${leaf} (${br})`
+	};
+	if (leaf) return {
+		text: `${BLUE}${leaf}${RESET}`,
+		plain: leaf
+	};
+	return {
+		text: `${CYAN}${br}${RESET}`,
+		plain: br
+	};
+}
+/**
+* Resolve the current git branch for `cwd`. Bounded (`GIT_TIMEOUT_MS`) and
+* total: any failure (no git binary, not a repo, detached `HEAD`, timeout,
+* `%` in a Windows path that cmd.exe cannot safely quote) yields `""`
+* (caller omits the branch) — never throws.
+*/
+function resolveGitBranch(cwd) {
+	try {
+		if (!cwd) return "";
+		const gitPath = resolveExecutable("git");
+		if (!gitPath) return "";
+		const { command, args, shell } = buildExecInvocation([
+			gitPath,
+			"-C",
+			cwd,
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]);
+		const result = spawnSync(command, args, {
+			shell,
+			timeout: GIT_TIMEOUT_MS,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		});
+		if (result.error) return "";
+		const out = typeof result.stdout === "string" ? result.stdout.trim() : "";
+		if (!out || out === "HEAD") return "";
+		return out.split("\n")[0]?.trim() ?? "";
+	} catch {
+		return "";
+	}
+}
+/** Terminal width for the drop-right-to-left assembly. */
+function terminalWidth(env = process.env) {
+	const raw = env.COLUMNS;
+	if (raw !== void 0) {
+		const n = Number(raw);
+		if (Number.isInteger(n) && n > 0) return n;
+	}
+	return WIDTH_FALLBACK;
+}
+/**
+* Assemble the full status line. `aicFragment` (e.g. `[AIC 12.42]`) is
+* PINNED — it renders even when nothing else fits. `actualUsd` feeds the
+* `~$` segment (the capped factor-discounted total from
+* `discountedUsdForSnapshot`, same snapshot the fragment came from).
+* Droppable segments in priority order: ctx, model, dir/git, ~$, toks,
+* dur, lines.
+*/
+function assembleStatusLine(aicFragment, input, opts = {}) {
+	const aic = aicFragment.trim();
+	const aicText = aic ? `${AIC_COLOR}${aic}${RESET}` : "";
+	const droppable = [buildCtxSegment(input.usedPct)];
+	const model = buildModelSegment(input.modelName);
+	if (model) droppable.push(model);
+	const dirGit = buildDirGitSegment(input.cwd, opts.branch);
+	if (dirGit) droppable.push(dirGit);
+	droppable.push(buildUsdSegment(opts.actualUsd), buildToksSegment(input.totalInputTokens, input.totalOutputTokens), buildDurSegment(input.totalDurationMs), buildLinesSegment(input.linesAdded, input.linesRemoved));
+	const width = opts.width ?? terminalWidth();
+	const sepLen = 3;
+	let count = droppable.length;
+	while (count > 0) {
+		let total = aic ? aic.length : 0;
+		for (let i = 0; i < count; i++) {
+			if (aic || i > 0) total += sepLen;
+			total += droppable[i].plain.length;
+		}
+		if (total <= width) break;
+		if (count === 1 && !aic) break;
+		count--;
+	}
+	const parts = [];
+	if (aic) parts.push(aicText);
+	for (let i = 0; i < count; i++) parts.push(droppable[i].text);
+	if (parts.length === 0) return "";
+	return parts.join(SEP_TEXT);
+}
+/**
+* Convenience: parse stdin JSON + assemble with branch resolution.
+* `branchOverride` skips the `git` spawn (used by tests). `actualUsd`
+* comes from `discountedUsdForSnapshot` on the same ledger snapshot as
+* `aicFragment` (read by the caller — this module never touches the
+* ledger file).
+*/
+function buildRichStatusLine(stdinRaw, aicFragment, opts = {}) {
+	const input = parseStatusInput(stdinRaw);
+	const branch = opts.branchOverride !== void 0 ? opts.branchOverride : resolveGitBranch(input.cwd);
+	return assembleStatusLine(aicFragment, input, {
+		...opts.width !== void 0 ? { width: opts.width } : {},
+		...branch ? { branch } : {},
+		...opts.actualUsd !== void 0 ? { actualUsd: opts.actualUsd } : {}
+	});
+}
+var ESC, RESET, DIM, GREEN, YELLOW, RED, ORANGE, CYAN, MAGENTA, BLUE, AIC_COLOR, CTX_BAR_LEN, GIT_TIMEOUT_MS, WIDTH_FALLBACK, SEP_TEXT;
+var init_default_statusline = __esmMin((() => {
+	init_copilot_discount();
+	init_exec();
+	ESC = "\x1B";
+	RESET = `${ESC}[0m`;
+	DIM = `${ESC}[90m`;
+	GREEN = `${ESC}[32m`;
+	YELLOW = `${ESC}[33m`;
+	RED = `${ESC}[31m`;
+	ORANGE = `${ESC}[38;5;208m`;
+	CYAN = `${ESC}[36m`;
+	MAGENTA = `${ESC}[35m`;
+	BLUE = `${ESC}[34m`;
+	AIC_COLOR = `${ESC}[1;33m`;
+	CTX_BAR_LEN = 10;
+	GIT_TIMEOUT_MS = 300;
+	WIDTH_FALLBACK = 120;
+	SEP_TEXT = `${DIM} | ${RESET}`;
+}));
+//#endregion
+//#region src/internal-aic-status.ts
+var internal_aic_status_exports = /* @__PURE__ */ __exportAll({
+	composeAicStatusLine: () => composeAicStatusLine,
+	internalAicStatus: () => internalAicStatus,
+	runUserStatusLine: () => runUserStatusLine
+});
+/**
+* Read stdin synchronously. Claude Code pipes session JSON to the
+* statusLine command; an unread pipe can SIGPIPE the writer on some
+* platforms. Returns "" when stdin is a TTY or unreadable — callers render
+* placeholders/omit segments rather than failing.
+*/
+function readStdin() {
+	try {
+		if (process.stdin.isTTY) return "";
+		return readFileSync(0, "utf8");
+	} catch {
+		return "";
+	}
+}
+/**
+* Pure core: compose the status line from an AIC fragment and a user line.
+* Exported for unit tests.
+*/
+function composeAicStatusLine(aicFragment, userLine) {
+	const aic = aicFragment.trim();
+	const user = userLine.split("\n")[0]?.trim() ?? "";
+	if (aic && user) return `${aic} ${user}`;
+	return aic || user;
+}
+/**
+* Run the user's own statusLine command (from `GH_ROUTER_AIC_USER_STATUSLINE`),
+* returning its first stdout line or "" on any failure/timeout. Exported for
+* unit tests (command + timeout injectable).
+*/
+function runUserStatusLine(command, timeoutMs = 5e3) {
+	if (!command.trim()) return "";
+	try {
+		const result = spawnSync(command, {
+			shell: true,
+			timeout: timeoutMs,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			],
+			env: process.env
+		});
+		if (result.error) return "";
+		return (typeof result.stdout === "string" ? result.stdout : "").split("\n")[0]?.trim() ?? "";
+	} catch {
+		return "";
+	}
+}
+function readAicSnapshot() {
+	try {
+		const ledgerPath = process.env.GH_ROUTER_AIC_LEDGER;
+		if (!ledgerPath) return { fragment: "" };
+		const snapshot = readAicSnapshotFile(ledgerPath);
+		if (!snapshot) return { fragment: "" };
+		if (snapshot.requests === 0 || snapshot.totalNanoAiu <= 0) return { fragment: "" };
+		return {
+			fragment: formatAicStatus(snapshot),
+			actualUsd: discountedUsdForSnapshot(snapshot).total
+		};
+	} catch {
+		return { fragment: "" };
+	}
+}
+var internalAicStatus;
+var init_internal_aic_status = __esmMin((() => {
+	init_dist$1();
+	init_aic_ledger();
+	init_copilot_discount();
+	init_default_statusline();
+	internalAicStatus = defineCommand({
+		meta: {
+			name: "internal-aic-status",
+			description: "Internal: Claude Code statusLine handler printing AIC total + rich session line."
+		},
+		async run() {
+			const stdinRaw = readStdin();
+			const { fragment: aic, actualUsd } = readAicSnapshot();
+			const userCommand = process.env.GH_ROUTER_AIC_USER_STATUSLINE ?? "";
+			if (userCommand.trim()) {
+				const line = composeAicStatusLine(aic, runUserStatusLine(userCommand));
+				if (line) process.stdout.write(`${line}\n`);
+				process.exitCode = 0;
+				return;
+			}
+			let line;
+			try {
+				line = buildRichStatusLine(stdinRaw, aic, { ...actualUsd !== void 0 ? { actualUsd } : {} });
+			} catch {
+				line = aic.trim();
+			}
+			if (line) process.stdout.write(`${line}\n`);
+			process.exitCode = 0;
+		}
+	});
+}));
+//#endregion
 //#region src/hooks.ts
 init_dist$1();
 init_dist();
@@ -38459,7 +39058,8 @@ await runMain(defineCommand({
 		"internal-first-mate-guard": () => Promise.resolve().then(() => (init_internal_first_mate_guard(), internal_first_mate_guard_exports)).then((m) => m.internalFirstMateGuard),
 		"internal-worker-guard": () => Promise.resolve().then(() => (init_internal_worker_guard(), internal_worker_guard_exports)).then((m) => m.internalWorkerGuard),
 		"internal-fast-dispatch-guard": () => Promise.resolve().then(() => (init_internal_fast_dispatch_guard(), internal_fast_dispatch_guard_exports)).then((m) => m.internalFastDispatchGuard),
-		"internal-max-dispatch-guard": () => Promise.resolve().then(() => (init_internal_max_dispatch_guard(), internal_max_dispatch_guard_exports)).then((m) => m.internalMaxDispatchGuard)
+		"internal-max-dispatch-guard": () => Promise.resolve().then(() => (init_internal_max_dispatch_guard(), internal_max_dispatch_guard_exports)).then((m) => m.internalMaxDispatchGuard),
+		"internal-aic-status": () => Promise.resolve().then(() => (init_internal_aic_status(), internal_aic_status_exports)).then((m) => m.internalAicStatus)
 	}
 }), { rawArgs: argv });
 //#endregion