meksus 0.3.1 → 0.5.0

package/README.md

@@ -35,10 +35,20 @@ meksus watch --label "build" -- npm run build # any command; a failure opens an
 
 Start a new Claude Code session after installing the hooks. It then appears on the dashboard's **Agents** page: working, waiting for you, finished, or stuck.
 
+## Claude plan limits on the dashboard
+
+```sh
+meksus statusline install --global   # once per computer (use --replace if you already have a status line)
+```
+
+Claude Code's status line then shows how much of your plan's 5-hour and weekly limits you've used and when each resets, and the dashboard's **Agents** page shows the same with a live countdown. A Discord DM tells you when a limit resets (turn it off on the Agents page). Claude Code provides these numbers for claude.ai Pro and Max plans, after the first reply in a session.
+
 ## Check
 
 ```sh
-meksus status    # who you're signed in as, whether you have access, and this repo's project
+meksus status    # who you're signed in as, this repo's project, then three cards:
+                 # AI assistants, services & spending, problems to fix (--all: every project)
+meksus ack 3f2a  # acknowledge a problem (the id's first characters are enough); resolve works the same
 ```
 
 ## What is sent
@@ -51,17 +61,23 @@ With `meksus task-lines` turned on (it's off by default), two more things are se
 
 The server scrubs anything that looks like a secret.
 
+When a Claude turn finishes, three numbers describe its size: how long it took, how many tool calls it made and how many files it changed (counted locally; file names never leave). Discord channels can then ask for big or small finished tasks only.
+
+With `meksus statusline` installed, your Claude plan limits are sent too: the used percentage and reset time of the 5-hour and weekly windows, at most once a minute. Nothing else from the status line is sent.
+
 ## Commands
 
 | Command | What it does |
 |---|---|
 | `meksus login` / `logout` | Sign in with GitHub, or sign out |
-| `meksus status` | Account, access, and this repo's project |
+| `meksus status [--all] [--json]` | Account and this repo's project, then the dashboard's three cards: AI assistants, services & spending, problems to fix |
+| `meksus ack <id>` · `meksus resolve <id>` | Acknowledge or resolve a problem from the terminal; the Discord card updates for everyone |
 | `meksus project list` | Your organisations, Personal, and their projects |
 | `meksus project create <name> [--in <parent>] [--use]` | Create a project (owners and admins) |
 | `meksus project use <owner/project>` | Write this repo's `.meksus` |
 | `meksus hooks install` / `uninstall` | Watch Claude Code in this repo |
 | `meksus task-lines off \| steps \| prompt` | Opt-in one-line "working on" |
+| `meksus statusline install [--global]` / `uninstall` | Claude plan limits in the status line and on the dashboard |
 | `meksus watch [--label <name>] -- <cmd>` | Run a command and report how it ends |
 
 © Lore Inc. All rights reserved.

package/bin/meksus.mjs

@@ -5,7 +5,9 @@ import { login, logout } from "../src/auth.mjs";
 import { install, runHook, uninstall } from "../src/hooks.mjs";
 import { apiBase, dir, readConfig } from "../src/config.mjs";
 import { projectCommand, readProjectFile } from "../src/project.mjs";
+import { incidentCommand, printCards } from "../src/cards.mjs";
 import { flush } from "../src/spool.mjs";
+import { limitsFlush, runStatusline, statuslineCommand } from "../src/statusline.mjs";
 import { taskLinesCommand } from "../src/tasks.mjs";
 import { VERSION } from "../src/version.mjs";
 import { watch } from "../src/watch.mjs";
@@ -14,12 +16,15 @@ const HELP = `M.E.K.S.U.S. CLI ${VERSION}
 
   meksus login [--no-browser]                     Sign in with GitHub (your account, not this machine)
   meksus logout                                   End this sign-in
-  meksus status                                   Who you are, and which project this repo reports to
+  meksus status [--all] [--json]                  Who you are, then AI assistants, services & spend, and problems
+  meksus ack <id> | meksus resolve <id>           Acknowledge or resolve a problem (id from status; a prefix is enough)
   meksus project list                             Your organisations, Personal, and their projects
   meksus project create <name> [--in <parent>] [--slug <slug>] [--use]
   meksus project use <owner/project>              Write this repo's .meksus file (commit it)
   meksus hooks install | uninstall                Watch Claude Code in the current repository
   meksus task-lines [off | steps | prompt]        Show what Claude is working on, in one line (opt-in)
+  meksus statusline install [--global]            Claude's plan limits (5-hour and weekly) in Claude Code's
+                                                  status line and on your M.E.K.S.U.S. dashboard
   meksus watch [--label <name>] -- <cmd> …        Run a command and report its status; a failure opens an incident
 
 Status only: code, prompts and command output never leave your machine. With task-lines on, the title
@@ -36,6 +41,8 @@ switch (command) {
   case "login": code = await login({ noBrowser: flag("--no-browser") }); break;
   case "logout": code = await logout(); break;
   case "status": code = await status(); break;
+  case "ack": case "acknowledge": code = await incidentCommand("acknowledge", rest[0]); break;
+  case "resolve": code = await incidentCommand("resolve", rest[0]); break;
   case "project": case "projects": code = (await requireAccess()) ? await projectCommand(rest) : 1; break;
   case "hooks":
     if (rest[0] === "install") code = (await requireAccess()) ? install() : 1;
@@ -44,6 +51,10 @@ switch (command) {
     break;
   case "hook": code = await runHook(); break; // called by Claude Code, silent
   case "task-lines": code = taskLinesCommand(rest); break;
+  case "statusline":
+    code = rest.length ? ((rest[0] === "install" && !(await requireAccess())) ? 1 : statuslineCommand(rest)) : await runStatusline();
+    break;
+  case "limits-flush": await limitsFlush(); break; // internal, detached
   case "flush": await flush(); break; // internal, detached
   case "watch": code = await watch(rest); break;
   case "--version": case "-v": case "version": console.log(VERSION); break;
@@ -64,5 +75,6 @@ async function status() {
   }
   console.log(project ? `This repo reports to ${project.name ?? project.id}  (${project.file})` : "This repo has no .meksus file: nothing here is reported. `meksus project use <owner/project>` adds one.");
   console.log(`API ${apiBase(c)}`);
-  return c?.session ? 0 : 1;
+  if (!c?.session) return 1;
+  return printCards({ json: flag("--json"), all: flag("--all") });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meksus",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "M.E.K.S.U.S. CLI: see what your AI coding agents (Claude Code) and builds are doing, live, and get Discord alerts when they fail or need you. Status only: code, prompts and output never leave your machine.",
   "keywords": [
     "meksus",

package/src/cards.mjs

@@ -0,0 +1,132 @@
+// `meksus status` (the dashboard's three cards in the terminal) and `meksus ack|resolve <id>` (CLI-3/4).
+// Reads go straight to the database as the signed-in user, so its access rules decide what's shown,
+// exactly as on the dashboard. Actions use the same incident_action as the dashboard (recorded with
+// source "cli"), then ask the ingest Worker to redraw the Discord card for everyone.
+import { getAccessToken } from "./auth.mjs";
+import { apiBase, readConfig } from "./config.mjs";
+import { readProjectFile } from "./project.mjs";
+import { VERSION } from "./version.mjs";
+
+const color = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code) => (s) => (color ? `\x1b[${code}m${s}\x1b[0m` : String(s));
+const dim = paint("2"), bold = paint("1"), red = paint("31"), orange = paint("33"), green = paint("32"), cyan = paint("36");
+const SEV = { critical: (s) => red(bold(s)), high: red, medium: orange, low: dim };
+
+export const shortId = (id) => id.slice(0, 8);
+
+async function db(config, token, path, init = {}) {
+  const res = await fetch(`${config.supabase_url.replace(/\/$/, "")}/rest/v1/${path}`, {
+    ...init,
+    headers: { apikey: config.supabase_publishable_key, Authorization: `Bearer ${token}`, "Content-Type": "application/json",
+      "User-Agent": `meksus-cli/${VERSION}`, "X-Meksus-Source": "cli", ...(init.headers ?? {}) },
+    signal: AbortSignal.timeout(10_000),
+  });
+  const body = await res.json().catch(() => null);
+  return { status: res.status, body };
+}
+
+const ago = (iso) => {
+  const s = Math.max(0, Math.round((Date.now() - Date.parse(iso)) / 1000));
+  return s < 60 ? `${s}s ago` : s < 3600 ? `${Math.round(s / 60)}m ago` : s < 86400 ? `${Math.round(s / 3600)}h ago` : `${Math.round(s / 86400)}d ago`;
+};
+const clip = (s, n) => (s && s.length > n ? `${s.slice(0, n - 1)}…` : s ?? "");
+const usd = (v) => (typeof v === "number" ? `$${v.toFixed(2)}` : "—");
+
+/** The three cards' data for one project (the repo's .meksus) or every project the user can see. */
+export async function loadOverview(config, token, projectId) {
+  const only = projectId ? `&project_id=eq.${projectId}` : "";
+  const [projects, incidents, agents, connectors] = await Promise.all([
+    db(config, token, `projects?select=id,name${projectId ? `&id=eq.${projectId}` : ""}&order=name`),
+    db(config, token, `incidents?select=id,title,severity,status,occurrences,last_seen_at,project_id,muted&status=neq.resolved${only}&order=last_seen_at.desc&limit=100`),
+    db(config, token, `agent_sessions?select=id,label,agent,state,task,last_event_at,project_id&ended_at=is.null${only}&order=last_event_at.desc&limit=20`),
+    db(config, token, `connectors?select=provider,status,snapshot,project_id${only}`),
+  ]);
+  for (const r of [projects, incidents, agents, connectors]) if (r.status === 401) return { error: "signed_out" };
+  if ([projects, incidents, agents, connectors].some((r) => !Array.isArray(r.body))) return { error: "unavailable" };
+  const name = Object.fromEntries(projects.body.map((p) => [p.id, p.name]));
+  const now = Date.now();
+  const live = agents.body.filter((a) => now - Date.parse(a.last_event_at) < 30 * 60_000);
+  const order = { critical: 0, high: 1, medium: 2, low: 3 };
+  const problems = incidents.body.filter((i) => !i.muted)
+    .sort((a, b) => (order[a.severity] - order[b.severity]) || Date.parse(b.last_seen_at) - Date.parse(a.last_seen_at));
+  return {
+    scope: projectId ? name[projectId] ?? "this project" : `${projects.body.length} project${projects.body.length === 1 ? "" : "s"}`,
+    agents: live.map((a) => ({ ...a, project: name[a.project_id], quiet: a.state !== "waiting" && now - Date.parse(a.last_event_at) > 5 * 60_000 })),
+    spend: connectors.body.map((c) => ({ provider: c.provider, status: c.status, today_usd: c.snapshot?.usage_daily_usd ?? null, remaining_usd: c.snapshot?.remaining_usd ?? null, project: name[c.project_id] })),
+    problems: problems.map((i) => ({ ...i, project: name[i.project_id] })),
+  };
+}
+
+/** Plain-text cards (no colour when piped or NO_COLOR is set). */
+export function renderCards(o, { width = 78 } = {}) {
+  const out = [];
+  const head = (title, note) => { out.push(""); out.push(`${bold(title)}${note ? `  ${dim(note)}` : ""}`); out.push(dim("─".repeat(Math.min(width, 78)))); };
+  const waiting = o.agents.filter((a) => a.state === "waiting").length;
+  head("AI assistants", o.agents.length ? `${o.agents.length} live · ${waiting} waiting for you` : "none running");
+  if (!o.agents.length) out.push(dim("  Claude Code and anything under `meksus watch` show up here while they work."));
+  for (const a of o.agents.slice(0, 5)) {
+    const state = a.state === "waiting" ? orange("waiting for you") : a.quiet ? orange("gone quiet") : a.state === "working" ? green("working") : a.state;
+    out.push(`  ${clip(a.label ?? a.agent, 32).padEnd(32)} ${state}  ${dim(ago(a.last_event_at))}${a.task ? `\n    ${dim("→")} ${clip(a.task, width - 6)}` : ""}`);
+  }
+  head("Service health & spending", o.spend.length ? `${o.spend.length} connected` : null);
+  if (!o.spend.length) out.push(dim("  No services connected yet. Connect one on the dashboard (Integrations / Spend)."));
+  for (const s of o.spend) {
+    const st = s.status === "ok" ? green("ok") : red(s.status);
+    out.push(`  ${(s.provider === "openrouter" ? "OpenRouter" : s.provider).padEnd(14)} ${st}  ${usd(s.today_usd)} today · ${usd(s.remaining_usd)} left${s.project ? dim(`  ${s.project}`) : ""}`);
+  }
+  const needs = o.problems.filter((p) => p.status === "open").length;
+  head("Problems to fix", o.problems.length ? `${o.problems.length} open · ${needs} need a person` : null);
+  if (!o.problems.length) out.push(`  ${green("All steady.")} ${dim("Nothing needs you.")}`);
+  for (const p of o.problems.slice(0, 10)) {
+    const sev = (SEV[p.severity] ?? dim)(p.severity.padEnd(8));
+    out.push(`  ${cyan(shortId(p.id))}  ${sev} ${clip(p.title, width - 36)}${p.occurrences > 1 ? dim(` ×${p.occurrences}`) : ""}${p.status === "acknowledged" ? dim(" (ack)") : ""}`);
+    out.push(`            ${dim(`${p.project ?? ""} · last ${ago(p.last_seen_at)}`)}`);
+  }
+  if (o.problems.length > 10) out.push(dim(`  … and ${o.problems.length - 10} more on the dashboard`));
+  if (o.problems.length) out.push(dim("\n  meksus ack <id> · meksus resolve <id>   (the first characters of the id are enough)"));
+  return out.join("\n");
+}
+
+async function session() {
+  const config = readConfig();
+  if (!config?.session) return { error: "Not signed in. Run `meksus login`." };
+  const token = await getAccessToken(config);
+  if (!token) return { error: "Your sign-in expired. Run `meksus login`." };
+  return { config, token };
+}
+
+/** Appended to `meksus status` (after who you are and which project this repo reports to). */
+export async function printCards({ json = false, all = false } = {}) {
+  const s = await session();
+  if (s.error) return 1;
+  const project = all ? null : readProjectFile();
+  const o = await loadOverview(s.config, s.token, project?.id ?? null);
+  if (o.error) { console.error(o.error === "signed_out" ? "Your sign-in expired. Run `meksus login`." : "Couldn't load the cards right now. Try again."); return 1; }
+  if (json) { console.log(JSON.stringify(o, null, 2)); return 0; }
+  console.log(dim(`\nShowing ${o.scope}${project && !all ? " (this repo's .meksus; --all for every project)" : ""}`));
+  console.log(renderCards(o, { width: Math.max(60, Math.min(process.stdout.columns ?? 80, 100)) }));
+  return 0;
+}
+
+/** `meksus ack <id>` / `meksus resolve <id>`: the id prefix is matched among open problems you can see. */
+export async function incidentCommand(action, ref) {
+  if (!ref || !/^[0-9a-f-]{4,36}$/i.test(ref)) { console.error(`Usage: meksus ${action === "acknowledge" ? "ack" : "resolve"} <id>   (see \`meksus status\`)`); return 2; }
+  const s = await session();
+  if (s.error) { console.error(s.error); return 1; }
+  const list = await db(s.config, s.token, "incidents?select=id,title,status,project_id&status=neq.resolved&order=last_seen_at.desc&limit=200");
+  if (!Array.isArray(list.body)) { console.error("Couldn't load your problems right now. Try again."); return 1; }
+  const matches = list.body.filter((i) => i.id.startsWith(ref.toLowerCase()));
+  if (!matches.length) { console.error(`No open problem starts with ${ref}. \`meksus status --all\` lists them.`); return 1; }
+  if (matches.length > 1) { console.error(`${ref} matches ${matches.length} problems; type more of the id:\n${matches.map((m) => `  ${m.id}  ${m.title}`).join("\n")}`); return 1; }
+  const i = matches[0];
+  const r = await db(s.config, s.token, "rpc/incident_action", { method: "POST", body: JSON.stringify({ p_incident: i.id, p_action: action }) });
+  if (r.status >= 300 || !r.body?.ok) { console.error(`Not done: ${r.body?.error ?? r.body?.message ?? `HTTP ${r.status}`}.`); return 1; }
+  // Redraw the Discord card(s) for everyone, like the dashboard does. Best effort.
+  let synced = false;
+  try {
+    const res = await fetch(`${apiBase(s.config)}/v1/incidents/${i.id}/discord-sync`, { method: "POST", headers: { Authorization: `Bearer ${s.token}`, "User-Agent": `meksus-cli/${VERSION}` }, signal: AbortSignal.timeout(10_000) });
+    synced = res.ok && (await res.json().catch(() => null))?.synced !== false;
+  } catch { /* the next action redraws it */ }
+  console.log(`${green("✔")} ${action === "acknowledge" ? "Acknowledged" : "Resolved"}: ${i.title}${synced ? dim("  (Discord card updated)") : ""}`);
+  return 0;
+}

package/src/hooks.mjs

@@ -9,6 +9,7 @@ import { basename, dirname, isAbsolute, join, relative, resolve } from "node:pat
 import { fileURLToPath } from "node:url";
 import { readProjectFile } from "./project.mjs";
 import { record } from "./spool.mjs";
+import { trackTurn } from "./turns.mjs";
 import { taskFrom, taskMode } from "./tasks.mjs";
 
 const EVENTS = ["SessionStart", "UserPromptSubmit", "PreToolUse", "PostToolUse", "Notification", "Stop", "SessionEnd"];
@@ -114,6 +115,8 @@ export async function runHook() {
       if (task) Object.assign(status, task);
       const file = fileFrom(input, mode);
       if (file) Object.assign(status, file);
+      const turn = trackTurn(input, status.session);
+      if (turn) status.turn = turn; // the finished turn's size: three numbers
       record(status);
     }
   } catch { /* a monitoring hook must never break the agent */ }
