@indigoai-us/hq-cli 5.345.91 → 5.345.93

package/dist/lib/capacity/collectors/claude-statusline.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Claude Code statusline collector (US-004).
+ *
+ * The statusline hot path is a shell append to
+ * `<ledgerRoot>/spool/claude-statusline.jsonl`. This module parses those
+ * lines and the same JSON from `hq capacity ingest claude-statusline`.
+ * It does not start a daemon, spawn a process, or call a provider.
+ *
+ * observedAt is when the line was written (spooledAt), not when the
+ * daemon woke up. A missing rate_limits object is the normal pre-response
+ * payload and is not a parser_failure. A malformed rate_limits object is
+ * a parser_failure once per Claude Code version.
+ */
+import { type LedgerOptions, type NowView, type ParserFailureEvent, type ReadingInput } from "../ledger.js";
+export declare const CLAUDE_PARSER_VERSION = "claude-statusline.1";
+export declare const CLAUDE_PROVIDER = "claude";
+export declare const CLAUDE_STATUSLINE_SOURCE: "statusline";
+export declare const CLAUDE_SPOOL_DIR = "spool";
+export declare const CLAUDE_SPOOL_FILE = "claude-statusline.jsonl";
+export declare const STATUSLINE_SPOOL_SCRIPT = "statusline-spool.sh";
+export declare const STATUSLINE_LINES_TO_ADD: readonly ["f=\"${HQ_CAPACITY_ROOT:-$HOME/.hq/capacity}/statusline-spool.sh\"", "[ -r \"$f\" ] && . \"$f\"", "command -v hq_capacity_statusline_spool >/dev/null 2>&1 && hq_capacity_statusline_spool \"$input\" || true"];
+export declare function statuslineSpoolScriptPath(root: string): string;
+export declare function installStatuslineSpoolScript(root: string): void;
+export interface StatuslineParseResult {
+    readings: ReadingInput[];
+    failures: ParserFailureEvent[];
+    /** Session model display name or id. Not stored on the reading. */
+    model: string | null;
+}
+export interface StatuslineIngestResult extends StatuslineParseResult {
+    /** Set when stdin is empty or not JSON. Nothing was written. */
+    error?: string;
+    view: NowView | null;
+}
+export interface SpoolConsumeResult extends StatuslineParseResult {
+    consumedLines: number;
+    view: NowView | null;
+}
+export declare function claudeStatuslineSpoolPath(root: string): string;
+export declare function hashClaudeAccountId(raw: string): string;
+export declare function parseStatuslinePayload(payload: unknown, options: {
+    observedAt: string;
+    cliVersion?: string;
+    accountId?: string;
+    readingSalt?: string;
+}): StatuslineParseResult;
+/** Parse one spool line. Blank lines return null. */
+export declare function parseClaudeStatuslineSpoolLine(line: string, options?: {
+    now?: Date;
+    accountId?: string;
+    readingSalt?: string;
+}): StatuslineParseResult | null;
+export declare function ingestClaudeStatuslinePayload(text: string, options?: LedgerOptions): StatuslineIngestResult;
+/**
+ * Read the spool, append complete lines once, and drop only the bytes
+ * that were consumed. Rename-then-read: a shell `>>` that opens after the
+ * rename creates a new spool file and is left for the next tick.
+ */
+export declare function consumeClaudeStatuslineSpool(options: {
+    root: string;
+    now?: Date;
+    afterClaim?: (paths: {
+        live: string;
+        reading: string;
+    }) => void;
+    /** When set, a spooled configDir selects the account label and account id. */
+    accounts?: readonly {
+        label: string;
+        home: string;
+    }[];
+}): SpoolConsumeResult;
+//# sourceMappingURL=claude-statusline.d.ts.map

package/dist/lib/capacity/collectors/claude-statusline.js

