@datename/fastcode-termux 0.0.0-stage → 0.1.6-beta

package/dist/ui/Spinner.d.ts

@@ -0,0 +1,5 @@
+export declare const Spinner: ({ theme, label, stable }: {
+    theme: any;
+    label: any;
+    stable?: boolean;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/Spinner.js

@@ -0,0 +1,39 @@
+import { jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * Custom thinking spinner.
+ *
+ * We don't use ink-spinner's built-in spinners directly because we want to
+ * (1) cycle through a varied set of action verbs ("Thinking…", "Pondering…")
+ * and (2) keep the dots animation in sync with the verb rotation.
+ */
+import { useEffect, useState } from "react";
+import { Text } from "ink";
+const FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+const VERBS = [
+    "Thinking",
+    "Pondering",
+    "Reasoning",
+    "Cooking",
+    "Crafting",
+    "Brewing",
+    "Sketching",
+    "Charging",
+];
+export const Spinner = ({ theme, label, stable = false }) => {
+    const [tick, setTick] = useState(0);
+    // stable UI only lowers the redraw rate; it must still animate. A frozen
+    // frame made long waits look like a hang.
+    const configured = Number(process.env["FASTCODE_SPINNER_MS"]);
+    const interval = Number.isFinite(configured) && configured >= 60
+        ? configured
+        : stable
+            ? 120
+            : 80;
+    useEffect(() => {
+        const id = setInterval(() => setTick((t) => t + 1), interval);
+        return () => clearInterval(id);
+    }, [interval]);
+    const frame = FRAMES[tick % FRAMES.length];
+    const verb = label ?? VERBS[Math.floor(tick / 24) % VERBS.length];
+    return (_jsxs(Text, { color: theme.accent, children: [frame, " ", _jsxs(Text, { color: theme.muted, children: [verb, "\u2026"] })] }));
+};

package/dist/ui/StatusBar.d.ts

@@ -0,0 +1,11 @@
+export declare const StatusBar: ({ theme, providerId, model, inputTokens, outputTokens, costUsd, enabledSkillCount, reasoningEffort, hint, }: {
+    theme: any;
+    providerId: any;
+    model: any;
+    inputTokens: any;
+    outputTokens: any;
+    costUsd: any;
+    enabledSkillCount: any;
+    reasoningEffort: any;
+    hint: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/StatusBar.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text, useStdout } from "ink";
+import { platformLabel } from "../lib/platform.js";
+export const StatusBar = ({ theme, providerId, model, inputTokens, outputTokens, costUsd, enabledSkillCount, reasoningEffort, hint, }) => {
+    const { stdout } = useStdout();
+    const columns = stdout?.columns ?? process.stdout.columns ?? 80;
+    const compact = columns < 88;
+    const cost = costUsd > 0 ? `$${costUsd.toFixed(4)}` : "$0.0000";
+    const providerModel = `${providerId}/${model}`;
+    const label = compact ? truncate(providerModel, Math.max(18, columns - 28)) : providerModel;
+    const effort = reasoningEffort && reasoningEffort !== "auto" ? `effort:${reasoningEffort}` : "";
+    return (_jsxs(Box, { flexDirection: compact ? "column" : "row", justifyContent: "space-between", borderStyle: "round", borderColor: theme.border, paddingX: 1, children: [_jsxs(Text, { color: theme.muted, children: [_jsx(Text, { color: theme.accent, children: "\u25CF" }), " ", label, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), inputTokens, "\u2191 ", outputTokens, "\u2193 ", cost, effort ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), effort] })) : null, !compact ? (_jsxs(_Fragment, { children: [_jsx(Text, { color: theme.muted, children: "  \u00B7  " }), "skills: ", enabledSkillCount, _jsx(Text, { color: theme.muted, children: "  \u00B7  " }), platformLabel()] })) : null] }), _jsx(Text, { color: theme.muted, children: compact
+                    ? `${effort ? effort + " \u00B7 " : ""}${platformLabel()} \u00B7 skills:${enabledSkillCount} \u00B7 ${hint ?? "/help \u00B7 esc \u00B7 ctrl+c"}`
+                    : hint ?? "/help \u00B7 esc cancel \u00B7 ctrl+c quit" })] }));
+};
+function truncate(value, max) {
+    if (value.length <= max)
+        return value;
+    return `${value.slice(0, Math.max(1, max - 1))}\u2026`;
+}

