@datename/fastcode-termux 0.1.6-beta → 0.1.8-beta.0

package/dist/config/trust.js

@@ -7,7 +7,7 @@
  *
  * FASTCODE_TRUST_ALL=1 marks every directory trusted (scripts, CI).
  */
-import { existsSync, readFileSync, realpathSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { ensureDir, getPaths } from "./paths.js";
 const TRUTHY = ["1", "true", "yes", "on"];
@@ -111,7 +111,20 @@ export function loadTrust() {
 function saveTrust(state) {
     const paths = getPaths();
     ensureDir(paths.root);
-    writeFileSync(paths.trust, JSON.stringify(state, null, 2), "utf8");
+    const tmp = paths.trust + "." + process.pid + ".tmp";
+    try {
+        writeFileSync(tmp, JSON.stringify(state, null, 2), "utf8");
+        renameSync(tmp, paths.trust);
+    }
+    catch (err) {
+        try {
+            rmSync(tmp, { force: true });
+        }
+        catch {
+            // best effort
+        }
+        throw err;
+    }
     try {
         const info = statSync(paths.trust);
         cache = { file: paths.trust, key: `${info.mtimeMs}:${info.size}`, state };
@@ -151,3 +164,29 @@ export function untrustProject(dir) {
 export function listTrusted() {
     return Object.entries(loadTrust().paths).map(([path, entry]) => ({ path, addedAt: entry.grantedAt }));
 }
+/** Check a tool/fingerprint approval bound to the current tool catalog. */
+export function isToolApproved(key, catalogHash) {
+    const entry = loadTrust().tools[key];
+    return Boolean(entry && entry.catalogHash === catalogHash);
+}
+export function rememberToolApproval(key, catalogHash) {
+    const state = loadTrust();
+    const at = new Date().toISOString();
+    state.tools[key] = { grantedAt: at, lastUsed: at, catalogHash };
+    saveTrust(state);
+}
+export function forgetToolApproval(key) {
+    const state = loadTrust();
+    if (!state.tools[key])
+        return false;
+    delete state.tools[key];
+    saveTrust(state);
+    return true;
+}
+export function listToolApprovals() {
+    return Object.entries(loadTrust().tools).map(([key, entry]) => ({
+        key,
+        grantedAt: entry.grantedAt,
+        catalogHash: entry.catalogHash,
+    }));
+}

package/dist/headless.d.ts

@@ -0,0 +1,7 @@
+interface HeadlessOptions {
+    prompt: string;
+    ui: "json" | "plain";
+    resume?: string;
+}
+export declare function runHeadless(options: HeadlessOptions): Promise<void>;
+export {};

package/dist/headless.js

@@ -0,0 +1,213 @@
+/**
+ * Non-Ink headless runner for `--ui json` / non-TTY `--ui plain`.
+ *
+ * stdout is reserved for the protocol/answer; diagnostics go to stderr.
+ */
+import readline from "node:readline";
+import { AGENT_SYSTEM_PROMPT } from "./agent/protocol.js";
+import { compactionConfigFromEnv } from "./agent/compaction.js";
+import { resolveToolProtocol } from "./agent/protocol-mode.js";
+import { runAgent } from "./agent/runner.js";
+import { setShellPoolSize } from "./agent/shell-session.js";
+import { toolSchemas } from "./agent/tool-schemas.js";
+import { encodeGateAsk, parseGateDecision } from "./agent/approval-json.js";
+import { decisionForOption, parseApprovalChoice } from "./agent/approval.js";
+import { buildPluginsPrompt } from "./plugins/manager.js";
+import { buildSkillsPrompt } from "./skills/manager.js";
+import { loadConfig, resolveApiKey } from "./config/store.js";
+import { getProviderOrThrow } from "./providers/index.js";
+import { resumeSession } from "./session/projection.js";
+let eventSeq = 0;
+function writeEvent(value) {
+    eventSeq += 1;
+    process.stdout.write(JSON.stringify({ v: 1, seq: eventSeq, ts: new Date().toISOString(), ...value }) + "\n");
+}
+function optionalBudget(name) {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+export async function runHeadless(options) {
+    const config = loadConfig();
+    setShellPoolSize(config.shellPoolSize);
+    const provider = getProviderOrThrow(config.providerId);
+    let apiKey;
+    if (provider.authEnv.length > 0) {
+        const lookup = resolveApiKey(provider.id, config.model, provider.authEnv);
+        if (lookup.status !== "ok")
+            throw new Error(`No usable API key for ${provider.id}.`);
+        apiKey = lookup.key;
+    }
+    const history = options.resume ? resumeSession(options.resume, process.cwd()).messages : [];
+    const system = [
+        config.systemPrompt,
+        buildSkillsPrompt(config.enabledSkills),
+        buildPluginsPrompt(config.enabledPlugins),
+        config.agentMode ? AGENT_SYSTEM_PROMPT : "",
+    ].filter((part) => part.trim()).join("\n\n");
+    const protocol = config.agentMode ? resolveToolProtocol(config, config.providerId, config.model) : "legacy";
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+    const queued = [];
+    const waiters = [];
+    let eof = false;
+    rl.on("line", (line) => {
+        const waiter = waiters.shift();
+        if (waiter)
+            waiter(line);
+        else
+            queued.push(line);
+    });
+    rl.on("close", () => {
+        eof = true;
+        while (waiters.length > 0)
+            waiters.shift()(undefined);
+    });
+    const nextLine = (timeoutMs) => {
+        if (queued.length > 0)
+            return Promise.resolve(queued.shift());
+        if (eof)
+            return Promise.resolve(undefined);
+        return new Promise((resolve) => {
+            const waiter = (line) => {
+                clearTimeout(timer);
+                resolve(line);
+            };
+            const timer = setTimeout(() => {
+                const index = waiters.indexOf(waiter);
+                if (index >= 0)
+                    waiters.splice(index, 1);
+                resolve(undefined);
+            }, Math.max(1000, timeoutMs));
+            timer.unref?.();
+            waiters.push(waiter);
+        });
+    };
+    const requestApproval = async (request) => {
+        if (options.ui === "json") {
+            writeEvent(encodeGateAsk(request));
+            const line = await nextLine(request.timeoutMs ?? 60_000);
+            if (line === undefined)
+                return { kind: "deny", reason: "approval timeout/EOF" };
+            const parsed = parseGateDecision(request, line);
+            if (parsed.error) {
+                writeEvent({ event: "gate:error", version: 1, id: request.id, error: parsed.error });
+                return parsed.decision;
+            }
+            return parsed.decision;
+        }
+        process.stderr.write(`${request.prompt ?? "Approval required"}\n`);
+        request.options.forEach((option, index) => process.stderr.write(`${index + 1}. ${option.label}\n`));
+        process.stderr.write(`Choose 1-${request.options.length}: `);
+        const line = await nextLine(request.timeoutMs ?? 60_000);
+        const option = line === undefined ? undefined : parseApprovalChoice(request, line);
+        if (!option)
+            return { kind: "deny", reason: "approval cancelled/invalid/timeout" };
+        if (option.kind === "feedback") {
+            process.stderr.write(`${option.prompt || "Why should this be denied?"}\n> `);
+            const feedbackLine = await nextLine(request.timeoutMs ?? 60_000);
+            const feedback = feedbackLine?.trim();
+            return feedback
+                ? { kind: "feedback", text: feedback }
+                : { kind: "deny", reason: "feedback cancelled/empty (fail closed)" };
+        }
+        return decisionForOption(option);
+    };
+    const abort = new AbortController();
+    const onSigint = () => abort.abort();
+    const onTerminate = () => abort.abort();
+    process.once("SIGINT", onSigint);
+    process.once("SIGTERM", onTerminate);
+    process.once("SIGHUP", onTerminate);
+    try {
+        for await (const event of runAgent({
+            provider,
+            apiKey,
+            model: config.model,
+            messages: history,
+            prompt: options.prompt,
+            system,
+            maxTurns: config.agentMode ? Math.max(1, Math.floor(Number(config.maxAgentTurns) || 24)) : 1,
+            allowTools: config.agentMode,
+            tokenBudget: optionalBudget("FASTCODE_TOKEN_BUDGET"),
+            costBudgetUsd: optionalBudget("FASTCODE_COST_BUDGET_USD"),
+            signal: abort.signal,
+            cwd: process.cwd(),
+            idleTimeoutMs: config.requestIdleTimeoutMs,
+            compaction: compactionConfigFromEnv(),
+            reasoningEffort: config.reasoningEffort,
+            protocol,
+            tools: protocol === "native" ? toolSchemas() : undefined,
+            requestApproval,
+        })) {
+            if (options.ui === "json") {
+                if (event.type === "assistant_text")
+                    writeEvent({ event: "assistant", text: event.text });
+                else if (event.type === "tool_call")
+                    writeEvent({
+                        event: "tool_call",
+                        id: event.id,
+                        tool: event.call.tool,
+                        args: event.call,
+                        ...(event.native ? { native: true } : {}),
+                    });
+                else if (event.type === "egress_denied")
+                    writeEvent({
+                        event: "egress_denied",
+                        outlet: event.outlet,
+                        ...(event.target ? { target: event.target } : {}),
+                        rule: event.rule,
+                        mode: event.mode,
+                        would_block: event.wouldBlock,
+                        code: event.code,
+                        reason: event.reason,
+                    });
+                else if (event.type === "tool_result")
+                    writeEvent({
+                        event: "tool_result",
+                        id: event.id,
+                        tool: event.call.tool,
+                        ok: event.ok,
+                        output: event.output,
+                        ...(event.sideEffects ? { side_effects: event.sideEffects } : {}),
+                        ...(event.code ? { code: event.code } : {}),
+                        ...(event.hint ? { hint: event.hint } : {}),
+                        ...(event.truncated !== undefined ? { truncated: event.truncated } : {}),
+                        ...(event.totalLines !== undefined ? { total_lines: event.totalLines } : {}),
+                        ...(event.returnedLines !== undefined ? { returned_lines: event.returnedLines } : {}),
+                        ...(event.totalBytes !== undefined ? { total_bytes: event.totalBytes } : {}),
+                        ...(event.returnedBytes !== undefined ? { returned_bytes: event.returnedBytes } : {}),
+                        ...(event.filesRead !== undefined ? { files_read: event.filesRead } : {}),
+                        ...(event.filesSkipped !== undefined ? { files_skipped: event.filesSkipped } : {}),
+                        ...(event.matches !== undefined ? { matches: event.matches } : {}),
+                    });
+                else if (event.type === "usage")
+                    writeEvent({
+                        event: "usage",
+                        input_tokens: event.usage.inputTokens ?? 0,
+                        output_tokens: event.usage.outputTokens ?? 0,
+                        cost_usd: event.usage.costUsd ?? 0,
+                    });
+                else if (event.type === "notice")
+                    writeEvent({ event: "notice", text: event.text });
+                else if (event.type === "error")
+                    writeEvent({ event: "error", kind: event.kind, code: event.kind, message: event.message });
+                else if (event.type === "done")
+                    writeEvent({ event: "done", stopReason: event.stopReason, finalText: event.finalText });
+            }
+            else if (event.type === "assistant_text") {
+                process.stdout.write(event.text);
+            }
+            else if (event.type === "notice") {
+                process.stderr.write(`[fastcode] ${event.text}\n`);
+            }
+            else if (event.type === "done" && event.finalText) {
+                process.stdout.write(event.finalText + "\n");
+            }
+        }
+    }
+    finally {
+        process.removeListener("SIGINT", onSigint);
+        process.removeListener("SIGTERM", onTerminate);
+        process.removeListener("SIGHUP", onTerminate);
+        rl.close();
+    }
+}

package/dist/index.js

@@ -5,13 +5,29 @@
  * Ink-based TUI. We keep this file tiny so the slow imports (Ink, React)
  * are not loaded for `fastcode skills list`.
  */
-import { parseCli } from "./cli.js";
+import { parseCli } from "./cli-main.js";
+import { installProcessGuards } from "./lib/lifecycle.js";
 async function main() {
+    installProcessGuards();
     const cli = await parseCli();
     if (cli.done)
         return;
+    if (cli.ui === "json") {
+        if (!cli.prompt) {
+            console.error("--ui json requires a prompt: fastcode --ui json \"<prompt>\"");
+            process.exit(1);
+        }
+        const { runHeadless } = await import("./headless.js");
+        await runHeadless({ prompt: cli.prompt, ui: "json", resume: cli.resume });
+        return;
+    }
     if (!process.stdout.isTTY) {
-        console.error("FastCode TUI requires a TTY. Pipe-mode prompts aren't supported yet — try `fastcode \"<prompt>\"` from a real terminal.");
+        if (cli.ui === "plain" && cli.prompt) {
+            const { runHeadless } = await import("./headless.js");
+            await runHeadless({ prompt: cli.prompt, ui: "plain", resume: cli.resume });
+            return;
+        }
+        console.error("FastCode TUI requires a TTY. Use `fastcode --ui plain|json \"<prompt>\"` for pipe mode.");
         process.exit(1);
     }
     // Lazy-load Ink so subcommands don't pay the React boot cost.
@@ -23,7 +39,7 @@ async function main() {
     // React.createElement avoids needing a separate .tsx loader for this file.
     // exitOnCtrlC: false lets the app own Ctrl+C so the documented
     // "press Ctrl+C twice to quit" behavior actually works.
-    render(React.createElement(App, { initialPrompt: cli.prompt, resume: cli.resume }), { exitOnCtrlC: false });
+    render(React.createElement(App, { initialPrompt: cli.prompt, resume: cli.resume, ui: cli.ui ?? "tty" }), { exitOnCtrlC: false });
 }
 main().catch((err) => {
     console.error(err);

package/dist/lib/debug.d.ts

@@ -0,0 +1,2 @@
+export declare function debugEnabled(): boolean;
+export declare function debugLog(scope: string, message: string): void;

package/dist/lib/debug.js

@@ -0,0 +1,22 @@
+/**
+ * Minimal debug logging.
+ *
+ * There is no logging framework in this project: normal output goes through
+ * Ink and lifecycle warnings go straight to stderr. `FASTCODE_DEBUG=1` opts
+ * into low-volume stderr diagnostics (for example timeout clamping or config
+ * cache invalidation) without changing the default experience.
+ */
+const TRUTHY = new Set(["1", "true", "yes", "on"]);
+export function debugEnabled() {
+    return TRUTHY.has((process.env["FASTCODE_DEBUG"] ?? "").trim().toLowerCase());
+}
+export function debugLog(scope, message) {
+    if (!debugEnabled())
+        return;
+    try {
+        process.stderr.write(`[fastcode:${scope}] ${message}\n`);
+    }
+    catch {
+        // Debug logging must never break the operation it observes.
+    }
+}

package/dist/lib/diagnostics.d.ts

@@ -22,6 +22,9 @@ export declare function collectDiagnostics(): {
     keyStatus: "ok" | "missing" | "unbound";
     keyEnv: string;
     skillsInstalled: number;
+    skillsRegistry: string;
+    debug: boolean;
+    configCache: boolean;
     pluginsInstalled: number;
     enabledSkills: any;
     enabledPlugins: any;
@@ -37,16 +40,32 @@ export declare function collectDiagnostics(): {
     shellDenyPatterns: number;
     allowDangerous: boolean;
     toolOutputLimit: number;
+    readMaxBytes: number;
+    readScanMaxBytes: number;
+    readManyMaxBytes: number;
+    grepMaxBytes: number;
+    egress: {
+        enabled: boolean;
+        mode: import("../agent/policy/defaults.js").EgressMode;
+        maxScanBytes: number;
+        denyPaths: number;
+        denyGlobs: number;
+        denyContentMarkers: number;
+        scanToolOutput: boolean;
+    };
     tokenBudget: number;
     costBudgetUsd: number;
     compactionEnabled: boolean;
     compactionRatio: number;
+    compactionKeepTurns: number;
+    compactionSummaryTokens: number;
     compactionHeapMb: number;
     compactionHeapUsedMb: number;
     compactionForced: boolean;
     serverCompactionAware: boolean;
     shellActive: number;
     shellPool: number;
+    shellPoolMax: number;
     shellSpawns: number;
     shellMaxSpawn: number;
     sseIdleMs: number;

package/dist/lib/diagnostics.js

@@ -11,14 +11,17 @@ import { detectPlatform, platformLabel } from "./platform.js";
 import { readPackageMeta } from "./pkg.js";
 import { shouldUseStableTerminalUi } from "./uiMode.js";
 import { getPaths } from "../config/paths.js";
-import { loadConfig, resolveApiKey, resolveProviderKey } from "../config/store.js";
+import { configCacheStatus, loadConfig, resolveApiKey, resolveProviderKey } from "../config/store.js";
+import { debugEnabled } from "./debug.js";
 import { PROVIDERS } from "../providers/index.js";
-import { listInstalledSkills } from "../skills/manager.js";
+import { listInstalledSkills, resolveRegistry } from "../skills/manager.js";
 import { listInstalledPlugins } from "../plugins/manager.js";
 import { findUnclosedSessions, fsyncMode, loggingEnabled, listSessions, sessionCacheLimitBytes } from "../session/log.js";
 import { isTrusted } from "../config/trust.js";
 import { DEFAULT_DENY_PATTERNS, loopExemptTools } from "../agent/guards.js";
 import { toolOutputLimit } from "../agent/limits.js";
+import { grepMaxBytes, readManyMaxBytes, readMaxBytes, readScanMaxBytes } from "../agent/tools/readers.js";
+import { normalizeEgressConfig } from "../agent/policy/egress.js";
 import { compactionConfigFromEnv, heapExceeded } from "../agent/compaction.js";
 import { shellPoolStats } from "../agent/shell-session.js";
 import { resolveToolProtocol, toolCapabilityKey } from "../agent/protocol-mode.js";
@@ -34,6 +37,7 @@ function nodeIsSupported() {
 }
 export function collectDiagnostics() {
     const config = loadConfig();
+    const egress = normalizeEgressConfig(config.egress);
     let paths;
     try {
         paths = getPaths();
@@ -95,6 +99,9 @@ export function collectDiagnostics() {
         keyStatus: provider ? keyLookup.status : "missing",
         keyEnv: provider?.authEnv?.[0],
         skillsInstalled,
+        skillsRegistry: resolveRegistry(process.env["FASTCODE_SKILLS_REGISTRY"], config.skillsRegistry),
+        debug: debugEnabled(),
+        configCache: configCacheStatus().cached,
         pluginsInstalled,
         enabledSkills: (config.enabledSkills ?? []).length,
         enabledPlugins: (config.enabledPlugins ?? []).length,
@@ -110,16 +117,32 @@ export function collectDiagnostics() {
         shellDenyPatterns: DEFAULT_DENY_PATTERNS.length,
         allowDangerous: ["1", "true", "yes", "on"].includes((process.env["FASTCODE_ALLOW_DANGEROUS"] ?? "").trim().toLowerCase()),
         toolOutputLimit: toolOutputLimit(),
+        readMaxBytes: readMaxBytes(),
+        readScanMaxBytes: readScanMaxBytes(),
+        readManyMaxBytes: readManyMaxBytes(),
+        grepMaxBytes: grepMaxBytes(),
+        egress: {
+            enabled: egress.enabled,
+            mode: egress.mode,
+            maxScanBytes: egress.maxScanBytes,
+            denyPaths: egress.denyPaths.length,
+            denyGlobs: egress.denyGlobs.length,
+            denyContentMarkers: egress.denyContentMarkers.length,
+            scanToolOutput: egress.scanToolOutput,
+        },
         tokenBudget: positiveEnv("FASTCODE_TOKEN_BUDGET"),
         costBudgetUsd: positiveEnv("FASTCODE_COST_BUDGET_USD"),
         compactionEnabled: compaction.enabled,
         compactionRatio: compaction.localThresholdRatio,
+        compactionKeepTurns: compaction.keepTurns,
+        compactionSummaryTokens: compaction.maxSummaryTokens,
         compactionHeapMb: compaction.heapLimitMb,
         compactionHeapUsedMb: process.memoryUsage().heapUsed / 1024 / 1024,
         compactionForced: heapExceeded(compaction),
         serverCompactionAware: compaction.serverCompactionAware,
         shellActive: shells.active,
         shellPool: shells.pool,
+        shellPoolMax: shells.maxPool,
         shellSpawns: shells.spawns,
         shellMaxSpawn: shells.maxSpawnPerTurn,
         sseIdleMs: positiveEnv("FASTCODE_SSE_IDLE_MS") || 25_000,
@@ -157,16 +180,19 @@ export function formatDiagnostics(info) {
     lines.push("  trusted cwd   " + (info.trusted ? "yes" : "NO - agent tools ask first or stay off") + "   (" + (info.trustFile ?? "?") + ")");
     lines.push("  session log   " + (info.sessionLogEnabled ? "on" : "off") + "   cache cap " + info.sessionCacheMb + "MB, " + info.sessionsCount + " file(s), " + (info.sessionsBytes / 1024 / 1024).toFixed(2) + "MB used");
     lines.push("  session fsync " + info.sessionFsync + "   unclosed " + info.unclosedSessions + "   " + (info.sessionsDir ?? "(unavailable)"));
-    lines.push("  shell guard   " + info.shellDenyPatterns + " deny patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
+    lines.push("  shell guard   " + info.shellDenyPatterns + " legacy soft patterns" + (info.allowDangerous ? "   [FASTCODE_ALLOW_DANGEROUS is ON]" : ""));
     lines.push("  tool output   " + info.toolOutputLimit + " chars max (streaming cap)");
+    lines.push(`  read limits   read ${info.readMaxBytes}B · scan ${info.readScanMaxBytes}B · read_many ${info.readManyMaxBytes}B · grep ${info.grepMaxBytes}B`);
+    lines.push(`  egress        ${info.egress.enabled ? "enforce" : "audit-only"} · mode ${info.egress.mode} · scan ${info.egress.maxScanBytes}B · paths ${info.egress.denyPaths} · globs ${info.egress.denyGlobs} · markers ${info.egress.denyContentMarkers}`);
     lines.push(`  budgets       ${info.tokenBudget > 0 ? "tokens ≤ " + info.tokenBudget : "token budget off"} · ${info.costBudgetUsd > 0 ? "$" + info.costBudgetUsd : "cost budget off"}`);
-    lines.push(`  compaction    ${info.compactionEnabled ? "on" : "off"} · ${Math.round(info.compactionRatio * 100)}% · heap ${info.compactionHeapUsedMb.toFixed(1)}/${info.compactionHeapMb}MB${info.compactionForced ? " [FORCED]" : ""}${info.serverCompactionAware ? " · server-aware" : ""}`);
-    lines.push(`  shell pool    ${info.shellActive} active · ${info.shellPool} resident · ${info.shellSpawns} spawns · cap ${info.shellMaxSpawn}/turn`);
+    lines.push(`  compaction    ${info.compactionEnabled ? "on" : "off"} · ${Math.round(info.compactionRatio * 100)}% · keep ${info.compactionKeepTurns} turns · summary ${info.compactionSummaryTokens} tok · heap ${info.compactionHeapUsedMb.toFixed(1)}/${info.compactionHeapMb}MB${info.compactionForced ? " [FORCED]" : ""}${info.serverCompactionAware ? " · server-aware" : ""}`);
+    lines.push(`  shell pool    ${info.shellActive} active · ${info.shellPool}/${info.shellPoolMax} resident · ${info.shellSpawns} spawns · cap ${info.shellMaxSpawn}/turn`);
     lines.push(`  loop exempt   ${info.loopExempt.length > 0 ? info.loopExempt.join(", ") : "(none)"}`);
     lines.push(`  model meta    ctx ${info.modelMeta.contextWindow} · ~${info.modelMeta.charsPerToken} chars/token · ${info.modelMeta.supportsTools ? "tools" : "no tools"} · ${info.modelMetaFile}`);
     lines.push(`  sse timeout   ${info.sseIdleMs}ms idle`);
     lines.push(`  tool protocol ${info.toolProtocol} (${info.toolProtocolMode}) · cached ${info.toolCapability}`);
     lines.push(`  provider      ${info.providerId} · model ${info.model}`);
+    lines.push(`  config cache  ${info.configCache ? "warm" : "cold"} · debug ${info.debug ? "on" : "off"}`);
     let apiKeyStatus;
     if (info.keyPresent)
         apiKeyStatus = "present";
@@ -175,7 +201,7 @@ export function formatDiagnostics(info) {
     else
         apiKeyStatus = `MISSING — set ${info.keyEnv ?? "the provider env var"} or /login ${info.providerId} ${info.model} <key>`;
     lines.push(`  api key       ${apiKeyStatus}`);
-    lines.push(`  skills        ${info.skillsInstalled} installed, ${info.enabledSkills} enabled`);
+    lines.push(`  skills        ${info.skillsInstalled} installed, ${info.enabledSkills} enabled (${info.skillsRegistry || "no registry configured"})`);
     lines.push(`  plugins       ${info.pluginsInstalled} installed, ${info.enabledPlugins} enabled`);
     lines.push("");
     lines.push("  provider keys:");

package/dist/lib/highlight-subset.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Trimmed highlight.js registry.
+ *
+ * cli-highlight imports the full `highlight.js` package, which registers every
+ * language and adds roughly a megabyte of language definitions to the bundle
+ * for a TUI that mostly renders JS/TS/JSON/sh/Python. The esbuild plugin in
+ * scripts/esbuild-plugins.mjs aliases the bare `highlight.js` import to this
+ * module so only the common set below is bundled.
+ *
+ * Unknown languages still work: cli-highlight throws, marked-terminal catches
+ * and renders the fence as plain styled text. `renderMarkdown` adds a short
+ * dimmed hint instead of failing or blanking the message.
+ */
+import hljs from "highlight.js/lib/core.js";
+export declare const COMMON_HIGHLIGHT_LANGUAGES: string[];
+export declare function supportsHighlightLanguage(language: string | undefined): boolean;
+export declare const highlight: any;
+export declare const highlightAuto: any;
+export declare const listLanguages: any;
+export declare const getLanguage: any;
+export default hljs;

package/dist/lib/highlight-subset.js

@@ -0,0 +1,88 @@
+/**
+ * Trimmed highlight.js registry.
+ *
+ * cli-highlight imports the full `highlight.js` package, which registers every
+ * language and adds roughly a megabyte of language definitions to the bundle
+ * for a TUI that mostly renders JS/TS/JSON/sh/Python. The esbuild plugin in
+ * scripts/esbuild-plugins.mjs aliases the bare `highlight.js` import to this
+ * module so only the common set below is bundled.
+ *
+ * Unknown languages still work: cli-highlight throws, marked-terminal catches
+ * and renders the fence as plain styled text. `renderMarkdown` adds a short
+ * dimmed hint instead of failing or blanking the message.
+ */
+import hljs from "highlight.js/lib/core.js";
+import javascript from "highlight.js/lib/languages/javascript.js";
+import typescript from "highlight.js/lib/languages/typescript.js";
+import json from "highlight.js/lib/languages/json.js";
+import bash from "highlight.js/lib/languages/bash.js";
+import python from "highlight.js/lib/languages/python.js";
+import go from "highlight.js/lib/languages/go.js";
+import rust from "highlight.js/lib/languages/rust.js";
+import java from "highlight.js/lib/languages/java.js";
+import c from "highlight.js/lib/languages/c.js";
+import cpp from "highlight.js/lib/languages/cpp.js";
+import csharp from "highlight.js/lib/languages/csharp.js";
+import css from "highlight.js/lib/languages/css.js";
+import xml from "highlight.js/lib/languages/xml.js";
+import yaml from "highlight.js/lib/languages/yaml.js";
+import markdown from "highlight.js/lib/languages/markdown.js";
+import sql from "highlight.js/lib/languages/sql.js";
+import diff from "highlight.js/lib/languages/diff.js";
+import dockerfile from "highlight.js/lib/languages/dockerfile.js";
+import powershell from "highlight.js/lib/languages/powershell.js";
+import kotlin from "highlight.js/lib/languages/kotlin.js";
+import swift from "highlight.js/lib/languages/swift.js";
+import ruby from "highlight.js/lib/languages/ruby.js";
+import php from "highlight.js/lib/languages/php.js";
+import lua from "highlight.js/lib/languages/lua.js";
+import r from "highlight.js/lib/languages/r.js";
+import scala from "highlight.js/lib/languages/scala.js";
+import ini from "highlight.js/lib/languages/ini.js";
+import makefile from "highlight.js/lib/languages/makefile.js";
+import plaintext from "highlight.js/lib/languages/plaintext.js";
+const LANGUAGES = {
+    javascript,
+    typescript,
+    json,
+    bash,
+    python,
+    go,
+    rust,
+    java,
+    c,
+    cpp,
+    csharp,
+    css,
+    xml,
+    yaml,
+    markdown,
+    sql,
+    diff,
+    dockerfile,
+    powershell,
+    kotlin,
+    swift,
+    ruby,
+    php,
+    lua,
+    r,
+    scala,
+    ini,
+    makefile,
+    plaintext,
+};
+for (const [name, definition] of Object.entries(LANGUAGES))
+    hljs.registerLanguage(name, definition);
+export const COMMON_HIGHLIGHT_LANGUAGES = Object.keys(LANGUAGES);
+export function supportsHighlightLanguage(language) {
+    if (!language)
+        return true;
+    const name = language.trim().toLowerCase().split(/\s+/)[0] ?? "";
+    return Boolean(name) && Boolean(hljs.getLanguage(name));
+}
+export const highlight = hljs.highlight.bind(hljs);
+export const highlightAuto = hljs.highlightAuto.bind(hljs);
+export const listLanguages = hljs.listLanguages.bind(hljs);
+export const getLanguage = hljs.getLanguage.bind(hljs);
+export default hljs;

package/dist/lib/lifecycle.d.ts

@@ -0,0 +1,5 @@
+export declare function cleanupProcesses(): void;
+export interface ProcessGuardOptions {
+    onFatal?: (error: unknown) => void;
+}
+export declare function installProcessGuards(options?: ProcessGuardOptions): () => void;