glm-acp-agent 1.7.0 → 1.8.0

package/README.md

@@ -24,12 +24,13 @@ Built-in web tools use Coding Plan-compatible MCP endpoints, not the general `/a
 
 ## Features
 
-- **Full ACP compliance** – implements `initialize`, `authenticate`, `session/new`, `session/set_mode`, `session/prompt`, `session/cancel`, `session/close`, `session/list`, `session/load`, `session/fork`, `session/resume`, and `session/set_model`
+- **Full ACP compliance** – implements `initialize`, `authenticate`, `session/new`, `session/set_mode`, `session/prompt`, `session/cancel`, `session/close`, `session/list`, `session/load`, `session/fork`, `session/resume`, and `session/set_model`, and pushes `session_info_update`, `config_option_update`, `current_mode_update`, and `available_commands_update` notifications
 - **Streaming** – assistant text and reasoning tokens are forwarded as incremental ACP chunks
 - **Tool calling** – agentic loop with a configurable cap of GLM function-calling turns (default 20; see `ACP_GLM_MAX_TURNS` / `--max-turns`)
 - **Thinking mode** – GLM's `reasoning_content` tokens are surfaced as `agent_thought_chunk` blocks so the client can show the model's chain of thought
 - **Session permission modes** – supports `default`, `accept_edits`, and `bypass_permissions` via `session/set_mode`. Clients like DevFlow can use this to toggle between prompting for every edit, auto-approving edits while prompting for commands, or bypassing permissions entirely.
 - **Per-session model switching** – `session/set_model` lets clients change the active GLM model mid-conversation; `session/new` returns the curated `availableModels` list
+- **Slash commands** – commands and skills found under the session's `.claude/` directory are advertised to the client with `available_commands_update`, so `/` autocomplete is populated (see [Slash commands](#slash-commands))
 - **Image input via Coding Plan-native vision or Vision MCP** – `promptCapabilities.image` is advertised; `glm-5.3-flash` sends supported pasted ACP image blocks directly as native `image_url` content parts, while the other advertised coding models (including default `glm-5.3`) route them through Z.AI Vision MCP (`@z_ai/mcp-server`). `glm-5v-turbo` keeps the same native-vision path when re-added via `ACP_GLM_AVAILABLE_MODELS` — it is no longer on the Coding Plan allowlist. Direct chat-image-only models (e.g. `glm-4v-plus`) are intentionally not used.
 - **Session persistence** – conversations are written to `~/.local/state/glm-acp-agent/sessions/` and can be reloaded via `session/load`, branched via `session/fork`, or resumed without replay via `session/resume`
 - **Seven built-in tools** (see below)
@@ -90,6 +91,36 @@ Reads, listings, and MCP tool calls are always silent across all modes.
 
 ---
 
+## Slash commands
+
+After `session/new`, `session/load`, `session/fork`, and `session/resume`, the agent
+sends an ACP [`available_commands_update`](https://agentclientprotocol.com/protocol/v2/slash-commands)
+notification. Clients such as Zed and Paseo use it to populate their `/` autocomplete.
+Each notification is a full snapshot that replaces the previous list.
+
+The snapshot is built from the same on-disk layout Claude Code uses, read from the
+session's working directory and from `~/.claude` for user-level definitions:
+
+| Path | Command name |
+|---|---|
+| `<cwd>/.claude/commands/commit.md` | `/commit` |
+| `<cwd>/.claude/commands/review/pr.md` | `/review:pr` |
+| `<cwd>/.claude/skills/audit/SKILL.md` | `/audit` |
+
+Project definitions shadow user-level ones with the same name. The `description`
+and `argument-hint` keys of a file's YAML frontmatter become the menu entry's
+description and input hint; without a `description`, the first heading (then the
+first line) of the body is used instead.
+
+Advertised names are sent **without** a leading slash — the client prepends it for
+display and invokes the command by sending `/name …` as ordinary prompt text. When
+that text names an advertised command, the agent injects the definition's body into
+the user message, substituting `$ARGUMENTS` where the file asks for it and otherwise
+appending the typed arguments. Unknown `/foo` is left untouched and reaches the model
+as prose, so typing a slash by accident never fails the turn.
+
+---
+
 ## Prerequisites
 
 - **Node.js** 20 or later (native `fetch` and Web Streams required)
@@ -386,6 +417,7 @@ src/
 ├── protocol/
 │   ├── connection.ts         # Sets up the ACP stdio connection
 │   ├── agent.ts              # GlmAcpAgent – ACP protocol implementation
+│   ├── slash-commands.ts     # Discovers .claude commands/skills; expands `/name`
 │   └── session-store.ts      # On-disk persistence for load/fork/resume
 ├── tools/
 │   ├── definitions.ts        # Tool JSON schemas (function-calling format)
@@ -395,6 +427,7 @@ src/
     ├── credentials.test.ts   # Credential resolution and --setup persistence
     ├── executor.test.ts      # Tests for ToolExecutor
     ├── glm-client.test.ts    # Tests for streaming / tool-call assembly
+    ├── slash-commands.test.ts # Command discovery and `/name` expansion
     └── integration.test.ts   # End-to-end tests over the real ACP ndjson transport
 ```
 

