@intent-systems/nexus 2026.1.5-3

package/dist/commands/send.js

@@ -0,0 +1,124 @@
+import { loadConfig } from "../config/config.js";
+import { callGateway, randomIdempotencyKey } from "../gateway/call.js";
+import { success } from "../globals.js";
+import { resolveTelegramToken } from "../telegram/token.js";
+export async function sendCommand(opts, deps, runtime) {
+    const provider = (opts.provider ?? "whatsapp").toLowerCase();
+    if (opts.dryRun) {
+        runtime.log(`[dry-run] would send via ${provider} -> ${opts.to}: ${opts.message}${opts.media ? ` (media ${opts.media})` : ""}`);
+        return;
+    }
+    if (provider === "telegram") {
+        const { token } = resolveTelegramToken(loadConfig());
+        const result = await deps.sendMessageTelegram(opts.to, opts.message, {
+            token: token || undefined,
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via telegram. Message ID: ${result.messageId} (chat ${result.chatId})`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "telegram",
+                via: "direct",
+                to: opts.to,
+                chatId: result.chatId,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "discord") {
+        const result = await deps.sendMessageDiscord(opts.to, opts.message, {
+            token: process.env.DISCORD_BOT_TOKEN,
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via discord. Message ID: ${result.messageId} (channel ${result.channelId})`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "discord",
+                via: "direct",
+                to: opts.to,
+                channelId: result.channelId,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "slack") {
+        const result = await deps.sendMessageSlack(opts.to, opts.message, {
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via slack. Message ID: ${result.messageId} (channel ${result.channelId})`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "slack",
+                via: "direct",
+                to: opts.to,
+                channelId: result.channelId,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "signal") {
+        const result = await deps.sendMessageSignal(opts.to, opts.message, {
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via signal. Message ID: ${result.messageId}`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "signal",
+                via: "direct",
+                to: opts.to,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "imessage" || provider === "imsg") {
+        const result = await deps.sendMessageIMessage(opts.to, opts.message, {
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via iMessage. Message ID: ${result.messageId}`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "imessage",
+                via: "direct",
+                to: opts.to,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    // Always send via gateway over WS to avoid multi-session corruption.
+    const sendViaGateway = async () => callGateway({
+        method: "send",
+        params: {
+            to: opts.to,
+            message: opts.message,
+            mediaUrl: opts.media,
+            gifPlayback: opts.gifPlayback,
+            accountId: opts.account,
+            provider,
+            idempotencyKey: randomIdempotencyKey(),
+        },
+        timeoutMs: 10_000,
+        clientName: "cli",
+        mode: "cli",
+    });
+    const result = await sendViaGateway();
+    runtime.log(success(`✅ Sent via gateway. Message ID: ${result.messageId ?? "unknown"}`));
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            provider: "web",
+            via: "gateway",
+            to: opts.to,
+            messageId: result.messageId,
+            mediaUrl: opts.media ?? null,
+        }, null, 2));
+    }
+}

package/dist/commands/sessions-ingest.js

@@ -0,0 +1,359 @@
+import { execFile } from "node:child_process";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { promisify } from "node:util";
+import JSON5 from "json5";
+import { resolveStateDir } from "../config/paths.js";
+import { danger, info } from "../globals.js";
+const execFileAsync = promisify(execFile);
+function normalizeFsPath(p) {
+    return path.resolve(p).replace(/\/+$/, "");
+}
+function decodeWorkspaceFolderUrl(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.startsWith("file://")) {
+        try {
+            const u = new URL(trimmed);
+            return decodeURIComponent(u.pathname);
+        }
+        catch {
+            // fall through
+        }
+    }
+    return trimmed;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function lexicalToPlainText(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (!isRecord(parsed))
+            return raw;
+        const root = parsed.root;
+        if (!isRecord(root))
+            return raw;
+        const out = [];
+        const walk = (node, depth = 0) => {
+            if (!isRecord(node))
+                return;
+            const type = typeof node.type === "string" ? node.type : "";
+            const text = typeof node.text === "string" ? node.text : "";
+            if (type === "text")
+                out.push(text);
+            if (type === "linebreak")
+                out.push("\n");
+            const children = node.children;
+            if (Array.isArray(children)) {
+                for (const child of children)
+                    walk(child, depth + 1);
+                // Heuristic: add paragraph breaks at shallow block levels.
+                if (depth === 1 && out.length > 0 && out[out.length - 1] !== "\n") {
+                    out.push("\n");
+                }
+            }
+        };
+        walk(root);
+        return out.join("").replace(/\n{3,}/g, "\n\n").trim();
+    }
+    catch {
+        return raw;
+    }
+}
+function cursorBubbleRole(b) {
+    if (b.type === "user" || b.messageType === 2)
+        return "user";
+    if (b.type === "assistant" || b.messageType === 3)
+        return "assistant";
+    return "unknown";
+}
+function cursorBubbleText(b) {
+    const role = cursorBubbleRole(b);
+    if (role === "assistant") {
+        const text = (b.text ?? b.rawText ?? "").trim();
+        if (text)
+            return text;
+    }
+    // User bubbles often store Lexical JSON in initText/richText.
+    const raw = (b.rawText ?? b.text ?? "").trim();
+    if (raw)
+        return raw;
+    const lexical = (b.initText ?? b.richText ?? "").trim();
+    if (lexical)
+        return lexicalToPlainText(lexical);
+    return "";
+}
+async function sqliteGetTextValue(params) {
+    const maxBufferBytes = params.maxBufferBytes ?? 30 * 1024 * 1024;
+    const sql = `select value from ItemTable where key='${params.key.replaceAll("'", "''")}';`;
+    const { stdout } = await execFileAsync("sqlite3", [params.dbPath, sql], {
+        maxBuffer: maxBufferBytes,
+    });
+    const trimmed = stdout.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+async function findCursorWorkspaceStorageDir(params) {
+    const baseDir = params.cursorBaseDir ??
+        path.join(os.homedir(), "Library", "Application Support", "Cursor", "User", "workspaceStorage");
+    const target = normalizeFsPath(params.workspacePath);
+    const entries = await fs.readdir(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const hash = entry.name;
+        const dir = path.join(baseDir, hash);
+        const workspaceJson = path.join(dir, "workspace.json");
+        try {
+            const raw = await fs.readFile(workspaceJson, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!isRecord(parsed))
+                continue;
+            const folder = typeof parsed.folder === "string" ? parsed.folder : "";
+            if (!folder)
+                continue;
+            const decoded = normalizeFsPath(decodeWorkspaceFolderUrl(folder));
+            if (decoded === target) {
+                const stateDbPath = path.join(dir, "state.vscdb");
+                return { hash, dir, stateDbPath };
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function exportCursorChats(params) {
+    const found = await findCursorWorkspaceStorageDir({
+        cursorBaseDir: params.cursorBaseDir,
+        workspacePath: params.workspacePath,
+    });
+    if (!found)
+        return null;
+    const tmpDb = path.join(os.tmpdir(), `cursor-state.${crypto.randomUUID()}.vscdb`);
+    await fs.copyFile(found.stateDbPath, tmpDb);
+    try {
+        const raw = await sqliteGetTextValue({
+            dbPath: tmpDb,
+            key: "workbench.panel.aichat.view.aichat.chatdata",
+            maxBufferBytes: 50 * 1024 * 1024,
+        });
+        if (!raw)
+            return null;
+        const parsed = JSON.parse(raw);
+        const tabs = Array.isArray(parsed.tabs) ? parsed.tabs : [];
+        const cursorOut = path.join(params.outDir, "cursor");
+        await fs.mkdir(cursorOut, { recursive: true });
+        const entries = [];
+        let exportedTabs = 0;
+        for (const tab of tabs) {
+            const tabId = (tab.tabId ?? "").trim();
+            if (!tabId)
+                continue;
+            const title = (tab.chatTitle ?? "").trim() || undefined;
+            const updatedAt = typeof tab.lastSendTime === "number" ? tab.lastSendTime : null;
+            const bubbles = Array.isArray(tab.bubbles) ? tab.bubbles : [];
+            const outPath = path.join(cursorOut, `tab-${tabId}.jsonl`);
+            const lines = [];
+            lines.push(JSON.stringify({
+                type: "meta",
+                source: "cursor",
+                exportedAt: Date.now(),
+                workspacePath: params.workspacePath,
+                workspaceStorageHash: found.hash,
+                tabId,
+                title,
+                updatedAt,
+                bubbleCount: bubbles.length,
+            }));
+            for (const bubble of bubbles) {
+                const role = cursorBubbleRole(bubble);
+                const content = cursorBubbleText(bubble);
+                if (!content.trim())
+                    continue;
+                lines.push(JSON.stringify({
+                    type: "message",
+                    source: "cursor",
+                    tabId,
+                    bubbleId: bubble.id ?? null,
+                    role,
+                    content,
+                    aiType: bubble.aiType ?? null,
+                    modelType: bubble.modelType ?? null,
+                    requestId: bubble.requestId ?? null,
+                    messageType: bubble.messageType ?? null,
+                }));
+            }
+            await fs.writeFile(outPath, `${lines.join("\n")}\n`, "utf-8");
+            exportedTabs += 1;
+            entries.push({
+                source: "cursor",
+                id: tabId,
+                title,
+                updatedAt,
+                path: outPath,
+                meta: {
+                    workspacePath: params.workspacePath,
+                    workspaceStorageHash: found.hash,
+                    bubbleCount: bubbles.length,
+                },
+            });
+        }
+        return {
+            entries,
+            meta: {
+                workspacePath: params.workspacePath,
+                workspaceStorageHash: found.hash,
+                dbPath: found.stateDbPath,
+                exportedTabs,
+            },
+        };
+    }
+    finally {
+        await fs.rm(tmpDb, { force: true });
+    }
+}
+async function listNexusAgentIds(stateDir) {
+    const agentsDir = path.join(stateDir, "agents");
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function loadNexusSessionStore(storePath) {
+    try {
+        const raw = await fs.readFile(storePath, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (isRecord(parsed))
+            return parsed;
+    }
+    catch {
+        // ignore
+    }
+    return {};
+}
+async function ingestNexusSessions(params) {
+    const agentIds = await listNexusAgentIds(params.stateDir);
+    const entries = [];
+    let indexedSessions = 0;
+    let copiedTranscripts = 0;
+    const clawOut = path.join(params.outDir, "nexus");
+    if (params.copyTranscripts) {
+        await fs.mkdir(clawOut, { recursive: true });
+    }
+    for (const agentId of agentIds) {
+        const sessionsDir = path.join(params.stateDir, "agents", agentId, "sessions");
+        const storePath = path.join(sessionsDir, "sessions.json");
+        const store = await loadNexusSessionStore(storePath);
+        for (const [sessionKey, entry] of Object.entries(store)) {
+            const sessionId = typeof entry?.sessionId === "string" ? entry.sessionId : "";
+            if (!sessionId)
+                continue;
+            const candidateA = path.join(sessionsDir, `${sessionId}.jsonl`);
+            const candidateB = path.join(params.stateDir, "sessions", `${sessionId}.jsonl`);
+            const transcriptPath = await fs
+                .access(candidateA)
+                .then(() => candidateA)
+                .catch(async () => fs
+                .access(candidateB)
+                .then(() => candidateB)
+                .catch(() => ""));
+            if (!transcriptPath)
+                continue;
+            let outPath = transcriptPath;
+            if (params.copyTranscripts) {
+                const agentOutDir = path.join(clawOut, agentId);
+                await fs.mkdir(agentOutDir, { recursive: true });
+                const copiedPath = path.join(agentOutDir, `${sessionId}.jsonl`);
+                await fs.copyFile(transcriptPath, copiedPath);
+                outPath = copiedPath;
+                copiedTranscripts += 1;
+            }
+            entries.push({
+                source: "nexus",
+                id: sessionId,
+                title: sessionKey,
+                updatedAt: typeof entry?.updatedAt === "number" ? entry.updatedAt : null,
+                path: outPath,
+                meta: {
+                    agentId,
+                    sessionKey,
+                    originalPath: transcriptPath,
+                    copied: params.copyTranscripts,
+                },
+            });
+            indexedSessions += 1;
+        }
+    }
+    return {
+        entries,
+        meta: {
+            stateDir: params.stateDir,
+            scannedAgentIds: agentIds,
+            indexedSessions,
+            copiedTranscripts,
+        },
+    };
+}
+export async function sessionsIngestCommand(opts, runtime) {
+    const outDir = typeof opts.out === "string" && opts.out.trim()
+        ? path.resolve(opts.out.trim().replace("~", os.homedir()))
+        : path.join(resolveStateDir(), "nexus", "sessions-ingest");
+    await fs.mkdir(outDir, { recursive: true });
+    const index = {
+        generatedAt: new Date().toISOString(),
+        outDir,
+        entries: [],
+    };
+    const includeCursor = opts.cursor !== false;
+    const includeNexus = opts.nexus !== false;
+    if (includeCursor) {
+        const workspacePath = (opts.cursorWorkspace ?? "").trim();
+        if (!workspacePath) {
+            runtime.log(info("Skipping Cursor ingest (pass --cursor-workspace /path/to/workspace to enable)."));
+        }
+        else {
+            runtime.log(info(`Ingesting Cursor sessions for workspace: ${workspacePath}`));
+            const exported = await exportCursorChats({
+                workspacePath,
+                cursorBaseDir: opts.cursorBaseDir,
+                outDir,
+            });
+            if (!exported) {
+                runtime.error(danger("Cursor ingest failed: workspace not found or chatdata missing. (Is Cursor installed and has this workspace been opened?)"));
+            }
+            else {
+                index.cursor = exported.meta;
+                index.entries.push(...exported.entries);
+                runtime.log(info(`Cursor exported tabs: ${exported.meta.exportedTabs}`));
+            }
+        }
+    }
+    if (includeNexus) {
+        const stateDir = typeof opts.nexusStateDir === "string" && opts.nexusStateDir.trim()
+            ? path.resolve(opts.nexusStateDir.trim().replace("~", os.homedir()))
+            : resolveStateDir();
+        runtime.log(info(`Indexing Nexus sessions from state dir: ${stateDir}`));
+        const claw = await ingestNexusSessions({
+            stateDir,
+            outDir,
+            copyTranscripts: Boolean(opts.copyNexus),
+        });
+        index.nexus = claw.meta;
+        index.entries.push(...claw.entries);
+        runtime.log(info(`NexusBot indexed sessions: ${claw.meta.indexedSessions}`));
+        if (claw.meta.copiedTranscripts > 0) {
+            runtime.log(info(`NexusBot copied transcripts: ${claw.meta.copiedTranscripts}`));
+        }
+    }
+    index.entries.sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    const indexPath = path.join(outDir, "index.json");
+    await fs.writeFile(indexPath, `${JSON.stringify(index, null, 2)}\n`, "utf-8");
+    runtime.log(info(`Wrote index: ${indexPath}`));
+    runtime.log(info(`Total entries: ${index.entries.length}`));
+}

package/dist/commands/sessions.js

@@ -0,0 +1,212 @@
+import chalk from "chalk";
+import { lookupContextTokens } from "../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER, } from "../agents/defaults.js";
+import { resolveConfiguredModelRef } from "../agents/model-selection.js";
+import { loadConfig } from "../config/config.js";
+import { loadSessionStore, resolveStorePath, } from "../config/sessions.js";
+import { info } from "../globals.js";
+const KIND_PAD = 6;
+const KEY_PAD = 26;
+const AGE_PAD = 9;
+const MODEL_PAD = 14;
+const TOKENS_PAD = 20;
+const isRich = () => Boolean(process.stdout.isTTY && chalk.level > 0);
+const formatKTokens = (value) => `${(value / 1000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+const truncateKey = (key) => {
+    if (key.length <= KEY_PAD)
+        return key;
+    const head = Math.max(4, KEY_PAD - 10);
+    return `${key.slice(0, head)}...${key.slice(-6)}`;
+};
+const colorByPct = (label, pct, rich) => {
+    if (!rich || pct === null)
+        return label;
+    if (pct >= 95)
+        return chalk.red(label);
+    if (pct >= 80)
+        return chalk.yellow(label);
+    if (pct >= 60)
+        return chalk.green(label);
+    return chalk.gray(label);
+};
+const formatTokensCell = (total, contextTokens, rich) => {
+    if (!total)
+        return "-".padEnd(TOKENS_PAD);
+    const totalLabel = formatKTokens(total);
+    const ctxLabel = contextTokens ? formatKTokens(contextTokens) : "?";
+    const pct = contextTokens
+        ? Math.min(999, Math.round((total / contextTokens) * 100))
+        : null;
+    const label = `${totalLabel}/${ctxLabel} (${pct ?? "?"}%)`;
+    const padded = label.padEnd(TOKENS_PAD);
+    return colorByPct(padded, pct, rich);
+};
+const formatKindCell = (kind, rich) => {
+    const label = kind.padEnd(KIND_PAD);
+    if (!rich)
+        return label;
+    if (kind === "group")
+        return chalk.magenta(label);
+    if (kind === "global")
+        return chalk.yellow(label);
+    if (kind === "direct")
+        return chalk.cyan(label);
+    return chalk.gray(label);
+};
+const formatAgeCell = (updatedAt, rich) => {
+    const ageLabel = updatedAt ? formatAge(Date.now() - updatedAt) : "unknown";
+    const padded = ageLabel.padEnd(AGE_PAD);
+    return rich ? chalk.gray(padded) : padded;
+};
+const formatModelCell = (model, rich) => {
+    const label = (model ?? "unknown").padEnd(MODEL_PAD);
+    return rich ? chalk.white(label) : label;
+};
+const formatFlagsCell = (row, rich) => {
+    const flags = [
+        row.thinkingLevel ? `think:${row.thinkingLevel}` : null,
+        row.verboseLevel ? `verbose:${row.verboseLevel}` : null,
+        row.groupActivation ? `activation:${row.groupActivation}` : null,
+        row.systemSent ? "system" : null,
+        row.abortedLastRun ? "aborted" : null,
+        row.sessionId ? `id:${row.sessionId}` : null,
+    ].filter(Boolean);
+    const label = flags.join(" ");
+    return label.length === 0 ? "" : rich ? chalk.gray(label) : label;
+};
+const formatAge = (ms) => {
+    if (!ms || ms < 0)
+        return "unknown";
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    const days = Math.round(hours / 24);
+    return `${days}d ago`;
+};
+function classifyKey(key, entry) {
+    if (key === "global")
+        return "global";
+    if (key === "unknown")
+        return "unknown";
+    if (entry?.chatType === "group" || entry?.chatType === "room")
+        return "group";
+    if (key.startsWith("group:") ||
+        key.includes(":group:") ||
+        key.includes(":channel:")) {
+        return "group";
+    }
+    return "direct";
+}
+function toRows(store) {
+    return Object.entries(store)
+        .map(([key, entry]) => {
+        const updatedAt = entry?.updatedAt ?? null;
+        return {
+            key,
+            kind: classifyKey(key, entry),
+            updatedAt,
+            ageMs: updatedAt ? Date.now() - updatedAt : null,
+            sessionId: entry?.sessionId,
+            systemSent: entry?.systemSent,
+            abortedLastRun: entry?.abortedLastRun,
+            thinkingLevel: entry?.thinkingLevel,
+            verboseLevel: entry?.verboseLevel,
+            groupActivation: entry?.groupActivation,
+            inputTokens: entry?.inputTokens,
+            outputTokens: entry?.outputTokens,
+            totalTokens: entry?.totalTokens,
+            model: entry?.model,
+            contextTokens: entry?.contextTokens,
+        };
+    })
+        .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+export async function sessionsCommand(opts, runtime) {
+    const cfg = loadConfig();
+    const resolved = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const configContextTokens = cfg.agent?.contextTokens ??
+        lookupContextTokens(resolved.model) ??
+        DEFAULT_CONTEXT_TOKENS;
+    const configModel = resolved.model ?? DEFAULT_MODEL;
+    const storePath = resolveStorePath(opts.store ?? cfg.session?.store);
+    const store = loadSessionStore(storePath);
+    let activeMinutes;
+    if (opts.active !== undefined) {
+        const parsed = Number.parseInt(String(opts.active), 10);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            runtime.error("--active must be a positive integer (minutes)");
+            runtime.exit(1);
+            return;
+        }
+        activeMinutes = parsed;
+    }
+    const rows = toRows(store).filter((row) => {
+        if (activeMinutes === undefined)
+            return true;
+        if (!row.updatedAt)
+            return false;
+        return Date.now() - row.updatedAt <= activeMinutes * 60_000;
+    });
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            path: storePath,
+            count: rows.length,
+            activeMinutes: activeMinutes ?? null,
+            sessions: rows.map((r) => ({
+                ...r,
+                contextTokens: r.contextTokens ??
+                    lookupContextTokens(r.model) ??
+                    configContextTokens ??
+                    null,
+                model: r.model ?? configModel ?? null,
+            })),
+        }, null, 2));
+        return;
+    }
+    runtime.log(info(`Session store: ${storePath}`));
+    runtime.log(info(`Sessions listed: ${rows.length}`));
+    if (activeMinutes) {
+        runtime.log(info(`Filtered to last ${activeMinutes} minute(s)`));
+    }
+    if (rows.length === 0) {
+        runtime.log("No sessions found.");
+        return;
+    }
+    const rich = isRich();
+    const header = [
+        "Kind".padEnd(KIND_PAD),
+        "Key".padEnd(KEY_PAD),
+        "Age".padEnd(AGE_PAD),
+        "Model".padEnd(MODEL_PAD),
+        "Tokens (ctx %)".padEnd(TOKENS_PAD),
+        "Flags",
+    ].join(" ");
+    runtime.log(rich ? chalk.bold(header) : header);
+    for (const row of rows) {
+        const model = row.model ?? configModel;
+        const contextTokens = row.contextTokens ?? lookupContextTokens(model) ?? configContextTokens;
+        const input = row.inputTokens ?? 0;
+        const output = row.outputTokens ?? 0;
+        const total = row.totalTokens ?? input + output;
+        const keyLabel = truncateKey(row.key).padEnd(KEY_PAD);
+        const keyCell = rich ? chalk.cyan(keyLabel) : keyLabel;
+        const line = [
+            formatKindCell(row.kind, rich),
+            keyCell,
+            formatAgeCell(row.updatedAt, rich),
+            formatModelCell(model, rich),
+            formatTokensCell(total, contextTokens ?? null, rich),
+            formatFlagsCell(row, rich),
+        ].join(" ");
+        runtime.log(line.trimEnd());
+    }
+}