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

package/src/headless.ts

@@ -0,0 +1,225 @@
+/**
+ * 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, type ApprovalDecision, type ApprovalRequest } 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";
+
+interface HeadlessOptions {
+    prompt: string;
+    ui: "json" | "plain";
+    resume?: string;
+}
+
+let eventSeq = 0;
+
+function writeEvent(value: Record<string, any>): void {
+    eventSeq += 1;
+    process.stdout.write(JSON.stringify({ v: 1, seq: eventSeq, ts: new Date().toISOString(), ...value }) + "\n");
+}
+
+function optionalBudget(name: string): number | undefined {
+    const value = Number(process.env[name]);
+    return Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
+export async function runHeadless(options: HeadlessOptions): Promise<void> {
+    const config = loadConfig();
+    setShellPoolSize(config.shellPoolSize);
+    const provider = getProviderOrThrow(config.providerId);
+    let apiKey: string | undefined;
+    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: string[] = [];
+    const waiters: Array<(line: string | undefined) => void> = [];
+    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: number): Promise<string | undefined> => {
+        if (queued.length > 0)
+            return Promise.resolve(queued.shift());
+        if (eof)
+            return Promise.resolve(undefined);
+        return new Promise((resolve) => {
+            const waiter = (line: string | undefined) => {
+                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: ApprovalRequest): Promise<ApprovalDecision> => {
+        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/src/index.ts

@@ -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/src/lib/debug.ts

@@ -0,0 +1,24 @@
+/**
+ * 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(): boolean {
+    return TRUTHY.has((process.env["FASTCODE_DEBUG"] ?? "").trim().toLowerCase());
+}
+
+export function debugLog(scope: string, message: string): void {
+    if (!debugEnabled())
+        return;
+    try {
+        process.stderr.write(`[fastcode:${scope}] ${message}\n`);
+    }
+    catch {
+        // Debug logging must never break the operation it observes.
+    }
+}

package/src/lib/diagnostics.ts

@@ -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/src/lib/highlight-subset.ts

@@ -0,0 +1,93 @@
+/**
+ * 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: Record<string, any> = {
+    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: string | undefined): boolean {
+    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/src/lib/lifecycle.ts

@@ -0,0 +1,69 @@
+/**
+ * Process-level shutdown guards.
+ *
+ * The TUI already calls shutdownShells() from its React cleanup, but fatal
+ * errors and SIGTERM/SIGHUP can bypass that path. These guards are best-effort
+ * and idempotent; they do not turn FastCode into a kernel-level sandbox.
+ */
+import { shutdownShells } from "../agent/shell-session.js";
+
+let installed = false;
+let cleaned = false;
+
+export function cleanupProcesses(): void {
+    if (cleaned)
+        return;
+    cleaned = true;
+    try {
+        shutdownShells();
+    }
+    catch {
+        // Best effort: never mask the original failure.
+    }
+}
+
+export interface ProcessGuardOptions {
+    onFatal?: (error: unknown) => void;
+}
+
+export function installProcessGuards(options: ProcessGuardOptions = {}): () => void {
+    if (installed)
+        return () => undefined;
+    installed = true;
+    const onSignal = (signal: NodeJS.Signals) => {
+        process.stderr.write(`[fastcode] ${signal} received; shutting down.\n`);
+        cleanupProcesses();
+        process.exit(signal === "SIGINT" ? 130 : 143);
+    };
+    const onFatal = (error: unknown) => {
+        const detail = error instanceof Error ? (error.stack ?? error.message) : String(error);
+        process.stderr.write(`[fastcode] fatal: ${detail}\n`);
+        cleanupProcesses();
+        options.onFatal?.(error);
+        process.exit(1);
+    };
+    const signals: NodeJS.Signals[] = ["SIGTERM", "SIGHUP"];
+    for (const signal of signals) {
+        try {
+            process.on(signal, onSignal);
+        }
+        catch {
+            // Some platforms do not expose every signal.
+        }
+    }
+    process.on("uncaughtException", onFatal);
+    process.on("unhandledRejection", onFatal);
+    return () => {
+        for (const signal of signals) {
+            try {
+                process.removeListener(signal, onSignal);
+            }
+            catch {
+                // Ignore unsupported signals.
+            }
+        }
+        process.removeListener("uncaughtException", onFatal);
+        process.removeListener("unhandledRejection", onFatal);
+        installed = false;
+    };
+}

package/src/lib/markdown.ts

@@ -6,8 +6,10 @@
  * markdown parser. The result is a fully-formatted ANSI string we can
  * print directly inside an Ink <Text>.
  */
+import chalk from "chalk";
 import { marked } from "marked";
 import { markedTerminal } from "marked-terminal";
+import { supportsHighlightLanguage } from "./highlight-subset.js";
 let configured = false;
 function configure() {
     if (configured)
@@ -15,16 +17,32 @@ function configure() {
     marked.use(markedTerminal({
         reflowText: false,
         tab: 2,
+        // marked-terminal calls this only when highlighting fails; keep the
+        // cold-language fallback as plain text instead of colored source.
+        code: (text: string) => text,
     }) as any);
     configured = true;
 }
+function unsupportedFenceLanguages(md: string): string[] {
+    const missing = new Set<string>();
+    for (const match of md.matchAll(/(?:^|\n)\s*(?:`{3,}|~{3,})([^\n]*)/g)) {
+        const info = (match[1] ?? "").trim();
+        if (!info)
+            continue;
+        const language = info.split(/\s+/)[0] ?? "";
+        if (language && !supportsHighlightLanguage(language))
+            missing.add(language);
+    }
+    return Array.from(missing);
+}
 export function renderMarkdown(md) {
     configure();
     try {
-        const out = marked.parse(md) as string;
-        // marked-terminal sometimes appends a stray trailing newline; trim only
-        // trailing whitespace so we don't lose meaningful blank lines.
-        return out.replace(/\s+$/, "");
+        const out = (marked.parse(md) as string).replace(/\s+$/, "");
+        const missing = unsupportedFenceLanguages(String(md));
+        if (missing.length === 0)
+            return out;
+        return out + "\n\n" + chalk.dim(`[fastcode] no syntax highlighting for ${missing.join(", ")}; rendered as plain text.`);
     }
     catch {
         return md;

package/src/providers/deepseek.ts

@@ -9,7 +9,7 @@ export const deepseekProvider = {
     label: "DeepSeek",
     authEnv: ["DEEPSEEK_API_KEY"],
     baseUrl: BASE,
-    defaultModel: "deepseek-v4-pro",
+    defaultModel: "deepseek-flash",
     listModels: (apiKey) => listModelsHttp({ baseUrl: BASE, apiKey, staticModels: STATIC }),
     stream: (req, apiKey) => streamChatCompletion(req, { baseUrl: BASE, apiKey, staticModels: STATIC, reasoning: "openai" }),
     supportsReasoning: () => true,