package/dist/protocol/agent.d.ts

@@ -58,6 +58,22 @@ export declare class GlmAcpAgent implements Agent {
     initialize(params: InitializeRequest): Promise<InitializeResponse>;
     authenticate(params: AuthenticateRequest): Promise<AuthenticateResponse>;
     newSession(params: NewSessionRequest): Promise<NewSessionResponse>;
+    /**
+     * Queue an `available_commands_update` snapshot for a session.
+     *
+     * The notification is the only channel ACP gives us for slash-command
+     * autocomplete — it is not part of any method's response — so every session
+     * entry point (create / load / fork / resume) has to send one.
+     *
+     * It is deliberately *deferred* rather than awaited inline: a client learns a
+     * session's id from the `session/new` / `session/fork` response, so a
+     * notification written ahead of that response arrives for a session the client
+     * has never heard of, and clients drop those. Sending on the next macrotask
+     * puts it behind the response the caller is about to return (and, on load,
+     * behind the replayed transcript), which is also when a client is ready to
+     * paint the menu. Each send replaces the previous list wholesale.
+     */
+    private scheduleAvailableCommands;
     unstable_setSessionModel(params: SetSessionModelRequest): Promise<SetSessionModelResponse>;
     /**
      * Switch a session to a new model id — shared by `session/set_model` and the

package/dist/protocol/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/protocol/agent.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/protocol/agent.ts"],"names":[],"mappings":"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"}

package/dist/protocol/agent.js

@@ -8,6 +8,7 @@ import { TOOL_DEFINITIONS } from "../tools/definitions.js";
 import { connectSessionMcpServers } from "../tools/session-mcp-client.js";
 import { SessionStore } from "./session-store.js";
 import { buildSystemPrompt } from "./system-prompt.js";
+import { discoverSlashCommands, parseSlashCommand, renderSlashCommand, } from "./slash-commands.js";
 import { preprocessImageBlocks, buildPromptBlockDiagnosticLines } from "./image-preprocessor.js";
 import { StdioVisionMcpClient } from "../tools/vision-mcp-client.js";
 import { resolveApiKey } from "../llm/credentials.js";
@@ -235,7 +236,10 @@ export class GlmAcpAgent {
             mcpTools,
             mode: "default",
             thoughtLevel,
+            commands: discoverSlashCommands(params.cwd),
+            displayText: new WeakMap(),
         });
+        this.scheduleAvailableCommands(sessionId);
         return {
             sessionId,
             models: this.modelsState(model),
@@ -243,6 +247,35 @@ export class GlmAcpAgent {
             configOptions: this.configOptionsState(model, thoughtLevel, "default"),
         };
     }
+    /**
+     * Queue an `available_commands_update` snapshot for a session.
+     *
+     * The notification is the only channel ACP gives us for slash-command
+     * autocomplete — it is not part of any method's response — so every session
+     * entry point (create / load / fork / resume) has to send one.
+     *
+     * It is deliberately *deferred* rather than awaited inline: a client learns a
+     * session's id from the `session/new` / `session/fork` response, so a
+     * notification written ahead of that response arrives for a session the client
+     * has never heard of, and clients drop those. Sending on the next macrotask
+     * puts it behind the response the caller is about to return (and, on load,
+     * behind the replayed transcript), which is also when a client is ready to
+     * paint the menu. Each send replaces the previous list wholesale.
+     */
+    scheduleAvailableCommands(sessionId) {
+        setTimeout(() => {
+            const session = this.sessions.get(sessionId);
+            if (!session)
+                return;
+            void safeSessionUpdate(this.connection, {
+                sessionId,
+                update: {
+                    sessionUpdate: "available_commands_update",
+                    availableCommands: availableCommandsState(session.commands),
+                },
+            });
+        }, 0);
+    }
     async unstable_setSessionModel(params) {
         const session = this.sessions.get(params.sessionId);
         if (!session) {
@@ -500,14 +533,28 @@ export class GlmAcpAgent {
                 debug(line);
             }
         }
+        // Clients invoke an advertised command by sending `/name …` as ordinary
+        // prompt text, so expand it here into the instructions its definition
+        // holds. Unknown `/foo` is left alone and reaches the model as prose.
+        const promptBlocks = expandPromptCommand(params.prompt, session.commands);
         const visionNative = isVisionNativeModel(session.model);
         const preprocessed = visionNative
-            ? { blocks: params.prompt, cleanups: [] }
-            : await preprocessImageBlocks(params.prompt, this.visionClient, abortController.signal);
-        const { content: userContent, plainText: userText } = visionNative
+            ? { blocks: promptBlocks, cleanups: [] }
+            : await preprocessImageBlocks(promptBlocks, this.visionClient, abortController.signal);
+        const userContent = visionNative
             ? renderVisionNativePromptBlocks(preprocessed.blocks)
-            : renderPromptBlocks(preprocessed.blocks);
-        session.messages.push({ role: "user", content: userContent });
+            : renderPromptBlocks(preprocessed.blocks).content;
+        const userMessage = { role: "user", content: userContent };
+        session.messages.push(userMessage);
+        // What the user typed, rendered from the blocks as they arrived — before
+        // command expansion and image analysis rewrote them for the model. Kept
+        // separately so `session/load` replays the conversation the user had (and
+        // the title names it), not the one the model saw. Persisted only when the
+        // two actually diverge.
+        const displayText = renderPromptBlocks(params.prompt).plainText;
+        if (displayText !== stringifyUserMessage(userContent)) {
+            session.displayText.set(userMessage, displayText);
+        }
         // Echo back the client-supplied messageId on every response (success,
         // cancelled, or error) so the client can correlate the turn.
         const userMessageId = params.messageId ?? undefined;
@@ -523,7 +570,10 @@ export class GlmAcpAgent {
             // updated timestamp so clients can show fresh metadata.
             const titleUpdate = session.title === null
                 ? (() => {
-                    const derived = userText.slice(0, 80).replace(/\s+/g, " ").trim();
+                    const derived = displayText
+                        .slice(0, 80)
+                        .replace(/\s+/g, " ")
+                        .trim();
                     session.title = derived.length > 0 ? derived : "New conversation";
                     return { title: session.title };
                 })()
@@ -659,12 +709,15 @@ export class GlmAcpAgent {
             mcpTools,
             mode: persisted.mode,
             thoughtLevel: resolveThoughtLevel(persisted.model, persisted.thoughtLevel ?? "max"),
+            commands: discoverSlashCommands(params.cwd),
+            displayText: deserializeDisplayText(persisted.messages, persisted.displayText),
         };
         this.sessions.set(params.sessionId, restored);
         // Replay user/assistant text turns so the client can rehydrate its UI.
         // Tool / system messages are skipped — they're internal and the client
         // doesn't render them on its own.
-        await this.replayMessages(params.sessionId, persisted.messages);
+        await this.replayMessages(params.sessionId, persisted.messages, restored.displayText);
+        this.scheduleAvailableCommands(params.sessionId);
         return {
             models: this.modelsState(persisted.model),
             modes: this.modesState(persisted.mode),
@@ -680,10 +733,11 @@ export class GlmAcpAgent {
         const toolDefinitions = this.availableToolDefinitions(mcpTools);
         const newSessionId = randomUUID();
         const forkedTitle = persisted.title === null ? null : `${persisted.title} (fork)`;
+        const forkedMessages = structuredClone(persisted.messages);
         const forked = {
             cwd: params.cwd,
             // Deep-clone messages so the fork doesn't share state with the parent.
-            messages: structuredClone(persisted.messages),
+            messages: forkedMessages,
             abortController: null,
             promptPromise: null,
             title: forkedTitle,
@@ -693,9 +747,16 @@ export class GlmAcpAgent {
             mcpTools,
             mode: persisted.mode,
             thoughtLevel: resolveThoughtLevel(persisted.model, persisted.thoughtLevel ?? "max"),
+            commands: discoverSlashCommands(params.cwd),
+            // Re-key onto the cloned messages: the parent's map is keyed by the
+            // originals, which the fork no longer holds.
+            displayText: deserializeDisplayText(forkedMessages, persisted.displayText),
         };
         this.sessions.set(newSessionId, forked);
         this.persistSession(newSessionId, forked);
+        // Notify on the *created* session id — the parent thread's command list is
+        // unchanged and a notify there would repaint the wrong menu.
+        this.scheduleAvailableCommands(newSessionId);
         return {
             sessionId: newSessionId,
             models: this.modelsState(forked.model),
@@ -720,8 +781,11 @@ export class GlmAcpAgent {
             mcpTools,
             mode: persisted.mode,
             thoughtLevel: resolveThoughtLevel(persisted.model, persisted.thoughtLevel ?? "max"),
+            commands: discoverSlashCommands(params.cwd),
+            displayText: deserializeDisplayText(persisted.messages, persisted.displayText),
         };
         this.sessions.set(params.sessionId, restored);
+        this.scheduleAvailableCommands(params.sessionId);
         // Resume does NOT replay history — the client keeps its own UI state and
         // just wants the agent to pick up where it left off.
         return {
@@ -734,6 +798,7 @@ export class GlmAcpAgent {
     // Persistence helpers
     // ---------------------------------------------------------------------------
     snapshot(sessionId, session) {
+        const displayText = serializeDisplayText(session.messages, session.displayText);
         return {
             sessionId,
             cwd: session.cwd,
@@ -743,6 +808,9 @@ export class GlmAcpAgent {
             model: session.model,
             mode: session.mode,
             thoughtLevel: session.thoughtLevel,
+            // Absent for the common case where nothing diverges, so an ordinary
+            // session gains no on-disk weight.
+            ...(displayText ? { displayText } : {}),
         };
     }
     persistSession(sessionId, session) {
@@ -766,10 +834,10 @@ export class GlmAcpAgent {
         }
         return persisted;
     }
-    async replayMessages(sessionId, messages) {
+    async replayMessages(sessionId, messages, displayText) {
         for (const msg of messages) {
             if (msg.role === "user") {
-                const text = stringifyUserMessage(msg.content);
+                const text = displayText.get(msg) ?? stringifyUserMessage(msg.content);
                 if (text.length === 0)
                     continue;
                 await this.connection.sessionUpdate({
@@ -884,7 +952,9 @@ export class GlmAcpAgent {
                 if (isOverflow && overflowRetryCount < 1) {
                     debug(`promptLoop: context overflow (1261) detected, performing emergency compaction`);
                     const window = getContextWindow(session.model);
-                    session.messages = compactMessages(session.messages, Math.floor(window * 0.7));
+                    session.messages = compactMessages(session.messages, Math.floor(window * 0.7), {
+                        force: true,
+                    });
                     overflowRetryCount++;
                     retryTurn = true;
                 }
@@ -1005,7 +1075,8 @@ function renderPromptBlocks(blocks) {
                 break;
             }
             case "image": {
-                // Defensive: image blocks should have been preprocessed away upstream.
+                // Only the display-text pass sees these; the model-facing pass has had
+                // its images preprocessed into `<image_analysis>` annotations upstream.
                 textParts.push(`[image: ${block.mimeType}]`);
                 break;
             }
@@ -1021,13 +1092,11 @@ function renderPromptBlocks(blocks) {
 }
 function renderVisionNativePromptBlocks(blocks) {
     const content = [];
-    const plainTextParts = [];
     let imageIndex = 0;
     const pushText = (text) => {
         if (text.length === 0)
             return;
         content.push({ type: "text", text });
-        plainTextParts.push(text);
     };
     for (const block of blocks) {
         switch (block.type) {
@@ -1052,7 +1121,6 @@ function renderVisionNativePromptBlocks(blocks) {
                 const imageUrl = toVisionNativeImageUrl(block);
                 if (imageUrl) {
                     content.push({ type: "image_url", image_url: { url: imageUrl } });
-                    plainTextParts.push(`[image: ${block.mimeType}]`);
                 }
                 else {
                     pushText(`<image_unsupported_format index="${imageIndex}" mime="${escapeAttribute(block.mimeType)}">Only image/jpeg, image/jpg, image/png inputs can be sent to the native vision model. Attach a supported HTTPS image URL or supported base64 image data.</image_unsupported_format>`);
@@ -1066,7 +1134,7 @@ function renderVisionNativePromptBlocks(blocks) {
                 pushText(`[unknown block type ${block.type}]`);
         }
     }
-    return { content, plainText: plainTextParts.join("\n") };
+    return content;
 }
 function toVisionNativeImageUrl(block) {
     if (!isSupportedVisionMime(block.mimeType))
@@ -1105,6 +1173,36 @@ function escapeAttribute(value) {
         .replaceAll("<", "&lt;")
         .replaceAll(">", "&gt;");
 }
+/**
+ * Project the identity-keyed display map onto indices into `messages`, ready
+ * to persist. Returns `undefined` when nothing diverges so the field can be
+ * left off the record entirely.
+ */
+function serializeDisplayText(messages, displayText) {
+    let out;
+    for (const [index, message] of messages.entries()) {
+        const text = displayText.get(message);
+        if (text === undefined)
+            continue;
+        out ??= {};
+        out[String(index)] = text;
+    }
+    return out;
+}
+/** Rebuild the identity-keyed display map from a persisted index map. */
+function deserializeDisplayText(messages, persisted) {
+    const out = new WeakMap();
+    if (!persisted)
+        return out;
+    for (const [key, text] of Object.entries(persisted)) {
+        const message = messages[Number(key)];
+        // A hand-edited or truncated record can point past the end of the array;
+        // dropping the entry just falls back to replaying the stored content.
+        if (message)
+            out.set(message, text);
+    }
+    return out;
+}
 /** Flatten the `content` of a user message into a plain string for replay. */
 function stringifyUserMessage(content) {
     if (typeof content === "string")
@@ -1142,6 +1240,45 @@ function availableModelsWith(currentModelId) {
         ? available
         : [...available, { modelId: currentModelId, name: currentModelId }];
 }
+/**
+ * Map discovered commands onto the ACP wire shape. Names are sent *without* a
+ * leading slash — the client prepends it for display and sends `/name …` back
+ * as prompt text. `input` is omitted for commands that declare no
+ * `argument-hint`, which is how a client learns the command takes no extra text.
+ */
+function availableCommandsState(commands) {
+    return commands.map((command) => ({
+        name: command.name,
+        description: command.description,
+        ...(command.argumentHint !== undefined
+            ? { input: { hint: command.argumentHint } }
+            : {}),
+    }));
+}
+/**
+ * Expand a leading `/name` in the prompt's first written text into the
+ * command's body.
+ *
+ * The target is the first text block that actually has content, not block 0:
+ * a client may place an image or resource block ahead of what the user typed,
+ * and the command would otherwise reach the model as a literal `/name`.
+ *
+ * Returns the blocks unchanged when that text does not start with an
+ * advertised command. The caller keeps the original blocks around to derive
+ * the replay/title text, so nothing here needs to report the typed form back.
+ */
+function expandPromptCommand(blocks, commands) {
+    const index = blocks.findIndex((block) => block.type === "text" && block.text.trim().length > 0);
+    const typed = blocks[index];
+    if (typed?.type !== "text")
+        return blocks;
+    const parsed = parseSlashCommand(typed.text, commands);
+    if (!parsed)
+        return blocks;
+    const expanded = [...blocks];
+    expanded[index] = { ...typed, text: renderSlashCommand(parsed) };
+    return expanded;
+}
 /**
  * Read an `AGENTS.md` (preferred) or `CLAUDE.md` from the session's cwd, returning
  * its contents capped to {@link PROJECT_CONTEXT_CAP_CHARS} characters. Read errors
@@ -1176,13 +1313,26 @@ async function safeSessionUpdate(connection, params) {
         // best-effort
     }
 }
+/**
+ * Token cost charged to a single `image_url` content part.
+ *
+ * Vision-native GLM models tile an image into 14px patches and merge them 2x2,
+ * so a full-size input (capped at 1120x1120) costs (1120/14)^2 / 4 = 1600
+ * tokens. The wire form — an HTTPS URL or a base64 data URL — says nothing
+ * about the decoded dimensions, so charge every image that ceiling:
+ * over-counting only makes compaction fire early, while under-counting is what
+ * lets an image-heavy session sail past the window and get rejected.
+ */
+const IMAGE_PART_TOKENS = 1600;
 /**
  * Heuristically estimate the number of tokens in a list of messages.
  * Uses a simple 4-character-per-token rule, which is a safe baseline for
- * English and code.
+ * English and code, plus a flat per-image charge for native `image_url` parts
+ * (see {@link IMAGE_PART_TOKENS}).
  */
 function estimateTokens(messages) {
     let chars = 0;
+    let tokens = 0;
     for (const m of messages) {
         if (typeof m.content === "string") {
             chars += m.content.length;
@@ -1192,6 +1342,9 @@ function estimateTokens(messages) {
                 if ("text" in part && typeof part.text === "string") {
                     chars += part.text.length;
                 }
+                else if (part.type === "image_url") {
+                    tokens += IMAGE_PART_TOKENS;
+                }
             }
         }
         if (m.role === "assistant" && m.tool_calls) {
@@ -1203,7 +1356,7 @@ function estimateTokens(messages) {
             }
         }
     }
-    return Math.ceil(chars / 4);
+    return tokens + Math.ceil(chars / 4);
 }
 /**
  * Prune message history to stay within a target token limit.
@@ -1215,8 +1368,15 @@ function estimateTokens(messages) {
  *    with a user message followed by assistant and tool responses.
  * 3. Evict the largest remaining interaction groups until the total estimate
  *    is below `targetTokens`.
+ *
+ * `force` is for the emergency path after the provider itself rejected the
+ * history. There {@link estimateTokens} has been proven wrong, so it can set
+ * neither the stopping point nor what is off limits: the target is halved, and
+ * the preserved tail becomes evictable from its oldest end. Only the final turn
+ * is sacred — it carries the live user message, and a request without it is not
+ * a retry of anything.
  */
-function compactMessages(messages, targetTokens, preserveTurns = 10) {
+function compactMessages(messages, targetTokens, { preserveTurns = 10, force = false } = {}) {
     if (messages.length <= 1)
         return messages;
     const systemPrompt = messages[0];
@@ -1234,40 +1394,56 @@ function compactMessages(messages, targetTokens, preserveTurns = 10) {
     if (currentTurn.length > 0) {
         turns.push(currentTurn);
     }
-    // If we have fewer turns than we want to preserve, just return the messages.
-    if (turns.length <= preserveTurns)
+    // The final turn holds the live user message, so it is never evictable —
+    // with nothing else to drop there is no compaction to do.
+    if (turns.length < 2)
+        return messages;
+    if (!force && turns.length <= preserveTurns)
         return messages;
     let currentEstimate = estimateTokens(messages);
-    if (currentEstimate <= targetTokens)
+    if (!force && currentEstimate <= targetTokens)
         return messages;
-    debug(`compactMessages: currentEstimate=${currentEstimate} target=${targetTokens} turns=${turns.length}`);
-    // Identify candidates for eviction: all turns except the last `preserveTurns`.
-    const tail = turns.slice(-preserveTurns);
-    const candidateTurns = turns
-        .slice(0, -preserveTurns)
-        .map((turn, index) => ({
-        turn,
-        index,
-        tokens: estimateTokens(turn),
-    }));
-    // Sort candidates by size (largest first).
-    candidateTurns.sort((a, b) => b.tokens - a.tokens);
+    // An estimate already above target names a real reduction to aim for, forced
+    // or not. One that sits *below* target while the provider is rejecting the
+    // payload has been disproven, and stopping on it would spend the single retry
+    // on another oversized request — so halve it instead. Wrong by an unknown
+    // factor still shrinks geometrically, and only that case pays the extra loss.
+    const estimateDisproven = force && currentEstimate <= targetTokens;
+    const effectiveTarget = estimateDisproven
+        ? Math.floor(currentEstimate / 2)
+        : targetTokens;
+    debug(`compactMessages: currentEstimate=${currentEstimate} target=${effectiveTarget} turns=${turns.length} force=${force}`);
+    const sized = turns.map((turn, index) => ({ index, tokens: estimateTokens(turn) }));
+    const protectedFrom = turns.length - preserveTurns;
     const evictedIndices = new Set();
+    // Largest first, among the turns outside the preserved tail.
+    const candidateTurns = sized
+        .filter((c) => c.index < protectedFrom)
+        .sort((a, b) => b.tokens - a.tokens);
     for (const c of candidateTurns) {
-        if (currentEstimate <= targetTokens)
+        if (currentEstimate <= effectiveTarget)
             break;
         evictedIndices.add(c.index);
         currentEstimate -= c.tokens;
     }
+    // Still over, and forced? Then the preserved tail is itself the problem — a
+    // run of image-heavy prompts can exceed the window on its own, leaving the
+    // candidates above unable to reach the target however many are dropped. Eat
+    // into the tail from its oldest end so the freshest context survives.
+    if (force) {
+        for (let i = Math.max(protectedFrom, 0); i < turns.length - 1; i++) {
+            if (currentEstimate <= effectiveTarget)
+                break;
+            evictedIndices.add(i);
+            currentEstimate -= sized[i].tokens;
+        }
+    }
     const compacted = [systemPrompt];
-    for (let i = 0; i < turns.length - preserveTurns; i++) {
+    for (let i = 0; i < turns.length; i++) {
         if (!evictedIndices.has(i)) {
             compacted.push(...turns[i]);
         }
     }
-    for (const turn of tail) {
-        compacted.push(...turn);
-    }
     debug(`compactMessages: done, newEstimate=${estimateTokens(compacted)} messageCount=${compacted.length}`);
     return compacted;
 }