package/dist/ui/TrustGate.d.ts

@@ -0,0 +1,5 @@
+export declare const TrustGate: ({ theme, cwd, onDecision }: {
+    theme: any;
+    cwd: any;
+    onDecision: any;
+}) => import("react").ReactElement<any, string | import("react").JSXElementConstructor<any>>;

package/dist/ui/TrustGate.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * First-run confirmation for a folder the agent is not trusted with yet.
+ *
+ * Agent tools can read, write, delete and execute in the workspace, so the user
+ * decides before anything loads.
+ */
+import { Box, Text, useInput } from "ink";
+export const TrustGate = ({ theme, cwd, onDecision }) => {
+    useInput((input) => {
+        const value = String(input ?? "").toLowerCase();
+        if (value === "y")
+            onDecision(true);
+        else if (value === "n" || value === "q")
+            onDecision(false);
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: theme.accent, paddingX: 1, marginTop: 1, children: [
+            _jsx(Text, { color: theme.accent, bold: true, children: "Trust this folder?" }),
+            _jsx(Text, { color: theme.muted, children: cwd }),
+            _jsx(Text, { children: "" }),
+            _jsx(Text, { children: "FastCode agent tools can read, write and delete files here, and run shell commands." }),
+            _jsx(Text, { children: "Continue only if you trust this project." }),
+            _jsx(Text, { children: "" }),
+            _jsx(Text, { children: "[y] trust and continue    [n] decline (chat only)    [q] quit" }),
+        ] }));
+};

package/package.json

@@ -1,6 +1,98 @@
 {
   "name": "@datename/fastcode-termux",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.6-beta",
+  "description": "FastCode — a blazing-fast TUI coding assistant. Multi-LLM, skills.sh skills, slash commands. Works on Termux, Linux, Windows, and macOS.",
+  "type": "module",
+  "bin": {
+    "fastcode": "bin/fastcode.mjs",
+    "fc": "bin/fastcode.mjs"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "tsconfig.json",
+    "assets",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json && node scripts/build.mjs",
+    "build:bundle": "node scripts/build.mjs",
+    "dev": "tsx src/index.ts",
+    "start": "node bin/fastcode.mjs",
+    "check": "npm test && npm run typecheck && npm run lint && npm run build",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node ../scripts/smoke-test.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "tui",
+    "cli",
+    "ai",
+    "coding-agent",
+    "claude",
+    "claude-code",
+    "openclaude",
+    "fastcode",
+    "skills",
+    "termux",
+    "openai",
+    "anthropic",
+    "gemini",
+    "openrouter",
+    "ollama",
+    "deepseek",
+    "groq",
+    "mistral",
+    "agent",
+    "ink",
+    "react"
+  ],
+  "author": "SimpleLittleDev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dateName/fastcode-termux.git"
+  },
+  "homepage": "https://github.com/dateName/fastcode-termux#readme",
+  "bugs": {
+    "url": "https://github.com/dateName/fastcode-termux/issues"
+  },
+  "dependencies": {
+    "boxen": "^7.1.1",
+    "chalk": "^5.3.0",
+    "cli-highlight": "^2.1.11",
+    "figures": "^6.1.0",
+    "gradient-string": "^2.0.2",
+    "ink": "^5.0.1",
+    "ink-big-text": "^2.0.0",
+    "ink-gradient": "^3.0.0",
+    "ink-link": "^4.1.0",
+    "ink-markdown": "^1.0.1",
+    "ink-select-input": "^6.0.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "marked": "^12.0.2",
+    "marked-terminal": "^7.1.0",
+    "meow": "^13.2.0",
+    "react": "^18.3.1",
+    "tar": "^7.4.3"
+  },
+  "devDependencies": {
+    "@types/marked-terminal": "^6.1.1",
+    "@types/node": "^22.10.0",
+    "@types/react": "^18.3.12",
+    "@typescript-eslint/eslint-plugin": "^8.18.0",
+    "@typescript-eslint/parser": "^8.18.0",
+    "esbuild": "^0.28.2",
+    "eslint": "^9.16.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.6.3"
+  }
+}

