codemax-cli 0.0.0-stage → 0.1.1

package/src/core/hotkey.ts

@@ -0,0 +1,75 @@
+/**
+ * Hotkeys arrive in different encodings depending on the terminal and on
+ * whether the agent TUI enabled an enhanced keyboard protocol:
+ *   legacy        single control byte (Ctrl+/ → 0x1f)
+ *   CSI u         ESC [ <codepoint> ; <mods> u   (kitty protocol; Warp, Ghostty, Kitty, WezTerm, iTerm2)
+ *   modifyOtherKeys  ESC [ 27 ; <mods> ; <codepoint> ~   (xterm)
+ * A hotkey name like "ctrl+/" expands to every encoding we know for it.
+ */
+
+const CTRL = 5; // modifier bitmask value for ctrl (1 + 4)
+const CTRL_SHIFT = 6;
+
+const LEGACY: Record<string, number> = {
+  "/": 0x1f, _: 0x1f, "^": 0x1e, "]": 0x1d, "\\": 0x1c, "[": 0x1b, " ": 0x00, "@": 0x00,
+};
+/** Keys reached with shift on US layouts: the terminal may report the unshifted key + shift. */
+const SHIFTED: Record<string, string> = { _: "-", "^": "6", "@": "2", "?": "/" };
+
+export interface HotkeySpec {
+  name: string;
+  patterns: Uint8Array[];
+}
+
+export function parseHotkey(name: string): HotkeySpec {
+  const n = name.trim().toLowerCase();
+  const m = n.match(/^ctrl\+(.)$/);
+  if (!m) throw new Error(`unsupported hotkey "${name}" (use ctrl+<key>, e.g. ctrl+/ or ctrl+^)`);
+  const key = m[1]!;
+  const enc = new TextEncoder();
+  const pats: Uint8Array[] = [];
+  const legacy = key in LEGACY ? LEGACY[key] : key >= "a" && key <= "z" ? key.charCodeAt(0) - 96 : undefined;
+  if (legacy !== undefined) pats.push(new Uint8Array([legacy]));
+  const cp = key.charCodeAt(0);
+  pats.push(enc.encode(`\x1b[${cp};${CTRL}u`), enc.encode(`\x1b[27;${CTRL};${cp}~`));
+  const base = SHIFTED[key];
+  if (base) {
+    const b = base.charCodeAt(0);
+    pats.push(enc.encode(`\x1b[${b};${CTRL_SHIFT}u`), enc.encode(`\x1b[27;${CTRL_SHIFT};${b}~`), enc.encode(`\x1b[${cp};${CTRL_SHIFT}u`));
+  }
+  return { name: `ctrl+${key}`, patterns: pats };
+}
+
+export function parseHotkeys(names: string[]): HotkeySpec[] {
+  return names.map(parseHotkey);
+}
+
+/** Find the first hotkey occurrence in an input chunk. */
+export function findHotkey(bytes: Uint8Array, specs: HotkeySpec[]): { index: number; length: number; name: string } | null {
+  let best: { index: number; length: number; name: string } | null = null;
+  for (const s of specs) {
+    for (const p of s.patterns) {
+      const i = indexOfSeq(bytes, p);
+      if (i >= 0 && (!best || i < best.index || (i === best.index && p.length > best.length))) best = { index: i, length: p.length, name: s.name };
+    }
+  }
+  return best;
+}
+
+function indexOfSeq(hay: Uint8Array, needle: Uint8Array): number {
+  if (needle.length === 1) return hay.indexOf(needle[0]!);
+  outer: for (let i = 0; i + needle.length <= hay.length; i++) {
+    for (let j = 0; j < needle.length; j++) if (hay[i + j] !== needle[j]) continue outer;
+    return i;
+  }
+  return -1;
+}
+
+/** Human-readable dump of raw input bytes, for `codemax keys`. */
+export function describeBytes(bytes: Uint8Array): string {
+  const hex = [...bytes].map((b) => b.toString(16).padStart(2, "0")).join(" ");
+  const printable = [...bytes]
+    .map((b) => (b === 0x1b ? "ESC" : b < 0x20 ? `^${String.fromCharCode(b + 64)}` : b === 0x7f ? "DEL" : String.fromCharCode(b)))
+    .join(" ");
+  return `${hex.padEnd(24)} ${printable}`;
+}

