@9thprotocol/cli 0.1.0

package/dist/repl.js

@@ -0,0 +1,266 @@
+import readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { AgentSession, McpManager, loadSkills, resolveVault, skillMessage, } from "@9thprotocol/agent-core";
+import { cyan, dim, red, requireAuth, usageLine, delegationLine, yellow, DEFAULT_MODEL, AUTO_BIASES, fetchCatalog, getAutoBias, setAutoBias, } from "./shared.js";
+const MODES = ["default", "accept-edits", "plan", "bypass"];
+/** Drain non-TTY stdin before anything else can consume it. */
+async function readAllStdin() {
+    let data = "";
+    stdin.setEncoding("utf8");
+    for await (const chunk of stdin)
+        data += chunk;
+    return data;
+}
+export async function runRepl(cwd) {
+    const auth = await requireAuth();
+    const platformGet = async (pathname) => {
+        const res = await fetch(`${auth.platform.baseUrl}${pathname}`, {
+            headers: { Authorization: `Bearer ${auth.apiKey}` },
+        });
+        if (!res.ok)
+            throw new Error(`${res.status}: ${await res.text()}`);
+        return res.json();
+    };
+    const platformPost = async (pathname, body) => {
+        const res = await fetch(`${auth.platform.baseUrl}${pathname}`, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${auth.apiKey}`, "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok)
+            throw new Error(`${res.status}: ${await res.text()}`);
+        return res.json();
+    };
+    // Piped stdin is fully buffered up front. readline would otherwise emit the
+    // piped lines during the async startup below (catalog fetch, MCP connect)
+    // with nothing listening yet, and they'd be silently dropped.
+    const piped = !stdin.isTTY ? await readAllStdin() : null;
+    const rl = readline.createInterface({ input: stdin, output: stdout });
+    const mcp = await McpManager.fromCwd(cwd);
+    let skills = loadSkills(cwd);
+    const vault = resolveVault(cwd);
+    const catalog = await fetchCatalog(auth);
+    // Held by reference so `/bias` retunes the live session without rebuilding it.
+    const autoRouter = { bias: getAutoBias(), ...(catalog ? { catalog } : {}) };
+    const session = new AgentSession({
+        apiKey: auth.apiKey,
+        ...(auth.platform ? { platform: auth.platform } : {}),
+        mcp,
+        model: process.env.NINEP_MODEL ?? DEFAULT_MODEL,
+        autoRouter,
+        cwd,
+        mode: "default",
+        decide: async (req) => {
+            const answer = await rl.question(`${yellow("● permission")} ${req.summary}, allow? [y/N] `);
+            return /^y(es)?$/i.test(answer.trim());
+        },
+        askUser: async (q) => {
+            console.log(`\n${cyan("● question")} ${q.question}`);
+            if (q.options?.length) {
+                q.options.forEach((o, i) => console.log(dim(`  ${i + 1}. ${o}`)));
+                const answer = (await rl.question("choose a number or type an answer: ")).trim();
+                const idx = Number(answer);
+                const pick = q.options[idx - 1];
+                return Number.isInteger(idx) && pick !== undefined ? pick : answer;
+            }
+            return (await rl.question("answer: ")).trim();
+        },
+    });
+    console.log(cyan("9th Protocol (9p) beta"));
+    console.log(dim(`model: ${session.isAuto ? `auto (${autoRouter.bias})` : session.model} · mode: ${session.mode} · auth: ${auth.platform ? "platform" : "byok"} · cwd: ${cwd}`));
+    if (vault)
+        console.log(dim(`vault: ${vault}`));
+    if (mcp.servers.length)
+        console.log(dim(`mcp: ${mcp.servers.join(", ")} (${mcp.tools.length} tools)`));
+    if (skills.length)
+        console.log(dim(`skills: ${skills.map((s) => "/" + s.name).join(" ")}`));
+    console.log(dim("/help for commands"));
+    async function showModels() {
+        if (!auth.platform) {
+            console.log(dim("model catalog requires platform auth; BYOK can use any OpenRouter id via /model <id>"));
+            return;
+        }
+        const data = (await platformGet("/models"));
+        for (const m of data.models) {
+            const marker = m.id === session.model ? cyan("→") : " ";
+            const lock = m.locked ? yellow(" 🔒 upgrade to use") : "";
+            console.log(`${marker} ${m.id.padEnd(34)} ${dim(m.tier.padEnd(9))} ${dim(`~${m.burn.heavySessionCredits} cr/heavy-session`)}${lock}`);
+        }
+    }
+    async function offerReset(code) {
+        if (!auth.platform)
+            return;
+        const scope = code === "weekly_limit" ? "week" : "window";
+        const answer = await rl.question(`${yellow("●")} buy a ${scope} reset to continue now? [y/N] `);
+        if (!/^y(es)?$/i.test(answer.trim()))
+            return;
+        try {
+            const result = (await platformPost("/billing/session-reset", { scope }));
+            console.log(dim(`reset applied ($${result.priceUsd}), ${result.resetsUsedThisWeek}/5 used this week. Re-send your message.`));
+        }
+        catch (err) {
+            console.log(red(`reset failed: ${err instanceof Error ? err.message : err}`));
+        }
+    }
+    async function run(message) {
+        let streaming = false;
+        const breakLine = () => {
+            if (streaming)
+                stdout.write("\n");
+            streaming = false;
+        };
+        for await (const ev of session.send(message)) {
+            switch (ev.type) {
+                case "text_delta":
+                    if (!streaming)
+                        stdout.write("\n");
+                    streaming = true;
+                    stdout.write(ev.text);
+                    break;
+                case "model_selected":
+                    console.log(dim(`◆ auto → ${ev.model} ${dim(`(${ev.reason})`)}`));
+                    break;
+                case "compacted":
+                    breakLine();
+                    console.log(dim(`⊙ compacted context ~${ev.beforeTokens} → ~${ev.afterTokens} tokens`));
+                    break;
+                case "tool_start":
+                    breakLine();
+                    console.log(dim(`⚙ ${ev.summary}`));
+                    break;
+                case "tool_end": {
+                    const first = ev.output.split("\n")[0] ?? "";
+                    const preview = first.length > 120 ? first.slice(0, 120) + "…" : first;
+                    console.log(ev.isError ? yellow(`  ✗ ${preview}`) : dim(`  ✓ ${preview} (${ev.durationMs}ms)`));
+                    break;
+                }
+                case "permission_denied":
+                    breakLine();
+                    console.log(yellow(`✗ denied: ${ev.summary}`));
+                    break;
+                case "turn_end": {
+                    breakLine();
+                    const saved = delegationLine(session.delegated);
+                    console.log(dim(`⏺ ${usageLine(ev.usage)}${saved ? ` · ${saved}` : ""}`));
+                    break;
+                }
+                case "error":
+                    breakLine();
+                    console.log(red(`error: ${ev.message}`));
+                    if (ev.code === "window_limit" || ev.code === "weekly_limit")
+                        await offerReset(ev.code);
+                    if (ev.code === "credits_exhausted") {
+                        console.log(yellow("Out of credits, top-ups and upgrades land with payments (MVP2)."));
+                    }
+                    break;
+            }
+        }
+    }
+    async function handleSlash(line) {
+        const [cmd = "", ...rest] = line.slice(1).split(/\s+/);
+        const arg = rest.join(" ").trim();
+        switch (cmd) {
+            case "help":
+                console.log(dim("/models · /model [id|auto] · /bias [economy|balanced|quality] · /mode [default|accept-edits|plan|bypass] · /skills · /<skill> [args] · /compact · /clear · /usage · /exit\n" +
+                    "subcommands: 9p init (memory/vault setup) · 9p map (codebase → vault graph)"));
+                return;
+            case "models":
+                await showModels().catch((err) => console.log(red(String(err))));
+                return;
+            case "model":
+                if (arg)
+                    session.setModel(arg);
+                console.log(dim(session.isAuto
+                    ? `model: auto (${autoRouter.bias}), last ran ${session.model}`
+                    : `model: ${session.model}`));
+                return;
+            case "bias":
+                if (arg && AUTO_BIASES.includes(arg)) {
+                    autoRouter.bias = arg;
+                    setAutoBias(autoRouter.bias);
+                }
+                else if (arg) {
+                    console.log(red(`unknown bias: ${arg} (${AUTO_BIASES.join(" | ")})`));
+                }
+                console.log(dim(`auto bias: ${autoRouter.bias}`));
+                return;
+            case "mode":
+                if (arg && MODES.includes(arg))
+                    session.mode = arg;
+                else if (arg)
+                    console.log(red(`unknown mode: ${arg}`));
+                console.log(dim(`mode: ${session.mode}`));
+                return;
+            case "skills":
+                skills = loadSkills(cwd);
+                if (!skills.length)
+                    console.log(dim("no skills found (~/.9p/skills or .9p/skills)"));
+                for (const s of skills)
+                    console.log(`  /${s.name}  ${dim(s.description || s.source)}`);
+                return;
+            case "clear":
+                session.clear();
+                console.log(dim("context cleared"));
+                return;
+            case "usage": {
+                const saved = delegationLine(session.delegated);
+                console.log(dim(`${usageLine(session.usage)} · context ~${session.contextTokens} tokens`));
+                if (saved)
+                    console.log(dim(saved));
+                return;
+            }
+            case "compact": {
+                const result = await session.compact();
+                console.log(dim(result
+                    ? `compacted ~${result.before} → ~${result.after} tokens`
+                    : "nothing to compact yet"));
+                return;
+            }
+            case "exit":
+            case "quit":
+                await mcp.close();
+                rl.close();
+                process.exit(0);
+            // eslint-disable-next-line no-fallthrough
+            default: {
+                const skill = skills.find((s) => s.name === cmd);
+                if (skill) {
+                    await run(skillMessage(skill, arg));
+                    return;
+                }
+                console.log(red(`unknown command: /${cmd}`));
+            }
+        }
+    }
+    // Non-interactive: run each piped line as a message, then exit.
+    if (piped !== null) {
+        for (const line of piped.split("\n").map((l) => l.trim()).filter(Boolean)) {
+            console.log(cyan(`\n9p ❯ ${line}`));
+            if (line.startsWith("/"))
+                await handleSlash(line);
+            else
+                await run(line);
+        }
+        await mcp.close();
+        rl.close();
+        return;
+    }
+    while (true) {
+        let line;
+        try {
+            line = (await rl.question(cyan("\n9p ❯ "))).trim();
+        }
+        catch {
+            break; // Ctrl-D / closed stdin, exit quietly rather than throwing.
+        }
+        if (!line)
+            continue;
+        if (line.startsWith("/"))
+            await handleSlash(line);
+        else
+            await run(line);
+    }
+    await mcp.close();
+    rl.close();
+}
+//# sourceMappingURL=repl.js.map

package/dist/scripts/tui-smoke.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/tui-smoke.js

@@ -0,0 +1,64 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink-testing-library";
+import { App } from "../tui/app.js";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const usage = { inputTokens: 10, cachedTokens: 5, outputTokens: 3, requests: 1 };
+// Non-zero so the statusline's delegation branch is actually rendered; a fixture
+// of all zeros would compile against the widened AgentLike and test nothing.
+const delegated = {
+    calls: 2,
+    contextTokensSaved: 6944,
+    workerUsage: { inputTokens: 6968, cachedTokens: 0, outputTokens: 2334, requests: 2 },
+};
+let bridge = null;
+let permissionAsked = false;
+const fake = {
+    model: "fake/test-model",
+    mode: "default",
+    usage,
+    delegated,
+    async *send(text) {
+        if (text.includes("dangerous")) {
+            permissionAsked = true;
+            const allowed = await bridge.requestPermission("bash: rm -i something");
+            yield { type: "text_delta", text: allowed ? "ran it" : "skipped it" };
+        }
+        else {
+            yield { type: "text_delta", text: `echo:${text}` };
+        }
+        yield { type: "turn_end", usage };
+    },
+    clear() { },
+};
+const { lastFrame, frames, stdin } = render(_jsx(App, { session: fake, meta: { cwd: "/tmp/x", authLabel: "byok", vault: "/tmp/x/vault", skills: [], mcpSummary: null }, register: (b) => (bridge = b) }));
+function expect(cond, label) {
+    console.log(`${cond ? "ok" : "FAIL"} - ${label}`);
+    if (!cond)
+        process.exitCode = 1;
+}
+await sleep(50);
+// the banner lives in <Static>. It appears in an early frame, not necessarily the last
+expect(frames.join("\n").includes("9th Protocol"), "banner renders");
+expect((lastFrame() ?? "").includes("fake/test-model"), "statusline shows model");
+expect((lastFrame() ?? "").includes("6.9k saved"), "statusline shows delegation saving");
+stdin.write("/usage");
+await sleep(30);
+stdin.write("\r");
+await sleep(80);
+expect(frames.join("\n").includes("6944 tokens kept out of context"), "/usage reports what delegation kept out of context");
+stdin.write("hello");
+await sleep(30);
+stdin.write("\r");
+await sleep(100);
+expect((lastFrame() ?? "").includes("echo:hello"), "message round-trip renders response");
+stdin.write("do the dangerous thing");
+await sleep(30);
+stdin.write("\r");
+await sleep(100);
+expect(permissionAsked, "permission prompt requested");
+expect((lastFrame() ?? "").includes("allow? [y/n]"), "permission prompt renders");
+stdin.write("y");
+await sleep(100);
+expect((lastFrame() ?? "").includes("ran it"), "permission allow resumes agent");
+process.exit(process.exitCode ?? 0);
+//# sourceMappingURL=tui-smoke.js.map

package/dist/serve.d.ts

@@ -0,0 +1,8 @@
+import { type AgentEvent } from "@9thprotocol/agent-core";
+/**
+ * `9p serve`: the local web session. One session per server, bound to
+ * 127.0.0.1 only (this is a local UI, not a network service). Used directly in
+ * a browser and embedded by the VS Code extension.
+ */
+export declare function runServe(cwd: string, port: number): Promise<void>;
+export type { AgentEvent };

package/dist/serve.js

@@ -0,0 +1,225 @@
+import http from "node:http";
+import crypto from "node:crypto";
+import { AgentSession, McpManager, loadSkills, resolveVault, skillMessage, } from "@9thprotocol/agent-core";
+import { cyan, dim, requireAuth, DEFAULT_MODEL, AUTO_BIASES, fetchCatalog, getAutoBias, setAutoBias, } from "./shared.js";
+import { chatHtml } from "./webui.js";
+const MODES = ["default", "accept-edits", "plan", "bypass"];
+function readJson(req) {
+    return new Promise((resolve, reject) => {
+        let body = "";
+        req.on("data", (c) => (body += c));
+        req.on("end", () => {
+            try {
+                resolve(body ? JSON.parse(body) : {});
+            }
+            catch {
+                reject(new Error("invalid JSON body"));
+            }
+        });
+        req.on("error", reject);
+    });
+}
+/**
+ * `9p serve`: the local web session. One session per server, bound to
+ * 127.0.0.1 only (this is a local UI, not a network service). Used directly in
+ * a browser and embedded by the VS Code extension.
+ */
+export async function runServe(cwd, port) {
+    const auth = await requireAuth();
+    const mcp = await McpManager.fromCwd(cwd);
+    const skills = loadSkills(cwd);
+    const vault = resolveVault(cwd);
+    const clients = new Set();
+    const pendingPerms = new Map();
+    const pendingAsks = new Map();
+    let busy = false;
+    const broadcast = (ev) => {
+        const line = `data: ${JSON.stringify(ev)}\n\n`;
+        for (const client of clients)
+            client.write(line);
+    };
+    const catalog = await fetchCatalog(auth);
+    // Held by reference so /config can retune the live session's routing bias
+    // without rebuilding it.
+    const autoRouter = { bias: getAutoBias(), ...(catalog ? { catalog } : {}) };
+    const session = new AgentSession({
+        apiKey: auth.apiKey,
+        ...(auth.platform ? { platform: auth.platform } : {}),
+        mcp,
+        model: process.env.NINEP_MODEL ?? DEFAULT_MODEL,
+        autoRouter,
+        cwd,
+        mode: "default",
+        decide: (req) => new Promise((resolve) => {
+            const id = crypto.randomUUID();
+            pendingPerms.set(id, resolve);
+            broadcast({ type: "permission_request", id, summary: req.summary });
+        }),
+        askUser: (q) => new Promise((resolve) => {
+            const id = crypto.randomUUID();
+            pendingAsks.set(id, resolve);
+            broadcast({ type: "ask_request", id, question: q.question, options: q.options ?? [] });
+        }),
+    });
+    let modelIds = [];
+    if (auth.platform) {
+        try {
+            const res = await fetch(`${auth.platform.baseUrl}/models`, {
+                headers: { Authorization: `Bearer ${auth.apiKey}` },
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                modelIds = data.models.filter((m) => !m.locked).map((m) => m.id);
+            }
+        }
+        catch {
+            // catalog is a nicety; the session still works without it
+        }
+    }
+    if (!modelIds.includes(session.model))
+        modelIds.unshift(session.model);
+    async function run(message) {
+        busy = true;
+        broadcast({ type: "busy", value: true });
+        try {
+            for await (const ev of session.send(message)) {
+                broadcast(ev);
+            }
+        }
+        finally {
+            busy = false;
+            broadcast({ type: "busy", value: false });
+        }
+    }
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://localhost");
+        try {
+            if (req.method === "GET" && url.pathname === "/") {
+                res.writeHead(200, { "Content-Type": "text/html" }).end(chatHtml());
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/events") {
+                res.writeHead(200, {
+                    "Content-Type": "text/event-stream",
+                    "Cache-Control": "no-cache",
+                    Connection: "keep-alive",
+                });
+                res.write(": connected\n\n");
+                clients.add(res);
+                req.on("close", () => clients.delete(res));
+                return;
+            }
+            if (req.method === "GET" && url.pathname === "/state") {
+                res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({
+                    model: session.model,
+                    mode: session.mode,
+                    usage: session.usage,
+                    delegated: session.delegated,
+                    contextTokens: session.contextTokens,
+                    busy,
+                    cwd,
+                    vault,
+                    models: modelIds,
+                    bias: autoRouter.bias,
+                    mcp: mcp.servers,
+                    skills: skills.map((s) => s.name),
+                }));
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/send") {
+                if (busy) {
+                    res.writeHead(409).end("busy");
+                    return;
+                }
+                const body = await readJson(req);
+                let message = String(body.message ?? "").trim();
+                if (!message) {
+                    res.writeHead(400).end("message required");
+                    return;
+                }
+                // /<skill> [args] invocations work in the web session too
+                if (message.startsWith("/")) {
+                    const [name = "", ...rest] = message.slice(1).split(/\s+/);
+                    const skill = skills.find((s) => s.name === name);
+                    if (skill)
+                        message = skillMessage(skill, rest.join(" "));
+                }
+                void run(message);
+                res.writeHead(202).end("ok");
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/permission") {
+                const body = await readJson(req);
+                const resolve = pendingPerms.get(String(body.id));
+                if (resolve) {
+                    pendingPerms.delete(String(body.id));
+                    resolve(Boolean(body.allow));
+                }
+                res.writeHead(200).end("ok");
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/answer") {
+                const body = await readJson(req);
+                const resolve = pendingAsks.get(String(body.id));
+                if (resolve) {
+                    pendingAsks.delete(String(body.id));
+                    resolve(String(body.answer ?? ""));
+                }
+                res.writeHead(200).end("ok");
+                return;
+            }
+            if (req.method === "POST" && url.pathname === "/config") {
+                const body = await readJson(req);
+                // setModel, not `session.model =`: assigning the field would be
+                // overwritten by the router on the next turn in Auto mode.
+                if (typeof body.model === "string" && body.model)
+                    session.setModel(body.model);
+                if (typeof body.mode === "string" && MODES.includes(body.mode)) {
+                    session.mode = body.mode;
+                }
+                if (typeof body.bias === "string" && AUTO_BIASES.includes(body.bias)) {
+                    autoRouter.bias = body.bias;
+                    setAutoBias(autoRouter.bias);
+                }
+                res.writeHead(200).end("ok");
+                return;
+            }
+            /**
+             * Account and usage for the Settings and Usage panels.
+             *
+             * Proxied rather than called from the page: the platform token lives in
+             * this process, and handing it to the renderer would put a credential
+             * into a browser context for no benefit.
+             */
+            if (req.method === "GET" && (url.pathname === "/me" || url.pathname === "/usage")) {
+                if (!auth.platform) {
+                    res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({ byok: true }));
+                    return;
+                }
+                const target = url.pathname === "/me"
+                    ? "/me"
+                    : `/billing/usage?groupBy=${encodeURIComponent(url.searchParams.get("groupBy") ?? "model")}` +
+                        `&days=${encodeURIComponent(url.searchParams.get("days") ?? "30")}`;
+                try {
+                    const r = await fetch(`${auth.platform.baseUrl}${target}`, {
+                        headers: { Authorization: `Bearer ${auth.apiKey}` },
+                    });
+                    res.writeHead(r.status, { "Content-Type": "application/json" }).end(await r.text());
+                }
+                catch (err) {
+                    res.writeHead(502, { "Content-Type": "application/json" }).end(JSON.stringify({ error: String(err) }));
+                }
+                return;
+            }
+            res.writeHead(404).end("not found");
+        }
+        catch (err) {
+            res.writeHead(500).end(err instanceof Error ? err.message : "error");
+        }
+    });
+    server.listen(port, "127.0.0.1", () => {
+        console.log(`${cyan("9p serve")}, local session at http://127.0.0.1:${port}`);
+        console.log(dim(`cwd: ${cwd} · auth: ${auth.platform ? "platform" : "byok"}${vault ? ` · vault: ${vault}` : ""}`));
+    });
+}
+//# sourceMappingURL=serve.js.map