package/src/agent/approval.ts

@@ -0,0 +1,47 @@
+export type ApprovalScope = "once" | "session" | "always";
+
+export type ApprovalReason =
+  | "trust"
+  | "sensitive_path"
+  | "ambiguous_match"
+  | "destructive"
+  | "large_diff";
+
+export interface ChoiceItem {
+  label: string;
+  value: string;
+}
+
+export type ApprovalPreview =
+  | { kind: "diff"; text: string }
+  | { kind: "choices"; items: ChoiceItem[] };
+
+export type ApprovalOption =
+  | { kind: "allow"; scope: ApprovalScope; label: string }
+  | { kind: "deny"; label: string }
+  | { kind: "choose"; label: string; value: string }
+  | { kind: "feedback"; label: string; prompt: string };
+
+export interface ApprovalRequest {
+  id: string;
+  tool: string;
+  args: unknown;
+  reason: ApprovalReason;
+  options: ApprovalOption[];
+  preview?: ApprovalPreview;
+}
+
+export type ApprovalDecision =
+  | { kind: "allow"; scope: ApprovalScope }
+  | { kind: "deny"; reason?: string; feedback?: string }
+  | { kind: "pending"; request: ApprovalRequest };
+
+export type ApprovalResolver = (request: ApprovalRequest) => ApprovalDecision | Promise<ApprovalDecision>;
+
+export const DEFAULT_ALLOW_OPTIONS: ApprovalOption[] = [
+  { kind: "allow", scope: "once", label: "Allow once" },
+  { kind: "allow", scope: "session", label: "Allow for this session" },
+  { kind: "allow", scope: "always", label: "Always allow" },
+  { kind: "deny", label: "Deny" },
+  { kind: "feedback", label: "Deny with feedback", prompt: "Why should this be denied?" },
+];

package/src/agent/compaction.ts

