@vortex-os/base 0.10.0 → 0.11.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 vortex-os-project
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 vortex-os-project
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -61,6 +61,25 @@ npx vortex session-start    # start-of-session boot report (git pull + counts +
 npx vortex session-end      # no-op (kept for hook compatibility; gap handling is at session-start)
 npx vortex doctor           # health diagnosis
 npx vortex update           # refresh framework templates (never clobbers your edits)
+npx vortex statusline       # Claude Code status-bar renderer (see below)
+```
+
+## Claude Code status bar (optional)
+
+`vortex statusline` renders a colored status bar for Claude Code's `statusLine` setting — model + a reasoning-effort meter (one bar whose height/color encode `low`→`ultracode`), a context-window gauge with used/total tokens, a clock, session cost, the 5-hour/7-day rate-limit gauges with time-to-reset, cache hit-rate, project + git branch/commit, session duration, lines changed, the number of open Claude Code sessions (best-effort process count) — and, inside a VortEX instance, the framework version and the latest worklog file:
+
+```
+🧠 Fable 5 │ █ max │ █░░░░░░░░░ 12% · 120K/1M │ 🕐 22:25 │ 💰 $9.22
+5h ██████░░ 75%(1h9m) │ 7d ███████░ 96%(7h30m) │ 📦 cache 99%
+📁 my-project │ ⎇ main 2b0949d │ ⏱ 1h26m │ +90 -49 │ ⧉ 1
+🌀 VortEX v0.11.0 │ last: 2026-06-10_0452-notes.md
+```
+
+Wire it up once — this writes the `statusLine` entry into the **current folder's** `.claude/settings.json` and **keeps any bar you already configured** (replace it explicitly with `--force`):
+
+```bash
+npx vortex statusline install          # full bar (4 lines inside an instance, 3 outside)
+npx vortex statusline install --lite   # compact 1-line bar
 ```
 
 ## Library usage

package/bin/vortex.mjs

@@ -1,17 +1,17 @@
-#!/usr/bin/env node
-// `vortex` — the CLI shipped by @vortex-os/base.
-//
-// `npm i @vortex-os/base` puts this on the instance's path (node_modules/.bin),
-// so `npx vortex init` / `npx vortex session-start` / `npx vortex --list` work
-// without any monorepo checkout. It is a thin wrapper over the canonical
-// dispatch (`runVortexCli`), which is bundled into base from
-// `@vortex-os/session-rituals` — exactly one source of truth for the CLI logic.
-//
-// The dispatch lazily probes the optional `@vortex-os/memory-extended` add-on:
-// when it is installed alongside base, `/recall` lights up; on a lean base-only
-// install the probe is caught and the CLI runs with every other command.
-
-import { sessionRituals } from "../dist/index.js";
-
-const code = await sessionRituals.runVortexCli(process.argv.slice(2));
-process.exitCode = code;
+#!/usr/bin/env node
+// `vortex` — the CLI shipped by @vortex-os/base.
+//
+// `npm i @vortex-os/base` puts this on the instance's path (node_modules/.bin),
+// so `npx vortex init` / `npx vortex session-start` / `npx vortex --list` work
+// without any monorepo checkout. It is a thin wrapper over the canonical
+// dispatch (`runVortexCli`), which is bundled into base from
+// `@vortex-os/session-rituals` — exactly one source of truth for the CLI logic.
+//
+// The dispatch lazily probes the optional `@vortex-os/memory-extended` add-on:
+// when it is installed alongside base, `/recall` lights up; on a lean base-only
+// install the probe is caught and the CLI runs with every other command.
+
+import { sessionRituals } from "../dist/index.js";
+
+const code = await sessionRituals.runVortexCli(process.argv.slice(2));
+process.exitCode = code;

package/dist/{catch-up-KIHTAUPX.js → catch-up-GDDKPZHJ.js}

@@ -1,8 +1,8 @@
 import {
   catchUpSessions
-} from "./chunk-7SNLVGBO.js";
+} from "./chunk-3L5DLEGP.js";
 import "./chunk-PZ5AY32C.js";
 export {
   catchUpSessions
 };
-//# sourceMappingURL=catch-up-KIHTAUPX.js.map
+//# sourceMappingURL=catch-up-GDDKPZHJ.js.map

package/dist/{chunk-7SNLVGBO.js → chunk-3L5DLEGP.js}

@@ -26,4 +26,4 @@ async function catchUpSessions(ctx, opts) {
 export {
   catchUpSessions
 };
-//# sourceMappingURL=chunk-7SNLVGBO.js.map
+//# sourceMappingURL=chunk-3L5DLEGP.js.map

package/dist/chunk-3L5DLEGP.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../plugins/session-rituals/src/catch-up.ts"],"sourcesContent":["import type { ModuleContext } from \"@vortex-os/core\";\n// Type-only — erased at compile time, so importing it does NOT pull the\n// `@vortex-os/memory-extended` add-on (or its native sqlite/level deps) into\n// the module graph of consumers that only need the types. The runtime engine\n// is loaded lazily inside the function body via `await import(...)`.\nimport type { sessionArchive } from \"@vortex-os/memory-extended\";\n\n/**\n * Start-of-session \"catch-up\": fold conversation transcripts into the local\n * search archive without the user ever having to wrap up a session.\n *\n * Two sources, one pass:\n *  - **local (a)** — this machine's own transcripts that are not archived yet,\n *    read from every detected agent host's transcript store (Claude Code,\n *    Codex, Gemini) and scoped to the current project. Because all hosts are\n *    swept on every start, a single Claude Code session-start also folds in the\n *    Codex/Gemini sessions you ran in the same project, into one archive.\n *  - **pulled (b)** — transcripts created on another machine that arrived as\n *    normalized text via git sync. Their text is present but this machine's\n *    DB (local, derived, gitignored) has never indexed them.\n *\n * Text only — vectorization is deferred to recall/rebuild so session start\n * stays fast. The whole step is gated by `autoRecord.archive` at the call site\n * and is best-effort: callers should treat a thrown archive backend (e.g. the\n * native sqlite module not built) as \"skip\", never as a fatal start error.\n */\nexport interface CatchUpResult {\n  /** Local transcripts newly archived this run (source a). */\n  readonly ingestedLocal: number;\n  /** Normalized transcripts from another machine newly indexed (source b). */\n  readonly indexedPulled: number;\n  /** Per-session ingest errors (source a). */\n  readonly errors: number;\n}\n\nexport interface CatchUpOptions {\n  /** Restrict local ingest to one project's transcripts. Default: `ctx.repoRoot`. */\n  readonly cwd?: string;\n  /**\n   * Transcript adapters for local ingest. Default: all CLI hosts — Claude Code,\n   * Codex, and Gemini. Each adapter's `detect()` returns false when its host is\n   * absent, so registering all three is ~free on a machine that only uses one.\n   * (Claude Desktop is opt-in — it needs the `classic-level` dependency — so it\n   * is not in the default set; a caller can add it.) Tests inject fakes (or a\n   * sandbox `env.home`) so the scan never touches the real home directory.\n   */\n  readonly adapters?: sessionArchive.IngestParams[\"adapters\"];\n  /** Adapter environment override (e.g. a sandbox HOME). Tests use this. */\n  readonly env?: sessionArchive.IngestParams[\"env\"];\n}\n\nexport async function catchUpSessions(\n  ctx: ModuleContext,\n  opts?: CatchUpOptions,\n): Promise<CatchUpResult> {\n  // Lazy-load the optional add-on. Base ships without `memory-extended`; this\n  // import resolves only when the add-on is installed alongside it. The call\n  // site already gates this step on `autoRecord.archive` and treats a thrown\n  // backend as \"skip\", so a missing add-on surfaces as a normal load error\n  // the caller can catch.\n  const { sessionArchive } = await import(\"@vortex-os/memory-extended\");\n\n  const dataDir = ctx.dataDir;\n  const cwd = opts?.cwd ?? ctx.repoRoot;\n  const adapters = opts?.adapters ?? [\n    sessionArchive.claudeCodeAdapter,\n    sessionArchive.codexAdapter,\n    sessionArchive.geminiAdapter,\n  ];\n\n  // (a) Ingest this machine's not-yet-archived transcripts for the current\n  // project. Writes the normalized copy into the archive (which git syncs) and\n  // a local DB row. Text only — no vectorization here.\n  const ingestResult = await sessionArchive.ingest({ adapters, dataDir, cwd, env: opts?.env });\n\n  // (b) Index normalized transcripts that arrived from another machine via git\n  // pull — their text is on disk but this machine's DB has no row yet.\n  const store = new sessionArchive.SessionArchiveStore(dataDir);\n  let indexedPulled = 0;\n  try {\n    indexedPulled = store.reindexFromNormalized().indexed;\n  } finally {\n    store.close();\n  }\n\n  return {\n    ingestedLocal: ingestResult.sessionsIngested,\n    indexedPulled,\n    errors: ingestResult.errors.length,\n  };\n}\n"],"mappings":";AAmDA,eAAsB,gBACpB,KACA,MAAqB;AAOrB,QAAM,EAAE,eAAc,IAAK,MAAM,OAAO,4BAA4B;AAEpE,QAAM,UAAU,IAAI;AACpB,QAAM,MAAM,MAAM,OAAO,IAAI;AAC7B,QAAM,WAAW,MAAM,YAAY;IACjC,eAAe;IACf,eAAe;IACf,eAAe;;AAMjB,QAAM,eAAe,MAAM,eAAe,OAAO,EAAE,UAAU,SAAS,KAAK,KAAK,MAAM,IAAG,CAAE;AAI3F,QAAM,QAAQ,IAAI,eAAe,oBAAoB,OAAO;AAC5D,MAAI,gBAAgB;AACpB,MAAI;AACF,oBAAgB,MAAM,sBAAqB,EAAG;EAChD;AACE,UAAM,MAAK;EACb;AAEA,SAAO;IACL,eAAe,aAAa;IAC5B;IACA,QAAQ,aAAa,OAAO;;AAEhC;","names":[]}

package/dist/chunk-DWANI3LV.js

@@ -0,0 +1,470 @@
+// ../plugins/session-rituals/dist/statusline.js
+import { execFileSync } from "child_process";
+import { closeSync, existsSync, openSync, readSync, readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+
+// ../plugins/session-rituals/dist/ensure-hooks.js
+var SESSION_START_COMMAND = "npx --no-install vortex session-start || exit 0";
+var SESSION_END_COMMAND = "npx --no-install vortex session-end || exit 0";
+var LEGACY_COMMANDS = {
+  SessionStart: [
+    "npx --no-install -p @vortex-os/base vortex session-start || exit 0",
+    "npx --no-install -p @vortex-os/base vortex session-start"
+  ],
+  SessionEnd: [
+    "npx --no-install -p @vortex-os/base vortex session-end || exit 0",
+    "npx --no-install -p @vortex-os/base vortex session-end"
+  ]
+};
+function parseSettings(text) {
+  const trimmed = (text ?? "").trim();
+  if (trimmed.length === 0)
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (e) {
+    throw new Error(`.claude/settings.json is not valid JSON \u2014 refusing to overwrite. Fix or remove it first. (${e.message})`);
+  }
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(".claude/settings.json is not a JSON object \u2014 refusing to overwrite.");
+  }
+  return parsed;
+}
+function ensureVortexHooks(existing) {
+  const base = existing && typeof existing === "object" ? existing : {};
+  const hooks = { ...base.hooks ?? {} };
+  const added = [];
+  const wire = (event, command) => {
+    const legacy = LEGACY_COMMANDS[event];
+    const src = hooks[event] ?? [];
+    let changed = false;
+    let kept = false;
+    const groups = [];
+    for (const g of src) {
+      const hookList = [];
+      for (const h of g.hooks ?? []) {
+        const migrated = legacy.includes(h.command);
+        const cmd = migrated ? command : h.command;
+        if (cmd === command) {
+          if (kept) {
+            changed = true;
+            continue;
+          }
+          kept = true;
+          if (migrated)
+            changed = true;
+          hookList.push(migrated ? { ...h, command } : h);
+        } else {
+          hookList.push(h);
+        }
+      }
+      if (hookList.length > 0)
+        groups.push({ ...g, hooks: hookList });
+      else
+        changed = true;
+    }
+    if (!kept) {
+      groups.push({ hooks: [{ type: "command", command }] });
+      changed = true;
+    }
+    hooks[event] = groups;
+    if (changed)
+      added.push(event);
+  };
+  wire("SessionStart", SESSION_START_COMMAND);
+  wire("SessionEnd", SESSION_END_COMMAND);
+  const settings = { ...base, hooks };
+  return { settings, added, alreadyWired: added.length === 0 };
+}
+function serializeSettings(settings) {
+  return JSON.stringify(settings, null, 2) + "\n";
+}
+
+// ../plugins/session-rituals/dist/statusline.js
+var RST = "\x1B[0m";
+var CYAN = "\x1B[36m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var BOLD = "\x1B[1m";
+var WHITE = "\x1B[37m";
+var MAGENTA = "\x1B[35m";
+var BLUE = "\x1B[34m";
+var GREY = "\x1B[38;5;242m";
+var ORANGE = "\x1B[38;5;208m";
+var SEP = ` ${DIM}\u2502${RST} `;
+function num(v, fallback = 0) {
+  return typeof v === "number" && Number.isFinite(v) ? v : fallback;
+}
+function nonneg(v, fallback = 0) {
+  return Math.max(0, num(v, fallback));
+}
+function clampPct(v) {
+  return Math.min(100, Math.max(0, v));
+}
+function safeSegment(s, max = 60) {
+  const cleaned = s.replace(/[\u0000-\u001f\u007f]/g, " ").replace(/\s+/g, " ").trim();
+  return cleaned.length > max ? cleaned.slice(0, max - 1) + "\u2026" : cleaned;
+}
+function str(v) {
+  return typeof v === "string" && v.length > 0 ? v : null;
+}
+function obj(v) {
+  return typeof v === "object" && v !== null ? v : {};
+}
+function parseStatuslineInput(text) {
+  const root = obj(JSON.parse(text));
+  const model = obj(root.model);
+  const effort = obj(root.effort);
+  const workspace = obj(root.workspace);
+  const cost = obj(root.cost);
+  const ctx = obj(root.context_window);
+  const usage = obj(ctx.current_usage);
+  const limits = obj(root.rate_limits);
+  const five = obj(limits.five_hour);
+  const seven = obj(limits.seven_day);
+  const rawName = str(model.display_name) ?? "Claude";
+  const windowSize = nonneg(ctx.context_window_size, 2e5);
+  return {
+    modelName: rawName.replace(/^Claude\s+/, ""),
+    effortLevel: str(effort.level),
+    transcriptPath: str(root.transcript_path),
+    dir: str(workspace.current_dir) ?? str(root.cwd),
+    contextWindowSize: windowSize > 0 ? windowSize : 2e5,
+    usedPercentage: clampPct(num(ctx.used_percentage)),
+    cacheReadTokens: nonneg(usage.cache_read_input_tokens),
+    cacheCreationTokens: nonneg(usage.cache_creation_input_tokens),
+    costUsd: nonneg(cost.total_cost_usd),
+    durationMs: nonneg(cost.total_duration_ms),
+    linesAdded: nonneg(cost.total_lines_added),
+    linesRemoved: nonneg(cost.total_lines_removed),
+    fiveHourUsedPct: clampPct(num(five.used_percentage)),
+    fiveHourResetsAt: nonneg(five.resets_at),
+    sevenDayUsedPct: clampPct(num(seven.used_percentage)),
+    sevenDayResetsAt: nonneg(seven.resets_at)
+  };
+}
+function effortMeter(level) {
+  switch (level) {
+    case "low":
+      return { meter: "\u2582", color: GREY };
+    case "medium":
+      return { meter: "\u2584", color: GREEN };
+    case "high":
+      return { meter: "\u2586", color: YELLOW };
+    case "xhigh":
+      return { meter: "\u2587", color: ORANGE };
+    case "max":
+      return { meter: "\u2588", color: RED };
+    case "ultracode":
+      return { meter: "\u2588\u2726", color: MAGENTA };
+    default:
+      return null;
+  }
+}
+function formatTokens(t) {
+  if (t >= 1e6)
+    return `${Math.floor(t / 1e6)}.${Math.floor(t % 1e6 / 1e5)}M`;
+  if (t >= 1e3)
+    return `${Math.floor(t / 1e3)}K`;
+  return String(Math.floor(t));
+}
+function formatWindow(t) {
+  if (t >= 1e6)
+    return `${Math.floor(t / 1e6)}M`;
+  if (t >= 1e3)
+    return `${Math.floor(t / 1e3)}K`;
+  return String(Math.floor(t));
+}
+function makeBar(pct, width) {
+  const filled = Math.min(width, Math.max(0, Math.floor(pct * width / 100)));
+  return "\u2588".repeat(filled) + "\u2591".repeat(width - filled);
+}
+function usageColor(pct) {
+  if (pct >= 80)
+    return RED;
+  if (pct >= 50)
+    return YELLOW;
+  return GREEN;
+}
+function healthColor(remaining) {
+  if (remaining <= 30)
+    return RED;
+  if (remaining <= 60)
+    return YELLOW;
+  return GREEN;
+}
+function formatDuration(ms) {
+  const totalMin = Math.floor(ms / 6e4);
+  if (totalMin >= 60)
+    return `${Math.floor(totalMin / 60)}h${totalMin % 60}m`;
+  return `${totalMin}m${Math.floor(ms / 1e3) % 60}s`;
+}
+function untilReset(resetsAtSec, now) {
+  if (resetsAtSec <= 0)
+    return "";
+  const diffSec = resetsAtSec - Math.floor(now.getTime() / 1e3);
+  if (diffSec <= 0)
+    return "";
+  if (diffSec >= 86400)
+    return `${Math.floor(diffSec / 86400)}d${Math.floor(diffSec % 86400 / 3600)}h`;
+  return `${Math.floor(diffSec / 3600)}h${Math.floor(diffSec % 3600 / 60)}m`;
+}
+function pad2(n) {
+  return String(n).padStart(2, "0");
+}
+function renderStatusline(d, p, mode = "full") {
+  const usedPctDisplay = Math.round(d.usedPercentage);
+  const ctxColor = usageColor(usedPctDisplay);
+  const ctxUsedTokens = Math.round(d.usedPercentage * d.contextWindowSize / 100);
+  const ctxText = `${WHITE}${formatTokens(ctxUsedTokens)}/${formatWindow(d.contextWindowSize)}${RST}`;
+  const clock = `\u{1F550} ${WHITE}${pad2(p.now.getHours())}:${pad2(p.now.getMinutes())}${RST}`;
+  const level = p.effortLevel ?? d.effortLevel;
+  const effort = effortMeter(level);
+  const effortSeg = effort ? `${effort.color}${effort.meter}${RST} ${GREY}${safeSegment(level ?? "")}${RST}` : null;
+  const modelSeg = `\u{1F9E0} ${BOLD}${CYAN}${safeSegment(d.modelName, 30)}${RST}`;
+  const fiveRemain = Math.max(0, 100 - Math.round(d.fiveHourUsedPct));
+  const sevenRemain = Math.max(0, 100 - Math.round(d.sevenDayUsedPct));
+  const fiveColor = healthColor(fiveRemain);
+  const sevenColor = healthColor(sevenRemain);
+  const sessionSeg = `${WHITE}\u29C9 ${Math.max(1, Math.floor(p.sessionCount))}${RST}`;
+  const project = safeSegment(p.vortex || d.dir ? (d.dir ?? "").replace(/[\\/]+$/, "").split(/[\\/]/).pop() || "?" : "?", 40);
+  const gitBranch = safeSegment(p.gitBranch, 40);
+  const gitHash = safeSegment(p.gitHash, 16);
+  if (mode === "lite") {
+    const parts = [
+      `\u{1F4C1} ${BLUE}${project}${RST}`,
+      `${WHITE}\u2387${RST} ${YELLOW}${gitBranch}${RST}`,
+      effortSeg ? `${modelSeg}${SEP}${effortSeg}` : modelSeg,
+      `${ctxColor}${makeBar(usedPctDisplay, 8)} ${usedPctDisplay}%${RST} ${DIM}\xB7${RST} ${ctxText}`,
+      `${GREY}5h${RST} ${fiveColor}${fiveRemain}%${RST} ${DIM}\xB7${RST} ${GREY}7d${RST} ${sevenColor}${sevenRemain}%${RST}`,
+      sessionSeg,
+      ...p.vortex?.version ? [`\u{1F300} ${MAGENTA}v${safeSegment(p.vortex.version, 20)}${RST}`] : [],
+      clock
+    ];
+    return parts.join(SEP);
+  }
+  const l1 = [
+    effortSeg ? `${modelSeg}${SEP}${effortSeg}` : modelSeg,
+    `${ctxColor}${makeBar(usedPctDisplay, 10)} ${usedPctDisplay}%${RST} ${DIM}\xB7${RST} ${ctxText}`,
+    clock,
+    `\u{1F4B0} ${BOLD}${YELLOW}$${d.costUsd.toFixed(2)}${RST}`
+  ].join(SEP);
+  const cacheTotal = d.cacheReadTokens + d.cacheCreationTokens;
+  const cachePct = cacheTotal > 0 ? Math.floor(d.cacheReadTokens * 100 / cacheTotal) : 0;
+  const fiveReset = untilReset(d.fiveHourResetsAt, p.now);
+  const sevenReset = untilReset(d.sevenDayResetsAt, p.now);
+  const l2 = [
+    `${GREY}5h${RST} ${fiveColor}${makeBar(fiveRemain, 8)} ${fiveRemain}%${RST}` + (fiveReset ? `${GREY}(${fiveReset})${RST}` : ""),
+    `${GREY}7d${RST} ${sevenColor}${makeBar(sevenRemain, 8)} ${sevenRemain}%${RST}` + (sevenReset ? `${GREY}(${sevenReset})${RST}` : ""),
+    `\u{1F4E6} ${GREEN}cache ${cachePct}%${RST}`
+  ].join(SEP);
+  const l3 = [
+    `\u{1F4C1} ${BLUE}${project}${RST}`,
+    `${WHITE}\u2387${RST} ${YELLOW}${gitBranch}${RST} ${GREY}${gitHash}${RST}`,
+    `\u23F1 ${MAGENTA}${formatDuration(d.durationMs)}${RST}`,
+    `${GREEN}+${d.linesAdded}${RST} ${RED}-${d.linesRemoved}${RST}`,
+    sessionSeg
+  ].join(SEP);
+  const lines = [l1, l2, l3];
+  if (p.vortex) {
+    let vx = `\u{1F300} ${BOLD}${MAGENTA}VortEX${RST}`;
+    if (p.vortex.version)
+      vx += ` ${GREY}v${safeSegment(p.vortex.version, 20)}${RST}`;
+    if (p.vortex.lastWorklog)
+      vx += `${SEP}${GREY}last:${RST} ${safeSegment(p.vortex.lastWorklog, 70)}`;
+    lines.push(vx);
+  }
+  return lines.join("\n");
+}
+function gitOut(dir, args) {
+  return execFileSync("git", ["-C", dir, ...args], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  }).trim();
+}
+function sniffEffortFromTranscript(transcriptPath, maxBytes = 4e6) {
+  try {
+    const size = statSync(transcriptPath).size;
+    const start = Math.max(0, size - maxBytes);
+    const length = size - start;
+    if (length <= 0)
+      return null;
+    const buf = Buffer.alloc(length);
+    const fd = openSync(transcriptPath, "r");
+    try {
+      readSync(fd, buf, 0, length, start);
+    } finally {
+      closeSync(fd);
+    }
+    const text = buf.toString("utf8");
+    const matches = text.match(/Set effort level to [a-z]+/g);
+    if (!matches || matches.length === 0)
+      return null;
+    return matches[matches.length - 1].slice("Set effort level to ".length);
+  } catch {
+    return null;
+  }
+}
+function countClaudeSessions() {
+  try {
+    if (process.platform === "win32") {
+      const out2 = execFileSync("tasklist", [], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      const n2 = (out2.match(/claude\.exe/gi) ?? []).length;
+      return n2 > 0 ? n2 : 1;
+    }
+    const out = execFileSync("pgrep", ["-x", "claude"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    const n = out.split(/\r?\n/).filter(Boolean).length;
+    return n > 0 ? n : 1;
+  } catch {
+    return 1;
+  }
+}
+function newestWorklogName(repoRoot) {
+  try {
+    const dir = join(repoRoot, "data", "worklog");
+    const entries = readdirSync(dir, { recursive: true });
+    let best = null;
+    for (const rel of entries) {
+      const s = String(rel);
+      if (!s.endsWith(".md") || s.endsWith("_INDEX.md"))
+        continue;
+      if (best === null || s > best)
+        best = s;
+    }
+    return best ? best.replace(/\\/g, "/").split("/").pop() : null;
+  } catch {
+    return null;
+  }
+}
+function collectStatuslineProbes(d, now = /* @__PURE__ */ new Date()) {
+  const dir = d.dir ?? process.cwd();
+  let gitBranch = "-";
+  let gitHash = "-";
+  try {
+    const branch = gitOut(dir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    gitBranch = branch === "HEAD" ? "detached" : branch || "-";
+    gitHash = gitOut(dir, ["rev-parse", "--short", "HEAD"]) || "-";
+  } catch {
+  }
+  let vortex = null;
+  try {
+    if (existsSync(join(dir, ".agent", "vortex.json"))) {
+      let version = null;
+      try {
+        const pkg = JSON.parse(readFileSync(join(dir, "node_modules", "@vortex-os", "base", "package.json"), "utf8"));
+        version = typeof pkg.version === "string" ? pkg.version : null;
+      } catch {
+      }
+      vortex = { version, lastWorklog: newestWorklogName(dir) };
+    }
+  } catch {
+    vortex = null;
+  }
+  let effortLevel = null;
+  if (d.effortLevel === "xhigh" && d.transcriptPath) {
+    const sniffed = sniffEffortFromTranscript(d.transcriptPath);
+    if (sniffed === "ultracode")
+      effortLevel = "ultracode";
+  }
+  return {
+    gitBranch,
+    gitHash,
+    sessionCount: countClaudeSessions(),
+    vortex,
+    effortLevel,
+    now
+  };
+}
+function statuslineCommand(lite) {
+  return `npx --no-install vortex statusline${lite ? " lite" : ""} || exit 0`;
+}
+function ensureStatusline(existing, lite, force = false) {
+  const command = statuslineCommand(lite);
+  const current = existing.statusLine;
+  const currentCmd = typeof current?.command === "string" ? current.command : void 0;
+  const isOurs = currentCmd === statuslineCommand(false) || currentCmd === statuslineCommand(true);
+  if (currentCmd === command && current?.type === "command") {
+    return { settings: existing, status: "already-ours" };
+  }
+  if (current && !isOurs && !force) {
+    return { settings: existing, status: "kept-existing", existing: currentCmd ?? JSON.stringify(current) };
+  }
+  return {
+    settings: { ...existing, statusLine: { type: "command", command } },
+    status: "installed"
+  };
+}
+async function runStatuslineCli(argv, repoRoot, out, err) {
+  if (argv[0] === "install") {
+    const lite = argv.includes("--lite");
+    const force = argv.includes("--force");
+    const settingsPath = join(repoRoot, ".claude", "settings.json");
+    const existingText = existsSync(settingsPath) ? readFileSync(settingsPath, "utf8") : null;
+    const parsed = parseSettings(existingText);
+    const result = ensureStatusline(parsed, lite, force);
+    if (result.status === "installed") {
+      const { mkdirSync, writeFileSync } = await import("fs");
+      mkdirSync(join(repoRoot, ".claude"), { recursive: true });
+      writeFileSync(settingsPath, serializeSettings(result.settings), "utf8");
+    }
+    const payload = {
+      status: result.status,
+      settingsPath,
+      ...result.status !== "kept-existing" ? { command: statuslineCommand(lite) } : {},
+      ...result.existing !== void 0 ? { existing: result.existing } : {}
+    };
+    out(JSON.stringify(payload, null, 2) + "\n");
+    if (result.status === "kept-existing") {
+      err("[vortex] statusLine already configured with a different command \u2014 kept it. Re-run with --force to replace.\n");
+    }
+    return 0;
+  }
+  const mode = argv[0] === "lite" ? "lite" : "full";
+  if (process.stdin.isTTY) {
+    err("[vortex] statusline renders Claude Code's statusLine stdin JSON \u2014 pipe it in, or wire it up with `vortex statusline install [--lite]`.\n");
+    return 0;
+  }
+  let raw = "";
+  try {
+    raw = readFileSync(0, "utf8");
+  } catch {
+    raw = "";
+  }
+  if (!raw.trim())
+    return 0;
+  let data;
+  try {
+    data = parseStatuslineInput(raw);
+  } catch {
+    return 0;
+  }
+  out(renderStatusline(data, collectStatuslineProbes(data), mode));
+  return 0;
+}
+
+export {
+  SESSION_START_COMMAND,
+  SESSION_END_COMMAND,
+  parseSettings,
+  ensureVortexHooks,
+  serializeSettings,
+  safeSegment,
+  parseStatuslineInput,
+  effortMeter,
+  formatTokens,
+  formatWindow,
+  makeBar,
+  renderStatusline,
+  sniffEffortFromTranscript,
+  collectStatuslineProbes,
+  statuslineCommand,
+  ensureStatusline,
+  runStatuslineCli
+};
+//# sourceMappingURL=chunk-DWANI3LV.js.map