package/dist/shared.d.ts

@@ -0,0 +1,60 @@
+import { type RouterBias, type RouterCandidate, type DelegationTotals, type UsageTotals } from "@9thprotocol/agent-core";
+export declare const dim: (s: string) => string;
+export declare const cyan: (s: string) => string;
+export declare const yellow: (s: string) => string;
+export declare const red: (s: string) => string;
+/** Auto routing is the product default (PLAN.md §5.5); `/model <id>` pins a model. */
+export declare const DEFAULT_MODEL = "auto";
+/** Auto bias from NINEP_AUTO_BIAS or ~/.9p/config.json; defaults to balanced. */
+export declare function getAutoBias(): RouterBias;
+export declare function setAutoBias(bias: RouterBias): void;
+export declare const AUTO_BIASES: RouterBias[];
+/**
+ * Catalog with plan locks for the Auto router. Platform-only: BYOK has no plan
+ * gating, so the router falls back to its built-in ladders.
+ */
+export declare function fetchCatalog(auth: Auth): Promise<RouterCandidate[] | undefined>;
+export interface Auth {
+    apiKey: string;
+    platform?: {
+        baseUrl: string;
+    };
+}
+/**
+ * Auth resolution order:
+ * 1. NINEP_API_URL + NINEP_TOKEN (platform, metered)
+ * 2. ~/.9p/auth.json {"apiUrl", "token"} (platform)
+ * 3. OPENROUTER_API_KEY or ~/.9p/auth.json {"openrouterApiKey"} (BYOK, direct)
+ */
+export declare function getAuth(): Auth | null;
+/**
+ * Resolve credentials, refreshing an expiring platform token first.
+ * Env-provided tokens are used verbatim. We don't own their lifecycle.
+ */
+export type AuthFailure = "none" | "expired";
+/**
+ * Resolve credentials, refreshing an expiring platform token first.
+ *
+ * Returns a reason rather than exiting, so hosts that are not a terminal (the
+ * desktop app) can surface it in their own UI. A library that calls
+ * `process.exit` kills an Electron app with a message nobody ever sees.
+ */
+export declare function resolveAuth(): Promise<{
+    ok: true;
+    auth: Auth;
+} | {
+    ok: false;
+    reason: AuthFailure;
+}>;
+/** CLI entry point: resolve credentials, or print and exit. */
+export declare function requireAuth(): Promise<Auth>;
+export declare function usageLine(u: UsageTotals): string;
+/**
+ * What delegation kept out of the context. Empty when nothing was delegated,
+ * so callers can append it unconditionally without printing a zero every turn.
+ *
+ * Phrased as context rather than money on purpose: those tokens are not merely
+ * unspent once, they are tokens that never get resent on any later turn, which
+ * is the whole reason a session window lasts longer with delegation on.
+ */
+export declare function delegationLine(d: DelegationTotals): string;