@@ -0,0 +1,276 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { estMessagesTokens, estTokens } from "../lib/model-meta.js";
+import { getPaths } from "../config/paths.js";
+import type { ChatMessage } from "../types.js";
+import { parseToolCalls, stripToolCalls } from "./protocol.js";
+
+export interface CompactionConfig {
+    enabled: boolean;
+    localThresholdRatio: number;
+    keepTurns: number;
+    serverCompactionAware: boolean;
+    serverCompactThreshold?: number;
+    clampAboveServerByTokens: number;
+    maxSummaryTokens: number;
+    heapLimitMb: number;
+}
+
+export const DEFAULT_COMPACTION_CONFIG: CompactionConfig = {
+    enabled: true,
+    localThresholdRatio: 0.7,
+    keepTurns: 6,
+    serverCompactionAware: false,
+    clampAboveServerByTokens: 8192,
+    maxSummaryTokens: 1500,
+    heapLimitMb: 220,
+};
+
+export interface CompactionOptions {
+    contextWindow: number;
+    providerId?: string;
+    model?: string;
+    force?: boolean;
+    serverOpaqueState?: string;
+}
+
+export interface CompactionResult {
+    messages: ChatMessage[];
+    compacted: boolean;
+    reason?: "threshold" | "heap";
+    source: "local" | "server" | "none";
+    beforeTokens: number;
+    afterTokens: number;
+    beforeChars: number;
+    afterChars: number;
+    droppedMessages: number;
+    keptMessages: number;
+    summary?: string;
+    summaryFile?: string;
+}
+
+export function compactionConfigFromEnv(): CompactionConfig {
+    const config = { ...DEFAULT_COMPACTION_CONFIG };
+    const disabled = (process.env["FASTCODE_COMPACTION"] ?? "").trim().toLowerCase();
+    if (["0", "false", "no", "off"].includes(disabled))
+        config.enabled = false;
+    const heap = Number(process.env["FASTCODE_HEAP_LIMIT_MB"]);
+    if (Number.isFinite(heap) && heap > 0)
+        config.heapLimitMb = heap;
+    const server = (process.env["FASTCODE_SERVER_COMPACTION"] ?? "").trim().toLowerCase();
+    if (["1", "true", "yes", "on"].includes(server))
+        config.serverCompactionAware = true;
+    return config;
+}
+
+export function localThresholdTokens(config: CompactionConfig, contextWindow: number): number {
+    const local = Math.floor(Math.max(1, contextWindow) * config.localThresholdRatio);
+    if (config.serverCompactionAware && typeof config.serverCompactThreshold === "number" && config.serverCompactThreshold > 0) {
+        return Math.max(local, config.serverCompactThreshold + config.clampAboveServerByTokens);
+    }
+    return local;
+}
+
+export function heapExceeded(config: CompactionConfig): boolean {
+    const used = process.memoryUsage().heapUsed;
+    return used > Math.max(0, config.heapLimitMb) * 1024 * 1024;
+}
+
+export function shouldCompact(messages: ChatMessage[], config: CompactionConfig, options: CompactionOptions): boolean {
+    if (!config.enabled)
+        return false;
+    if (options.force || heapExceeded(config))
+        return true;
+    return messageTokens(messages, options) > localThresholdTokens(config, options.contextWindow);
+}
+
+export function compactMessages(messages: ChatMessage[], config: CompactionConfig = DEFAULT_COMPACTION_CONFIG, options: CompactionOptions): CompactionResult {
+    const beforeTokens = messageTokens(messages, options);
+    const beforeChars = messageChars(messages);
+    const heap = heapExceeded(config);
+    const noop: CompactionResult = {
+        messages,
+        compacted: false,
+        source: "none",
+        beforeTokens,
+        afterTokens: beforeTokens,
+        beforeChars,
+        afterChars: beforeChars,
+        droppedMessages: 0,
+        keptMessages: messages.length,
+    };
+    if (!config.enabled)
+        return noop;
+    const threshold = localThresholdTokens(config, options.contextWindow);
+    if (!options.force && !heap && beforeTokens <= threshold)
+        return noop;
+    const reason: "threshold" | "heap" = heap && beforeTokens <= threshold ? "heap" : "threshold";
+    if (config.serverCompactionAware && options.serverOpaqueState) {
+        return {
+            ...noop,
+            compacted: true,
+            reason,
+            source: "server",
+        };
+    }
+    const headCount = messages[0]?.role === "user" ? 1 : 0;
+    const keep = Math.max(2, Math.floor(config.keepTurns * 2));
+    const tailStart = Math.max(headCount, messages.length - keep);
+    if (tailStart <= headCount)
+        return noop;
+    const middle = messages.slice(headCount, tailStart);
+    const summary = buildSummary(middle, config, options);
+    const summaryFile = writeSummaryFile(summary);
+    const marker: ChatMessage = {
+        role: "system",
+        content: `[context compacted: ${middle.length} earlier messages were summarized to stay within the context window.` +
+            `${summaryFile ? ` Summary file: ${summaryFile}.` : ""} Recent turns are kept verbatim.` +
+            " If an earlier detail is missing, re-read that file with a tool.]\n\n" +
+            summary,
+    };
+    const next = [...messages.slice(0, headCount), marker, ...messages.slice(tailStart)];
+    return {
+        messages: next,
+        compacted: true,
+        reason,
+        source: "local",
+        beforeTokens,
+        afterTokens: messageTokens(next, options),
+        beforeChars,
+        afterChars: messageChars(next),
+        droppedMessages: middle.length,
+        keptMessages: next.length - headCount - 1,
+        summary,
+        summaryFile,
+    };
+}
+
+function messageTokens(messages: ChatMessage[], options: CompactionOptions): number {
+    return estMessagesTokens(messages, { providerId: options.providerId, model: options.model });
+}
+
+function messageChars(messages: ChatMessage[]): number {
+    return messages.reduce((sum, message) => sum + (message.content?.length ?? 0), 0);
+}
+
+export function buildSummary(messages: ChatMessage[], config: CompactionConfig, options: Pick<CompactionOptions, "providerId" | "model">): string {
+    const requests: string[] = [];
+    const actions: string[] = [];
+    const outcomes: string[] = [];
+    const notes: string[] = [];
+    const files = new Set<string>();
+    for (const message of messages) {
+        if (!message.content)
+            continue;
+        if (message.role === "user") {
+            if (message.content.startsWith("FastCode executed the requested local tools.")) {
+                for (const line of message.content.split(/\r?\n/)) {
+                    if (/error|failed|not found|denied|timed out/i.test(line))
+                        outcomes.push(clip(line, 240));
+                }
+            }
+            else {
+                requests.push(clip(message.content, 300));
+            }
+            collectFiles(message.content, files);
+            continue;
+        }
+        if (message.role === "assistant") {
+            const calls = parseToolCalls(message.content);
+            for (const call of calls)
+                actions.push(describeCall(call));
+            const visible = stripToolCalls(message.content);
+            if (visible)
+                notes.push(clip(visible, 300));
+            collectFiles(message.content, files);
+            continue;
+        }
+        const lines = message.content.split(/\r?\n/);
+        for (const line of lines) {
+            if (/error|failed|not found|denied|timed out/i.test(line))
+                outcomes.push(clip(line, 240));
+        }
+        collectFiles(message.content, files);
+    }
+    const sections = [
+        "# Session summary",
+        "",
+        "## Requests",
+        ...limitLines(requests, 8).map((line) => `- ${line}`),
+        "",
+        "## Actions",
+        ...limitLines(actions, 20).map((line) => `- ${line}`),
+        "",
+        "## Outcomes",
+        ...limitLines(outcomes, 10).map((line) => `- ${line}`),
+        "",
+        "## Files touched",
+        ...(files.size > 0 ? Array.from(files).slice(0, 40).map((file) => `- ${file}`) : ["- (none recorded)"]),
+        "",
+        "## Notes",
+        ...limitLines(notes, 10).map((line) => `- ${line}`),
+    ];
+    const budget = Math.max(200, Math.floor(config.maxSummaryTokens));
+    const kept: string[] = [];
+    let used = 0;
+    for (const line of sections) {
+        const cost = estTokens(line + "\n", options);
+        if (used + cost > budget) {
+            kept.push("[... summary truncated ...]");
+            break;
+        }
+        kept.push(line);
+        used += cost;
+    }
+    return kept.join("\n").trimEnd() + "\n";
+}
+
+function describeCall(call: any): string {
+    const tool = String(call?.tool ?? "unknown");
+    if (tool === "shell" && typeof call.command === "string")
+        return `shell: ${clip(call.command, 200)}`;
+    if (typeof call.path === "string")
+        return `${tool}: ${call.path}`;
+    if (typeof call.from === "string" || typeof call.to === "string")
+        return `${tool}: ${call.from ?? "?"} -> ${call.to ?? "?"}`;
+    if (typeof call.pattern === "string")
+        return `${tool}: /${clip(call.pattern, 120)}/`;
+    return tool;
+}
+
+function collectFiles(text: string, files: Set<string>): void {
+    const matches = text.match(/[A-Za-z0-9_@./\\-]+\.[A-Za-z0-9]{1,8}\b/g);
+    if (!matches)
+        return;
+    for (const match of matches) {
+        if (match.length <= 3 || match.length > 240)
+            continue;
+        if (/^\d+(\.\d+)+$/.test(match))
+            continue;
+        files.add(match);
+        if (files.size >= 200)
+            return;
+    }
+}
+
+function limitLines(lines: string[], max: number): string[] {
+    return lines.slice(0, max);
+}
+
+function clip(text: string, max: number): string {
+    const oneLine = String(text).replace(/\s+/g, " ").trim();
+    return oneLine.length > max ? oneLine.slice(0, max) + "…" : oneLine;
+}
+
+function writeSummaryFile(summary: string): string | undefined {
+    try {
+        const dir = getPaths().sessions;
+        mkdirSync(dir, { recursive: true });
+        const file = join(dir, `summary-${Date.now()}-${Math.random().toString(36).slice(2, 6)}.md`);
+        writeFileSync(file, summary, "utf8");
+        return file;
+    }
+    catch {
+        return undefined;
+    }
+}