package/src/core/journal.ts

@@ -0,0 +1,213 @@
+import { join } from "node:path";
+import { appendFileSync, existsSync, readFileSync } from "node:fs";
+import type { AgentId } from "../adapters/types.ts";
+
+/**
+ * The step journal: everything every agent did, as it happened, in
+ * ~/.codemax/projects/<project>/journal.jsonl. This is what makes handoffs a
+ * resume rather than a summary: the next agent sees the task, the plan, each
+ * tool call with its input and result, the step that was in flight when the
+ * last agent stopped, and why it stopped.
+ *
+ * Steps are appended as they happen (a turn cut off by a limit still leaves
+ * its trail). A step that changes (a tool finishing) is appended again with
+ * the same id; readers keep the last copy.
+ */
+
+export type Outcome = "done" | "cancelled" | "limit" | "error";
+
+interface Base {
+  id: string;
+  ts: number;
+  agent: AgentId;
+  /** Groups the steps of one agent turn. */
+  turn: string;
+}
+
+export type Step = Base &
+  (
+    | { kind: "user"; text: string; checkpoint?: string }
+    | { kind: "text"; text: string }
+    | { kind: "thought"; text: string }
+    | { kind: "tool"; title: string; toolKind?: string; status: string; input?: string; output?: string; files?: string[] }
+    | { kind: "plan"; entries: { content: string; status: string }[] }
+    | { kind: "end"; outcome: Outcome; detail?: string; inFlight?: string[] }
+    | { kind: "handoff"; from?: AgentId; reason?: string; mode: "packet" | "catchup"; chars: number; checkpoint?: string }
+  );
+
+export type StepOf<K extends Step["kind"]> = Extract<Step, { kind: K }>;
+
+/** Caps applied when a step is written: enough to resume from, small enough to keep the file sane. */
+export const CAP = { text: 6000, thought: 2000, input: 2000, output: 4000 } as const;
+
+export function clip(s: string | undefined, max: number): string | undefined {
+  if (s === undefined) return undefined;
+  return s.length <= max ? s : s.slice(0, Math.floor(max * 0.6)) + `\n…[${s.length - max} chars cut]…\n` + s.slice(-Math.floor(max * 0.4));
+}
+
+export class Journal {
+  private path: string;
+
+  constructor(dir: string) {
+    this.path = join(dir, "journal.jsonl");
+  }
+
+  append(step: Step) {
+    appendFileSync(this.path, JSON.stringify(step) + "\n");
+  }
+
+  /** All steps in order, each at its latest version. */
+  steps(): Step[] {
+    if (!existsSync(this.path)) return [];
+    const byId = new Map<string, Step>();
+    const order: string[] = [];
+    for (const line of readFileSync(this.path, "utf8").split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        const s = JSON.parse(line) as Step;
+        if (!byId.has(s.id)) order.push(s.id);
+        byId.set(s.id, s);
+      } catch {
+        /* skip a torn line */
+      }
+    }
+    return order.map((id) => byId.get(id)!);
+  }
+
+  /**
+   * The current task: everything since the user's latest request, plus the
+   * follow-ups. Earlier steps are history.
+   */
+  task(steps = this.steps()): { request?: StepOf<"user">; followUps: StepOf<"user">[]; steps: Step[]; earlier: Step[] } {
+    const users = steps.filter((s): s is StepOf<"user"> => s.kind === "user");
+    if (!users.length) return { followUps: [], steps: [], earlier: steps };
+    // A task begins at a user message that follows a turn which ended "done";
+    // messages sent while the work was cut short continue the same task.
+    let startIdx = steps.indexOf(users[users.length - 1]!);
+    for (let i = users.length - 1; i > 0; i--) {
+      const prevEnd = [...steps.slice(0, steps.indexOf(users[i]!))].reverse().find((s) => s.kind === "end") as StepOf<"end"> | undefined;
+      if (prevEnd && prevEnd.outcome === "done") break;
+      startIdx = steps.indexOf(users[i - 1]!);
+    }
+    const task = steps.slice(startIdx);
+    const taskUsers = task.filter((s): s is StepOf<"user"> => s.kind === "user");
+    return { request: taskUsers[0], followUps: taskUsers.slice(1), steps: task, earlier: steps.slice(0, startIdx) };
+  }
+
+  /** When this agent last did any work (not counting being briefed). */
+  lastSeen(agent: AgentId, steps = this.steps()): number | undefined {
+    for (let i = steps.length - 1; i >= 0; i--) {
+      const s = steps[i]!;
+      if (s.agent === agent && s.kind !== "handoff" && s.kind !== "user") return s.ts;
+    }
+    return undefined;
+  }
+}
+
+/** Builds journal steps for one agent turn from the engine's event stream. */
+export class TurnRecorder {
+  readonly turn: string;
+  private seq = 0;
+  private text: { id: string; messageId?: string; text: string } | null = null;
+  private thought: { id: string; text: string } | null = null;
+  private tools = new Map<string, StepOf<"tool">>();
+  private dirtyTools = new Set<string>();
+  private limitHit = false;
+  private lastError?: string;
+
+  constructor(
+    private journal: Journal,
+    readonly agent: AgentId,
+  ) {
+    this.turn = `${agent}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
+  }
+
+  private nextId(kind: string) {
+    return `${this.turn}:${kind}:${++this.seq}`;
+  }
+
+  private base() {
+    return { ts: Date.now(), agent: this.agent, turn: this.turn };
+  }
+
+  user(text: string, checkpoint?: string) {
+    this.journal.append({ ...this.base(), id: this.nextId("user"), kind: "user", text: clip(text, CAP.text)!, checkpoint });
+  }
+
+  handoff(o: { from?: AgentId; reason?: string; mode: "packet" | "catchup"; chars: number; checkpoint?: string }) {
+    this.journal.append({ ...this.base(), id: this.nextId("handoff"), kind: "handoff", ...o });
+  }
+
+  textDelta(t: string, messageId?: string) {
+    if (this.text && messageId && this.text.messageId && messageId !== this.text.messageId) this.flushText();
+    this.flushThought();
+    this.text ??= { id: this.nextId("text"), messageId, text: "" };
+    this.text.text += t;
+  }
+
+  thoughtDelta(t: string) {
+    this.thought ??= { id: this.nextId("thought"), text: "" };
+    this.thought.text += t;
+  }
+
+  tool(callId: string, o: { title?: string; kind?: string; status?: string; input?: unknown; output?: string; files?: string[] }) {
+    this.flushText();
+    this.flushThought();
+    let s = this.tools.get(callId);
+    const first = !s;
+    s ??= { ...this.base(), id: this.nextId("tool"), kind: "tool", title: o.title ?? callId, status: o.status ?? "pending" };
+    if (o.title) s.title = o.title;
+    if (o.kind) s.toolKind = o.kind;
+    if (o.input !== undefined) s.input = clip(typeof o.input === "string" ? o.input : JSON.stringify(o.input), CAP.input);
+    if (o.output !== undefined) s.output = clip(o.output, CAP.output);
+    if (o.files?.length) s.files = [...new Set([...(s.files ?? []), ...o.files])];
+    const statusChanged = !!o.status && o.status !== s.status;
+    if (o.status) s.status = o.status;
+    this.tools.set(callId, s);
+    // Write at the start and at each status change; streamed output waits for the next one.
+    if (first || statusChanged) this.writeTool(callId);
+    else this.dirtyTools.add(callId);
+  }
+
+  plan(entries: { content: string; status: string }[]) {
+    if (!entries.length) return;
+    this.journal.append({ ...this.base(), id: `${this.turn}:plan`, kind: "plan", entries });
+  }
+
+  /** The agent reported running out (error or a limit-notice reply). */
+  markLimit(detail?: string) {
+    this.limitHit = true;
+    if (detail) this.lastError = detail;
+  }
+
+  markError(detail: string) {
+    this.lastError = detail;
+  }
+
+  /** Close the turn: flush buffered steps and record how it ended and what was still running. */
+  end(stopReason: string, detail?: string) {
+    this.flushText();
+    this.flushThought();
+    for (const id of this.dirtyTools) this.writeTool(id);
+    this.dirtyTools.clear();
+    const inFlight = [...this.tools.values()].filter((t) => t.status === "pending" || t.status === "in_progress").map((t) => t.id);
+    const outcome: Outcome = this.limitHit ? "limit" : stopReason === "cancelled" ? "cancelled" : stopReason === "error" ? "error" : "done";
+    this.journal.append({ ...this.base(), id: `${this.turn}:end`, kind: "end", outcome, detail: clip(detail ?? this.lastError, 400), inFlight: inFlight.length ? inFlight : undefined });
+  }
+
+  private writeTool(callId: string) {
+    const s = this.tools.get(callId);
+    if (s) this.journal.append({ ...s, ts: Date.now() });
+    this.dirtyTools.delete(callId);
+  }
+
+  private flushText() {
+    if (this.text?.text.trim()) this.journal.append({ ...this.base(), id: this.text.id, kind: "text", text: clip(this.text.text.trim(), CAP.text)! });
+    this.text = null;
+  }
+
+  private flushThought() {
+    if (this.thought?.text.trim()) this.journal.append({ ...this.base(), id: this.thought.id, kind: "thought", text: clip(this.thought.text.trim(), CAP.thought)! });
+    this.thought = null;
+  }
+}

package/src/core/ledger.ts

@@ -0,0 +1,153 @@
+import { join } from "node:path";
+import { appendFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
+import { ensureDir, projectDir } from "./paths.ts";
+import type { AgentId, QuotaStatus, SessionRef, Turn } from "../adapters/types.ts";
+import type { UsageRecord } from "./usage.ts";
+import { Journal } from "./journal.ts";
+
+export interface LedgerEvent {
+  ts: number;
+  kind: "start" | "switch" | "exit" | "quota" | "note";
+  agent?: AgentId;
+  to?: AgentId;
+  detail?: string;
+  diffStat?: string;
+}
+
+/**
+ * Project ledger in ~/.codemax/projects/<escaped-cwd>/.
+ *  - turns.jsonl     normalized conversation turns from every agent
+ *  - sessions.json   latest vendor session per agent (for native resume)
+ *  - events.jsonl    switches, quota detections, notes
+ *  - summary.md      optional hand- or agent-written compacted summary
+ *  - journal.jsonl   every step every agent took (see journal.ts); handoffs resume from it
+ */
+export class Ledger {
+  readonly dir: string;
+  readonly journal: Journal;
+  private seen = new Set<string>();
+
+  constructor(readonly cwd: string, dir?: string) {
+    this.dir = ensureDir(dir ?? projectDir(cwd));
+    this.journal = new Journal(this.dir);
+    for (const t of this.turns()) this.seen.add(turnKey(t));
+  }
+
+  private file(name: string) {
+    return join(this.dir, name);
+  }
+
+  /**
+   * Recorded turns. A streaming assistant turn is appended again each time it
+   * grows (its key includes the text length), so collapse by identity keeping
+   * the last, longest copy.
+   */
+  turns(): Turn[] {
+    const byId = new Map<string, Turn>();
+    for (const t of readJsonl<Turn>(this.file("turns.jsonl"))) byId.set(turnId(t), t);
+    return [...byId.values()].sort((a, b) => a.ts - b.ts);
+  }
+
+  /** Append turns not already recorded. Returns how many were new. */
+  addTurns(turns: Turn[]): number {
+    let n = 0;
+    for (const t of turns) {
+      // The handoff brief shows up as a user message in the next agent's
+      // transcript; recording it would nest briefs inside later briefs.
+      if (t.role === "user" && t.text.startsWith(BRIEF_MARKER)) continue;
+      const k = turnKey(t);
+      if (this.seen.has(k)) continue;
+      this.seen.add(k);
+      appendFileSync(this.file("turns.jsonl"), JSON.stringify(t) + "\n");
+      n++;
+    }
+    return n;
+  }
+
+  events(): LedgerEvent[] {
+    return readJsonl<LedgerEvent>(this.file("events.jsonl"));
+  }
+
+  addEvent(e: Omit<LedgerEvent, "ts"> & { ts?: number }) {
+    appendFileSync(this.file("events.jsonl"), JSON.stringify({ ts: Date.now(), ...e }) + "\n");
+  }
+
+  sessions(): Partial<Record<AgentId, SessionRef>> {
+    const p = this.file("sessions.json");
+    if (!existsSync(p)) return {};
+    try {
+      return JSON.parse(readFileSync(p, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+
+  saveSession(ref: SessionRef) {
+    const all = this.sessions();
+    all[ref.agent] = ref;
+    writeFileSync(this.file("sessions.json"), JSON.stringify(all, null, 2) + "\n");
+  }
+
+  summary(): string {
+    const p = this.file("summary.md");
+    return existsSync(p) ? readFileSync(p, "utf8").trim() : "";
+  }
+
+  writeSummary(text: string) {
+    writeFileSync(this.file("summary.md"), text.trimEnd() + "\n");
+  }
+
+  usage(): UsageRecord[] {
+    return readJsonl<UsageRecord>(this.file("usage.jsonl"));
+  }
+
+  addUsage(r: UsageRecord) {
+    appendFileSync(this.file("usage.jsonl"), JSON.stringify(r) + "\n");
+  }
+
+  quota(): Partial<Record<AgentId, QuotaStatus>> {
+    const p = this.file("quota.json");
+    if (!existsSync(p)) return {};
+    try {
+      return JSON.parse(readFileSync(p, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+
+  saveQuota(q: QuotaStatus) {
+    const all = this.quota();
+    all[q.agent] = q;
+    writeFileSync(this.file("quota.json"), JSON.stringify(all, null, 2) + "\n");
+  }
+
+  clearQuota(agent?: AgentId) {
+    const all = agent ? this.quota() : {};
+    if (agent) delete all[agent];
+    writeFileSync(this.file("quota.json"), JSON.stringify(all, null, 2) + "\n");
+  }
+}
+
+export const BRIEF_MARKER = "[codemax handoff]";
+
+function turnId(t: Turn): string {
+  return `${t.agent}:${t.sessionId}:${t.role}:${t.ts}`;
+}
+
+function turnKey(t: Turn): string {
+  return `${turnId(t)}:${t.text.length}:${t.tools?.length ?? 0}`;
+}
+
+function readJsonl<T>(path: string): T[] {
+  if (!existsSync(path)) return [];
+  const out: T[] = [];
+  for (const line of readFileSync(path, "utf8").split("\n")) {
+    if (!line.trim()) continue;
+    try {
+      out.push(JSON.parse(line));
+    } catch {
+      /* skip corrupt line */
+    }
+  }
+  return out;
+}

package/src/core/menu.ts

@@ -0,0 +1,134 @@
+import type { Adapter, AgentId, QuotaStatus, SessionRef } from "../adapters/types.ts";
+import { ALT_OFF, ALT_ON, CSI, out, termSize } from "./terminal.ts";
+import { isExhausted, quotaLabel } from "./quota.ts";
+import { hotkeyLabel } from "../config.ts";
+
+export interface MenuRow {
+  adapter: Adapter;
+  installed: boolean;
+  version?: string;
+  session?: SessionRef;
+  quota?: QuotaStatus;
+}
+
+export type MenuAction =
+  | { kind: "switch"; agent: AgentId; fresh: boolean }
+  | { kind: "close" }
+  | { kind: "quit" };
+
+export interface MenuState {
+  title: string;
+  rows: MenuRow[];
+  current?: AgentId;
+  notice?: string;
+  /** When the current agent has exited, "close" is not offered. */
+  canClose: boolean;
+  hotkeys: string[];
+}
+
+const dim = (s: string) => `${CSI}2m${s}${CSI}22m`;
+const bold = (s: string) => `${CSI}1m${s}${CSI}22m`;
+const red = (s: string) => `${CSI}31m${s}${CSI}39m`;
+const green = (s: string) => `${CSI}32m${s}${CSI}39m`;
+const yellow = (s: string) => `${CSI}33m${s}${CSI}39m`;
+const cyan = (s: string) => `${CSI}36m${s}${CSI}39m`;
+
+/** Full-screen codemax menu drawn on the alternate screen. */
+export class Menu {
+  private fresh = false;
+  private cursor = 0;
+  constructor(private state: MenuState) {
+    const i = state.rows.findIndex((r) => r.adapter.id !== state.current && r.installed && !isExhausted(r.quota));
+    this.cursor = i >= 0 ? i : 0;
+  }
+
+  /** `useAltScreen` false: the agent is already on the alternate screen, so just draw over it. */
+  open(useAltScreen = true) {
+    out(useAltScreen ? ALT_ON : `${CSI}?25l${CSI}H${CSI}2J`);
+    this.render();
+  }
+
+  close(useAltScreen = true) {
+    out(useAltScreen ? ALT_OFF : `${CSI}H${CSI}2J${CSI}?25h`);
+  }
+
+  update(patch: Partial<MenuState>) {
+    Object.assign(this.state, patch);
+    this.render();
+  }
+
+  render() {
+    const { cols } = termSize();
+    const w = Math.min(cols - 2, 96);
+    const L: string[] = [];
+    L.push(bold(cyan(" codemax ")) + dim(`— ${this.state.title}`));
+    L.push(dim("─".repeat(w)));
+    if (this.state.notice) L.push(yellow(" ! " + this.state.notice), "");
+    this.state.rows.forEach((r, i) => {
+      const sel = i === this.cursor ? cyan("›") : " ";
+      const num = dim(`${i + 1}.`);
+      const name = r.adapter.id === this.state.current ? bold(r.adapter.name) + dim(" (current)") : r.adapter.name;
+      const inst = r.installed ? green("installed") + (r.version ? dim(` ${r.version}`) : "") : red("not found");
+      const sess = r.session ? dim(`session ${r.session.id.slice(0, 8)}… ${ago(r.session.lastUsedAt)}`) : dim("no session");
+      const q = r.quota ? (isExhausted(r.quota) ? red(quotaLabel(r.quota)) : yellow(quotaLabel(r.quota))) : "";
+      L.push(` ${sel} ${num} ${pad(name, 22)} ${pad(inst, 28)} ${pad(sess, 34)} ${q}`);
+    });
+    L.push("");
+    const mode = this.fresh ? yellow("fresh session") : green("resume if a session exists");
+    L.push(dim(" ↑/↓ or 1-9 pick · Enter switch · f toggle: ") + mode);
+    L.push(dim(` ${this.state.canClose ? "Esc/q back to agent · " : ""}x quit codemax · hotkey ${hotkeyLabel(this.state.hotkeys)}`));
+    out(`${CSI}H${CSI}2J` + L.map((l) => l + `${CSI}K`).join("\r\n"));
+  }
+
+  /** Returns an action when the key completes one; null otherwise. */
+  handleKey(bytes: Uint8Array): MenuAction | null {
+    const s = Buffer.from(bytes).toString("utf8");
+    // A chunk may hold several keys typed quickly; escape sequences stay whole.
+    if (s.length > 1 && !s.startsWith("\x1b")) {
+      for (const ch of s) {
+        const a = this.handleKey(Buffer.from(ch));
+        if (a) return a;
+      }
+      return null;
+    }
+    if (s === "\x1b[A" || s === "k") this.move(-1);
+    else if (s === "\x1b[B" || s === "j") this.move(1);
+    else if (s === "f") {
+      this.fresh = !this.fresh;
+      this.render();
+    } else if (s === "\r" || s === "\n") return this.pick(this.cursor);
+    else if (/^[1-9]$/.test(s)) return this.pick(Number(s) - 1);
+    else if (s === "x" || s === "\x03") return { kind: "quit" };
+    else if ((s === "\x1b" || s === "q") && this.state.canClose) return { kind: "close" };
+    return null;
+  }
+
+  private move(d: number) {
+    const n = this.state.rows.length;
+    this.cursor = (this.cursor + d + n) % n;
+    this.render();
+  }
+
+  private pick(i: number): MenuAction | null {
+    const r = this.state.rows[i];
+    if (!r) return null;
+    if (!r.installed) {
+      this.update({ notice: `${r.adapter.name} is not installed (looked for "${r.adapter.bin}" on PATH).` });
+      return null;
+    }
+    return { kind: "switch", agent: r.adapter.id, fresh: this.fresh };
+  }
+}
+
+function pad(s: string, n: number): string {
+  const visible = s.replace(/\x1b\[[0-9;]*m/g, "").length;
+  return visible >= n ? s : s + " ".repeat(n - visible);
+}
+
+function ago(ts: number): string {
+  const m = Math.round((Date.now() - ts) / 60_000);
+  if (m < 1) return "just now";
+  if (m < 60) return `${m}m ago`;
+  const h = Math.round(m / 60);
+  return h < 48 ? `${h}h ago` : `${Math.round(h / 24)}d ago`;
+}