@ironbee-ai/cli 0.11.4 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.12.0 (2026-05-23)
+
+### Features
+
+* **statusline:** add session_status events via a chained statusline wrapper ([#16](https://github.com/ironbee-ai/ironbee-cli/issues/16)) ([a0a5a10](https://github.com/ironbee-ai/ironbee-cli/commit/a0a5a109d9691531711ec1d20ecc5d176aafcc15))
+
 ## 0.11.4 (2026-05-21)
 
 ### Features

package/README.md

@@ -159,6 +159,18 @@ Turns off enforcement but keeps the telemetry path intact. Session lifecycle and
 
 The toggle re-renders all client artifacts (hooks, skill, rule, MCP servers, permissions) atomically. The change takes effect on the next agent session — restart your editor / agent after toggling.
 
+### Optional: statusline `session_status` events (Claude)
+
+```bash
+ironbee statusline enable
+```
+
+Wraps your Claude Code statusline so that, on every statusline tick, IronBee emits a `session_status` event carrying live **context-window size**, **cost**, and **subscription rate-limit utilization** — signals that are unavailable to hooks or the transcript and can only be read from the statusline. Your existing statusline keeps rendering exactly as before: IronBee installs its wrapper into `.claude/settings.local.json` (the highest-priority, gitignored settings layer) and **chains** to whatever statusline you already had (committed project, global, or local), so the display is unchanged — we just piggyback the telemetry.
+
+Auto-enabled when a collector is configured (same as analytics); otherwise opt in with `ironbee statusline enable` or `statusLine.enable: true`. `ironbee statusline disable` restores your original statusline and stops the events. If you change your upstream statusline mid-session, `ironbee statusline sync` re-resolves it for active sessions (otherwise it's picked up on the next session). The change takes effect on the next agent session — restart your editor after toggling.
+
+> Claude-only — Cursor has no equivalent statusline mechanism. The events ship through the same queue + collector pipeline as everything else; nothing is written when no collector is configured.
+
 ### Cursor: additional setup
 
 Cursor requires manual activation of MCP servers after install:
@@ -187,6 +199,7 @@ ironbee browser <enable|disable>   [-g|--local] [--client <name>]   Manage the b
 ironbee backend <enable|disable>   [-g|--local] [--client <name>]   Manage the runtime-agnostic backend protocol cycle (HTTP/gRPC/GraphQL/WS via backend-devtools)
 ironbee node <enable|disable>      [-g|--local] [--client <name>]   Manage the Node.js runtime debug cycle (V8 inspector probes via node-devtools)
 ironbee verification <enable|disable> [-g|--local] [--client <name>]   Master verification toggle (enable = enforce; disable = monitoring-only, no enforcement but sessions/tools still ship to collector)
+ironbee statusline <enable|disable|sync> [-g|--local] [--client <name>]   Manage the Claude statusline integration (emits session_status events — context-window size, cost, subscription rate-limits — and chains your existing statusline). sync re-resolves the chained statusline for active sessions
 ironbee config get   <key>         [-g|--project|--local]   Read a config value (default: merged effective value; flags narrow to one of the three layers)
 ironbee config set   <key> <value> [-g|--local] [--client <name>] [--no-rerender] [--json] [--apply-all|--no-apply-all]   Write a config value; auto re-renders client artifacts on artifact-affecting keys; -g writes global, --local writes project-local (gitignored)
 ironbee config unset <key>         [-g|--local] [--client <name>] [--no-rerender] [--apply-all|--no-apply-all]   Remove a config value (idempotent); same target / rerender rules as set
@@ -320,7 +333,7 @@ Target flags are mutually exclusive: pass at most one of `-g/--global`, `--proje
 
 **Type coercion** — `set` parses the value as JSON when it can (`true`/`42`/`[…]`/`{…}`) and falls back to a raw string when JSON parse fails. URLs and paths pass through unquoted; pass `--json` to force strict JSON parsing (e.g. when you want the literal string `"42"` instead of the number `42`).
 
-**Smart artifact re-render** — when a top-level key affects installed client artifacts (`verification`, `collector`, `browser`, `backend`, `node`, `browserDevTools`, `backendDevTools`, `nodeDevTools`), `set` and `unset` re-render the client files (hooks, MCP entries, skill, rule, permissions) automatically — same code path `verification enable` / `backend enable` / `node enable` use. Other keys (`maxRetries`, `recording`, `jobQueue`, `analytics`, `import`, `ignoredVerifyPatterns`) are pure config flips that the next agent session picks up — no rerender needed.
+**Smart artifact re-render** — when a top-level key affects installed client artifacts (`verification`, `telemetry`, `statusLine`, `collector`, `browser`, `backend`, `node`, `browserDevTools`, `backendDevTools`, `nodeDevTools`), `set` and `unset` re-render the client files (hooks, MCP entries, skill, rule, permissions, statusline) automatically — same code path `verification enable` / `backend enable` / `node enable` use. Other keys (`maxRetries`, `recording`, `jobQueue`, `analytics`, `import`, `ignoredVerifyPatterns`) are pure config flips that the next agent session picks up — no rerender needed.
 
 Pass `--no-rerender` to skip the rerender on artifact-affecting keys (handy for scripted bulk edits — follow up with `ironbee install` to resync). If a rerender fails midway, the config file is rolled back to its prior bytes so disk state never diverges from installed artifacts.
 

package/dist/clients/claude/hooks/session-start.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"session-start.d.ts","sourceRoot":"","sources":["../../../../src/clients/claude/hooks/session-start.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAgBH,wBAAsB,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CA0F3D"}
+{"version":3,"file":"session-start.d.ts","sourceRoot":"","sources":["../../../../src/clients/claude/hooks/session-start.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAiBH,wBAAsB,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiG3D"}

package/dist/clients/claude/hooks/session-start.js

@@ -13,6 +13,7 @@ const actions_1 = require("../../../hooks/core/actions");
 const session_state_1 = require("../../../hooks/core/session-state");
 const util_1 = require("../util");
 const config_1 = require("../../../lib/config");
+const session_status_1 = require("./session-status");
 const logger_1 = require("../../../lib/logger");
 const output_1 = require("../../../lib/output");
 const stdin_1 = require("../../../lib/stdin");
@@ -38,6 +39,12 @@ async function run(projectDir) {
     // them on next start.
     (0, session_state_1.setUserEmail)(sessionDir, (0, util_1.getClaudeUserEmail)());
     (0, session_state_1.setUsage)(sessionDir, (0, util_1.resolveClaudeUsage)());
+    // Resolve + cache the chained statusline command once per session so the
+    // statusline wrapper reads a single state.json field per tick instead of
+    // walking the settings cascade. Gated on the feature; harmless when off.
+    if ((0, config_1.isSessionStatusEnabled)((0, config_1.loadConfig)(projectDir))) {
+        (0, session_state_1.setChainedStatusLine)(sessionDir, (0, session_status_1.resolveChainTarget)(projectDir) ?? null);
+    }
     const entry = {
         ...(0, actions_1.baseFields)(actionsFile),
         type: "session_start",

package/dist/clients/claude/hooks/session-start.js.map

@@ -1 +1 @@
-{"version":3,"file":"session-start.js","sourceRoot":"","sources":["../../../../src/clients/claude/hooks/session-start.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"session-start.js","sourceRoot":"","sources":["../../../../src/clients/claude/hooks/session-start.ts"],"names":[],"mappings":"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"}

package/dist/clients/claude/hooks/session-status.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Claude Code — statusline wrapper (`ironbee hook session-status`)
+ *
+ * Installed as the project's `statusLine.command`. On every statusline tick
+ * it does two independent things:
+ *   1. Submits a `session_status` event (context-window size, cost,
+ *      subscription rate-limits) to the queue — signals unavailable to hooks
+ *      or the transcript.
+ *   2. Chains to the user's ORIGINAL statusline command so their statusline
+ *      keeps rendering exactly as before (we wrap, never replace).
+ *
+ * The event submit is fire-and-forget and must NEVER block or break the
+ * statusline render. The chain target is resolved once at SessionStart and
+ * cached in state.json; this wrapper falls back to live cascade resolution
+ * if the cache is missing/unreadable, so a cache miss can never make the
+ * user's statusline vanish.
+ */
+import { SessionStatusEvent } from "../../../lib/event";
+/** Subset of the statusline stdin JSON this wrapper consumes. */
+interface StatusLinePayload {
+    session_id?: string;
+    model?: {
+        id?: string;
+    };
+    workspace?: {
+        project_dir?: string;
+    };
+    cost?: {
+        total_cost_usd?: number;
+        total_duration_ms?: number;
+        total_api_duration_ms?: number;
+        total_lines_added?: number;
+        total_lines_removed?: number;
+    };
+    context_window?: {
+        total_input_tokens?: number;
+        total_output_tokens?: number;
+        context_window_size?: number;
+        used_percentage?: number;
+        remaining_percentage?: number;
+        current_usage?: {
+            input_tokens?: number;
+            output_tokens?: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        } | null;
+    };
+    rate_limits?: {
+        five_hour?: {
+            used_percentage?: number;
+            resets_at?: number;
+        };
+        seven_day?: {
+            used_percentage?: number;
+            resets_at?: number;
+        };
+    };
+}
+/**
+ * True only when the command is EXACTLY our bare wrapper invocation. A tight
+ * match so a user who wraps us themselves (`tee >(ironbee hook session-status)
+ * | real-cmd`) is NOT mis-identified as "ours" — that compound is their own
+ * statusline and must be chained, not skipped.
+ */
+export declare function isIronbeeStatusLine(command: string | undefined): boolean;
+/**
+ * Resolve the project dir anchor. Prefers `CLAUDE_PROJECT_DIR` to stay
+ * consistent with every other hook and with SessionStart (session runtime
+ * files — state.json, queue — live under exactly this path), falling back to
+ * the statusline's `workspace.project_dir` and finally cwd. NOT canonicalized
+ * — the snapshot store canonicalizes internally on lookup, and the session
+ * dir must match the raw path SessionStart wrote under.
+ */
+export declare function resolveProjectDir(input: StatusLinePayload): string;
+/**
+ * Resolve the chain target = the statusline command Claude Code WOULD run
+ * without us = the highest-priority non-ours `statusLine.command` across the
+ * settings layers, walking high → low:
+ *   1. localSettings layer — our wrapper overwrote it, so the original lives
+ *      in the install snapshot.
+ *   2. projectSettings (`.claude/settings.json`) — untouched, read live.
+ *   3. userSettings (`~/.claude/settings.json`) — untouched, read live.
+ * First non-ours wins. `undefined` = nothing to chain.
+ */
+export declare function resolveChainTarget(projectDir: string): string | undefined;
+/**
+ * Strip the bracketed runtime suffix from the model id
+ * (`claude-opus-4-7[1m]` → `claude-opus-4-7`). The `[1m]` extended-context
+ * marker is redundant on the event — `context_window.context_window_size`
+ * already carries the effective window — so we keep the model field a clean
+ * canonical id.
+ */
+export declare function normalizeModelId(id: string | undefined): string;
+/**
+ * Build the wire event. Maps fields EXPLICITLY from the statusline JSON (R12)
+ * so our wire contract is independent of host JSON drift. `model` is the flat
+ * id string. `actionsFile` is only the derivation anchor for `baseFields`
+ * (id/session_id/project_name + user/usage) — we never write to it.
+ */
+export declare function buildSessionStatusEvent(input: StatusLinePayload, projectDir: string, sessionId: string): SessionStatusEvent;
+/**
+ * Deterministic per-tick id. `total_duration_ms` is monotonic within a
+ * session (`Date.now() - startTime`), so each tick gets a distinct id and the
+ * backend keeps every tick; a cancelled-then-refired identical tick collides
+ * on the same id (dedup). UUID-shaped via the same hashing convention as the
+ * analytics deterministic ids.
+ */
+export declare function deriveSessionStatusEventId(sessionId: string, totalDurationMs: number): string;
+/**
+ * Signature over the RESOURCE-METRIC fields of the event — the fields that
+ * only change on an API response. Deliberately EXCLUDES:
+ *   - `cost.total_duration` / `total_api_duration` — wall-clock durations that
+ *     tick up on every statusline fire (including them would make the
+ *     signature differ every tick, defeating the dedup).
+ *   - `id` / `timestamp` — per-emit, not metrics.
+ *   - `activity_id` — correlation metadata, not a resource metric (a new turn
+ *     with frozen metrics shouldn't re-emit; the next real metric change
+ *     captures the new activity_id).
+ * Used by skip-if-unchanged: two ticks with the same signature carry the same
+ * resource snapshot, so the later one is a redundant emit and is skipped.
+ */
+export declare function computeSessionStatusSignature(e: SessionStatusEvent): string;
+/**
+ * Statusline entry point. Reads stdin, submits the event (gated, fire-and-
+ * forget), then chains the user's original statusline.
+ */
+export declare function runSessionStatus(): Promise<void>;
+export {};
+//# sourceMappingURL=session-status.d.ts.map

package/dist/clients/claude/hooks/session-status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-status.d.ts","sourceRoot":"","sources":["../../../../src/clients/claude/hooks/session-status.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAeH,OAAO,EAAuC,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAO7F,iEAAiE;AACjE,UAAU,iBAAiB;IACvB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE;QAAE,EAAE,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACxB,SAAS,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IACrC,IAAI,CAAC,EAAE;QACH,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAC;KAChC,CAAC;IACF,cAAc,CAAC,EAAE;QACb,kBAAkB,CAAC,EAAE,MAAM,CAAC;QAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,mBAAmB,CAAC,EAAE,MAAM,CAAC;QAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;QACzB,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,aAAa,CAAC,EAAE;YACZ,YAAY,CAAC,EAAE,MAAM,CAAC;YACtB,aAAa,CAAC,EAAE,MAAM,CAAC;YACvB,2BAA2B,CAAC,EAAE,MAAM,CAAC;YACrC,uBAAuB,CAAC,EAAE,MAAM,CAAC;SACpC,GAAG,IAAI,CAAC;KACZ,CAAC;IACF,WAAW,CAAC,EAAE;QACV,SAAS,CAAC,EAAE;YAAE,eAAe,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;QAC7D,SAAS,CAAC,EAAE;YAAE,eAAe,CAAC,EAAE,MAAM,CAAC;YAAC,SAAS,CAAC,EAAE,MAAM,CAAA;SAAE,CAAC;KAChE,CAAC;CACL;AAID;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAKxE;AAED;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,MAAM,CAIlE;AAwBD;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAczE;AAMD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,CAE/D;AA+BD;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,iBAAiB,EAAE,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,kBAAkB,CA6C3H;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,SAAS,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,MAAM,CAK7F;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAAE,kBAAkB,GAAG,MAAM,CAY3E;AAgLD;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC,CA+CtD"}

package/dist/clients/claude/hooks/session-status.js

@@ -0,0 +1,444 @@
+"use strict";
+/**
+ * Claude Code — statusline wrapper (`ironbee hook session-status`)
+ *
+ * Installed as the project's `statusLine.command`. On every statusline tick
+ * it does two independent things:
+ *   1. Submits a `session_status` event (context-window size, cost,
+ *      subscription rate-limits) to the queue — signals unavailable to hooks
+ *      or the transcript.
+ *   2. Chains to the user's ORIGINAL statusline command so their statusline
+ *      keeps rendering exactly as before (we wrap, never replace).
+ *
+ * The event submit is fire-and-forget and must NEVER block or break the
+ * statusline render. The chain target is resolved once at SessionStart and
+ * cached in state.json; this wrapper falls back to live cascade resolution
+ * if the cache is missing/unreadable, so a cache miss can never make the
+ * user's statusline vanish.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIronbeeStatusLine = isIronbeeStatusLine;
+exports.resolveProjectDir = resolveProjectDir;
+exports.resolveChainTarget = resolveChainTarget;
+exports.normalizeModelId = normalizeModelId;
+exports.buildSessionStatusEvent = buildSessionStatusEvent;
+exports.deriveSessionStatusEventId = deriveSessionStatusEventId;
+exports.computeSessionStatusSignature = computeSessionStatusSignature;
+exports.runSessionStatus = runSessionStatus;
+const child_process_1 = require("child_process");
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const install_snapshots_1 = require("../../../lib/install-snapshots");
+const config_1 = require("../../../lib/config");
+const logger_1 = require("../../../lib/logger");
+const stdin_1 = require("../../../lib/stdin");
+const queue_1 = require("../../../queue");
+const actions_1 = require("../../../hooks/core/actions");
+const session_state_1 = require("../../../hooks/core/session-state");
+const CLIENT = "claude";
+/**
+ * True only when the command is EXACTLY our bare wrapper invocation. A tight
+ * match so a user who wraps us themselves (`tee >(ironbee hook session-status)
+ * | real-cmd`) is NOT mis-identified as "ours" — that compound is their own
+ * statusline and must be chained, not skipped.
+ */
+function isIronbeeStatusLine(command) {
+    if (typeof command !== "string") {
+        return false;
+    }
+    return /^\s*ironbee\s+hook\s+session-status(\s+--client\s+\S+)?\s*$/.test(command);
+}
+/**
+ * Resolve the project dir anchor. Prefers `CLAUDE_PROJECT_DIR` to stay
+ * consistent with every other hook and with SessionStart (session runtime
+ * files — state.json, queue — live under exactly this path), falling back to
+ * the statusline's `workspace.project_dir` and finally cwd. NOT canonicalized
+ * — the snapshot store canonicalizes internally on lookup, and the session
+ * dir must match the raw path SessionStart wrote under.
+ */
+function resolveProjectDir(input) {
+    return process.env.CLAUDE_PROJECT_DIR
+        ?? input.workspace?.project_dir
+        ?? process.cwd();
+}
+/** Read `statusLine.command` from a settings.json file; undefined on any failure. */
+function readStatusLineCommand(settingsPath) {
+    if (!(0, fs_1.existsSync)(settingsPath)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(settingsPath, "utf-8"));
+        if (parsed === null || typeof parsed !== "object") {
+            return undefined;
+        }
+        const sl = parsed.statusLine;
+        if (sl === null || typeof sl !== "object") {
+            return undefined;
+        }
+        const cmd = sl.command;
+        return typeof cmd === "string" && cmd.length > 0 ? cmd : undefined;
+    }
+    catch (e) {
+        logger_1.logger.debug(`session-status: failed to read statusLine from ${settingsPath}: ${e instanceof Error ? e.message : e}`);
+        return undefined;
+    }
+}
+/**
+ * Resolve the chain target = the statusline command Claude Code WOULD run
+ * without us = the highest-priority non-ours `statusLine.command` across the
+ * settings layers, walking high → low:
+ *   1. localSettings layer — our wrapper overwrote it, so the original lives
+ *      in the install snapshot.
+ *   2. projectSettings (`.claude/settings.json`) — untouched, read live.
+ *   3. userSettings (`~/.claude/settings.json`) — untouched, read live.
+ * First non-ours wins. `undefined` = nothing to chain.
+ */
+function resolveChainTarget(projectDir) {
+    const snapshot = (0, install_snapshots_1.readStatusLineSnapshot)(projectDir, CLIENT)?.command;
+    if (snapshot && !isIronbeeStatusLine(snapshot)) {
+        return snapshot;
+    }
+    const projectCmd = readStatusLineCommand((0, path_1.join)(projectDir, ".claude", "settings.json"));
+    if (projectCmd && !isIronbeeStatusLine(projectCmd)) {
+        return projectCmd;
+    }
+    const userCmd = readStatusLineCommand((0, path_1.join)((0, os_1.homedir)(), ".claude", "settings.json"));
+    if (userCmd && !isIronbeeStatusLine(userCmd)) {
+        return userCmd;
+    }
+    return undefined;
+}
+function num(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/**
+ * Strip the bracketed runtime suffix from the model id
+ * (`claude-opus-4-7[1m]` → `claude-opus-4-7`). The `[1m]` extended-context
+ * marker is redundant on the event — `context_window.context_window_size`
+ * already carries the effective window — so we keep the model field a clean
+ * canonical id.
+ */
+function normalizeModelId(id) {
+    return (id ?? "").replace(/\[[^\]]*\]/g, "").trim();
+}
+/** Map the statusline's `current_usage` explicitly (R12); null passes through. */
+function mapCurrentUsage(usage) {
+    if (usage === null || usage === undefined) {
+        return null;
+    }
+    return {
+        input_tokens: num(usage.input_tokens),
+        output_tokens: num(usage.output_tokens),
+        cache_creation_input_tokens: num(usage.cache_creation_input_tokens),
+        cache_read_input_tokens: num(usage.cache_read_input_tokens),
+    };
+}
+function mapRateLimitWindow(w) {
+    if (!w || typeof w.used_percentage !== "number" || typeof w.resets_at !== "number") {
+        return undefined;
+    }
+    // The statusline reports `resets_at` in epoch seconds; convert to ms to
+    // match every other IronBee timestamp.
+    return { used_percentage: w.used_percentage, resets_at: w.resets_at * 1000 };
+}
+/**
+ * Build the wire event. Maps fields EXPLICITLY from the statusline JSON (R12)
+ * so our wire contract is independent of host JSON drift. `model` is the flat
+ * id string. `actionsFile` is only the derivation anchor for `baseFields`
+ * (id/session_id/project_name + user/usage) — we never write to it.
+ */
+function buildSessionStatusEvent(input, projectDir, sessionId) {
+    const sessionDir = (0, path_1.join)(projectDir, ".ironbee", "sessions", sessionId);
+    const actionsFile = (0, path_1.join)(sessionDir, "actions.jsonl");
+    const cw = input.context_window ?? {};
+    const cost = input.cost ?? {};
+    const rl = mapRateLimitWindow(input.rate_limits?.five_hour);
+    const rl7 = mapRateLimitWindow(input.rate_limits?.seven_day);
+    // The active activity in flight at this tick (torn-read-safe via readState's
+    // try/catch). Empty string when no activity is open — e.g. a tick between
+    // turns or before the first user prompt.
+    const state = (0, session_state_1.readState)(sessionDir);
+    const event = {
+        ...(0, actions_1.baseFields)(actionsFile),
+        id: deriveSessionStatusEventId(sessionId, num(cost.total_duration_ms)),
+        type: "session_status",
+        timestamp: Date.now(),
+        activity_id: state.activeActivityId ?? "",
+        model: normalizeModelId(input.model?.id),
+        cost: {
+            total_cost_usd: num(cost.total_cost_usd),
+            // Host fields carry the `_ms` suffix; our wire shape drops it (ms implied).
+            total_duration: num(cost.total_duration_ms),
+            total_api_duration: num(cost.total_api_duration_ms),
+            total_lines_added: num(cost.total_lines_added),
+            total_lines_removed: num(cost.total_lines_removed),
+        },
+        context_window: {
+            total_input_tokens: num(cw.total_input_tokens),
+            total_output_tokens: num(cw.total_output_tokens),
+            context_window_size: num(cw.context_window_size),
+            used_percentage: num(cw.used_percentage),
+            remaining_percentage: num(cw.remaining_percentage),
+            current_usage: mapCurrentUsage(cw.current_usage),
+        },
+    };
+    if (rl || rl7) {
+        event.rate_limits = {};
+        if (rl) {
+            event.rate_limits.five_hour = rl;
+        }
+        if (rl7) {
+            event.rate_limits.seven_day = rl7;
+        }
+    }
+    return event;
+}
+/**
+ * Deterministic per-tick id. `total_duration_ms` is monotonic within a
+ * session (`Date.now() - startTime`), so each tick gets a distinct id and the
+ * backend keeps every tick; a cancelled-then-refired identical tick collides
+ * on the same id (dedup). UUID-shaped via the same hashing convention as the
+ * analytics deterministic ids.
+ */
+function deriveSessionStatusEventId(sessionId, totalDurationMs) {
+    const hex = (0, crypto_1.createHash)("sha256")
+        .update(`session_status:${sessionId}:${totalDurationMs}`)
+        .digest("hex");
+    return formatHexAsUuid(hex);
+}
+/**
+ * Signature over the RESOURCE-METRIC fields of the event — the fields that
+ * only change on an API response. Deliberately EXCLUDES:
+ *   - `cost.total_duration` / `total_api_duration` — wall-clock durations that
+ *     tick up on every statusline fire (including them would make the
+ *     signature differ every tick, defeating the dedup).
+ *   - `id` / `timestamp` — per-emit, not metrics.
+ *   - `activity_id` — correlation metadata, not a resource metric (a new turn
+ *     with frozen metrics shouldn't re-emit; the next real metric change
+ *     captures the new activity_id).
+ * Used by skip-if-unchanged: two ticks with the same signature carry the same
+ * resource snapshot, so the later one is a redundant emit and is skipped.
+ */
+function computeSessionStatusSignature(e) {
+    const source = {
+        model: e.model,
+        context_window: e.context_window,
+        cost: {
+            total_cost_usd: e.cost.total_cost_usd,
+            total_lines_added: e.cost.total_lines_added,
+            total_lines_removed: e.cost.total_lines_removed,
+        },
+        rate_limits: e.rate_limits,
+    };
+    return (0, crypto_1.createHash)("sha256").update(JSON.stringify(source)).digest("hex");
+}
+/** Path of the per-session statusline state file (single writer: this wrapper). */
+function statuslineStatePath(projectDir, sessionId) {
+    return (0, path_1.join)(projectDir, ".ironbee", "sessions", sessionId, "statusline-state.json");
+}
+function readStatuslineState(path) {
+    if (!(0, fs_1.existsSync)(path)) {
+        return {};
+    }
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(path, "utf-8"));
+        if (parsed === null || typeof parsed !== "object") {
+            return {};
+        }
+        const obj = parsed;
+        return {
+            sig: typeof obj.sig === "string" ? obj.sig : undefined,
+            lastEmitMs: typeof obj.lastEmitMs === "number" ? obj.lastEmitMs : undefined,
+        };
+    }
+    catch (e) {
+        logger_1.logger.debug(`session-status: failed to read statusline state ${path}: ${e instanceof Error ? e.message : e}`);
+        return {};
+    }
+}
+/** Atomic write (tmp+rename). Single writer, so no lost-update concern. */
+function writeStatuslineState(path, state) {
+    const tmp = `${path}.tmp.${process.pid}.${Date.now()}`;
+    try {
+        (0, fs_1.writeFileSync)(tmp, JSON.stringify(state));
+        (0, fs_1.renameSync)(tmp, path);
+    }
+    catch (e) {
+        try {
+            if ((0, fs_1.existsSync)(tmp)) {
+                (0, fs_1.unlinkSync)(tmp);
+            }
+        }
+        catch {
+            // best-effort cleanup
+        }
+        logger_1.logger.debug(`session-status: failed to write statusline state ${path}: ${e instanceof Error ? e.message : e}`);
+    }
+}
+/** Format a hex digest as a UUID-shaped string (8-4-4-4-12). */
+function formatHexAsUuid(hex) {
+    const h = hex.padEnd(32, "0").slice(0, 32);
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+/**
+ * Submit the session_status event. Gated on `isSessionStatusEnabled` and on
+ * the session being IronBee-tracked. Skips empty pre-first-response ticks (no
+ * usage yet) AND content-identical ticks (skip-if-unchanged): the statusline
+ * fires far more often than API responses (vim toggles, permission-mode
+ * changes, re-renders during tool execution) but the metrics only change on an
+ * API response, so without this the wire fills with byte-identical events.
+ * Fire-and-forget: errors are swallowed so the statusline render is never
+ * affected.
+ */
+async function submitSessionStatusEvent(input, projectDir) {
+    const sessionId = input.session_id;
+    if (!sessionId) {
+        return;
+    }
+    const cfg = (0, config_1.loadConfig)(projectDir);
+    if (!(0, config_1.isSessionStatusEnabled)(cfg)) {
+        return;
+    }
+    // Session-tracking guard: only emit for IronBee-tracked sessions.
+    const sessionDir = (0, path_1.join)(projectDir, ".ironbee", "sessions", sessionId);
+    if (!(0, fs_1.existsSync)(sessionDir)) {
+        return;
+    }
+    // Skip empty ticks before the first API response (no usage, zero cost).
+    const cw = input.context_window ?? {};
+    if ((cw.current_usage === null || cw.current_usage === undefined) && num(cw.total_input_tokens) === 0) {
+        return;
+    }
+    const event = buildSessionStatusEvent(input, projectDir, sessionId);
+    const sig = computeSessionStatusSignature(event);
+    const statePath = statuslineStatePath(projectDir, sessionId);
+    const prev = readStatuslineState(statePath);
+    // 1) Skip-if-unchanged: same resource signature → redundant tick, skip
+    //    without writing (the dominant case — vim/permission/re-render ticks).
+    if (prev.sig === sig) {
+        return;
+    }
+    // 2) Min-interval throttle: even on a real metric change, don't emit more
+    //    often than `emitMinIntervalSeconds` (default 10; 0 disables). Rapid
+    //    changes coalesce — the next tick after the interval elapses emits the
+    //    latest state. Skip WITHOUT advancing state so the pending change is
+    //    still emitted once the window opens.
+    const intervalMs = (0, config_1.getStatusLineEmitMinIntervalSeconds)(cfg) * 1000;
+    const now = Date.now();
+    if (intervalMs > 0 && prev.lastEmitMs !== undefined && now - prev.lastEmitMs < intervalMs) {
+        return;
+    }
+    (0, queue_1.submit)(projectDir, sessionId, "send_event", event);
+    writeStatuslineState(statePath, { sig, lastEmitMs: now });
+}
+/**
+ * Spawn the chained statusline command, piping our stdin to it and inheriting
+ * its stdout (so its output becomes the rendered statusline). On Windows,
+ * Claude Code runs statuslines via Git Bash, so a bash command would break
+ * under cmd.exe — prefer Git Bash there when available.
+ */
+function runChained(userCmd, stdinPayload) {
+    return new Promise((resolve) => {
+        let child;
+        const bash = process.platform === "win32" ? findGitBash() : undefined;
+        try {
+            child = bash
+                ? (0, child_process_1.spawn)(bash, ["-c", userCmd], { stdio: ["pipe", "inherit", "inherit"] })
+                : (0, child_process_1.spawn)(userCmd, [], { stdio: ["pipe", "inherit", "inherit"], shell: true });
+        }
+        catch (e) {
+            logger_1.logger.debug(`session-status: failed to spawn chained statusline: ${e instanceof Error ? e.message : e}`);
+            resolve();
+            return;
+        }
+        child.on("error", (e) => {
+            logger_1.logger.debug(`session-status: chained statusline error: ${e.message}`);
+            resolve();
+        });
+        child.on("exit", (code) => {
+            // Preserve the chained command's exit code so its render semantics
+            // (CC drops stdout on non-zero) match the unwrapped behavior.
+            process.exitCode = code ?? 0;
+            resolve();
+        });
+        if (child.stdin) {
+            child.stdin.on("error", () => { });
+            child.stdin.write(stdinPayload);
+            child.stdin.end();
+        }
+    });
+}
+/** Common Git Bash install locations on Windows; undefined → fall back to cmd.exe. */
+function findGitBash() {
+    const candidates = [
+        "C:\\Program Files\\Git\\bin\\bash.exe",
+        "C:\\Program Files\\Git\\usr\\bin\\bash.exe",
+        "C:\\Program Files (x86)\\Git\\bin\\bash.exe",
+    ];
+    for (const c of candidates) {
+        if ((0, fs_1.existsSync)(c)) {
+            return c;
+        }
+    }
+    return undefined;
+}
+/** Minimal default statusline when there is nothing to chain. */
+function buildDefaultLine(input) {
+    const model = input.model?.id ?? "?";
+    const pct = num(input.context_window?.used_percentage);
+    return `[${model}] ${pct}% ctx`;
+}
+/**
+ * Statusline entry point. Reads stdin, submits the event (gated, fire-and-
+ * forget), then chains the user's original statusline.
+ */
+async function runSessionStatus() {
+    let raw;
+    try {
+        raw = (0, stdin_1.readStdin)();
+    }
+    catch (e) {
+        logger_1.logger.debug(`session-status: failed to read stdin: ${e}`);
+        return;
+    }
+    let input;
+    try {
+        input = JSON.parse(raw);
+    }
+    catch (e) {
+        logger_1.logger.debug(`session-status: failed to parse stdin: ${e}`);
+        return;
+    }
+    const projectDir = resolveProjectDir(input);
+    // 1) Submit our metrics — never blocks/breaks the render.
+    await submitSessionStatusEvent(input, projectDir).catch((e) => {
+        logger_1.logger.debug(`session-status: submit failed: ${e instanceof Error ? e.message : e}`);
+    });
+    // 2) Chain the user's original statusline. Primary: SessionStart cache.
+    //    Fallback: live resolution (cache missing/torn/absent) so a cache miss
+    //    never makes the user's statusline disappear.
+    let chained;
+    if (input.session_id) {
+        const sessionDir = (0, path_1.join)(projectDir, ".ironbee", "sessions", input.session_id);
+        try {
+            chained = (0, session_state_1.getChainedStatusLine)(sessionDir);
+        }
+        catch {
+            chained = undefined;
+        }
+    }
+    if (chained === undefined) {
+        chained = resolveChainTarget(projectDir);
+    }
+    if (chained && !isIronbeeStatusLine(chained)) {
+        await runChained(chained, raw);
+        return;
+    }
+    // 3) Nothing to chain → silent unless renderDefault is on.
+    if ((0, config_1.getStatusLineRenderDefault)((0, config_1.loadConfig)(projectDir))) {
+        process.stdout.write(buildDefaultLine(input) + "\n");
+    }
+}
+//# sourceMappingURL=session-status.js.map