@@ -0,0 +1,436 @@
+/**
+ * Claude Code statusline collector (US-004).
+ *
+ * The statusline hot path is a shell append to
+ * `<ledgerRoot>/spool/claude-statusline.jsonl`. This module parses those
+ * lines and the same JSON from `hq capacity ingest claude-statusline`.
+ * It does not start a daemon, spawn a process, or call a provider.
+ *
+ * observedAt is when the line was written (spooledAt), not when the
+ * daemon woke up. A missing rate_limits object is the normal pre-response
+ * payload and is not a parser_failure. A malformed rate_limits object is
+ * a parser_failure once per Claude Code version.
+ */
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { appendReadings, LedgerMissing, readLedgerEvents, } from "../ledger.js";
+export const CLAUDE_PARSER_VERSION = "claude-statusline.1";
+export const CLAUDE_PROVIDER = "claude";
+export const CLAUDE_STATUSLINE_SOURCE = "statusline";
+export const CLAUDE_SPOOL_DIR = "spool";
+export const CLAUDE_SPOOL_FILE = "claude-statusline.jsonl";
+export const STATUSLINE_SPOOL_SCRIPT = "statusline-spool.sh";
+export const STATUSLINE_LINES_TO_ADD = [
+    'f="${HQ_CAPACITY_ROOT:-$HOME/.hq/capacity}/statusline-spool.sh"',
+    '[ -r "$f" ] && . "$f"',
+    'command -v hq_capacity_statusline_spool >/dev/null 2>&1 && hq_capacity_statusline_spool "$input" || true',
+];
+const STATUSLINE_SCRIPT_BODY = "#!/bin/sh\n# Claude Code statusline spool. Hot path: one append, no stdout, no stderr.\n# A missing spool directory returns 0. Never calls hq, node, or jq.\n#\n# hq capacity enable installs this file at\n# ${HQ_CAPACITY_ROOT:-$HOME/.hq/capacity}/statusline-spool.sh\n# The status line sources that path and no-ops when it is missing:\n#   f=\"${HQ_CAPACITY_ROOT:-$HOME/.hq/capacity}/statusline-spool.sh\"\n#   [ -r \"$f\" ] && . \"$f\"\n#   command -v hq_capacity_statusline_spool >/dev/null 2>&1 && hq_capacity_statusline_spool \"$input\" || true\n#\n# The status line runs this several times a minute, so the bash path forks at\n# most once per call (date, on bash before 5) and checks the spool size on\n# about one call in 32. Variables are local so nothing leaks into the\n# status-line script that sources this file. Other shells take the POSIX path\n# in a subshell, which is slower but leaks nothing either.\n\n# Spool cap. The daemon drains the spool; this bounds it while the daemon is down.\nHQ_CAPACITY_SPOOL_MAX_BYTES=1048576\n\nif [ -n \"${BASH_VERSION-}\" ]; then\n  hq_capacity_statusline_spool() {\n    [ -n \"${1-}\" ] || return 0\n    local dir=\"${HQ_CAPACITY_ROOT:-${HOME:-}/.hq/capacity}/spool\"\n    [ -d \"$dir\" ] || return 0\n    local file=\"${dir}/claude-statusline.jsonl\"\n    if [ $((RANDOM % 32)) -eq 0 ] && [ -f \"$file\" ]; then\n      local size\n      size=$(wc -c < \"$file\" 2>/dev/null) || size=0\n      [ \"${size// /}\" -lt \"$HQ_CAPACITY_SPOOL_MAX_BYTES\" ] 2>/dev/null || return 0\n    fi\n    # Control characters (newlines included) would split or forge spool lines.\n    local payload=\"${1//[$'\\001'-$'\\037']/}\"\n    [ -n \"$payload\" ] || return 0\n    local now_s=\"${EPOCHSECONDS-}\"\n    if [ -z \"$now_s\" ]; then\n      now_s=$(date +%s 2>/dev/null) || return 0\n    fi\n    local config_field=\"\"\n    if [ -n \"${CLAUDE_CONFIG_DIR-}\" ]; then\n      local config_dir=\"$CLAUDE_CONFIG_DIR\"\n      # A config dir with control characters is dropped rather than repaired.\n      if [ \"${config_dir//[$'\\001'-$'\\037']/}\" = \"$config_dir\" ]; then\n        case $config_dir in\n          /*) ;;\n          *) config_dir=\"${PWD}/${config_dir}\" ;;\n        esac\n        config_dir=${config_dir//\\\\/\\\\\\\\}\n        config_dir=${config_dir//\\\"/\\\\\\\"}\n        config_field=\",\\\"configDir\\\":\\\"${config_dir}\\\"\"\n      fi\n    fi\n    # The format string is fixed so payload metacharacters stay literal.\n    printf '%s\\n' \"{\\\"spooledAt\\\":$((now_s * 1000))${config_field},\\\"payload\\\":${payload}}\" 2>/dev/null >> \"$file\" || return 0\n  }\nelse\n  hq_capacity_statusline_spool() (\n    [ -n \"${1-}\" ] || exit 0\n    dir=\"${HQ_CAPACITY_ROOT:-${HOME:-}/.hq/capacity}/spool\"\n    [ -d \"$dir\" ] || exit 0\n    file=\"${dir}/claude-statusline.jsonl\"\n    if [ -f \"$file\" ]; then\n      size=$(wc -c < \"$file\" 2>/dev/null) || size=0\n      size=$(printf '%s' \"$size\" | tr -d ' ')\n      [ \"$size\" -lt \"$HQ_CAPACITY_SPOOL_MAX_BYTES\" ] 2>/dev/null || exit 0\n    fi\n    payload=$(printf '%s' \"$1\" | tr -d '\\000-\\037')\n    [ -n \"$payload\" ] || exit 0\n    now_s=$(date +%s 2>/dev/null) || exit 0\n    config_field=\"\"\n    if [ -n \"${CLAUDE_CONFIG_DIR-}\" ]; then\n      config_dir=$CLAUDE_CONFIG_DIR\n      cleaned=$(printf '%s' \"$config_dir\" | tr -d '\\000-\\037')\n      if [ \"$cleaned\" = \"$config_dir\" ]; then\n        case $config_dir in\n          /*) ;;\n          *) config_dir=\"$(pwd)/${config_dir}\" ;;\n        esac\n        escaped=$(printf '%s' \"$config_dir\" | sed 's/\\\\/\\\\\\\\/g; s/\"/\\\\\"/g')\n        config_field=\",\\\"configDir\\\":\\\"${escaped}\\\"\"\n      fi\n    fi\n    printf '%s\\n' \"{\\\"spooledAt\\\":$((now_s * 1000))${config_field},\\\"payload\\\":${payload}}\" 2>/dev/null >> \"$file\" || exit 0\n  )\nfi\n\nif [ -n \"${BASH_VERSION-}\" ]; then\n  if [ \"${BASH_SOURCE[0]-}\" = \"$0\" ]; then\n    hq_capacity_statusline_spool \"$(cat)\"\n  fi\nfi\n";
+export function statuslineSpoolScriptPath(root) {
+    return path.join(root, STATUSLINE_SPOOL_SCRIPT);
+}
+export function installStatuslineSpoolScript(root) {
+    fs.mkdirSync(root, { recursive: true, mode: 0o700 });
+    const dest = statuslineSpoolScriptPath(root);
+    fs.writeFileSync(dest, STATUSLINE_SCRIPT_BODY, { mode: 0o700 });
+    fs.chmodSync(dest, 0o700);
+}
+const LOCAL_ACCOUNT = "claude-local";
+const WINDOWS = [
+    { key: "five_hour", limitId: "five_hour", kind: "session", windowMinutes: 5 * 60 },
+    { key: "seven_day", limitId: "seven_day", kind: "weekly_all", windowMinutes: 7 * 24 * 60 },
+];
+export function claudeStatuslineSpoolPath(root) {
+    return path.join(root, CLAUDE_SPOOL_DIR, CLAUDE_SPOOL_FILE);
+}
+export function hashClaudeAccountId(raw) {
+    const digest = crypto.createHash("sha256").update(raw, "utf8").digest("hex").slice(0, 16);
+    return `acct_${digest}`;
+}
+export function parseStatuslinePayload(payload, options) {
+    const accountId = hashClaudeAccountId(options.accountId ?? LOCAL_ACCOUNT);
+    const salt = options.readingSalt ?? options.observedAt;
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+        return {
+            readings: [],
+            model: null,
+            failures: [failure(options.observedAt, options.cliVersion ?? "unknown", accountId, "claude statusline payload is not an object")],
+        };
+    }
+    const record = payload;
+    const cliVersion = readCliVersion(record, options.cliVersion);
+    const model = readModel(record);
+    if (!("rate_limits" in record) || record.rate_limits === null) {
+        return { readings: [], failures: [], model: model.name };
+    }
+    const limits = record.rate_limits;
+    if (!limits || typeof limits !== "object" || Array.isArray(limits)) {
+        return {
+            readings: [],
+            model: model.name,
+            failures: [failure(options.observedAt, cliVersion, accountId, "claude statusline rate_limits malformed")],
+        };
+    }
+    const readings = [];
+    let drifted = model.drifted;
+    const windowRecord = limits;
+    for (const spec of WINDOWS) {
+        if (!(spec.key in windowRecord) || windowRecord[spec.key] === null)
+            continue;
+        const window = windowRecord[spec.key];
+        const parsed = parseWindow(window);
+        if (!parsed) {
+            drifted = true;
+            continue;
+        }
+        readings.push({
+            readingId: makeReadingId([CLAUDE_STATUSLINE_SOURCE, salt, accountId, spec.limitId, options.observedAt, String(parsed.usedPercent)]),
+            observedAt: options.observedAt,
+            provider: CLAUDE_PROVIDER,
+            accountId,
+            source: CLAUDE_STATUSLINE_SOURCE,
+            cliVersion,
+            confidence: "observed",
+            parserVersion: CLAUDE_PARSER_VERSION,
+            limit: {
+                limitId: spec.limitId,
+                kind: spec.kind,
+                scope: null,
+                usedPercent: parsed.usedPercent,
+                windowMinutes: spec.windowMinutes,
+                resetsAt: parsed.resetsAt,
+                balance: null,
+                planType: null,
+            },
+        });
+    }
+    return {
+        readings,
+        model: model.name,
+        failures: drifted
+            ? [failure(options.observedAt, cliVersion, accountId, "claude statusline rate_limits malformed")]
+            : [],
+    };
+}
+/** Parse one spool line. Blank lines return null. */
+export function parseClaudeStatuslineSpoolLine(line, options = {}) {
+    if (line.trim() === "")
+        return null;
+    const observedFallback = (options.now ?? new Date()).toISOString();
+    const accountId = hashClaudeAccountId(options.accountId ?? LOCAL_ACCOUNT);
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch {
+        return {
+            readings: [],
+            model: null,
+            failures: [failure(observedFallback, "unknown", accountId, "claude statusline spool line is not JSON")],
+        };
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        return {
+            readings: [],
+            model: null,
+            failures: [failure(observedFallback, "unknown", accountId, "claude statusline spool line malformed")],
+        };
+    }
+    const record = parsed;
+    const spooledAt = record.spooledAt;
+    if (typeof spooledAt !== "number" || !Number.isFinite(spooledAt)) {
+        return {
+            readings: [],
+            model: null,
+            failures: [failure(observedFallback, "unknown", accountId, "claude statusline spool line malformed")],
+        };
+    }
+    const observedAt = new Date(spooledAt).toISOString();
+    if (Number.isNaN(Date.parse(observedAt))) {
+        return {
+            readings: [],
+            model: null,
+            failures: [failure(observedFallback, "unknown", accountId, "claude statusline spool line malformed")],
+        };
+    }
+    if (!("payload" in record)) {
+        return {
+            readings: [],
+            model: null,
+            failures: [failure(observedAt, "unknown", accountId, "claude statusline spool line malformed")],
+        };
+    }
+    return parseStatuslinePayload(record.payload, {
+        observedAt,
+        accountId: options.accountId,
+        readingSalt: options.readingSalt ?? `${spooledAt}`,
+    });
+}
+export function ingestClaudeStatuslinePayload(text, options) {
+    const observedAt = (options?.now ? options.now() : new Date()).toISOString();
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return { readings: [], failures: [], model: null, view: null, error: "claude statusline payload is empty" };
+    }
+    let payload;
+    try {
+        payload = JSON.parse(trimmed);
+    }
+    catch {
+        return { readings: [], failures: [], model: null, view: null, error: "claude statusline payload is not JSON" };
+    }
+    const parsed = parseStatuslinePayload(payload, { observedAt, readingSalt: `stdin\0${observedAt}` });
+    const failures = takeNewFailures(parsed.failures, failureVersions(options));
+    const view = writeIfAny(parsed.readings, failures, options);
+    return { readings: parsed.readings, failures, model: parsed.model, view };
+}
+/**
+ * Read the spool, append complete lines once, and drop only the bytes
+ * that were consumed. Rename-then-read: a shell `>>` that opens after the
+ * rename creates a new spool file and is left for the next tick.
+ */
+export function consumeClaudeStatuslineSpool(options) {
+    const live = claudeStatuslineSpoolPath(options.root);
+    const ledger = { root: options.root, ...(options.now ? { now: () => options.now } : {}) };
+    const claims = claimStatuslineSpool(live);
+    if (claims.length === 0) {
+        return { readings: [], failures: [], model: null, consumedLines: 0, view: null };
+    }
+    const reading = claims[claims.length - 1] ?? live;
+    options.afterClaim?.({ live, reading });
+    const chunks = [];
+    for (const claim of claims) {
+        if (fs.existsSync(claim))
+            chunks.push(readSettled(claim));
+    }
+    const { lines, remainder } = splitCompleteLines(joinChunks(chunks));
+    const readings = [];
+    const rawFailures = [];
+    let model = null;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === undefined)
+            continue;
+        const parsed = parseClaudeStatuslineSpoolLine(line, {
+            now: options.now,
+            readingSalt: `${index}`,
+        });
+        if (!parsed)
+            continue;
+        if (options.accounts)
+            stampStatuslineAccount(line, parsed, options.accounts);
+        if (parsed.model)
+            model = parsed.model;
+        readings.push(...parsed.readings);
+        rawFailures.push(...parsed.failures);
+    }
+    const failures = takeNewFailures(rawFailures, failureVersions(ledger));
+    // A throw here leaves the claimed spool file in place for the next tick.
+    const view = writeIfAny(readings, failures, ledger);
+    for (const claim of claims) {
+        if (claim === reading && remainder.length > 0) {
+            fs.writeFileSync(claim, remainder, { mode: 0o600 });
+            continue;
+        }
+        if (fs.existsSync(claim))
+            fs.unlinkSync(claim);
+    }
+    return { readings, failures, model, consumedLines: lines.length, view };
+}
+function claimStatuslineSpool(live) {
+    const claimed = [];
+    const dir = path.dirname(live);
+    const base = path.basename(live);
+    if (fs.existsSync(dir)) {
+        let names;
+        try {
+            names = fs.readdirSync(dir);
+        }
+        catch {
+            names = [];
+        }
+        for (const name of names) {
+            if (name.startsWith(`${base}.reading.`))
+                claimed.push(path.join(dir, name));
+        }
+    }
+    const mine = `${live}.reading.${process.pid}.${Date.now()}.${crypto.randomBytes(4).toString("hex")}`;
+    try {
+        fs.renameSync(live, mine);
+        claimed.push(mine);
+    }
+    catch (err) {
+        const code = err.code;
+        if (code !== "ENOENT")
+            throw err;
+    }
+    return claimed;
+}
+function stampStatuslineAccount(line, parsed, accounts) {
+    let configDir;
+    try {
+        const record = JSON.parse(line);
+        if (typeof record.configDir === "string" && record.configDir.trim())
+            configDir = record.configDir.trim();
+    }
+    catch {
+        configDir = undefined;
+    }
+    const match = configDir
+        ? accounts.filter((account) => path.resolve(account.home) === path.resolve(configDir))
+        : [];
+    const chosen = match.find((account) => account.label !== "default")
+        ?? match[0]
+        ?? accounts.find((account) => account.label === "default");
+    const label = chosen?.label ?? "default";
+    const home = chosen?.home ?? configDir;
+    const accountId = home ? statuslineAccountId(home) : undefined;
+    for (const reading of parsed.readings) {
+        reading.accountLabel = label;
+        reading.accountLabels = [label];
+        if (home)
+            reading.accountHome = home;
+        if (accountId)
+            reading.accountId = accountId;
+    }
+    for (const failure of parsed.failures) {
+        failure.accountLabel = label;
+        failure.accountLabels = [label];
+        if (home)
+            failure.accountHome = home;
+        if (accountId)
+            failure.accountId = accountId;
+    }
+}
+function statuslineAccountId(home) {
+    const resolved = path.resolve(home);
+    if (process.platform === "darwin") {
+        const defaultHome = path.resolve(path.join(os.homedir(), ".claude"));
+        const service = resolved === defaultHome
+            ? "Claude Code-credentials"
+            : `Claude Code-credentials-${crypto.createHash("sha256").update(resolved, "utf8").digest("hex").slice(0, 8)}`;
+        return hashClaudeAccountId(`keychain:${service}`);
+    }
+    return hashClaudeAccountId(`file:${resolved}`);
+}
+function writeIfAny(readings, failures, options) {
+    if (readings.length === 0 && failures.length === 0)
+        return null;
+    return appendReadings(readings, failures, null, options);
+}
+function failure(observedAt, cliVersion, accountId, error) {
+    return {
+        event: "parser_failure",
+        observedAt,
+        provider: CLAUDE_PROVIDER,
+        source: CLAUDE_STATUSLINE_SOURCE,
+        error,
+        accountId,
+        cliVersion,
+        parserVersion: CLAUDE_PARSER_VERSION,
+    };
+}
+function failureVersions(options) {
+    let events;
+    try {
+        events = readLedgerEvents(options);
+    }
+    catch (err) {
+        if (err instanceof LedgerMissing)
+            return new Set();
+        throw err;
+    }
+    const seen = new Set();
+    for (const event of events) {
+        if (!("event" in event) || event.event !== "parser_failure")
+            continue;
+        if (event.provider !== CLAUDE_PROVIDER || event.source !== CLAUDE_STATUSLINE_SOURCE)
+            continue;
+        seen.add(event.cliVersion ?? "unknown");
+    }
+    return seen;
+}
+function takeNewFailures(failures, seen) {
+    const kept = [];
+    for (const item of failures) {
+        const version = item.cliVersion ?? "unknown";
+        if (seen.has(version))
+            continue;
+        seen.add(version);
+        kept.push(item);
+    }
+    return kept;
+}
+function readCliVersion(record, fallback) {
+    const version = record.version;
+    if (typeof version === "string" && version.trim())
+        return version.trim();
+    if (fallback && fallback.trim())
+        return fallback.trim();
+    return "unknown";
+}
+function readModel(record) {
+    if (!("model" in record) || record.model === null)
+        return { name: null, drifted: false };
+    const model = record.model;
+    if (typeof model === "string") {
+        const name = model.trim();
+        return name ? { name, drifted: false } : { name: null, drifted: true };
+    }
+    if (typeof model === "object" && !Array.isArray(model)) {
+        const fields = model;
+        const display = typeof fields.display_name === "string" ? fields.display_name.trim() : "";
+        const id = typeof fields.id === "string" ? fields.id.trim() : "";
+        if (display || id)
+            return { name: display || id, drifted: false };
+        return { name: null, drifted: true };
+    }
+    return { name: null, drifted: true };
+}
+function parseWindow(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const record = value;
+    const used = record.used_percentage;
+    const resets = record.resets_at;
+    if (typeof used !== "number" || !Number.isFinite(used) || used < 0 || used > 100)
+        return null;
+    if (typeof resets !== "number" || !Number.isFinite(resets) || resets <= 0)
+        return null;
+    return { usedPercent: used, resetsAt: resets };
+}
+function makeReadingId(parts) {
+    const digest = crypto.createHash("sha256").update(parts.join("\0"), "utf8").digest("hex").slice(0, 20);
+    return `rdg_${digest}`;
+}
+function readSettled(file) {
+    const first = fs.readFileSync(file);
+    if (fs.statSync(file).size === first.length)
+        return first;
+    return fs.readFileSync(file);
+}
+function joinChunks(chunks) {
+    if (chunks.length === 0)
+        return Buffer.alloc(0);
+    const parts = [];
+    for (const chunk of chunks) {
+        if (chunk.length === 0)
+            continue;
+        const prev = parts[parts.length - 1];
+        if (prev && prev[prev.length - 1] !== 0x0a)
+            parts.push(Buffer.from("\n"));
+        parts.push(chunk);
+    }
+    return parts.length === 0 ? Buffer.alloc(0) : Buffer.concat(parts);
+}
+function splitCompleteLines(buf) {
+    const end = buf.lastIndexOf(0x0a);
+    if (end < 0)
+        return { lines: [], remainder: buf };
+    const text = buf.subarray(0, end).toString("utf8");
+    const lines = text.length === 0 ? [] : text.split("\n").filter((line) => line.length > 0);
+    return { lines, remainder: buf.subarray(end + 1) };
+}
+//# sourceMappingURL=claude-statusline.js.map