package/src/agent/context.ts

@@ -0,0 +1,97 @@
+/**
+ * Context compaction for long agent sessions.
+ *
+ * The chat loop keeps appending tool results to the conversation, so a long
+ * investigation can grow past the model's window and fail with a provider 400.
+ * Instead of silently truncating the tail (which loses the current task), we
+ * keep the first user request and the most recent turns, and shrink the middle
+ * into short summaries with an explicit marker.
+ *
+ * Token counts are approximated at 4 characters per token. That is deliberately
+ * crude: it must work for every provider without a tokenizer dependency.
+ */
+import type { ChatMessage } from "../types.js";
+
+export interface CompactOptions {
+    /** Character budget for the whole history (default 400k ≈ 100k tokens). */
+    maxChars?: number;
+    /** Number of trailing messages to keep verbatim. */
+    keepRecent?: number;
+    /** Maximum characters kept from one old tool result. */
+    toolSummaryChars?: number;
+}
+
+export interface CompactResult {
+    messages: ChatMessage[];
+    compacted: boolean;
+    beforeChars: number;
+    afterChars: number;
+}
+
+const TOOL_MARKER = "FastCode executed the requested local tools.";
+
+export function historyChars(messages: ChatMessage[]): number {
+    return messages.reduce((sum, message) => sum + (message.content?.length ?? 0), 0);
+}
+
+export function compactHistory(messages: ChatMessage[], options: CompactOptions = {}): CompactResult {
+    const beforeChars = historyChars(messages);
+    const maxChars = positive(options.maxChars, 400_000);
+    const keepRecent = Math.max(2, Math.floor(positive(options.keepRecent, 6)));
+    const toolSummaryChars = Math.max(200, Math.floor(positive(options.toolSummaryChars, 2_000)));
+    if (beforeChars <= maxChars || messages.length <= keepRecent + 1) {
+        return { messages, compacted: false, beforeChars, afterChars: beforeChars };
+    }
+    // Keep the original request (usually the first message) plus the newest
+    // turns. Everything between is summarized, never dropped without a marker.
+    const head = messages[0]?.role === "user" ? [messages[0]] : [];
+    const tailStart = Math.max(head.length, messages.length - keepRecent);
+    const middle = messages.slice(head.length, tailStart);
+    const summarized = middle.map((message) => ({
+        role: message.role,
+        content: summarizeMessage(message.content, toolSummaryChars),
+    }));
+    const marker: ChatMessage = {
+        role: "system",
+        content: `[context compacted: ${middle.length} earlier message(s) were summarized to stay within the context window. ` +
+            `Recent tool results are kept in full. If an earlier detail is missing, re-read that file with a tool.]`,
+    };
+    const next = [...head, marker, ...summarized, ...messages.slice(tailStart)];
+    return {
+        messages: next,
+        compacted: true,
+        beforeChars,
+        afterChars: historyChars(next),
+    };
+}
+
+function summarizeMessage(content: string, limit: number): string {
+    if (!content)
+        return content;
+    if (content.includes(TOOL_MARKER))
+        return summarizeToolMessage(content, limit);
+    if (content.length <= limit)
+        return content;
+    const head = content.slice(0, Math.floor(limit * 0.6));
+    const tail = content.slice(-Math.floor(limit * 0.3));
+    return `${head}\n[… ${content.length - head.length - tail.length} chars summarized …]\n${tail}`;
+}
+
+/**
+ * Tool results have the shape:
+ *   FastCode executed ...\n\nTool result 1 (ok)\ncall: {...}\noutput:\n```...```
+ * Keep the call and the start/end of each output so file paths and errors
+ * survive compaction.
+ */
+function summarizeToolMessage(content: string, limit: number): string {
+    if (content.length <= limit)
+        return content;
+    const keep = Math.max(120, Math.floor((limit - 240) / 2));
+    const head = content.slice(0, keep);
+    const tail = content.slice(-keep);
+    return `${head}\n[… ${content.length - keep * 2} chars of tool output summarized; re-run the tool if you need the middle …]\n${tail}`;
+}
+
+function positive(value: number | undefined, fallback: number): number {
+    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : fallback;
+}