@@ -121,7 +124,7 @@ export async function runHook() {
 }
 
 // ── install / uninstall ─────────────────────────────────────────
-function settingsPath(cwd) {
+export function settingsPath(cwd) {
   let d = resolve(cwd);
   for (let i = 0; i < 20; i++) {
     if (existsSync(join(d, ".git"))) break;
@@ -134,7 +137,7 @@ function settingsPath(cwd) {
 
 // Reads the settings file, or explains (and changes nothing) when it isn't valid JSON — often two
 // { … } blocks pasted one after the other, which Claude Code can't read either.
-function readSettings(file) {
+export function readSettings(file) {
   if (!existsSync(file)) return {};
   const text = readFileSync(file, "utf8");
   try {
@@ -151,6 +154,12 @@ function readSettings(file) {
   return null;
 }
 
+export function writeSettings(file, settings) {
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(settings, null, 2)}
+`);
+}
+
 export function install(cwd = process.cwd()) {
   const file = settingsPath(cwd);
   const settings = readSettings(file);

package/src/spool.mjs

@@ -72,6 +72,7 @@ export function aggregate(events) {
     if (e.exit_code !== undefined && e.exit_code !== null) cur.exit_code = e.exit_code;
     if (e.ended) cur.ended = true;
     if (e.transcript) cur.transcript = e.transcript;
+    if (e.turn) cur.turn = e.turn;
     if (e.started_at && e.started_at < cur.started_at) cur.started_at = e.started_at;
     if (typeof e.task === "string") {
       Object.assign(cur, { task: e.task, task_source: e.task_source, task_done: e.task_done ?? 0, task_total: e.task_total ?? 0, task_at: e.at });

package/src/statusline.mjs

@@ -0,0 +1,135 @@
+// Claude plan limits on the M.E.K.S.U.S. dashboard (Rik, 2026-09-26).
+//   `meksus statusline`   Claude Code's status line command. Reads the status line JSON on stdin and
+//                         prints one short line ("5h 23% · resets in 2h 14m │ week 41% · Tue 09:00").
+//                         Keeps ONLY rate_limits (percentages + reset times) in ~/.meksus/limits.json and,
+//                         when they changed (or every 5 minutes), starts a detached `meksus limits-flush`,
+//                         at most once a minute (G-1). Never blocks, never breaks the status line.
+//   `meksus statusline install [--global] [--replace]` / `uninstall [--global]`
+//                         <repo>/.claude/settings.local.json, or ~/.claude/settings.json with --global.
+//   `meksus limits-flush` internal, detached: one POST /v1/claude-limits as the signed-in user.
+import { spawn } from "node:child_process";
+import { readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { getAccessToken } from "./auth.mjs";
+import { apiBase, dir, ensureDir, readConfig } from "./config.mjs";
+import { readSettings, settingsPath, writeSettings } from "./hooks.mjs";
+import { VERSION } from "./version.mjs";
+
+const CLI = fileURLToPath(new URL("../bin/meksus.mjs", import.meta.url));
+const MARK = "meksus.mjs\" statusline";
+const WINDOWS = ["five_hour", "seven_day", "spend_limit"];
+export const SEND_MIN_MS = 60_000;
+export const SEND_EVERY_MS = 5 * 60_000;
+const limitsFile = () => join(dir(), "limits.json");
+
+/** Only the numbers: { five_hour: { used_percentage, resets_at }, … }, or null. */
+export function pickLimits(input) {
+  const src = input?.rate_limits;
+  if (!src || typeof src !== "object") return null;
+  const out = {};
+  for (const w of WINDOWS) {
+    const v = src[w];
+    const pct = Number(v?.used_percentage);
+    const at = Number(v?.resets_at);
+    if (Number.isFinite(pct) && Number.isFinite(at)) out[w] = { used_percentage: Math.round(pct * 100) / 100, resets_at: Math.round(at) };
+  }
+  return Object.keys(out).length ? out : null;
+}
+
+export function until(resetsAtS, nowMs = Date.now()) {
+  const s = Math.max(0, Math.round(resetsAtS - nowMs / 1000));
+  const d = Math.floor(s / 86400), hh = Math.floor((s % 86400) / 3600), mm = Math.floor((s % 3600) / 60);
+  return d ? `${d}d ${hh}h` : hh ? `${hh}h ${String(mm).padStart(2, "0")}m` : `${mm}m`;
+}
+
+export function renderLine(limits, nowMs = Date.now()) {
+  if (!limits) return "Claude limits: after the first reply";
+  const part = (label, w) => (w ? `${label} ${Math.round(w.used_percentage)}% · resets in ${until(w.resets_at, nowMs)}` : null);
+  return [part("5h", limits.five_hour), part("week", limits.seven_day), part("spend", limits.spend_limit)].filter(Boolean).join(" │ ");
+}
+
+const signature = (l) => JSON.stringify(WINDOWS.map((w) => (l?.[w] ? [Math.round(l[w].used_percentage), l[w].resets_at] : null)));
+
+/** Should this run start a send? (changed and a minute since the last one, or 5 minutes regardless) */
+export function sendDue(state, limits, nowMs = Date.now()) {
+  if (!limits) return false;
+  const since = nowMs - (state?.sent_at ?? 0);
+  return (signature(limits) !== state?.sent_sig && since >= SEND_MIN_MS) || since >= SEND_EVERY_MS;
+}
+
+function readState() { try { return JSON.parse(readFileSync(limitsFile(), "utf8")); } catch { return null; } }
+function writeState(s) { try { ensureDir(); writeFileSync(limitsFile(), JSON.stringify(s)); } catch { /* read-only home: just don't send */ } }
+
+export async function runStatusline() {
+  let limits = null;
+  try {
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    limits = pickLimits(JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"));
+  } catch { /* bad input: still print something */ }
+  const state = readState();
+  const shown = limits ?? state?.limits ?? null;
+  process.stdout.write(`${renderLine(shown)}\n`);
+  if (limits && sendDue(state, limits) && readConfig()?.session) {
+    writeState({ limits, at: Date.now(), sent_at: Date.now(), sent_sig: signature(limits) }); // claim before spawning
+    try { spawn(process.execPath, [CLI, "limits-flush"], { detached: true, stdio: "ignore", windowsHide: true, env: process.env }).unref(); } catch { /* next run */ }
+  } else if (limits) {
+    writeState({ ...(state ?? {}), limits, at: Date.now() });
+  }
+  return 0;
+}
+
+export async function limitsFlush() {
+  const state = readState();
+  const config = readConfig();
+  if (!state?.limits || !config?.session) return 0;
+  const token = await getAccessToken(config);
+  if (!token) return 0;
+  try {
+    const res = await fetch(`${apiBase(config)}/v1/claude-limits`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "User-Agent": `meksus-cli/${VERSION}`, Authorization: `Bearer ${token}` },
+      body: JSON.stringify({ rate_limits: state.limits }),
+      signal: AbortSignal.timeout(8000),
+    });
+    await res.body?.cancel();
+    return res.status;
+  } catch { return 0; } // dropped; the next status line run sends again (G-11)
+}
+
+// ── install / uninstall ─────────────────────────────────────────
+const globalSettings = () => join(homedir(), ".claude", "settings.json");
+
+export function statuslineCommand(args) {
+  const global = args.includes("--global");
+  const file = global ? globalSettings() : settingsPath(process.cwd());
+  if (args[0] === "install") {
+    const settings = readSettings(file);
+    if (!settings) return 1;
+    const current = settings.statusLine?.command ?? "";
+    if (current && !current.includes(MARK) && !args.includes("--replace")) {
+      console.error(`✖ ${file} already has a status line: ${current}`);
+      console.error("  Run again with --replace to use the M.E.K.S.U.S. one instead (it shows your Claude plan limits).");
+      return 1;
+    }
+    settings.statusLine = { type: "command", command: `node "${CLI}" statusline`, padding: 0, refreshInterval: 30 };
+    writeSettings(file, settings);
+    console.log(`✔ Status line installed in ${file}`);
+    console.log("  It shows your Claude plan limits (5-hour and weekly) and sends only those numbers to your M.E.K.S.U.S. dashboard, at most once a minute.");
+    console.log("  Claude Code provides them for claude.ai Pro and Max plans, after the first reply in a session.");
+    return 0;
+  }
+  if (args[0] === "uninstall") {
+    const settings = readSettings(file);
+    if (!settings) return 1;
+    if (!String(settings.statusLine?.command ?? "").includes(MARK)) { console.log(`No M.E.K.S.U.S. status line in ${file}.`); return 0; }
+    delete settings.statusLine;
+    writeSettings(file, settings);
+    console.log(`✔ Status line removed from ${file}`);
+    return 0;
+  }
+  console.error("Usage: meksus statusline install [--global] [--replace] | uninstall [--global]");
+  return 2;
+}

package/src/turns.mjs

@@ -0,0 +1,41 @@
+// How big was the turn Claude just finished? Measured here, on this machine, from the hooks themselves:
+// the time from the prompt (UserPromptSubmit) to Stop, the tool calls in between, and how many distinct
+// files it changed (Edit / Write / MultiEdit / NotebookEdit). Only those three numbers are sent, with the
+// Stop event; file names are kept locally as hashes, only to count them once, and dropped with the turn.
+// The server scores big vs small (packages/shared/src/notices.ts taskSize) for the AI-coder notices.
+import { createHash } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { dir, ensureDir } from "./config.mjs";
+
+const EDITS = new Set(["Edit", "MultiEdit", "Write", "NotebookEdit"]);
+const KEEP = 50; // sessions remembered at most
+const file = () => join(dir(), "turns.json");
+
+function load() { try { return JSON.parse(readFileSync(file(), "utf8")); } catch { return {}; } }
+function save(turns) {
+  const entries = Object.entries(turns).sort((a, b) => (b[1].at ?? 0) - (a[1].at ?? 0)).slice(0, KEEP);
+  try { ensureDir(); writeFileSync(file(), JSON.stringify(Object.fromEntries(entries))); } catch { /* not measured, not fatal */ }
+}
+
+/** Updates the session's running turn; on Stop returns { seconds, tool_calls, files }, else null. */
+export function trackTurn(input, session, now = Date.now()) {
+  const name = input?.hook_event_name;
+  if (!session || !["UserPromptSubmit", "PreToolUse", "Stop"].includes(name)) return null;
+  const turns = load();
+  let t = turns[session];
+  if (name === "UserPromptSubmit" || !t) t = { start: now, tools: 0, files: [], at: now };
+  if (name === "PreToolUse") {
+    t.tools += 1;
+    const target = input.tool_input?.file_path ?? input.tool_input?.notebook_path;
+    if (EDITS.has(input.tool_name) && typeof target === "string") {
+      const h = createHash("sha256").update(target).digest("hex").slice(0, 16);
+      if (!t.files.includes(h) && t.files.length < 500) t.files.push(h);
+    }
+  }
+  t.at = now;
+  turns[session] = t;
+  save(turns);
+  if (name !== "Stop") return null;
+  return { seconds: Math.max(0, Math.round((now - t.start) / 1000)), tool_calls: t.tools, files: t.files.length };
+}