package/dist/lib/capacity/collectors/codex.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Codex capacity collector for the resident daemon (US-008 calls these;
+ * this module does not start the daemon).
+ *
+ * The session JSONL tail is the primary feed: server-reported token_count
+ * rate limits, resumed by byte offset. The app-server read is a live
+ * account/rateLimits/read after initialize. That method does not refresh
+ * tokens. Starting the app-server process can still rewrite
+ * ~/.codex/auth.json for a managed ChatGPT login, so the read stays
+ * idle-gated. It never starts a thread, never sends a prompt, and never
+ * opens the Codex credential file.
+ */
+import { type LedgerOptions, type NowView, type ParserFailureEvent, type RateLimitResetCredits, type ReadingInput } from "../ledger.js";
+export declare const CODEX_PARSER_VERSION = "codex.1";
+export declare const CODEX_IDLE_MS: number;
+export declare const CODEX_APP_SERVER_TIMEOUT_MS = 20000;
+export declare const CODEX_APP_SERVER_BACKOFF_MS: number;
+export declare const CODEX_PROVIDER = "codex";
+export interface CodexTailCursor {
+    offset: number;
+    ino: number;
+    dev: number;
+    /**
+     * Hash of the bytes just before `offset`. Linux reuses a freed inode
+     * number at once, so a file unlinked and recreated at the same path can
+     * match ino, dev, and size. A different mark means a different file.
+     * Cursors written before this field existed have no mark and are trusted.
+     */
+    mark?: string;
+}
+export interface CodexTailState {
+    files: Record<string, CodexTailCursor>;
+}
+export interface CodexProviderMeta {
+    observedAt: string;
+    source: "codex-app-server";
+    cliVersion: string;
+    accountId: string;
+    ordinaryUsageAllowed: boolean | null;
+    rateLimitResetCredits: RateLimitResetCredits | null;
+}
+export interface CodexCollectResult {
+    readings: ReadingInput[];
+    failures: ParserFailureEvent[];
+    providerMeta: CodexProviderMeta | null;
+}
+export interface CodexTailResult extends CodexCollectResult {
+    state: CodexTailState;
+}
+export interface CodexAppServerResult extends CodexCollectResult {
+    ok: boolean;
+    reason?: "spawn-failed" | "timeout" | "exited" | "rpc-error";
+    backoffMs?: number;
+}
+export interface CodexAppServerChild {
+    stdin: {
+        write(chunk: string): unknown;
+        end(): unknown;
+        on?(event: "error", listener: (error: unknown) => void): unknown;
+    };
+    stdout: {
+        on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    };
+    kill(signal?: NodeJS.Signals): unknown;
+    once?(event: "exit" | "error", listener: (...args: unknown[]) => void): unknown;
+    pid?: number;
+}
+export type CodexAppServerSpawn = (command: string, args: readonly string[], env?: NodeJS.ProcessEnv) => CodexAppServerChild;
+export interface ShouldReadAppServerInput {
+    lastSessionWriteAt: number | null;
+    codexProcessRunning: boolean;
+    now: number;
+}
+export declare function hashAccountId(raw: string): string;
+export declare function hashCreditId(raw: string): string;
+export declare function parseCodexCliVersion(text: string): string | null;
+/** Idle at least 30 minutes and no codex process. A missing session write counts as idle. */
+export declare function shouldReadAppServer(input: ShouldReadAppServerInput): boolean;
+/** True when a process listing shows a `codex` executable, not a directory named codex. */
+export declare function isCodexProcessRunning(psOutput: string): boolean;
+export declare function latestCodexSessionWriteAt(sessionsDir: string, recentDays?: number): number | null;
+export declare function defaultCodexSpawn(command: string, args: readonly string[], env?: NodeJS.ProcessEnv): CodexAppServerChild;
+export declare function readInstalledCodexVersion(spawnImpl?: CodexAppServerSpawn): Promise<string>;
+export declare function tailCodexSessions(options: {
+    sessionsDir: string;
+    state?: CodexTailState;
+    cliVersion: string;
+    now?: Date;
+    accountId?: string;
+    accountLabel?: string;
+    accountLabels?: string[];
+    accountHome?: string;
+    /** Only session day directories this recent are walked. */
+    recentDays?: number;
+}): CodexTailResult;
+/** Map an account/rateLimits/read result. Does not spawn. */
+export declare function mapCodexAppServerBody(body: unknown, options: {
+    cliVersion: string;
+    now?: Date;
+    accountId?: string;
+    accountLabel?: string;
+    accountLabels?: string[];
+    accountHome?: string;
+}): CodexCollectResult;
+export declare function readCodexAppServer(options: {
+    spawn?: CodexAppServerSpawn;
+    cliVersion: string;
+    now?: Date;
+    timeoutMs?: number;
+    command?: string;
+    accountId?: string;
+    /** Sets CODEX_HOME for the app-server child. Omitted on the single-home path. */
+    home?: string;
+    accountLabel?: string;
+    accountLabels?: string[];
+    accountHome?: string;
+    signal?: AbortSignal;
+}): Promise<CodexAppServerResult>;
+export declare function ingestCodexResult(result: CodexCollectResult, options?: LedgerOptions): NowView | null;
+//# sourceMappingURL=codex.d.ts.map