🤖 refactor: remove /truncate slash command (#3332)

## Summary

Removes the `/truncate <percentage>` slash command from every
user-facing surface (browser registry, ACP, mobile, palette ghost-text
hints, docs, placeholder tips). The underlying
`workspace.truncateHistory` IPC, the `onTruncateHistory` callback chain,
and the **Truncate History to 25/50/75%** command-palette entries remain
in place — they back `/clear` and the palette and aren't reachable via
the removed slash command.

## Background

`/truncate` was a free-form, percentage-based destructive command
sitting next to `/clear`, `/compact`, and the palette entries. Its UX
was awkward (the user had to know what percentage they wanted, then
re-confirm in the destructive modal), it didn't work with the OpenAI
Responses API at all, and the palette already exposes fixed 25/50/75%
truncation as discrete actions for users who want bounded history
pruning. The slash command itself was redundant.

## Implementation

Removed the command at every layer that referenced it explicitly:

- **Browser slash command system** (`registry.ts`, `types.ts`,
`parser_multiline.test.ts`) — dropped `truncateCommandDefinition`, the
`{ type: "truncate"; percentage: number }` union member, and the parser
test.
- **Command dispatch** (`chatCommands.ts`) — removed the `case
"truncate":` switch arm and `handleTruncateCommand`.
- **ChatInput destructive-confirmation modal** — simplified
`pendingDestructiveCommand` from a discriminated `{ type, percentage }`
object to a plain `boolean`. `/clear` is now the only path through the
modal, so the title/description/confirm label are hard-coded.
- **ACP integration** (`acp/slashCommands.ts`, `acp/agent.ts`,
`tests/ipc/acp.slashCommands.test.ts`) — removed
`TRUNCATE_COMMAND_NAME`, the server command definition, the `kind:
"truncate"` union member, `parseTruncateCommand`, the agent dispatch
case, and the corresponding test cases.
- **Shared constants** (`constants/slashCommands.ts`,
`common/constants/slashCommandHints.ts`) — removed `"truncate"` from the
workspace-only key/type sets and dropped the `truncate` hint.
- **Mobile** (`mobile/src/utils/slashCommandRunner.ts`) — removed the
`case "truncate":` branch and renamed the now-clear-only
`handleTruncate` helper to `handleClear`, dropping the dead `percentage
< 1` branch.
- **Discovery surfaces** — removed the `/truncate 50` placeholder tip
from the carousel and the e2e scenario that exercised the command; the
review e2e now uses `/clear`.
- **Docs** (`docs/workspaces/compaction/manual.mdx`, `index.mdx`) —
removed the "Truncate (Simple Truncation)" section and the table row in
the approaches table; regenerated `builtInSkillContent.generated.ts` via
`bun scripts/gen_builtin_skills.ts`.

Stale references to `/truncate` in code comments (`aiService.ts`,
`acp/agent.ts`) were also updated.

## Validation

- `make typecheck`, `make lint`, `make fmt-check`, `make static-check` —
green.
- Targeted unit tests: `tests/ipc/acp.slashCommands.test.ts`,
`src/browser/utils/slashCommands/parser_multiline.test.ts`,
`src/browser/utils/chatCommands.test.ts`, `make test-mobile` — all
passing.
- `make test` — 21 pre-existing `GitStatusStore` failures reproduce
identically on `main` without these changes; unrelated to this PR.

## Risks

Low. Three call sites that look similar to `/truncate` are intentionally
preserved:

1. `workspace.truncateHistory` IPC — still used by `/clear` (calls with
`percentage: 1.0`) and the palette **Truncate History to N%** actions.
2. `onTruncateHistory` callback drilled through `ChatPane` → `ChatInput`
— still used by `/clear`.
3. The destructive-confirmation modal is now `/clear`-only; the
previously dynamic title/description are hard-coded.

The only behavioral change visible to users is that typing `/truncate
...` now falls through to the "Unknown command" path instead of
executing.

---

_Generated with `mux` • Model: `anthropic:claude-opus-4-7` • Thinking:
`max` • Cost: `$8.53`_

<!-- mux-attribution: model=anthropic:claude-opus-4-7 thinking=max
costs=8.53 -->

Author: ammar-agent

docs/workspaces/compaction/index.mdx

@@ -7,13 +7,12 @@ As conversations grow, they consume more of the model's context window. Compacti
 
 ## Approaches
 
-| Approach                                                                | Speed            | Context Preservation | Cost            | Reversible |
-| ----------------------------------------------------------------------- | ---------------- | -------------------- | --------------- | ---------- |
-| [Start Here](/workspaces/compaction/manual#start-here)                  | Instant          | Intelligent          | Free            | Yes        |
-| [`/compact`](/workspaces/compaction/manual#compact-ai-summarization)    | Slower (uses AI) | Intelligent          | Uses API tokens | No         |
-| [`/clear`](/workspaces/compaction/manual#clear-all-history)             | Instant          | None                 | Free            | No         |
-| [`/truncate`](/workspaces/compaction/manual#truncate-simple-truncation) | Instant          | Temporal             | Free            | No         |
-| [Auto-Compaction](/workspaces/compaction/automatic)                     | Automatic        | Intelligent          | Uses API tokens | No         |
+| Approach                                                             | Speed            | Context Preservation | Cost            | Reversible |
+| -------------------------------------------------------------------- | ---------------- | -------------------- | --------------- | ---------- |
+| [Start Here](/workspaces/compaction/manual#start-here)               | Instant          | Intelligent          | Free            | Yes        |
+| [`/compact`](/workspaces/compaction/manual#compact-ai-summarization) | Slower (uses AI) | Intelligent          | Uses API tokens | No         |
+| [`/clear`](/workspaces/compaction/manual#clear-all-history)          | Instant          | None                 | Free            | No         |
+| [Auto-Compaction](/workspaces/compaction/automatic)                  | Automatic        | Intelligent          | Uses API tokens | No         |
 
 ## When to compact
 

docs/workspaces/compaction/manual.mdx

@@ -109,52 +109,3 @@ Remove all messages from conversation history.
 - Instant deletion of all messages
 - **Irreversible** — all history is permanently removed
 - Use when you want to start a completely new conversation
-
----
-
-## Truncate (Simple Truncation)
-
-Remove a percentage of messages from conversation history (from the oldest first).
-
-### Syntax
-
-```
-/truncate <percentage>
-```
-
-### Parameters
-
-- `percentage` (required) — Percentage of messages to remove (0-100)
-
-### Examples
-
-```
-/truncate 50
-```
-
-Remove oldest 50% of messages.
-
-### Notes
-
-- Simple deletion, no AI involved
-- Removes messages from oldest to newest
-- About as fast as `/clear`
-- `/truncate 100` is equivalent to `/clear`
-- **Irreversible** — messages are permanently removed
-
-### OpenAI Responses API Limitation
-
-<Warning>
-  `/truncate` does not work with OpenAI models due to the Responses API architecture:
-</Warning>
-
-- OpenAI's Responses API stores conversation state server-side
-- Manual message deletion via `/truncate` doesn't affect the server-side state
-- Instead, OpenAI models use **automatic truncation** (`truncation: "auto"`)
-- When context exceeds the limit, the API automatically drops messages from the middle of the conversation
-
-**Workarounds for OpenAI:**
-
-- Use `/clear` to start a fresh conversation
-- Use `/compact` to intelligently summarize and reduce context
-- Rely on automatic truncation (enabled by default)

mobile/src/utils/slashCommandRunner.ts

@@ -34,7 +34,7 @@ export async function executeSlashCommand(
 
   switch (parsed.type) {
     case "clear":
-      return handleTruncate(ctx, 1);
+      return handleClear(ctx);
     case "compact":
       return handleCompaction(ctx, parsed);
     case "model-set":
@@ -57,8 +57,6 @@ export async function executeSlashCommand(
       return true;
     case "new":
       return handleNew(ctx, parsed);
-    case "truncate":
-      return handleTruncate(ctx, parsed.percentage);
     case "idle-compaction":
       return handleIdleCompaction(ctx, parsed.hours);
     case "plan-show":
@@ -84,23 +82,18 @@ function ensureWorkspaceId(ctx: SlashCommandRunnerContext): string {
   return ctx.workspaceId;
 }
 
-async function handleTruncate(
-  ctx: SlashCommandRunnerContext,
-  percentage: number
-): Promise<boolean> {
+async function handleClear(ctx: SlashCommandRunnerContext): Promise<boolean> {
   try {
     const workspaceId = ensureWorkspaceId(ctx);
-    const result = await ctx.client.workspace.truncateHistory({ workspaceId, percentage });
+    // /clear maps to a 100% truncate at the backend.
+    const result = await ctx.client.workspace.truncateHistory({ workspaceId, percentage: 1 });
     if (!result.success) {
-      ctx.showError("History", result.error ?? "Failed to truncate history");
+      ctx.showError("History", result.error ?? "Failed to clear history");
       return true;
     }
     ctx.onClearTimeline();
     ctx.onCancelEdit();
-    ctx.showInfo(
-      "History",
-      percentage >= 1 ? "Cleared conversation" : `Truncated to ${(percentage * 100).toFixed(0)}%`
-    );
+    ctx.showInfo("History", "Cleared conversation");
     return true;
   } catch (error) {
     ctx.showError("History", getErrorMessage(error));

src/browser/features/ChatInput/index.tsx

@@ -364,11 +364,8 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
   const [commandSuggestions, setCommandSuggestions] = useState<SlashSuggestion[]>([]);
   const [agentSkillDescriptors, setAgentSkillDescriptors] = useState<AgentSkillDescriptor[]>([]);
   const [toast, setToast] = useState<Toast | null>(null);
-  // State for destructive command confirmation modal
-  const [pendingDestructiveCommand, setPendingDestructiveCommand] = useState<{
-    type: "clear" | "truncate";
-    percentage?: number;
-  } | null>(null);
+  // State for destructive command confirmation modal (currently only /clear).
+  const [pendingDestructiveCommand, setPendingDestructiveCommand] = useState(false);
   const pushToast = useCallback(
     (nextToast: Omit<Toast, "id" | "type"> & { type: Toast["type"] | "info" }) => {
       // Keep a dedicated "info" intent for callsites while rendering with the shared non-error toast style.
@@ -1925,13 +1922,9 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
       return false;
     }
 
-    const isDestructive =
-      (parsed.type === "clear" && parsed.mode === "hard") || parsed.type === "truncate";
+    const isDestructive = parsed.type === "clear" && parsed.mode === "hard";
     if (isDestructive && variant === "workspace" && !options?.skipConfirmation) {
-      setPendingDestructiveCommand({
-        type: parsed.type,
-        percentage: parsed.type === "truncate" ? parsed.percentage : undefined,
-      });
+      setPendingDestructiveCommand(true);
       return true;
     }
 
@@ -2006,24 +1999,18 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
     return true;
   };
 
-  // Handle destructive command confirmation
+  // Handle destructive command confirmation (currently only /clear).
   const handleDestructiveCommandConfirm = async () => {
     if (!pendingDestructiveCommand || variant !== "workspace") return;
 
-    const parsedCommand: ParsedCommand =
-      pendingDestructiveCommand.type === "clear"
-        ? { type: "clear", mode: "hard" }
-        : {
-            type: "truncate",
-            percentage: pendingDestructiveCommand.percentage ?? 0,
-          };
+    const parsedCommand: ParsedCommand = { type: "clear", mode: "hard" };
 
-    setPendingDestructiveCommand(null);
+    setPendingDestructiveCommand(false);
     await executeParsedCommand(parsedCommand, input, { skipConfirmation: true });
   };
 
   const handleDestructiveCommandCancel = useCallback(() => {
-    setPendingDestructiveCommand(null);
+    setPendingDestructiveCommand(false);
   }, []);
 
   // Handle drag over to allow drop
@@ -3128,21 +3115,13 @@ const ChatInputInner: React.FC<ChatInputProps> = (props) => {
         </div>
       </div>
 
-      {/* Confirmation modal for destructive commands */}
+      {/* Confirmation modal for destructive commands (currently only /clear). */}
       <ConfirmationModal
-        isOpen={pendingDestructiveCommand !== null}
-        title={
-          pendingDestructiveCommand?.type === "clear"
-            ? "Clear Chat History?"
-            : `Truncate ${Math.round((pendingDestructiveCommand?.percentage ?? 0) * 100)}% of Chat History?`
-        }
-        description={
-          pendingDestructiveCommand?.type === "clear"
-            ? "This will remove all messages from the conversation."
-            : `This will remove approximately ${Math.round((pendingDestructiveCommand?.percentage ?? 0) * 100)}% of the oldest messages.`
-        }
+        isOpen={pendingDestructiveCommand}
+        title="Clear Chat History?"
+        description="This will remove all messages from the conversation."
         warning="This action cannot be undone."
-        confirmLabel={pendingDestructiveCommand?.type === "clear" ? "Clear" : "Truncate"}
+        confirmLabel="Clear"
         onConfirm={handleDestructiveCommandConfirm}
         onCancel={handleDestructiveCommandCancel}
       />

src/browser/features/ChatInput/placeholderTips.ts

@@ -50,7 +50,6 @@ export const PLACEHOLDER_TIPS: readonly string[] = [
   "Try /clear --soft to reset context while keeping the chat visible",
   "Try /new <start> to start a fresh workspace from the trunk branch",
   "Try /vim to toggle vim keybindings in the chat input",
-  "Try /truncate 50 to drop the oldest half of the conversation",
 ];
 
 /**

src/browser/utils/chatCommands.ts

@@ -508,8 +508,6 @@ export async function processSlashCommand(
     switch (parsed.type) {
       case "clear":
         return handleClearCommand(parsed, context);
-      case "truncate":
-        return handleTruncateCommand(parsed, context);
       case "compact":
         // handleCompactCommand expects workspaceId in context
         if (!context.workspaceId) throw new Error("Workspace ID required");
@@ -982,37 +980,6 @@ async function handleClearCommand(
   }
 }
 
-async function handleTruncateCommand(
-  parsed: Extract<ParsedCommand, { type: "truncate" }>,
-  context: SlashCommandContext
-): Promise<CommandHandlerResult> {
-  const { setInput, onTruncateHistory, resetInputHeight, setToast } = context;
-
-  setInput("");
-  resetInputHeight();
-
-  if (!onTruncateHistory) return { clearInput: true, toastShown: false };
-
-  try {
-    await onTruncateHistory(parsed.percentage);
-    setToast({
-      id: Date.now().toString(),
-      type: "success",
-      message: `Chat history truncated by ${Math.round(parsed.percentage * 100)}%`,
-    });
-    return { clearInput: true, toastShown: true };
-  } catch (error) {
-    const normalized = error instanceof Error ? error : new Error("Failed to truncate history");
-    console.error("Failed to truncate history:", normalized);
-    setToast({
-      id: Date.now().toString(),
-      type: "error",
-      message: normalized.message,
-    });
-    return { clearInput: false, toastShown: true };
-  }
-}
-
 async function handleForkCommand(
   parsed: Extract<ParsedCommand, { type: "fork" }>,
   context: SlashCommandContext

src/browser/utils/slashCommands/parser_multiline.test.ts

@@ -22,12 +22,4 @@ describe("parser multiline compatibility", () => {
       modelString: KNOWN_MODELS.OPUS.id,
     });
   });
-
-  it("allows /truncate with newlines", () => {
-    const result = parseCommand("/truncate\n50");
-    expect(result).toEqual({
-      type: "truncate",
-      percentage: 0.5,
-    });
-  });
 });

src/browser/utils/slashCommands/registry.ts

@@ -114,48 +114,6 @@ const clearCommandDefinition: SlashCommandDefinition = {
   },
 };
 
-const TRUNCATE_USAGE = `/truncate ${SLASH_COMMAND_HINTS.truncate} (percentage to remove)`;
-
-const truncateCommandDefinition: SlashCommandDefinition = {
-  key: "truncate",
-  description: "Truncate conversation history by percentage (0-100)",
-  inputHint: SLASH_COMMAND_HINTS.truncate,
-  handler: ({ cleanRemainingTokens }): ParsedCommand => {
-    if (cleanRemainingTokens.length === 0) {
-      return {
-        type: "command-missing-args",
-        command: "truncate",
-        usage: TRUNCATE_USAGE,
-      };
-    }
-
-    if (cleanRemainingTokens.length > 1) {
-      return {
-        type: "command-invalid-args",
-        command: "truncate",
-        input: cleanRemainingTokens.join(" "),
-        usage: TRUNCATE_USAGE,
-      };
-    }
-
-    // Parse percentage (0-100)
-    const pctStr = cleanRemainingTokens[0];
-    const pct = parseFloat(pctStr);
-
-    if (isNaN(pct) || pct < 0 || pct > 100) {
-      return {
-        type: "command-invalid-args",
-        command: "truncate",
-        input: pctStr,
-        usage: TRUNCATE_USAGE,
-      };
-    }
-
-    // Convert to 0.0-1.0
-    return { type: "truncate", percentage: pct / 100 };
-  },
-};
-
 const compactCommandDefinition: SlashCommandDefinition = {
   key: "compact",
   description:
@@ -708,7 +666,6 @@ const debugLlmRequestCommandDefinition: SlashCommandDefinition = {
 
 export const SLASH_COMMAND_DEFINITIONS: readonly SlashCommandDefinition[] = [
   clearCommandDefinition,
-  truncateCommandDefinition,
   compactCommandDefinition,
   modelCommandDefinition,
   planCommandDefinition,

src/browser/utils/slashCommands/types.ts

@@ -25,7 +25,6 @@ export type ParsedCommand =
     }
   | { type: "model-help" }
   | { type: "clear"; mode: "hard" | "soft" }
-  | { type: "truncate"; percentage: number }
   | { type: "compact"; maxOutputTokens?: number; continueMessage?: string; model?: string }
   | { type: "fork"; startMessage?: string }
   | { type: "new"; startMessage?: string }

src/common/constants/slashCommandHints.ts

@@ -4,7 +4,6 @@
  * Keyed by command name (without the leading "/").
  */
 export const SLASH_COMMAND_HINTS = {
-  truncate: "<0-100>",
   compact: "[-t <tokens>] [-m <model>] [continue message]",
   model: "<abbreviation|full-id>",
   fork: "[start message]",