@@ -19,6 +19,11 @@ export interface ChatSession {
     // The agent's last set_plan checklist for this conversation, persisted so
     // reopening a chat mid-task shows where the plan stood.
     planSteps?: { text: string; done: boolean }[];
+    // Running summary produced by context compaction, replacing everything
+    // in `messages` before contextSummaryThroughIndex when this session's
+    // history is sent to a provider.
+    contextSummary?: string;
+    contextSummaryThroughIndex?: number;
     tags?: string[];
     createdAt: string;
     updatedAt: string;
@@ -66,7 +71,7 @@ export function updateSession(
     partial: Partial<
         Pick<
             ChatSession,
-            "title" | "model" | "messages" | "params" | "projectId" | "systemPrompt" | "agentMode" | "agentWorkspace" | "planSteps" | "tags"
+            "title" | "model" | "messages" | "params" | "projectId" | "systemPrompt" | "agentMode" | "agentWorkspace" | "planSteps" | "contextSummary" | "contextSummaryThroughIndex" | "tags"
         >
     >
 ): ChatSession | null {
 
@@ -0,0 +1,110 @@
+import { describe, it, expect } from "vitest";
+import {
+    estimateTokens,
+    estimateMessagesTokens,
+    planCompaction,
+    shouldCompact,
+    buildSummarizationPrompt,
+} from "./context-compaction";
+import type { ChatMessage } from "@/types/electron";
+
+function msg(role: ChatMessage["role"], content: string): ChatMessage {
+    return { role, content };
+}
+
+describe("estimateTokens", () => {
+    it("scales roughly with character count", () => {
+        expect(estimateTokens("")).toBe(0);
+        expect(estimateTokens("a".repeat(400))).toBe(100);
+    });
+});
+
+describe("estimateMessagesTokens", () => {
+    it("sums estimated tokens across messages", () => {
+        const messages = [msg("user", "a".repeat(40)), msg("assistant", "b".repeat(80))];
+        expect(estimateMessagesTokens(messages)).toBe(10 + 20);
+    });
+});
+
+describe("planCompaction", () => {
+    it("keeps everything when there aren't more messages than keepRecent", () => {
+        const messages = Array.from({ length: 5 }, (_, i) => msg("user", `msg ${i}`));
+        const plan = planCompaction(messages, 0, 12);
+        expect(plan.toFold).toEqual([]);
+        expect(plan.kept).toEqual(messages);
+    });
+
+    it("folds everything except the most recent keepRecent messages", () => {
+        const messages = Array.from({ length: 20 }, (_, i) => msg("user", `msg ${i}`));
+        const plan = planCompaction(messages, 0, 12);
+        expect(plan.toFold).toHaveLength(8);
+        expect(plan.kept).toHaveLength(12);
+        expect(plan.kept[0].content).toBe("msg 8");
+        expect(plan.foldEndIndex).toBe(8);
+    });
+
+    it("never re-folds messages already covered by a previous compaction", () => {
+        const messages = Array.from({ length: 20 }, (_, i) => msg("user", `msg ${i}`));
+        const plan = planCompaction(messages, 8, 12);
+        expect(plan.toFold).toEqual([]);
+        expect(plan.kept).toHaveLength(12);
+    });
+
+    it("folds only the newly-eligible slice on a second compaction pass", () => {
+        const messages = Array.from({ length: 30 }, (_, i) => msg("user", `msg ${i}`));
+        const plan = planCompaction(messages, 8, 12);
+        expect(plan.toFold).toHaveLength(10);
+        expect(plan.toFold[0].content).toBe("msg 8");
+        expect(plan.kept).toHaveLength(12);
+    });
+});
+
+describe("shouldCompact", () => {
+    const keepRecent = 12;
+    const budget = 100;
+
+    it("returns false when there's nothing beyond the recent window", () => {
+        const messages = Array.from({ length: 12 }, () => msg("user", "x".repeat(1000)));
+        expect(shouldCompact(messages, 0, keepRecent, budget)).toBe(false);
+    });
+
+    it("returns false when the unfolded portion is under budget", () => {
+        const messages = Array.from({ length: 20 }, () => msg("user", "hi"));
+        expect(shouldCompact(messages, 0, keepRecent, budget)).toBe(false);
+    });
+
+    it("returns true when the unfolded portion exceeds the token budget", () => {
+        const messages = Array.from({ length: 20 }, () => msg("user", "x".repeat(1000)));
+        expect(shouldCompact(messages, 0, keepRecent, budget)).toBe(true);
+    });
+
+    it("re-evaluates against only what's beyond the already-folded count", () => {
+        const messages = Array.from({ length: 20 }, () => msg("user", "x".repeat(1000)));
+        // Everything but the recent window is already folded, so nothing new to weigh.
+        expect(shouldCompact(messages, 8, keepRecent, budget)).toBe(false);
+    });
+});
+
+describe("buildSummarizationPrompt", () => {
+    it("includes the transcript with speaker labels", () => {
+        const prompt = buildSummarizationPrompt(null, [msg("user", "hello"), msg("assistant", "hi there")]);
+        expect(prompt).toContain("User: hello");
+        expect(prompt).toContain("Assistant: hi there");
+    });
+
+    it("carries forward an existing summary for incremental compaction", () => {
+        const prompt = buildSummarizationPrompt("earlier context here", [msg("user", "more")]);
+        expect(prompt).toContain("Existing summary of earlier context:\nearlier context here");
+    });
+
+    it("omits tool-role messages from the excerpt", () => {
+        const prompt = buildSummarizationPrompt(null, [
+            msg("user", "run the tests"),
+            { role: "tool", content: "42 passed", toolName: "run_command" },
+            msg("assistant", "all green"),
+        ]);
+        expect(prompt).not.toContain("42 passed");
+        expect(prompt).toContain("run the tests");
+        expect(prompt).toContain("all green");
+    });
+});
@@ -0,0 +1,71 @@
+import type { ChatMessage } from "@/types/electron";
+
+// No tokenizer is wired up per-provider, so this trades precision for a
+// heuristic that works everywhere without pulling in a vendor-specific
+// tokenizer just to decide "is this conversation getting long".
+const CHARS_PER_TOKEN = 4;
+
+// Never folded away — keeps immediate context exact so the model doesn't
+// lose track of what was just said.
+export const COMPACTION_KEEP_RECENT = 12;
+// Conservative across providers; well under even the smallest context
+// windows in this app's model catalog once system prompts and a response
+// budget are accounted for.
+export const COMPACTION_BUDGET_TOKENS = 6000;
+
+export function estimateTokens(text: string): number {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+export function estimateMessagesTokens(messages: ChatMessage[]): number {
+    return messages.reduce((sum, m) => sum + estimateTokens(m.content), 0);
+}
+
+export interface CompactionPlan {
+    toFold: ChatMessage[];
+    kept: ChatMessage[];
+    foldEndIndex: number;
+}
+
+// Decides which messages get folded into a running summary vs. kept
+// verbatim. Never re-folds anything already covered by `alreadyFoldedCount`,
+// and never folds into the last `keepRecent` messages.
+export function planCompaction(
+    messages: ChatMessage[],
+    alreadyFoldedCount: number,
+    keepRecent: number
+): CompactionPlan {
+    const foldEndIndex = Math.max(alreadyFoldedCount, messages.length - keepRecent);
+    return {
+        toFold: messages.slice(alreadyFoldedCount, foldEndIndex),
+        kept: messages.slice(foldEndIndex),
+        foldEndIndex,
+    };
+}
+
+export function shouldCompact(
+    messages: ChatMessage[],
+    alreadyFoldedCount: number,
+    keepRecent: number,
+    budgetTokens: number
+): boolean {
+    if (messages.length - alreadyFoldedCount <= keepRecent) return false;
+    return estimateMessagesTokens(messages.slice(alreadyFoldedCount)) > budgetTokens;
+}
+
+// Tool call/result messages are dropped from the excerpt handed to the
+// summarizer — they're agent-mode bookkeeping the model can act on later
+// via read_notes if it mattered, not context a summary needs to preserve.
+export function buildSummarizationPrompt(previousSummary: string | null, toFold: ChatMessage[]): string {
+    const transcript = toFold
+        .filter((m) => (m.role === "user" || m.role === "assistant") && m.content)
+        .map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${m.content}`)
+        .join("\n\n");
+    const previous = previousSummary ? `Existing summary of earlier context:\n${previousSummary}\n\n` : "";
+    return (
+        `${previous}Summarize the following conversation excerpt concisely, preserving names, decisions, ` +
+        `numbers, and anything a continuation of this conversation would need to know. Write it as a compact ` +
+        `paragraph or short bullet list, not a transcript — this replaces the original messages in the model's ` +
+        `context, so it needs to stand on its own.\n\n${transcript}`
+    );
+}
@@ -26,6 +26,7 @@ export interface Dictionary {
     toolResult: string;
     toolFailed: string;
     transientErrorRetrying: string;
+    contextCompacted: string;
     alwaysAllowThisSession: string;
     agentStep: string;
     agentStepTooltip: string;
@@ -333,6 +334,7 @@ export const en: Dictionary = {
     toolResult: "result",
     toolFailed: "failed",
     transientErrorRetrying: "Temporary provider error — retrying once...",
+    contextCompacted: "Older messages summarized to stay within context — nothing is lost from the saved chat.",
     alwaysAllowThisSession: "Always allow this session",
     agentStep: "Agent step",
     agentStepTooltip: "How many automatic tool-result → model-continuation round trips have happened for this turn.",
@@ -650,6 +652,7 @@ export const tr: Dictionary = {
     toolResult: "sonucu",
     toolFailed: "başarısız oldu",
     transientErrorRetrying: "Geçici sağlayıcı hatası — bir kez yeniden deneniyor...",
+    contextCompacted: "Bağlamda kalmak için eski mesajlar özetlendi — kaydedilen sohbetten hiçbir şey kaybolmadı.",
     alwaysAllowThisSession: "Bu oturumda her zaman izin ver",
     agentStep: "Ajan adımı",
     agentStepTooltip: "Bu tur için kaç otomatik araç sonucu → model devamı gidiş-dönüşü gerçekleşti.",
 
@@ -70,6 +70,13 @@ import { speakText, stopSpeaking } from "@/lib/tts";
 import { computeLineDiff } from "@/lib/diff";
 import { useToast } from "@/components/toast";
 import { isTransientError } from "@/lib/transient-errors";
+import {
+    COMPACTION_BUDGET_TOKENS,
+    COMPACTION_KEEP_RECENT,
+    buildSummarizationPrompt,
+    planCompaction,
+    shouldCompact,
+} from "@/lib/context-compaction";
 import type {
     ChatMessage,
     OllamaModel,
@@ -430,6 +437,8 @@ export default function Chat() {
     const [agentStepCount, setAgentStepCount] = useState(0);
     const [autoApprovedTools, setAutoApprovedTools] = useState<Set<string>>(new Set());
     const [planSteps, setPlanSteps] = useState<PlanStep[]>([]);
+    const [contextSummary, setContextSummary] = useState<string | null>(null);
+    const [contextSummaryThroughIndex, setContextSummaryThroughIndex] = useState(0);
     const [projectScripts, setProjectScripts] = useState<ProjectScripts>({});
     const [quickActionRunning, setQuickActionRunning] = useState(false);
     const [undoMessage, setUndoMessage] = useState<string | null>(null);
@@ -511,6 +520,8 @@ export default function Chat() {
             setPendingToolCalls([]);
             setAgentStepCount(0);
             setPlanSteps(session.planSteps ?? []);
+            setContextSummary(session.contextSummary ?? null);
+            setContextSummaryThroughIndex(session.contextSummaryThroughIndex ?? 0);
             setAutoApprovedTools(new Set());
             setWriteDiffPreviews({});
             setUndoMessage(null);
@@ -847,13 +858,74 @@ export default function Chat() {
         }
     }
 
+    // A plain, non-streaming-to-the-UI completion used only to produce a
+    // compaction summary — same provider/model/agentMode:false, but its
+    // tokens are accumulated locally instead of touching message state.
+    async function summarizeText(prompt: string): Promise<string | null> {
+        const parsed = parseModelRef(model);
+        if (!parsed) return null;
+        let text = "";
+        const { promise } = window.api.chat.send(
+            parsed.provider,
+            parsed.modelId,
+            [{ role: "user", content: prompt }],
+            {},
+            (chunk) => {
+                text += chunk.message?.content ?? "";
+            },
+            false
+        );
+        const result = await promise;
+        return result.error ? null : text.trim() || null;
+    }
+
+    // Folds everything but the most recent messages into a running summary
+    // once the unfolded portion gets too large to keep sending verbatim —
+    // otherwise a long conversation eventually fails outright (or gets
+    // silently truncated by the provider) once it outgrows the model's
+    // context window. Returns null when no compaction was needed, in which
+    // case the caller sends its already-built history unchanged.
+    async function maybeCompactHistory(baseMessages: ChatMessage[]): Promise<ChatMessage[] | null> {
+        // Editing/forking/regenerating can shorten the message list after a
+        // fold point was recorded — clamp so a stale index never causes the
+        // "kept" slice to come up empty and silently drop recent context.
+        const alreadyFolded = Math.min(contextSummaryThroughIndex, baseMessages.length);
+        if (!shouldCompact(baseMessages, alreadyFolded, COMPACTION_KEEP_RECENT, COMPACTION_BUDGET_TOKENS)) {
+            return null;
+        }
+        const { toFold, kept, foldEndIndex } = planCompaction(baseMessages, alreadyFolded, COMPACTION_KEEP_RECENT);
+        if (toFold.length === 0) return null;
+
+        const summary = await summarizeText(buildSummarizationPrompt(contextSummary, toFold));
+        // Summarization itself failed (network blip, provider error) — fall
+        // back to sending the full uncompacted history rather than losing
+        // context or blocking the user's message.
+        if (!summary) return null;
+
+        setContextSummary(summary);
+        setContextSummaryThroughIndex(foldEndIndex);
+        if (sessionId) {
+            window.api.sessions.update(sessionId, { contextSummary: summary, contextSummaryThroughIndex: foldEndIndex });
+        }
+        toast.info(t.contextCompacted);
+        return [
+            ...buildSystemMessages(),
+            { role: "system", content: `Summary of earlier conversation:\n${summary}` },
+            ...kept,
+        ];
+    }
+
     async function runCompletion(
         history: ChatMessage[],
         baseMessages: ChatMessage[],
         opts: { isFirstMessage: boolean; titleSource: string; attempt?: number }
     ) {
         const parsed = parseModelRef(model);
         if (!parsed || !sessionId) return;
+
+        const compactedHistory = await maybeCompactHistory(baseMessages);
+        const requestHistory = compactedHistory ?? history;
+
         // Timing an in-flight network stream, not computing render output —
         // the react-hooks purity rule can't tell this closure only runs once
         // per user-initiated send, not during render.
@@ -910,7 +982,7 @@ export default function Chat() {
         const { requestId, promise } = window.api.chat.send(
             parsed.provider,
             parsed.modelId,
-            history,
+            requestHistory,
             effectiveOptions(),
             (chunk) => {
                 const piece = chunk.message?.content ?? "";
 
@@ -275,6 +275,8 @@ export interface ChatSession {
   agentMode?: boolean;
   agentWorkspace?: string | null;
   planSteps?: { text: string; done: boolean }[];
+  contextSummary?: string;
+  contextSummaryThroughIndex?: number;
   tags?: string[];
   createdAt: string;
   updatedAt: string;
@@ -424,6 +426,8 @@ export interface ElectronApi {
           | "agentMode"
           | "agentWorkspace"
           | "planSteps"
+          | "contextSummary"
+          | "contextSummaryThroughIndex"
           | "tags"
         >
       >