atom-agent 1.2.0 → 1.4.0

package/dist/cli.js

@@ -4,8 +4,13 @@ import { render } from "ink";
 import { App } from "./App.js";
 import { DEFAULT_ENDPOINT, DEFAULT_MODEL, endpointConfig, } from "./zen.js";
 import { loadAuth, resolveApiKey } from "./auth.js";
+import { parseExtensionFlags } from "./extensions.js";
 import { writeTelemetryDashboard } from "./telemetry-dashboard.js";
 const args = process.argv.slice(2);
+// Extension trust lockdown (ticket 07): --no-extensions (--lockdown alias)
+// boots with zero third-party extensions; --enable/--disable-extension take
+// repeatable `*`/`?` patterns over extension names (CLI wins over atom.json).
+const extFlags = parseExtensionFlags(args);
 if (args.includes("--dashboard")) {
     // Local observability dashboard without starting the TUI: render every
     // stored session to ~/.atom/telemetry/dashboard.html and print the path.
@@ -54,15 +59,18 @@ else if (args.includes("--help") || args.includes("-h")) {
 Usage: npm start
 Flags: --dashboard (write ~/.atom/telemetry/dashboard.html and exit)
        --serve [--port <n>] (serve the live dashboard webUI on loopback and keep running)
+       --no-extensions (--lockdown alias: boot with zero third-party extensions; builtins unchanged)
+       --enable-extension <glob> (repeatable; only matching extensions load)
+       --disable-extension <glob> (repeatable; wins over --enable-extension)
 Env:
   KILO_API_KEY  optional (Kilo free models work anonymously; get a key at https://kilo.ai) — env wins over ~/.atom/auth.json
   OPENCODE_ZEN_API_KEY  optional when ~/.atom/auth.json has a zen key (get one at https://opencode.ai/auth)
   OPENAI_API_KEY / ANTHROPIC_API_KEY / DEEPSEEK_API_KEY / MISTRAL_API_KEY / GEMINI_API_KEY (GOOGLE_API_KEY alias)  optional per provider (env wins over stored)
   OPENCODE_ZEN_MODEL    optional (default: ${DEFAULT_MODEL}; when set, wins over the saved /model)
   OPENCODE_ZEN_ENDPOINT optional (default: ${DEFAULT_ENDPOINT})
- Commands: /model (model picker) | /models [refresh] (local discovery refresh; Kilo catalog refresh when Kilo is active) | /provider (provider + key picker) | /effort (reasoning-effort picker) | /tools | /skills (list installed skills) | /skill:name (invoke) | /context (context usage) | /queue + /steer (follow-ups while busy) | /autoscroll (toggle follow new output) | /thinking (toggle reasoning visibility) | /mode | /clear | /new (fresh conversation, previous kept) | /rename <name> (rename current session) | /session (switch session picker) | /resume (restore last saved session) | /help | /exit | /quit — Tab cycles the permission mode normal → yolo → plan
+ Commands: /model (model picker) | /models [refresh] (local discovery refresh; Kilo catalog refresh when Kilo is active) | /provider (provider + key picker) | /effort (reasoning-effort picker) | /goal <objective> (pin one session objective; bare shows it, pause/resume/clear manage it) | /compact [focus] (summarize older turns) | /tools | /skills (list installed skills) | /skill:name (invoke) | /context (context usage) | /queue + /steer (follow-ups while busy) | /autoscroll (toggle follow new output) | /thinking (toggle reasoning visibility) | /mode | /trust | /allow | /deny | /rules | /clear | /new (fresh conversation, previous kept) | /rename <name> (rename current session) | /session (switch session picker) | /resume (restore last saved session) | /telemetry | /dashboard | /rewind | /help | /exit | /quit — Tab cycles the permission mode normal → yolo → plan → normal (extension slash commands appear in the / menu and palette, not in this static list)
 Providers: kilo (default; anonymous free models, key optional)/opencode-zen/openai/anthropic/deepseek/mistral/google-gemini/openai-compatible (keys in ~/.atom/auth.json, 0600 POSIX; use /provider to paste one) + local auto-discovery: ollama (:11434), lmstudio (:1234), llamacpp (:8080) — no keys needed, overrides via ATOM_OLLAMA_URL/ATOM_LMSTUDIO_URL/ATOM_LLAMACPP_URL.
-Note: reasoning_effort is sent only for opencode-zen supported models.`);
+Effort (Auto/Low/Medium/High/Max) applies on every provider: reasoning_effort for OpenAI-chat kinds, thinking budgets for Anthropic, thinking levels for Gemini. Auto omits the knob.`);
     process.exit(0);
 }
 const { endpoint, apiKey: envKey } = endpointConfig();
@@ -96,7 +104,7 @@ if (!args.includes("--serve")) {
     // - concurrent: enables React concurrent features (useTransition /
     //   useDeferredValue) for future deferral of expensive subtrees.
     // Tests are unaffected: they render via ink-testing-library, not here.
-    render(_jsx(App, { apiKey: apiKey, endpoint: endpoint, initialModel: envModel, restorePrefs: true }), {
+    render(_jsx(App, { apiKey: apiKey, endpoint: endpoint, initialModel: envModel, restorePrefs: true, extensionsLockdown: extFlags.lockdown, enableExtensions: extFlags.enable, disableExtensions: extFlags.disable }), {
         incrementalRendering: process.env.ATOM_INCREMENTAL !== "0",
         maxFps: 30,
         concurrent: true,

package/dist/compact.js

@@ -8,7 +8,7 @@
 //   by the summary; manual `/compact [focus]`; thrashing guard.
 // - opencode V2: preflight estimate = JSON-serialized request size at
 //   4 chars/token; summary via session model with TOOLS DISABLED, ≤4096
-//   output tokens, structured template; newest tail retained (~8000 tokens,
+//   output tokens, structured template; newest tail retained (~20000 tokens,
 //   tool outputs capped 2000 chars); overflow-recovery retry once.
 //
 // This module is pure + testable (mocked fetch only in tests, never live).
@@ -23,7 +23,7 @@ import { estimateTokensForChars, messageChars } from "./context-manager.js";
 import { truncateHead } from "./tools/shared.js";
 export { COMPACT_PCT_DEFAULT, compactPct, computeContextLoad, estimateTokensForChars, historyChars, shouldAutoCompact, } from "./context-manager.js";
 // ---- Constants ----
-export const COMPACT_KEEP_TOKENS = 8000;
+export const COMPACT_KEEP_TOKENS = 20000;
 export const COMPACT_SUMMARY_MAX_TOKENS = 4096;
 export const COMPACT_TOOL_OUTPUT_CAP = 2000;
 // opencode's 4ch/token heuristic (V2 preflight estimate): chars/4 floors to
@@ -103,7 +103,7 @@ export function splitHistoryForCompaction(history, keepTokens = COMPACT_KEEP_TOK
     // Everything fits but >1 turn: keep only the newest turn in the tail so
     // manual /compact still has an older turn to summarize (auto never
     // reaches here — its load would be far below threshold when everything
-    // fits in 8000 tokens).
+    // fits in 20000 tokens).
     if (tailStart === starts[0] && starts.length > 1) {
         tailStart = starts[starts.length - 1];
     }
@@ -117,28 +117,38 @@ export function splitHistoryForCompaction(history, keepTokens = COMPACT_KEEP_TOK
     return { head, tail, olderTurnCount };
 }
 // ---- Instruction template ----
-export function buildCompactionInstruction(focusText) {
+// goalObjective (ticket 08) is a prompt hint only: when a session goal is
+// live, the summarizer is told to preserve goal-relevant progress, evidence,
+// and next steps inside its prose (the canonical `Goal:` block is appended
+// separately after the POST). Absent/blank reads exactly as before, so
+// non-goal compaction output stays byte-identical.
+export function buildCompactionInstruction(focusText, goalObjective) {
     const focus = typeof focusText === "string" && focusText.trim().length > 0
         ? `\nFocus for this summary: ${focusText.trim()}\n`
         : "";
+    const goal = typeof goalObjective === "string" && goalObjective.trim().length > 0
+        ? `\nSession goal to preserve: "${goalObjective.trim()}" — keep goal-relevant progress, ` +
+            `evidence, and next steps for it in the summary so the next turn can continue it ` +
+            `without re-exploring.\n`
+        : "";
     return (`Summarize the conversation so far for context compaction. Be concise but preserve all information needed to continue the work without re-reading the full history.` +
-        `${focus}\n` +
+        `${focus}${goal}\n` +
         `Structure your summary with these headings (omit a section only when it has no content):\n` +
         `## Objective\n` +
-        `## Requirements\n` +
-        `## Decisions\n` +
-        `## Completed work\n` +
-        `## Active work\n` +
-        `## Blockers\n` +
-        `## Next moves\n` +
-        `## Relevant files\n` +
+        `## Important Details\n` +
+        `## Work State\n` +
+        `### Completed\n` +
+        `### Active\n` +
+        `### Blocked\n` +
+        `## Next Move\n` +
+        `## Relevant Files\n` +
         `Rules: no tools are available for this request — answer with the summary text only, no tool calls, no preamble beyond the headings.`);
 }
-export function buildSummaryMessages(systemContent, head, focusText) {
+export function buildSummaryMessages(systemContent, head, focusText, goalObjective) {
     return [
         { role: "system", content: systemContent },
         ...head.map((m) => ({ ...m })),
-        { role: "user", content: buildCompactionInstruction(focusText) },
+        { role: "user", content: buildCompactionInstruction(focusText, goalObjective) },
     ];
 }
 export function buildCompactedHistory(systemMessage, summaryText, tail, olderTurnCount, nowISO) {
@@ -193,7 +203,7 @@ export function truncateHeadForRetry(head) {
 // throw immediately with history untouched (caller must not swap).
 export async function requestCompactSummary(req) {
     const attempt = async (head) => {
-        const messages = buildSummaryMessages(req.systemContent, head, req.focusText);
+        const messages = buildSummaryMessages(req.systemContent, head, req.focusText, req.goalObjective);
         const res = await chatCompletionForProvider(req.provider, req.apiKey, req.model, messages, {
             baseURL: req.baseURL,
             endpointOverride: req.endpointOverride,
@@ -335,6 +345,22 @@ export function fitSummaryWithFiles(summaryText, touched, maxChars = COMPACT_SUM
         return { text: summaryText, truncated };
     return { text: `${summaryText}\n\n${shrunkBlock}`, truncated };
 }
+// ---- Goal block fitting (ticket 08) ----
+// Append the canonical `Goal:` block plus the touched-files lists within one
+// shared budget: the goal block rides with the model text (never shrunk — it
+// is one short line plus a capped checklist tail, see formatGoalForCompact),
+// so only the touched-files lists shrink via the same rule above. The goal
+// block lands BEFORE the files block, keeping `Touched files:` last so its
+// verbatim extractor (lastIndexOf below) still finds the appended block. An
+// empty goal block degrades exactly to fitSummaryWithFiles (non-goal output
+// byte-identical); an over-budget summary still stands alone and compaction
+// still succeeds.
+export function fitSummaryWithFilesAndGoal(summaryText, touched, goalBlock, maxChars = COMPACT_SUMMARY_MAX_CHARS) {
+    const base = typeof goalBlock === "string" && goalBlock.length > 0
+        ? `${summaryText}\n\n${goalBlock}`
+        : summaryText;
+    return fitSummaryWithFiles(base, touched, maxChars);
+}
 // ---- Resume surfacing ----
 // Pull the stored block(s) verbatim out of compacted summary messages — the
 // same format as stored, no reformatting. lastIndexOf prefers the appended

package/dist/config.js

@@ -19,13 +19,15 @@
 // Keys:
 // - provider: ProviderId for first-run default (needs its key, else zen)
 // - model: default model id (non-empty string)
-// - reasoningEffort: default/low/medium/high/max
-// - maxHistoryMessages: 10–1000 (message-count safety ceiling)
-// - maxHistoryChars: 10_000–2_000_000 (char safety ceiling — caps the
-//   window-derived budget, never the primary limit)
+// - reasoningEffort: auto/low/medium/high/max ("default" is accepted as a
+//   deprecated alias for "auto")
 // - maxToolSteps: 5–100 (tool rounds per turn)
 // - compactPct: 50–95 (auto-compact percent of verified window)
 // - telemetry: {enabled?: boolean} (local observability recording, default on)
+// - extensions: {enabled?: string[], disabled?: string[]} (per-extension
+//   enable/disable patterns over the extension name, `*`/`?` globs; disabled
+//   wins over enabled, non-empty enabled is an allowlist — see extensions.ts
+//   precedence. CLI --enable/--disable-extension wins over this when set.)
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
 import { homeDir } from "./auth.js";
@@ -35,7 +37,11 @@ export const ATOM_CONFIG_FILENAME = "atom.json";
 // Kept local (not imported from zen.js) so config.ts has no runtime import
 // of zen.js — zen.js imports loadAtomConfig for budget fallbacks, and a
 // runtime cycle would be fragile. Mirrors EFFORT_OPTIONS exactly.
-const EFFORT_VALUES = ["default", "low", "medium", "high", "max"];
+const EFFORT_VALUES = ["auto", "low", "medium", "high", "max"];
+// Pre-auto name for the same level (old atom.json files keep working).
+const LEGACY_EFFORT_VALUES = {
+    default: "auto",
+};
 export function projectConfigPath(projectDir) {
     return path.join(projectDir ?? process.cwd(), ATOM_CONFIG_FILENAME);
 }
@@ -106,13 +112,14 @@ function parseLevel(filePath, label) {
         if (typeof effort === "string" && EFFORT_VALUES.includes(effort)) {
             config.reasoningEffort = effort;
         }
+        else if (typeof effort === "string" && effort in LEGACY_EFFORT_VALUES) {
+            config.reasoningEffort = LEGACY_EFFORT_VALUES[effort];
+        }
         else {
             bad("reasoningEffort", `must be one of ${EFFORT_VALUES.join("/")}`);
         }
     }
     const ranged = [
-        { key: "maxHistoryMessages", min: 10, max: 1000 },
-        { key: "maxHistoryChars", min: 10_000, max: 2_000_000 },
         { key: "maxToolSteps", min: 5, max: 100 },
         { key: "compactPct", min: 50, max: 95 },
     ];
@@ -158,6 +165,35 @@ function parseLevel(filePath, label) {
             }
         }
     }
+    // Per-extension patterns (ticket 07): validated arrays of non-empty
+    // strings; a non-array key is ignored wholesale, bad entries are dropped
+    // with a warning (never throw, like every other key here).
+    const extensions = data["extensions"];
+    if (extensions !== undefined) {
+        if (!isRecord(extensions)) {
+            warnings.push(`${label} atom.json: ignoring invalid "extensions" (must be an object)`);
+        }
+        else {
+            const parsed = {};
+            for (const key of ["enabled", "disabled"]) {
+                const v = extensions[key];
+                if (v === undefined)
+                    continue;
+                if (!Array.isArray(v)) {
+                    warnings.push(`${label} atom.json: ignoring invalid "extensions.${key}" (must be an array of patterns)`);
+                    continue;
+                }
+                const kept = v.filter((e) => typeof e === "string" && e.length > 0);
+                if (kept.length !== v.length) {
+                    warnings.push(`${label} atom.json: "extensions.${key}" dropped ${v.length - kept.length} empty/non-string pattern(s)`);
+                }
+                parsed[key] = kept;
+            }
+            if (parsed.enabled !== undefined || parsed.disabled !== undefined) {
+                config.extensions = parsed;
+            }
+        }
+    }
     return { config, warnings, present: true };
 }
 export function loadAtomConfig(projectDir, homeDir) {

package/dist/context-manager.js

@@ -2,7 +2,6 @@
 //   - How much context is available?      (budget())
 //   - How much is currently used?         (usage())
 //   - Should we compact?                  (needsCompaction())
-//   - What messages should be sent?       (trimForSend())
 //
 // Budget derivation (no fixed-200K assumption): the history allowance comes
 // from the model's ACTUAL verified context window:
@@ -12,20 +11,18 @@
 //
 // measured in tokens via the shared 4ch/token estimator. A model with a 1M
 // window therefore gets ~1M of usable history instead of ~50K tokens.
+// Models with NO verified window report no allowance (a window is never
+// invented; auto-compact stays off for them).
 //
-// Hard safety ceiling (configurable, never primary): env ATOM_MAX_HISTORY_*
-// and atom.json maxHistory* still resolve through historyCharSource /
-// historyMessageSource. The ceiling only ever CAPS the derived budget — with
-// nothing configured it never binds for known-window models. Models with NO
-// verified window keep the legacy 200K-char / 100-message behavior exactly
-// (a window is never invented; auto-compact stays off for them).
+// History itself is NEVER truncated: there are no message/char caps.
+// Compaction (manual /compact, auto at ~83% of the verified window) is the
+// only pressure valve — Pi-style.
 //
 // Layering: this module owns measurement + budget math. It imports
-// context-windows (metadata) and config (file fallback) at runtime, and
-// zen.js types ONLY (no runtime cycle — zen.ts imports this module for its
-// loop trim). The agent loop, compaction mechanics, and providers are
-// untouched: truncateHistory/shouldAutoCompact/compactPct keep working via
-// re-exports from their original modules.
+// context-windows (metadata) and config (file fallback for compactPct) at
+// runtime, and zen.js types ONLY (no runtime cycle — zen.ts imports this
+// module for context math). The agent loop, compaction mechanics, and
+// providers are untouched.
 //
 // Prompt-caching foundation (NOT implemented): all inputs here are explicit
 // values (system/tools/history split, measured sizes, stable options), so a
@@ -72,8 +69,10 @@ export function historyChars(history) {
         total += messageChars(m);
     return total;
 }
-// Load = last POST's reported prompt_tokens when available, else the
-// 4ch/token estimate of the sent history chars.
+// Load = last POST's reported input-side tokens (prompt_tokens, normalized at
+// parse time to include exclusive prefix-cache counters like Anthropic's
+// cache_read/_creation) when available, else the 4ch/token estimate of the
+// sent history chars.
 export function computeContextLoad(lastPromptTokens, sentHistoryChars) {
     if (typeof lastPromptTokens === "number" &&
         Number.isFinite(lastPromptTokens) &&
@@ -82,51 +81,6 @@ export function computeContextLoad(lastPromptTokens, sentHistoryChars) {
     }
     return estimateTokensForChars(sentHistoryChars);
 }
-// ---- Safety-ceiling sources (env > atom.json > compiled default) ----
-export const MAX_HISTORY_MESSAGES = 100;
-export const MAX_HISTORY_CHARS = 200_000;
-function clampInt(n, min, max) {
-    return Math.min(Math.max(Math.floor(n), min), max);
-}
-function envInt(raw) {
-    if (raw === undefined)
-        return undefined;
-    const text = raw.trim();
-    if (!/^\d+$/.test(text))
-        return undefined;
-    const n = Number(text);
-    return Number.isFinite(n) ? Math.floor(n) : undefined;
-}
-// Message-count ceiling source. `explicit` tells whether a human configured
-// it (env or file) as opposed to the compiled default.
-export function historyMessageSource() {
-    const env = envInt(process.env.ATOM_MAX_HISTORY_MESSAGES);
-    if (env !== undefined)
-        return { value: clampInt(env, 10, 1000), explicit: true };
-    const file = loadAtomConfig().config.maxHistoryMessages;
-    if (file !== undefined)
-        return { value: file, explicit: true };
-    return { value: MAX_HISTORY_MESSAGES, explicit: false };
-}
-// Char-count safety ceiling source. Same explicit contract.
-export function historyCharSource() {
-    const env = envInt(process.env.ATOM_MAX_HISTORY_CHARS);
-    if (env !== undefined)
-        return { value: clampInt(env, 10_000, 2_000_000), explicit: true };
-    const file = loadAtomConfig().config.maxHistoryChars;
-    if (file !== undefined)
-        return { value: file, explicit: true };
-    return { value: MAX_HISTORY_CHARS, explicit: false };
-}
-// Legacy accessors (env → file → default). Kept for the loop's legacy path
-// and existing callers; the manager uses the sources above so it can tell
-// configured ceilings apart from defaults.
-export function historyMessageBudget() {
-    return historyMessageSource().value;
-}
-export function historyCharBudget() {
-    return historyCharSource().value;
-}
 // ---- Compaction threshold (moved here: the manager owns "should compact") ----
 export const COMPACT_PCT_DEFAULT = 0.83;
 function clampPctPercent(n) {
@@ -159,135 +113,20 @@ export function shouldAutoCompact(load, model, pctOverride) {
         : compactPct();
     return load / window >= pct;
 }
-// Searchable text for todo matching: message content plus the assistant's
-// tool_calls payload (todowrite CALLS carry the list, tool RESULTS echo it).
-// Tool call ids are NOT searched — they are pairing keys, not goal text, so
-// a todo that reads like an id can never false-pin a turn.
-function todoHaystack(m) {
-    let hay = "";
-    const content = m.content;
-    if (typeof content === "string")
-        hay += content;
-    if (m.role === "assistant" && m.tool_calls !== undefined) {
-        try {
-            hay += JSON.stringify(m.tool_calls);
-        }
-        catch {
-            // unstringifiable payload pins nothing
-        }
-    }
-    return hay;
-}
-function turnMentionsTodo(history, start, end, needles) {
-    for (let i = start; i < end; i++) {
-        const hay = todoHaystack(history[i]);
-        if (hay.length === 0)
-            continue;
-        for (const n of needles) {
-            if (n.length > 0 && hay.includes(n))
-                return true;
-        }
-    }
-    return false;
-}
-// Drop oldest user-turns until history fits BOTH caps (message count AND
-// total chars, each plus the caller's `reserve` headroom for a message it is
-// about to push). A user turn = the `user` message plus all following
-// messages up to (excluding) the next `user` message, so assistant
-// tool_calls always stay paired with their tool results across all three
-// wire formats. NEVER drops history[0] (system prompt), the first user turn
-// (the task prompt — the goal a long run must never forget), any turn that
-// still quotes a CURRENT open todo, or the latest turn (the one being
-// sent/built). Budget-aware edge: when the pinned content alone (first turn
-// + todo turns + latest) already exceeds a cap, there is nothing left to
-// drop — stop and still send (same never-drop-the-live-turn principle).
-// Mutates `history` in place via splice (so caller indices captured after
-// this call stay valid) and, when at least one turn dropped, fires ONE
-// `notify` (the caller surfaces it dim in the TUI); silence otherwise.
-// Returns what was dropped.
-export function truncateHistoryWithCaps(history, caps, opts) {
-    const result = { droppedTurns: 0, droppedMessages: 0 };
-    if (history.length <= 1)
-        return result;
-    const maxMessages = caps.maxMessages;
-    const maxChars = caps.maxChars;
-    const reserve = opts?.reserve;
-    const needles = opts?.todoNeedles ?? [];
-    const roomMessages = reserve?.messages !== undefined && Number.isFinite(reserve.messages)
-        ? Math.max(0, Math.floor(reserve.messages))
-        : 0;
-    const roomChars = reserve?.chars !== undefined && Number.isFinite(reserve.chars)
-        ? Math.max(0, reserve.chars)
-        : 0;
-    for (;;) {
-        const over = history.length + roomMessages > maxMessages ||
-            historyChars(history) + roomChars > maxChars;
-        if (!over)
-            break;
-        // Turn boundaries over history[1..]: each turn starts at a `user`
-        // message (the oldest slice starts at 1 even when it isn't one, matching
-        // the pre-pin drop unit). Whole-turn drops keep assistant/tool pairing.
-        const starts = [1];
-        for (let i = 2; i < history.length; i++) {
-            if (history[i]?.role === "user")
-                starts.push(i);
-        }
-        // Oldest NON-pinned, non-latest turn goes first: the first turn (task
-        // prompt) and any turn still quoting a current open todo stay, and the
-        // latest turn is never dropped. No candidate means pinned content alone
-        // is over budget — stop and send it as-is (see edge above).
-        let drop = -1;
-        for (let t = 0; t < starts.length; t++) {
-            if (t === starts.length - 1)
-                continue; // latest turn
-            if (t === 0)
-                continue; // task prompt
-            const end = t + 1 < starts.length ? starts[t + 1] : history.length;
-            if (needles.length > 0 && turnMentionsTodo(history, starts[t], end, needles))
-                continue;
-            drop = t;
-            break;
-        }
-        if (drop === -1)
-            break;
-        const end = drop + 1 < starts.length ? starts[drop + 1] : history.length;
-        const removed = history.splice(starts[drop], end - starts[drop]);
-        result.droppedTurns += 1;
-        result.droppedMessages += removed.length;
-    }
-    if (result.droppedTurns > 0) {
-        try {
-            opts?.notify?.(`(history truncated: dropped ${result.droppedTurns} oldest turn(s))`);
-        }
-        catch {
-            // observer errors never break the loop
-        }
-    }
-    return result;
-}
 // ---- Budget derivation ----
 // Expected completion/output reserve: one full summary-sized generation must
 // always fit alongside history (mirrors the compaction output cap).
 export const OUTPUT_RESERVE_TOKENS = 4096;
-// Safety headroom below the raw window: the trim cap never plans to use the
+// Safety headroom below the raw window: the budget never plans to use the
 // last 5% (auto-compact at ~83% fires long before this matters — the margin
-// is the last defense, not the trigger).
+// is informational, not a trigger).
 export const SAFETY_MARGIN_PCT = 0.05;
-// Default safety ceiling when nothing is configured AND no window is known
-// (the legacy 200K-char budget, preserved byte-for-byte as fallback).
-export const HARD_CEILING_FLOOR_CHARS = 200_000;
 export function createContextManager(opts) {
     const model = opts.model;
     const toolsChars = opts.toolsChars ?? 0;
     const reserveTokens = opts.outputReserveTokens ?? OUTPUT_RESERVE_TOKENS;
     const marginPct = opts.safetyMarginPct ?? SAFETY_MARGIN_PCT;
     const pct = opts.compactPct ?? compactPct();
-    function ceilingChars() {
-        if (opts.hardCeilingChars !== undefined) {
-            return { value: opts.hardCeilingChars, explicit: opts.hardCeilingExplicit ?? true };
-        }
-        return historyCharSource();
-    }
     function budget(history) {
         const window = contextWindowFor(model);
         const stats = ledgerStats(history);
@@ -298,18 +137,6 @@ export function createContextManager(opts) {
             ? Math.max(0, window - systemTokens - toolsTokens - reserveTokens - margin)
             : undefined;
         const historyCharsCap = historyTokens !== undefined ? historyTokens * CHARS_PER_TOKEN : undefined;
-        const ceil = ceilingChars();
-        const ceilMsgs = opts.hardCeilingMessages ?? historyMessageSource().value;
-        // The ceiling only ever CAPS: with nothing configured the derived budget
-        // rules (large windows stay usable); an explicit ceiling still binds as
-        // the safety net it is. Unknown windows fall back to the legacy floor.
-        const effectiveMaxChars = historyCharsCap !== undefined
-            ? ceil.explicit
-                ? Math.min(historyCharsCap, ceil.value)
-                : historyCharsCap
-            : ceil.explicit
-                ? ceil.value
-                : HARD_CEILING_FLOOR_CHARS;
         return {
             windowTokens: window,
             systemTokens,
@@ -318,11 +145,6 @@ export function createContextManager(opts) {
             safetyMarginTokens: margin,
             historyTokens,
             historyChars: historyCharsCap,
-            hardCeilingChars: ceil.value,
-            hardCeilingExplicit: ceil.explicit,
-            hardCeilingMessages: ceilMsgs,
-            effectiveMaxChars,
-            effectiveMaxMessages: ceilMsgs,
         };
     }
     function usage(history, lastPromptTokens) {
@@ -340,11 +162,7 @@ export function createContextManager(opts) {
     function needsCompaction(loadTokens) {
         return shouldAutoCompact(loadTokens, model, pct);
     }
-    function trimForSend(history, notify, reserve, todoNeedles = []) {
-        const b = budget(history);
-        return truncateHistoryWithCaps(history, { maxMessages: b.effectiveMaxMessages, maxChars: b.effectiveMaxChars }, { notify, reserve, todoNeedles });
-    }
-    return { model, budget, usage, needsCompaction, trimForSend };
+    return { model, budget, usage, needsCompaction };
 }
 const ledgerByRaw = new WeakMap();
 const ledgerByProxy = new WeakMap();

package/dist/context-windows.js

@@ -77,7 +77,9 @@ export function contextWindowFor(model) {
     return CONTEXT_WINDOWS[model];
 }
 // Total session tokens: prefer usage.total_tokens when present, else
-// prompt_tokens + completion_tokens (missing keys count as 0).
+// prompt_tokens + completion_tokens (missing keys count as 0). prompt_tokens
+// is normalized at parse time to total input-side tokens (exclusive
+// prefix-cache counters folded in), so both paths count cached context.
 export function totalTokens(usage) {
     if (typeof usage.total_tokens === "number") {
         return Math.max(0, Math.floor(usage.total_tokens));
@@ -90,7 +92,7 @@ export function totalTokens(usage) {
 // - no usage reported yet: `token: n/a` (never estimated)
 // - known window: `token: (P%) NK` (NK = round(total/1024) + "K" from the
 //   CUMULATIVE session spend; P = round(100*load/window) from the CURRENT
-//   context load — prompt_tokens of the last POST, else the 4ch/token
+//   context load — input-side tokens of the last POST, else the 4ch/token
 //   estimate. Cumulative spend keeps growing after compaction, so it must
 //   NOT drive P; load does. Pass load explicitly; when omitted it falls
 //   back to the cumulative total for backward compat.)

package/dist/env-block.js

@@ -3,11 +3,11 @@
 // timestamp.
 //
 // Placement: pinned to the SYSTEM message only (suffix to history[0]'s
-// content via withEnvBlock), NEVER into user content. history[0] is the only
-// slot truncateHistory never drops, so the block survives budget trimming.
-// Caching: the App refreshes history[0] once per turn in submit() (before the
-// budget check, so truncation accounts for it) — the loop's POSTs reuse the
-// same history[0], so git is shelled at most once per turn.
+// content via withEnvBlock), NEVER into user content. history[0] is the
+// system prompt, so the block survives every turn.
+// Caching: the App refreshes history[0] once per turn in submit() — the
+// loop's POSTs reuse the same history[0], so git is shelled at most once
+// per turn.
 // Failure-silent: missing git / non-repo cwd / timeout → the block shrinks
 // (cwd + node + time only), never throws, never blocks the turn. No new
 // dependencies; one cheap `git status` invocation with a short timeout, and