diff --git a/builds/typescript/client_web/src/api/gateway-adapter.test.ts b/builds/typescript/client_web/src/api/gateway-adapter.test.ts
index 667c182..06602d6 100644
--- a/builds/typescript/client_web/src/api/gateway-adapter.test.ts
+++ b/builds/typescript/client_web/src/api/gateway-adapter.test.ts
@@ -14,14 +14,15 @@ import {
   type ChatEvent,
 } from "./gateway-adapter";
 
-function sseResponse(frames: string): Response {
-  return new Response(frames, {
-    status: 200,
-    headers: {
-      "content-type": "text/event-stream",
-    },
-  });
-}
+function sseResponse(frames: string, headers?: Record<string, string>): Response {
+  return new Response(frames, {
+    status: 200,
+    headers: {
+      "content-type": "text/event-stream",
+      ...(headers ?? {}),
+    },
+  });
+}
 
 async function collectEvents(stream: AsyncIterable<ChatEvent>): Promise<ChatEvent[]> {
   const events: ChatEvent[] = [];
@@ -67,7 +68,7 @@ describe("gateway-adapter SSE parsing", () => {
     ]);
   });
 
-  it("maps legacy text-delta content field to delta", async () => {
+  it("maps legacy text-delta content field to delta", async () => {
     vi.stubGlobal(
       "fetch",
       vi.fn(async () =>
@@ -85,12 +86,54 @@ describe("gateway-adapter SSE parsing", () => {
     );
 
     const events = await collectEvents(sendMessage(null, "hi"));
-    expect(events[0]).toMatchObject({
-      type: "text-delta",
-      delta: "Legacy format",
-    });
-  });
-});
+    expect(events[0]).toMatchObject({
+      type: "text-delta",
+      delta: "Legacy format",
+    });
+  });
+
+  it("exposes context-window warnings from response headers", async () => {
+    const onContextWarning = vi.fn();
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(async () =>
+        sseResponse(
+          [
+            "event: done",
+            'data: {"finish_reason":"stop","conversation_id":"conv_3"}',
+            "",
+          ].join("\n"),
+          {
+            "x-context-window-warning": "1",
+            "x-context-window-estimated-tokens": "90000",
+            "x-context-window-budget-tokens": "100000",
+            "x-context-window-ratio": "0.9",
+            "x-context-window-threshold": "0.8",
+            "x-context-window-managed": "1",
+            "x-context-window-message": "This session is getting long.",
+          }
+        )
+      )
+    );
+
+    const events = await collectEvents(sendMessage(null, "hi", { onContextWarning }));
+    expect(events).toEqual([
+      {
+        type: "done",
+        finish_reason: "stop",
+        conversation_id: "conv_3",
+      },
+    ]);
+    expect(onContextWarning).toHaveBeenCalledWith({
+      estimated_tokens: 90000,
+      budget_tokens: 100000,
+      ratio: 0.9,
+      threshold: 0.8,
+      managed: true,
+      message: "This session is getting long.",
+    });
+  });
+});
 
 describe("gateway-adapter settings models", () => {
   beforeEach(() => {
diff --git a/builds/typescript/client_web/src/api/gateway-adapter.ts b/builds/typescript/client_web/src/api/gateway-adapter.ts
index 450f39e..a188438 100644
--- a/builds/typescript/client_web/src/api/gateway-adapter.ts
+++ b/builds/typescript/client_web/src/api/gateway-adapter.ts
@@ -5,10 +5,11 @@ import { parseSSE } from "./sse-parser";
 import {
   GatewayError,
   GatewayNotFoundError,
-  type ApprovalDecision,
-  type ChatEvent,
-  type Conversation,
-  type ConversationDetail,
+  type ApprovalDecision,
+  type ChatEvent,
+  type Conversation,
+  type ConversationDetail,
+  type ContextWindowWarning,
   type GatewayCredentialUpdateRequest,
   type GatewayCredentialUpdateResponse,
   type GatewayMemoryBackupRestoreRequest,
@@ -36,10 +37,11 @@ type ConversationListResponse = {
   offset: number;
 };
 
-type SendMessageOptions = {
-  signal?: AbortSignal;
-  metadata?: Record<string, unknown>;
-};
+type SendMessageOptions = {
+  signal?: AbortSignal;
+  metadata?: Record<string, unknown>;
+  onContextWarning?: (warning: ContextWindowWarning) => void;
+};
 
 type ErrorPayload = {
   code?: string;
@@ -188,7 +190,7 @@ function toChatEvent(eventName: string, data: string): ChatEvent {
   return normalized;
 }
 
-function normalizeChatEventPayload(eventName: string, parsed: unknown): unknown {
+function normalizeChatEventPayload(eventName: string, parsed: unknown): unknown {
   if (!isRecord(parsed)) {
     return parsed;
   }
@@ -216,8 +218,34 @@ function normalizeChatEventPayload(eventName: string, parsed: unknown): unknown
     };
   }
 
-  return withType;
-}
+  return withType;
+}
+
+function parseContextWindowWarning(headers: Headers): ContextWindowWarning | null {
+  if (headers.get("x-context-window-warning") !== "1") {
+    return null;
+  }
+
+  const estimatedTokens = Number.parseInt(headers.get("x-context-window-estimated-tokens") ?? "", 10);
+  const budgetTokens = Number.parseInt(headers.get("x-context-window-budget-tokens") ?? "", 10);
+  const ratio = Number.parseFloat(headers.get("x-context-window-ratio") ?? "");
+  const threshold = Number.parseFloat(headers.get("x-context-window-threshold") ?? "");
+  const managed = headers.get("x-context-window-managed") === "1";
+  const message = headers.get("x-context-window-message") ?? "This session is getting long.";
+
+  if (!Number.isFinite(estimatedTokens) || !Number.isFinite(budgetTokens) || !Number.isFinite(ratio)) {
+    return null;
+  }
+
+  return {
+    estimated_tokens: estimatedTokens,
+    budget_tokens: budgetTokens,
+    ratio,
+    threshold: Number.isFinite(threshold) ? threshold : 0.8,
+    managed,
+    message,
+  };
+}
 
 export async function* sendMessage(
   conversationId: string | null,
@@ -241,14 +269,19 @@ export async function* sendMessage(
     signal: options.signal
   });
 
-  if (!response.ok) {
-    throw await toGatewayError(response);
-  }
-
-  for await (const event of parseSSE(response)) {
-    yield toChatEvent(event.event, event.data);
-  }
-}
+  if (!response.ok) {
+    throw await toGatewayError(response);
+  }
+
+  const contextWarning = parseContextWindowWarning(response.headers);
+  if (contextWarning) {
+    options.onContextWarning?.(contextWarning);
+  }
+
+  for await (const event of parseSSE(response)) {
+    yield toChatEvent(event.event, event.data);
+  }
+}
 
 export async function listConversations(): Promise<Conversation[]> {
   const response = await authenticatedFetch(`${GATEWAY_BASE_URL}/conversations`, {
diff --git a/builds/typescript/client_web/src/api/types.ts b/builds/typescript/client_web/src/api/types.ts
index 0928aad..47eae1c 100644
--- a/builds/typescript/client_web/src/api/types.ts
+++ b/builds/typescript/client_web/src/api/types.ts
@@ -94,6 +94,15 @@ export type ChatEvent =
   | ChatErrorEvent
   | DoneEvent;
 
+export type ContextWindowWarning = {
+  estimated_tokens: number;
+  budget_tokens: number;
+  ratio: number;
+  threshold: number;
+  managed: boolean;
+  message: string;
+};
+
 export type ApprovalDecision = "approved" | "denied";
 export type ApprovalMode = "ask-on-write" | "auto-approve";
 
diff --git a/builds/typescript/client_web/src/api/useGatewayChat.test.tsx b/builds/typescript/client_web/src/api/useGatewayChat.test.tsx
index 4a3ba0e..a97adfe 100644
--- a/builds/typescript/client_web/src/api/useGatewayChat.test.tsx
+++ b/builds/typescript/client_web/src/api/useGatewayChat.test.tsx
@@ -7,7 +7,18 @@ const sendMessageMock = vi.fn<
   (
     conversationId: string | null,
     content: string,
-    options?: { signal?: AbortSignal; metadata?: Record<string, unknown> }
+    options?: {
+      signal?: AbortSignal;
+      metadata?: Record<string, unknown>;
+      onContextWarning?: (warning: {
+        estimated_tokens: number;
+        budget_tokens: number;
+        ratio: number;
+        threshold: number;
+        managed: boolean;
+        message: string;
+      }) => void;
+    }
   ) => AsyncIterable<ChatEvent>
 >();
 
@@ -41,7 +52,18 @@ vi.mock("./gateway-adapter", () => ({
   sendMessage: (
     conversationId: string | null,
     content: string,
-    options?: { signal?: AbortSignal; metadata?: Record<string, unknown> }
+    options?: {
+      signal?: AbortSignal;
+      metadata?: Record<string, unknown>;
+      onContextWarning?: (warning: {
+        estimated_tokens: number;
+        budget_tokens: number;
+        ratio: number;
+        threshold: number;
+        managed: boolean;
+        message: string;
+      }) => void;
+    }
   ) => sendMessageMock(conversationId, content, options),
   submitApprovalDecision: (requestId: string, decision: "approved" | "denied") =>
     submitApprovalDecisionMock(requestId, decision),
@@ -160,11 +182,75 @@ describe("useGatewayChat", () => {
     });
 
     expect(result.current.error?.message).toBe("Provider unavailable");
+    expect(result.current.errorCode).toBe("provider_error");
     expect(result.current.messages).toEqual([
       { id: "message-1", role: "user", content: "Hello" }
     ]);
   });
 
+  it("stores context overflow error code for overflow-specific UI actions", async () => {
+    sendMessageMock.mockImplementation(() =>
+      streamEvents([
+        {
+          type: "error",
+          code: "context_overflow",
+          message: "This session has gotten long. Start a new conversation to continue - all your work is saved.",
+        },
+      ])
+    );
+
+    const { result } = renderHook(() => useGatewayChat());
+
+    act(() => {
+      result.current.append("Hello");
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.errorCode).toBe("context_overflow");
+  });
+
+  it("stores context warning metadata passed from the gateway adapter", async () => {
+    sendMessageMock.mockImplementation((_conversationId, _content, options) =>
+      (async function* contextWarningStream() {
+        options?.onContextWarning?.({
+          estimated_tokens: 90_000,
+          budget_tokens: 100_000,
+          ratio: 0.9,
+          threshold: 0.8,
+          managed: true,
+          message: "This session is getting long. Earlier turns were compacted so you can keep chatting.",
+        });
+        yield {
+          type: "done",
+          finish_reason: "stop",
+          conversation_id: "conv-warning",
+        } as ChatEvent;
+      })()
+    );
+
+    const { result } = renderHook(() => useGatewayChat());
+
+    act(() => {
+      result.current.append("Hello");
+    });
+
+    await waitFor(() => {
+      expect(result.current.isLoading).toBe(false);
+    });
+
+    expect(result.current.contextWindowWarning).toEqual({
+      estimated_tokens: 90_000,
+      budget_tokens: 100_000,
+      ratio: 0.9,
+      threshold: 0.8,
+      managed: true,
+      message: "This session is getting long. Earlier turns were compacted so you can keep chatting.",
+    });
+  });
+
   it("auto-approves approval requests during streaming", async () => {
     sendMessageMock.mockImplementation(() =>
       streamEvents([
diff --git a/builds/typescript/client_web/src/api/useGatewayChat.ts b/builds/typescript/client_web/src/api/useGatewayChat.ts
index 465873c..e262bc1 100644
--- a/builds/typescript/client_web/src/api/useGatewayChat.ts
+++ b/builds/typescript/client_web/src/api/useGatewayChat.ts
@@ -11,7 +11,7 @@ import {
   updateConversationSkills,
   updateProjectSkills,
 } from "./gateway-adapter";
-import type { ActivityEvent, ApprovalDecision, PendingApproval } from "./types";
+import type { ActivityEvent, ApprovalDecision, ContextWindowWarning, PendingApproval } from "./types";
 
 const EMPTY_MESSAGES: Message[] = [];
 const EMPTY_ACTIVITY: ActivityEvent[] = [];
@@ -35,9 +35,11 @@ type ConversationState = {
   messages: Message[];
   isLoading: boolean;
   error: Error | null;
+  errorCode: string | null;
   toolStatus: string | null;
   pendingApprovals: PendingApproval[];
   activity: ActivityEvent[];
+  contextWindowWarning: ContextWindowWarning | null;
   conversationId: string | null;
   abortController: AbortController | null;
   requestToken: number;
@@ -75,13 +77,16 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
   messages: Message[];
   isLoading: boolean;
   error: Error | null;
+  errorCode: string | null;
   conversationId: string | null;
   toolStatus: string | null;
   pendingApprovals: PendingApproval[];
   activity: ActivityEvent[];
+  contextWindowWarning: ContextWindowWarning | null;
   append: (content: string, options?: { metadata?: Record<string, unknown> }) => void;
   resolveApproval: (requestId: string, decision: ApprovalDecision) => Promise<void>;
   stop: () => void;
+  startNewConversation: () => void;
 } {
   const externalConversationId = options.conversationId ?? null;
   const externalProjectId = options.projectId ?? null;
@@ -97,6 +102,7 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
   const [messages, setMessages] = useState<Message[]>(cached?.messages ?? externalMessages);
   const [isLoading, setIsLoading] = useState(cached?.isLoading ?? false);
   const [error, setError] = useState<Error | null>(cached?.error ?? null);
+  const [errorCode, setErrorCode] = useState<string | null>(cached?.errorCode ?? null);
   const [conversationId, setConversationId] = useState<string | null>(
     cached?.conversationId ?? externalConversationId
   );
@@ -105,6 +111,9 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
     cached?.pendingApprovals ?? EMPTY_APPROVALS
   );
   const [activity, setActivity] = useState<ActivityEvent[]>(cached?.activity ?? EMPTY_ACTIVITY);
+  const [contextWindowWarning, setContextWindowWarning] = useState<ContextWindowWarning | null>(
+    cached?.contextWindowWarning ?? null
+  );
 
   const abortControllerRef = useRef<AbortController | null>(cached?.abortController ?? null);
   const requestTokenRef = useRef(cached?.requestToken ?? 0);
@@ -130,9 +139,11 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
 
       setIsLoading(false);
       setError(null);
+      setErrorCode(null);
       setToolStatus(null);
       setPendingApprovals([]);
       setActivity([]);
+      setContextWindowWarning(null);
     }
 
     window.addEventListener(GATEWAY_CHAT_RUNTIME_RESET_EVENT, handleRuntimeReset);
@@ -151,9 +162,11 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
         messages: messages,
         isLoading,
         error,
+        errorCode,
         toolStatus,
         pendingApprovals,
         activity,
+        contextWindowWarning,
         conversationId,
         abortController: abortControllerRef.current,
         requestToken: requestTokenRef.current,
@@ -170,9 +183,11 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
       setMessages(restored.messages);
       setIsLoading(restored.isLoading);
       setError(restored.error);
+      setErrorCode(restored.errorCode);
       setToolStatus(restored.toolStatus);
       setPendingApprovals(restored.pendingApprovals);
       setActivity(restored.activity);
+      setContextWindowWarning(restored.contextWindowWarning);
       setConversationId(restored.conversationId);
       abortControllerRef.current = restored.abortController;
       requestTokenRef.current = restored.requestToken;
@@ -184,12 +199,14 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
       // Start empty when switching conversations; externalMessages can be stale
       // from the previous project's history that has not cleared yet. A later
       // effect repopulates the correct history once async fetch completes.
-      setMessages(EMPTY_MESSAGES);
+      setMessages(EMPTY_MESSAGES);
       setIsLoading(false);
       setError(null);
+      setErrorCode(null);
       setToolStatus(null);
       setPendingApprovals([]);
       setActivity([]);
+      setContextWindowWarning(null);
       setConversationId(externalConversationId);
       abortControllerRef.current = null;
       requestTokenRef.current = 0;
@@ -236,6 +253,28 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
     setIsLoading(false);
   }
 
+  function startNewConversation() {
+    requestTokenRef.current += 1;
+    abortControllerRef.current?.abort();
+    abortControllerRef.current = null;
+    backgroundStreams.delete(cacheKeyRef.current);
+    backgroundStates.delete(cacheKeyRef.current);
+
+    setMessages(EMPTY_MESSAGES);
+    setIsLoading(false);
+    setError(null);
+    setErrorCode(null);
+    setToolStatus(null);
+    setPendingApprovals([]);
+    setActivity([]);
+    setContextWindowWarning(null);
+    setConversationId(null);
+
+    conversationIdRef.current = null;
+    messageCounterRef.current = 0;
+    activityCounterRef.current = 0;
+  }
+
   async function resolveApproval(requestId: string, decision: ApprovalDecision): Promise<void> {
     // Capture the tool name before removing the approval so we can show
     // a user-friendly status ("Writing to your library...") instead of "Approval approved"
@@ -269,6 +308,7 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
       };
 
       setError(null);
+      setErrorCode(null);
       setIsLoading(true);
       setToolStatus("Running slash command...");
       setMessages((current) => [...current, userMessage]);
@@ -289,6 +329,7 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
           setToolStatus(null);
         } catch (error) {
           setError(toError(error));
+          setErrorCode(null);
           setToolStatus(null);
         } finally {
           setIsLoading(false);
@@ -315,7 +356,9 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
     const assistantMessageId = nextMessageId();
 
     setError(null);
+    setErrorCode(null);
     setIsLoading(true);
+    setContextWindowWarning(null);
     setMessages((current) => [...current, userMessage]);
 
     // Track this as a background stream so state updates route correctly
@@ -392,7 +435,17 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
       try {
         for await (const event of sendMessage(conversationIdRef.current, trimmed, {
           signal: controller.signal,
-          metadata: options?.metadata
+          metadata: options?.metadata,
+          onContextWarning: (warning) => {
+            if (isActive()) {
+              setContextWindowWarning(warning);
+              return;
+            }
+
+            updateBackground(() => ({
+              contextWindowWarning: warning,
+            }));
+          },
         })) {
           if (requestToken !== requestTokenRef.current && isActive()) {
             return;
@@ -461,11 +514,13 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
             case "done":
               if (isActive()) {
                 setToolStatus(null);
+                setErrorCode(null);
                 updateConversationId(event.conversation_id);
               } else {
                 updateBackground(() => ({
                   toolStatus: null,
                   isLoading: false,
+                  errorCode: null,
                   conversationId: event.conversation_id ?? null,
                 }));
               }
@@ -475,11 +530,13 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
               if (isActive()) {
                 setToolStatus(null);
                 setError(new Error(event.message));
+                setErrorCode(event.code);
               } else {
                 updateBackground(() => ({
                   toolStatus: null,
                   isLoading: false,
                   error: new Error(event.message),
+                  errorCode: event.code,
                 }));
               }
               backgroundStreams.delete(activeCacheKey);
@@ -526,11 +583,13 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
                 if (isActive()) {
                   setToolStatus(null);
                   setError(toError(approvalError));
+                  setErrorCode(null);
                 } else {
                   updateBackground(() => ({
                     toolStatus: null,
                     isLoading: false,
                     error: toError(approvalError),
+                    errorCode: null,
                   }));
                 }
                 backgroundStreams.delete(activeCacheKey);
@@ -557,6 +616,7 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
           updateBackground(() => ({
             isLoading: false,
             error: toError(caughtError),
+            errorCode: null,
           }));
           backgroundStreams.delete(activeCacheKey);
           return;
@@ -566,6 +626,7 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
         }
 
         setError(toError(caughtError));
+        setErrorCode(null);
       } finally {
         backgroundStreams.delete(activeCacheKey);
         if (isActive() && requestToken === requestTokenRef.current) {
@@ -583,13 +644,16 @@ export function useGatewayChat(options: UseGatewayChatOptions = {}): {
     messages,
     isLoading,
     error,
+    errorCode,
     conversationId,
     toolStatus,
     pendingApprovals,
     activity,
+    contextWindowWarning,
     append,
     resolveApproval,
-    stop
+    stop,
+    startNewConversation
   };
 }
 
diff --git a/builds/typescript/client_web/src/components/chat/ChatPanel.test.tsx b/builds/typescript/client_web/src/components/chat/ChatPanel.test.tsx
index 69f9ace..df38cd6 100644
--- a/builds/typescript/client_web/src/components/chat/ChatPanel.test.tsx
+++ b/builds/typescript/client_web/src/components/chat/ChatPanel.test.tsx
@@ -13,19 +13,32 @@ vi.mock("@/api/useGatewayChat", () => ({
 function makeHookState(overrides: Partial<{
   messages: Message[];
   isLoading: boolean;
+  error: Error | null;
+  errorCode: string | null;
   toolStatus: string | null;
+  contextWindowWarning: {
+    estimated_tokens: number;
+    budget_tokens: number;
+    ratio: number;
+    threshold: number;
+    managed: boolean;
+    message: string;
+  } | null;
 }> = {}) {
   return {
     messages: overrides.messages ?? [],
     isLoading: overrides.isLoading ?? false,
-    error: null,
+    error: overrides.error ?? null,
+    errorCode: overrides.errorCode ?? null,
     conversationId: null,
     toolStatus: overrides.toolStatus ?? null,
     pendingApprovals: [],
     activity: [],
+    contextWindowWarning: overrides.contextWindowWarning ?? null,
     append: vi.fn(),
     resolveApproval: vi.fn(async () => undefined),
     stop: vi.fn(),
+    startNewConversation: vi.fn(),
   };
 }
 
@@ -62,4 +75,41 @@ describe("ChatPanel typing indicator behavior", () => {
 
     expect(screen.queryByText("Thinking...")).not.toBeInTheDocument();
   });
+
+  it("shows context warning banner when near limit", () => {
+    useGatewayChatMock.mockReturnValue(
+      makeHookState({
+        contextWindowWarning: {
+          estimated_tokens: 80_000,
+          budget_tokens: 100_000,
+          ratio: 0.8,
+          threshold: 0.8,
+          managed: false,
+          message: "This session is getting long.",
+        },
+      })
+    );
+
+    render(<ChatPanel activeConversationId={null} isEmpty={false} />);
+
+    expect(screen.getByText("This session is getting long.")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Start New Conversation" })).toBeInTheDocument();
+  });
+
+  it("shows overflow-specific recovery actions", () => {
+    useGatewayChatMock.mockReturnValue(
+      makeHookState({
+        messages: [{ id: "u-1", role: "user", content: "Continue from this prompt" }],
+        error: new Error("This session has gotten long."),
+        errorCode: "context_overflow",
+      })
+    );
+
+    render(<ChatPanel activeConversationId={null} isEmpty={false} />);
+
+    expect(screen.getByRole("button", { name: "Start New Conversation" })).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Continue in New Conversation" })).toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Open Settings" })).not.toBeInTheDocument();
+    expect(screen.queryByRole("button", { name: "Try Again" })).not.toBeInTheDocument();
+  });
 });
diff --git a/builds/typescript/client_web/src/components/chat/ChatPanel.tsx b/builds/typescript/client_web/src/components/chat/ChatPanel.tsx
index a864897..fc03bf4 100644
--- a/builds/typescript/client_web/src/components/chat/ChatPanel.tsx
+++ b/builds/typescript/client_web/src/components/chat/ChatPanel.tsx
@@ -89,11 +89,14 @@ export default function ChatPanel({
     messages,
     isLoading,
     error,
+    errorCode,
     conversationId,
     toolStatus,
     pendingApprovals,
+    contextWindowWarning,
     append,
-    stop
+    stop,
+    startNewConversation,
   } = useGatewayChat({
     conversationId: activeConversationId,
     projectId: activeProjectId ?? null,
@@ -176,15 +179,38 @@ export default function ChatPanel({
   const chatError = historyError ?? error?.message ?? null;
   const visibleChatError =
     chatError && chatError !== dismissedError ? chatError : null;
+  const isContextOverflowError = errorCode === "context_overflow";
   const isProviderError = visibleChatError != null && (
     visibleChatError.includes("credentials") ||
     visibleChatError.includes("could not be reached") ||
     visibleChatError.includes("provider") ||
     visibleChatError.includes("model")
-  );
+  ) && !isContextOverflowError;
+  const lastUserMessage = [...messages].reverse().find((message) => message.role === "user") ?? null;
   const shouldShowEmptyState = isEmpty && messages.length === 0 && !isLoading;
   const shouldShowConversation = contentOverride === undefined;
 
+  function resetErrorPresentation() {
+    setHistoryError(null);
+    if (visibleChatError) {
+      setDismissedError(visibleChatError);
+    }
+    setConnectionStatus("connected");
+  }
+
+  function handleStartNewConversation() {
+    resetErrorPresentation();
+    startNewConversation();
+  }
+
+  function handleContinueInNewConversation() {
+    const replayContent = lastUserMessage?.content?.trim();
+    handleStartNewConversation();
+    if (replayContent && replayContent.length > 0) {
+      append(replayContent, { metadata: messageMetadata });
+    }
+  }
+
   function handleDragOver(e: DragEvent) {
     e.preventDefault();
     setIsDragOver(true);
@@ -323,15 +349,38 @@ export default function ChatPanel({
               isTyping={showTypingFeedback}
               typingStatus={typingStatus}
             >
+              {contextWindowWarning && !visibleChatError && (
+                <div className="mx-auto w-full max-w-[780px] py-2">
+                  <div className="rounded-xl border border-bd-amber/40 bg-bd-amber/10 px-4 py-3 text-sm text-bd-text-primary">
+                    <p>
+                      {contextWindowWarning.message}{" "}
+                      <span className="text-bd-text-secondary">
+                        ({Math.round(contextWindowWarning.ratio * 100)}% of current prompt budget)
+                      </span>
+                    </p>
+                    <button
+                      type="button"
+                      onClick={handleStartNewConversation}
+                      className="mt-2 rounded-lg bg-bd-amber px-3 py-1.5 text-xs font-medium text-bd-bg-primary transition-colors hover:bg-bd-amber-hover"
+                    >
+                      Start New Conversation
+                    </button>
+                  </div>
+                </div>
+              )}
               {visibleChatError && (
                 <ErrorMessage
                   message={visibleChatError}
                   onOpenSettings={isProviderError ? onOpenSettings : undefined}
-                  onRetry={() => {
-                    setHistoryError(null);
-                    setDismissedError(visibleChatError);
-                    setConnectionStatus("connected");
-                  }}
+                  onRetry={isContextOverflowError ? undefined : () => resetErrorPresentation()}
+                  primaryActionLabel={isContextOverflowError ? "Start New Conversation" : undefined}
+                  onPrimaryAction={isContextOverflowError ? handleStartNewConversation : undefined}
+                  secondaryActionLabel={
+                    isContextOverflowError && lastUserMessage ? "Continue in New Conversation" : undefined
+                  }
+                  onSecondaryAction={
+                    isContextOverflowError && lastUserMessage ? handleContinueInNewConversation : undefined
+                  }
                   onDismiss={() => {
                     setHistoryError(null);
                     setDismissedError(visibleChatError);
diff --git a/builds/typescript/client_web/src/components/chat/ErrorMessage.tsx b/builds/typescript/client_web/src/components/chat/ErrorMessage.tsx
index 828939f..7552fab 100644
--- a/builds/typescript/client_web/src/components/chat/ErrorMessage.tsx
+++ b/builds/typescript/client_web/src/components/chat/ErrorMessage.tsx
@@ -5,13 +5,21 @@ type ErrorMessageProps = {
   onRetry?: () => void;
   onDismiss?: () => void;
   onOpenSettings?: () => void;
+  primaryActionLabel?: string;
+  onPrimaryAction?: () => void;
+  secondaryActionLabel?: string;
+  onSecondaryAction?: () => void;
 };
 
 export default function ErrorMessage({
   message,
   onRetry,
   onDismiss,
-  onOpenSettings
+  onOpenSettings,
+  primaryActionLabel,
+  onPrimaryAction,
+  secondaryActionLabel,
+  onSecondaryAction,
 }: ErrorMessageProps) {
   return (
     <div className="mx-auto w-full max-w-[780px] py-2">
@@ -24,6 +32,24 @@ export default function ErrorMessage({
         <div className="min-w-0 flex-1">
           <p className="text-sm text-bd-text-primary">{message}</p>
           <div className="mt-2 flex gap-2">
+            {onPrimaryAction && primaryActionLabel && (
+              <button
+                type="button"
+                onClick={onPrimaryAction}
+                className="flex items-center gap-1.5 rounded-lg bg-bd-amber px-3 py-1.5 text-xs font-medium text-bd-bg-primary transition-colors hover:bg-bd-amber-hover"
+              >
+                {primaryActionLabel}
+              </button>
+            )}
+            {onSecondaryAction && secondaryActionLabel && (
+              <button
+                type="button"
+                onClick={onSecondaryAction}
+                className="flex items-center gap-1.5 rounded-lg bg-bd-bg-tertiary px-3 py-1.5 text-xs text-bd-text-secondary transition-colors hover:bg-bd-bg-hover"
+              >
+                {secondaryActionLabel}
+              </button>
+            )}
             {onOpenSettings && (
               <button
                 type="button"
diff --git a/builds/typescript/engine/errors.test.ts b/builds/typescript/engine/errors.test.ts
new file mode 100644
index 0000000..b0696ca
--- /dev/null
+++ b/builds/typescript/engine/errors.test.ts
@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+
+import { classifyProviderError } from "./errors.js";
+
+describe("classifyProviderError", () => {
+  it("maps context/token failures to human-readable context_overflow messaging", () => {
+    const event = classifyProviderError(new Error("Request failed: context length exceeded"));
+
+    expect(event).toEqual({
+      type: "error",
+      code: "context_overflow",
+      message: "This session has gotten long. Start a new conversation to continue - all your work is saved.",
+    });
+  });
+
+  it("sanitizes credential failures", () => {
+    const event = classifyProviderError(new Error("API key invalid"));
+
+    expect(event).toEqual({
+      type: "error",
+      code: "provider_error",
+      message: "Model provider credentials were rejected — check your API key in Settings",
+    });
+  });
+});
diff --git a/builds/typescript/engine/errors.ts b/builds/typescript/engine/errors.ts
index 0c17964..d1b910e 100644
--- a/builds/typescript/engine/errors.ts
+++ b/builds/typescript/engine/errors.ts
@@ -8,7 +8,7 @@ export function classifyProviderError(error: unknown): StreamEvent {
     return {
       type: "error",
       code: "context_overflow",
-      message: "The model context limit was exceeded",
+      message: "This session has gotten long. Start a new conversation to continue - all your work is saved.",
     };
   }
 
diff --git a/builds/typescript/engine/loop.ts b/builds/typescript/engine/loop.ts
index 0c2e936..870a5c4 100644
--- a/builds/typescript/engine/loop.ts
+++ b/builds/typescript/engine/loop.ts
@@ -38,7 +38,7 @@ export async function* runAgentLoop(
       yield {
         type: "error",
         code: "context_overflow",
-        message: "Conversation exceeded the configured safety limit",
+        message: "This session has gotten long. Start a new conversation to continue - all your work is saved.",
       };
       return;
     }
diff --git a/builds/typescript/gateway/context-window.test.ts b/builds/typescript/gateway/context-window.test.ts
new file mode 100644
index 0000000..da9f741
--- /dev/null
+++ b/builds/typescript/gateway/context-window.test.ts
@@ -0,0 +1,158 @@
+import path from "node:path";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+
+import { describe, expect, it } from "vitest";
+
+import type { GatewayMessage, ToolDefinition } from "../contracts.js";
+import { prepareContextWindow, resolveContextWindowSettingsFromEnv } from "./context-window.js";
+
+function createTool(name: string): ToolDefinition {
+  return {
+    name,
+    description: `${name} description`,
+    requiresApproval: false,
+    readOnly: true,
+    inputSchema: {
+      type: "object",
+      properties: {
+        q: { type: "string" },
+      },
+    },
+    execute: async () => ({ ok: true }),
+  };
+}
+
+describe("context window manager", () => {
+  it("resolves env settings safely", () => {
+    const settings = resolveContextWindowSettingsFromEnv({
+      BRAINDRIVE_CONTEXT_WINDOW_TOKENS: "64000",
+      BRAINDRIVE_CONTEXT_RESPONSE_HEADROOM_TOKENS: "4000",
+      BRAINDRIVE_CONTEXT_WARNING_THRESHOLD: "0.75",
+    });
+
+    expect(settings).toEqual({
+      contextWindowTokens: 64_000,
+      responseHeadroomTokens: 4_000,
+      warningThreshold: 0.75,
+    });
+
+    const invalid = resolveContextWindowSettingsFromEnv({
+      BRAINDRIVE_CONTEXT_WINDOW_TOKENS: "0",
+      BRAINDRIVE_CONTEXT_RESPONSE_HEADROOM_TOKENS: "-1",
+      BRAINDRIVE_CONTEXT_WARNING_THRESHOLD: "1.2",
+    });
+
+    expect(invalid.warningThreshold).toBe(0.8);
+    expect(invalid.contextWindowTokens).toBe(128_000);
+    expect(invalid.responseHeadroomTokens).toBe(8_000);
+  });
+
+  it("compacts older turns and writes a summary artifact when over budget", async () => {
+    const memoryRoot = await mkdtemp(path.join(tmpdir(), "bd-context-window-"));
+
+    try {
+      const messages: GatewayMessage[] = [
+        {
+          role: "system",
+          content: "You are BrainDrive.",
+        },
+      ];
+
+      for (let index = 0; index < 12; index += 1) {
+        messages.push(
+          {
+            role: "user",
+            content: `Long user turn ${index}: ${"alpha ".repeat(900)}`,
+          },
+          {
+            role: "assistant",
+            content: `Long assistant turn ${index}: ${"beta ".repeat(900)}`,
+          }
+        );
+      }
+
+      const prepared = await prepareContextWindow({
+        memoryRoot,
+        conversationId: "conv-heavy",
+        correlationId: "corr-heavy",
+        messages,
+        tools: [createTool("memory_search"), createTool("memory_read")],
+        settings: {
+          contextWindowTokens: 4_096,
+          responseHeadroomTokens: 512,
+          warningThreshold: 0.8,
+        },
+      });
+
+      expect(prepared.messages.length).toBeLessThan(messages.length);
+      expect(prepared.usage.droppedUnits).toBeGreaterThan(0);
+      expect(prepared.usage.summaryApplied).toBe(true);
+      expect(prepared.warning?.managed).toBe(true);
+      expect(prepared.warning?.message).toContain("compacted");
+      expect(prepared.usage.summaryArtifactPath).toBeTruthy();
+
+      const artifactPath = path.join(memoryRoot, prepared.usage.summaryArtifactPath!);
+      const artifact = await readFile(artifactPath, "utf8");
+      expect(artifact).toContain("# Context Summary Artifact");
+      expect(artifact).toContain("Conversation ID: conv-heavy");
+      expect(artifact).toContain("Summary Text");
+    } finally {
+      await rm(memoryRoot, { recursive: true, force: true });
+    }
+  });
+
+  it("preserves assistant tool-call blocks without splitting tool responses", async () => {
+    const memoryRoot = await mkdtemp(path.join(tmpdir(), "bd-context-window-"));
+
+    try {
+      const messages: GatewayMessage[] = [
+        { role: "system", content: "You are BrainDrive." },
+        { role: "user", content: `Older question ${"x ".repeat(1500)}` },
+        { role: "assistant", content: `Older answer ${"y ".repeat(1500)}` },
+        {
+          role: "assistant",
+          content: "",
+          tool_calls: [
+            {
+              id: "tool-1",
+              name: "memory_search",
+              input: { q: "finance notes" },
+            },
+          ],
+        },
+        {
+          role: "tool",
+          tool_call_id: "tool-1",
+          content: JSON.stringify({ status: "ok", output: { matches: ["doc-1"] } }),
+        },
+        { role: "assistant", content: "I found your finance notes." },
+      ];
+
+      const prepared = await prepareContextWindow({
+        memoryRoot,
+        conversationId: "conv-tools",
+        correlationId: "corr-tools",
+        messages,
+        tools: [createTool("memory_search")],
+        settings: {
+          contextWindowTokens: 3_000,
+          responseHeadroomTokens: 500,
+          warningThreshold: 0.8,
+        },
+      });
+
+      const toolIndices = prepared.messages
+        .map((message, index) => (message.role === "tool" ? index : -1))
+        .filter((index) => index >= 0);
+
+      for (const toolIndex of toolIndices) {
+        const previousMessage = prepared.messages[toolIndex - 1];
+        expect(previousMessage?.role).toBe("assistant");
+        expect(previousMessage?.tool_calls?.length).toBeGreaterThan(0);
+      }
+    } finally {
+      await rm(memoryRoot, { recursive: true, force: true });
+    }
+  });
+});
diff --git a/builds/typescript/gateway/context-window.ts b/builds/typescript/gateway/context-window.ts
new file mode 100644
index 0000000..6003938
--- /dev/null
+++ b/builds/typescript/gateway/context-window.ts
@@ -0,0 +1,506 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { mkdir, writeFile } from "node:fs/promises";
+
+import type { GatewayMessage, ToolDefinition } from "../contracts.js";
+
+const DEFAULT_CONTEXT_WINDOW_TOKENS = 128_000;
+const DEFAULT_RESPONSE_HEADROOM_TOKENS = 8_000;
+const DEFAULT_WARNING_THRESHOLD = 0.8;
+const MIN_MESSAGE_BUDGET_TOKENS = 2_048;
+const SUMMARY_MAX_LINES = 24;
+
+const MAX_CONTENT_CHARS: Record<GatewayMessage["role"], number> = {
+  system: 24_000,
+  user: 8_000,
+  assistant: 12_000,
+  tool: 4_000,
+};
+
+type ContextUnit = {
+  messages: GatewayMessage[];
+  estimatedTokens: number;
+};
+
+export type ContextWindowSettings = {
+  contextWindowTokens: number;
+  responseHeadroomTokens: number;
+  warningThreshold: number;
+};
+
+export type ContextWindowWarning = {
+  estimated_tokens: number;
+  budget_tokens: number;
+  ratio: number;
+  threshold: number;
+  managed: boolean;
+  message: string;
+};
+
+export type ContextWindowUsage = {
+  estimatedPromptTokensBefore: number;
+  estimatedPromptTokensAfter: number;
+  budgetTokens: number;
+  ratioBefore: number;
+  ratioAfter: number;
+  threshold: number;
+  droppedUnits: number;
+  droppedMessages: number;
+  summaryApplied: boolean;
+  summaryArtifactPath: string | null;
+  summaryArtifactWriteError: string | null;
+};
+
+export type PreparedContextWindow = {
+  messages: GatewayMessage[];
+  usage: ContextWindowUsage;
+  warning: ContextWindowWarning | null;
+};
+
+export type PrepareContextWindowInput = {
+  memoryRoot: string;
+  conversationId: string;
+  correlationId: string;
+  messages: GatewayMessage[];
+  tools: ToolDefinition[];
+  settings?: Partial<ContextWindowSettings>;
+};
+
+export function resolveContextWindowSettingsFromEnv(
+  env: NodeJS.ProcessEnv = process.env
+): ContextWindowSettings {
+  return {
+    contextWindowTokens:
+      parsePositiveInteger(env.BRAINDRIVE_CONTEXT_WINDOW_TOKENS) ?? DEFAULT_CONTEXT_WINDOW_TOKENS,
+    responseHeadroomTokens:
+      parsePositiveInteger(env.BRAINDRIVE_CONTEXT_RESPONSE_HEADROOM_TOKENS) ??
+      DEFAULT_RESPONSE_HEADROOM_TOKENS,
+    warningThreshold: parseRatio(env.BRAINDRIVE_CONTEXT_WARNING_THRESHOLD) ?? DEFAULT_WARNING_THRESHOLD,
+  };
+}
+
+export async function prepareContextWindow(input: PrepareContextWindowInput): Promise<PreparedContextWindow> {
+  const settings = {
+    ...resolveContextWindowSettingsFromEnv(),
+    ...(input.settings ?? {}),
+  };
+
+  if (input.messages.length === 0) {
+    return {
+      messages: [],
+      usage: {
+        estimatedPromptTokensBefore: 0,
+        estimatedPromptTokensAfter: 0,
+        budgetTokens: settings.contextWindowTokens,
+        ratioBefore: 0,
+        ratioAfter: 0,
+        threshold: settings.warningThreshold,
+        droppedUnits: 0,
+        droppedMessages: 0,
+        summaryApplied: false,
+        summaryArtifactPath: null,
+        summaryArtifactWriteError: null,
+      },
+      warning: null,
+    };
+  }
+
+  const boundedMessages = input.messages.map((message) => boundedMessage(message));
+  const toolTokens = estimateToolDefinitionTokens(input.tools);
+  const promptBudgetTokens = Math.max(
+    MIN_MESSAGE_BUDGET_TOKENS,
+    settings.contextWindowTokens - settings.responseHeadroomTokens
+  );
+  const messageBudgetTokens = Math.max(MIN_MESSAGE_BUDGET_TOKENS, promptBudgetTokens - toolTokens);
+
+  const estimatedPromptTokensBefore = estimateMessagesTokens(boundedMessages) + toolTokens;
+  const ratioBefore = safeRatio(estimatedPromptTokensBefore, promptBudgetTokens);
+
+  const fallbackSystemMessage: GatewayMessage = { role: "system", content: "" };
+  const systemMessage: GatewayMessage =
+    boundedMessages[0]?.role === "system" ? boundedMessages[0] : fallbackSystemMessage;
+  const replayMessages = boundedMessages[0]?.role === "system" ? boundedMessages.slice(1) : boundedMessages;
+  const replayUnits = buildReplayUnits(replayMessages);
+
+  const selectedUnits: ContextUnit[] = [];
+  const droppedUnits: ContextUnit[] = [];
+  let usedTokens = estimateMessageTokens(systemMessage);
+
+  for (let index = replayUnits.length - 1; index >= 0; index -= 1) {
+    const unit = replayUnits[index];
+    const wouldExceed = usedTokens + unit.estimatedTokens > messageBudgetTokens;
+    if (!wouldExceed || selectedUnits.length === 0) {
+      selectedUnits.unshift(unit);
+      usedTokens += unit.estimatedTokens;
+      continue;
+    }
+
+    droppedUnits.unshift(unit);
+  }
+
+  let summaryLines = droppedUnits.length > 0 ? buildSummaryLines(droppedUnits) : [];
+  let summaryMessage = summaryLines.length > 0 ? buildSummaryMessage(summaryLines) : null;
+
+  const rebuildMessages = (): GatewayMessage[] => {
+    const replay = flattenUnits(selectedUnits);
+    return [
+      systemMessage,
+      ...(summaryMessage ? [summaryMessage] : []),
+      ...replay,
+    ];
+  };
+
+  let managedMessages = rebuildMessages();
+  let managedMessageTokens = estimateMessagesTokens(managedMessages);
+
+  while (summaryLines.length > 1 && managedMessageTokens > messageBudgetTokens) {
+    summaryLines = summaryLines.slice(0, Math.max(1, summaryLines.length - 2));
+    summaryMessage = buildSummaryMessage(summaryLines);
+    managedMessages = rebuildMessages();
+    managedMessageTokens = estimateMessagesTokens(managedMessages);
+  }
+
+  while (managedMessageTokens > messageBudgetTokens && selectedUnits.length > 1) {
+    const removed = selectedUnits.shift();
+    if (removed) {
+      droppedUnits.push(removed);
+    }
+
+    summaryLines = buildSummaryLines(droppedUnits);
+    summaryMessage = buildSummaryMessage(summaryLines);
+    managedMessages = rebuildMessages();
+    managedMessageTokens = estimateMessagesTokens(managedMessages);
+
+    while (summaryLines.length > 1 && managedMessageTokens > messageBudgetTokens) {
+      summaryLines = summaryLines.slice(0, Math.max(1, summaryLines.length - 2));
+      summaryMessage = buildSummaryMessage(summaryLines);
+      managedMessages = rebuildMessages();
+      managedMessageTokens = estimateMessagesTokens(managedMessages);
+    }
+  }
+
+  if (managedMessageTokens > messageBudgetTokens) {
+    managedMessages = aggressivelyTrimForBudget(managedMessages, messageBudgetTokens);
+    managedMessageTokens = estimateMessagesTokens(managedMessages);
+  }
+
+  const summaryApplied = droppedUnits.length > 0 && summaryMessage !== null;
+
+  let summaryArtifactPath: string | null = null;
+  let summaryArtifactWriteError: string | null = null;
+  if (droppedUnits.length > 0 && summaryMessage) {
+    try {
+      summaryArtifactPath = await writeSummaryArtifact({
+        memoryRoot: input.memoryRoot,
+        conversationId: input.conversationId,
+        correlationId: input.correlationId,
+        summaryContent: summaryMessage.content,
+        droppedUnits,
+        estimatedPromptTokensBefore,
+        estimatedPromptTokensAfter: managedMessageTokens + toolTokens,
+        budgetTokens: promptBudgetTokens,
+      });
+    } catch (error) {
+      summaryArtifactWriteError = error instanceof Error ? error.message : String(error);
+    }
+  }
+
+  const estimatedPromptTokensAfter = managedMessageTokens + toolTokens;
+  const ratioAfter = safeRatio(estimatedPromptTokensAfter, promptBudgetTokens);
+  const droppedMessages = droppedUnits.reduce((count, unit) => count + unit.messages.length, 0);
+
+  const warningNeeded = ratioBefore >= settings.warningThreshold || droppedUnits.length > 0;
+  const warning: ContextWindowWarning | null = warningNeeded
+    ? {
+        estimated_tokens: estimatedPromptTokensBefore,
+        budget_tokens: promptBudgetTokens,
+        ratio: roundTo(ratioBefore, 3),
+        threshold: settings.warningThreshold,
+        managed: summaryApplied,
+        message: summaryApplied
+          ? "This session is getting long. Earlier turns were compacted so you can keep chatting."
+          : "This session is getting long. Consider starting a new conversation soon.",
+      }
+    : null;
+
+  return {
+    messages: managedMessages,
+    usage: {
+      estimatedPromptTokensBefore,
+      estimatedPromptTokensAfter,
+      budgetTokens: promptBudgetTokens,
+      ratioBefore,
+      ratioAfter,
+      threshold: settings.warningThreshold,
+      droppedUnits: droppedUnits.length,
+      droppedMessages,
+      summaryApplied,
+      summaryArtifactPath,
+      summaryArtifactWriteError,
+    },
+    warning,
+  };
+}
+
+function parsePositiveInteger(value: string | undefined): number | null {
+  if (!value) {
+    return null;
+  }
+
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    return null;
+  }
+
+  return parsed;
+}
+
+function parseRatio(value: string | undefined): number | null {
+  if (!value) {
+    return null;
+  }
+
+  const parsed = Number.parseFloat(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || parsed >= 1) {
+    return null;
+  }
+
+  return parsed;
+}
+
+function safeRatio(numerator: number, denominator: number): number {
+  if (denominator <= 0) {
+    return 0;
+  }
+
+  return numerator / denominator;
+}
+
+function roundTo(value: number, decimals: number): number {
+  const multiplier = 10 ** decimals;
+  return Math.round(value * multiplier) / multiplier;
+}
+
+function estimateTokens(value: string): number {
+  if (value.length === 0) {
+    return 0;
+  }
+
+  return Math.ceil(value.length / 4);
+}
+
+function estimateMessageTokens(message: GatewayMessage): number {
+  const toolCallsTokens = message.tool_calls ? estimateTokens(JSON.stringify(message.tool_calls)) : 0;
+  const toolCallIdTokens = message.tool_call_id ? estimateTokens(message.tool_call_id) : 0;
+  return 6 + estimateTokens(message.content) + toolCallsTokens + toolCallIdTokens;
+}
+
+function estimateMessagesTokens(messages: GatewayMessage[]): number {
+  return messages.reduce((total, message) => total + estimateMessageTokens(message), 0);
+}
+
+function estimateToolDefinitionTokens(tools: ToolDefinition[]): number {
+  const serializable = tools.map((tool) => ({
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema,
+    },
+  }));
+
+  return estimateTokens(JSON.stringify(serializable));
+}
+
+function boundedMessage(message: GatewayMessage): GatewayMessage {
+  const maxChars = MAX_CONTENT_CHARS[message.role] ?? 8_000;
+  const boundedContent = truncateMiddle(message.content, maxChars);
+  return {
+    ...message,
+    content: boundedContent,
+  };
+}
+
+function truncateMiddle(value: string, maxChars: number): string {
+  if (value.length <= maxChars) {
+    return value;
+  }
+
+  const marker = `\n...[truncated ${value.length - maxChars} chars for context budget]...\n`;
+  const remaining = Math.max(0, maxChars - marker.length);
+  const head = Math.ceil(remaining * 0.65);
+  const tail = Math.max(0, remaining - head);
+  return `${value.slice(0, head)}${marker}${value.slice(value.length - tail)}`;
+}
+
+function buildReplayUnits(messages: GatewayMessage[]): ContextUnit[] {
+  const units: ContextUnit[] = [];
+
+  for (let index = 0; index < messages.length; index += 1) {
+    const message = messages[index];
+
+    if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
+      const unitMessages: GatewayMessage[] = [message];
+      let cursor = index + 1;
+      while (cursor < messages.length && messages[cursor]?.role === "tool") {
+        unitMessages.push(messages[cursor]);
+        cursor += 1;
+      }
+
+      units.push({
+        messages: unitMessages,
+        estimatedTokens: estimateMessagesTokens(unitMessages),
+      });
+      index = cursor - 1;
+      continue;
+    }
+
+    units.push({
+      messages: [message],
+      estimatedTokens: estimateMessageTokens(message),
+    });
+  }
+
+  return units;
+}
+
+function flattenUnits(units: ContextUnit[]): GatewayMessage[] {
+  return units.flatMap((unit) => unit.messages);
+}
+
+function buildSummaryLines(units: ContextUnit[]): string[] {
+  const lines: string[] = [];
+
+  for (const unit of units) {
+    for (const message of unit.messages) {
+      if (message.role === "tool") {
+        continue;
+      }
+
+      if (message.role === "assistant" && message.tool_calls && message.tool_calls.length > 0) {
+        const names = message.tool_calls.map((toolCall) => toolCall.name).join(", ");
+        lines.push(`- Assistant requested tools: ${names}`);
+      }
+
+      const snippet = compactSnippet(message.content);
+      if (snippet.length === 0) {
+        continue;
+      }
+
+      if (message.role === "user") {
+        lines.push(`- User: ${snippet}`);
+      } else if (message.role === "assistant") {
+        lines.push(`- Assistant: ${snippet}`);
+      }
+
+      if (lines.length >= SUMMARY_MAX_LINES) {
+        return lines;
+      }
+    }
+
+    if (lines.length >= SUMMARY_MAX_LINES) {
+      return lines;
+    }
+  }
+
+  if (lines.length === 0) {
+    lines.push("- Earlier turns were compressed to keep this session within context limits.");
+  }
+
+  return lines.slice(0, SUMMARY_MAX_LINES);
+}
+
+function compactSnippet(value: string): string {
+  const cleaned = value.replace(/\s+/g, " ").trim();
+  if (cleaned.length === 0) {
+    return "";
+  }
+
+  return cleaned.length <= 180 ? cleaned : `${cleaned.slice(0, 180)}...`;
+}
+
+function buildSummaryMessage(lines: string[]): GatewayMessage {
+  return {
+    role: "system",
+    content: [
+      "Earlier conversation summary (auto-generated to keep this session running):",
+      ...lines,
+      "Use this summary as prior context for continuity.",
+    ].join("\n"),
+  };
+}
+
+function aggressivelyTrimForBudget(messages: GatewayMessage[], budgetTokens: number): GatewayMessage[] {
+  const caps = [2_000, 1_200, 700, 400];
+  let candidate = [...messages];
+
+  for (const cap of caps) {
+    candidate = candidate.map((message, index) => {
+      if (index === 0 && message.role === "system") {
+        return { ...message, content: truncateMiddle(message.content, Math.max(cap * 2, cap)) };
+      }
+
+      return {
+        ...message,
+        content: truncateMiddle(message.content, cap),
+      };
+    });
+
+    if (estimateMessagesTokens(candidate) <= budgetTokens) {
+      return candidate;
+    }
+  }
+
+  while (candidate.length > 2 && estimateMessagesTokens(candidate) > budgetTokens) {
+    candidate = [candidate[0], ...candidate.slice(2)];
+  }
+
+  return candidate;
+}
+
+async function writeSummaryArtifact(input: {
+  memoryRoot: string;
+  conversationId: string;
+  correlationId: string;
+  summaryContent: string;
+  droppedUnits: ContextUnit[];
+  estimatedPromptTokensBefore: number;
+  estimatedPromptTokensAfter: number;
+  budgetTokens: number;
+}): Promise<string> {
+  const safeConversationId = sanitizePathSegment(input.conversationId);
+  const safeCorrelationId = sanitizePathSegment(input.correlationId);
+  const relativePath = path.posix.join("conversations", "summaries", safeConversationId, `${safeCorrelationId}.md`);
+  const absolutePath = path.join(input.memoryRoot, relativePath);
+  await mkdir(path.dirname(absolutePath), { recursive: true });
+
+  const digest = createHash("sha256").update(input.summaryContent).digest("hex");
+  const artifact = [
+    "# Context Summary Artifact",
+    "",
+    `Conversation ID: ${input.conversationId}`,
+    `Correlation ID: ${input.correlationId}`,
+    `Generated At: ${new Date().toISOString()}`,
+    "",
+    "## Budget",
+    `- Prompt tokens before management: ${input.estimatedPromptTokensBefore}`,
+    `- Prompt tokens after management: ${input.estimatedPromptTokensAfter}`,
+    `- Prompt budget tokens: ${input.budgetTokens}`,
+    "",
+    "## Compression",
+    `- Dropped context units: ${input.droppedUnits.length}`,
+    `- Dropped messages: ${input.droppedUnits.reduce((count, unit) => count + unit.messages.length, 0)}`,
+    `- Summary digest (sha256): ${digest}`,
+    "",
+    "## Summary Text",
+    input.summaryContent,
+    "",
+  ].join("\n");
+
+  await writeFile(absolutePath, artifact, "utf8");
+  return relativePath;
+}
+
+function sanitizePathSegment(value: string): string {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
diff --git a/builds/typescript/gateway/server.ts b/builds/typescript/gateway/server.ts
index 4a7f33b..6317288 100644
--- a/builds/typescript/gateway/server.ts
+++ b/builds/typescript/gateway/server.ts
@@ -66,6 +66,7 @@ import { GatewayConversationService } from "./conversations.js";
 import { createMemoryBackupScheduler } from "./memory-backup-scheduler.js";
 import { GatewayProjectService, isProjectMetadata, ProtectedProjectError } from "./projects.js";
 import { GatewaySkillService } from "./skills.js";
+import { prepareContextWindow } from "./context-window.js";
 
 const approvalDecisionSchema = z.object({
   decision: z.enum(["approved", "denied"]),
@@ -596,19 +597,54 @@ export async function buildServer(rootDir = process.cwd()) {
       : "";
     const finalPrompt = promptWithSkills.prompt + projectContext;
 
-    const engineRequest = gatewayAdapter.buildEngineRequest({
-      conversationId,
-      correlationId: crypto.randomUUID(),
-      messages: conversations.buildConversationMessages(conversationId, finalPrompt),
-      ...(body.metadata ? { clientMetadata: body.metadata } : {}),
-    });
-
-    reply.raw.writeHead(200, {
-      "content-type": "text/event-stream",
-      "cache-control": "no-cache",
-      connection: "keep-alive",
-      "x-conversation-id": conversationId,
-    });
+    const correlationId = crypto.randomUUID();
+    const contextWindow = await prepareContextWindow({
+      memoryRoot: runtimeConfig.memory_root,
+      conversationId,
+      correlationId,
+      messages: conversations.buildConversationMessages(conversationId, finalPrompt),
+      tools: toolExecutor.listTools(request.authContext),
+    });
+
+    auditLog("context.window", {
+      conversation_id: conversationId,
+      estimated_prompt_tokens_before: contextWindow.usage.estimatedPromptTokensBefore,
+      estimated_prompt_tokens_after: contextWindow.usage.estimatedPromptTokensAfter,
+      budget_tokens: contextWindow.usage.budgetTokens,
+      ratio_before: Number(contextWindow.usage.ratioBefore.toFixed(3)),
+      ratio_after: Number(contextWindow.usage.ratioAfter.toFixed(3)),
+      warning_threshold: contextWindow.usage.threshold,
+      dropped_units: contextWindow.usage.droppedUnits,
+      dropped_messages: contextWindow.usage.droppedMessages,
+      summary_applied: contextWindow.usage.summaryApplied,
+      summary_artifact_path: contextWindow.usage.summaryArtifactPath,
+      summary_artifact_write_error: contextWindow.usage.summaryArtifactWriteError,
+    });
+
+    const engineRequest = gatewayAdapter.buildEngineRequest({
+      conversationId,
+      correlationId,
+      messages: contextWindow.messages,
+      ...(body.metadata ? { clientMetadata: body.metadata } : {}),
+    });
+
+    const streamHeaders: Record<string, string> = {
+      "content-type": "text/event-stream",
+      "cache-control": "no-cache",
+      connection: "keep-alive",
+      "x-conversation-id": conversationId,
+    };
+    if (contextWindow.warning) {
+      streamHeaders["x-context-window-warning"] = "1";
+      streamHeaders["x-context-window-estimated-tokens"] = String(contextWindow.warning.estimated_tokens);
+      streamHeaders["x-context-window-budget-tokens"] = String(contextWindow.warning.budget_tokens);
+      streamHeaders["x-context-window-ratio"] = String(contextWindow.warning.ratio);
+      streamHeaders["x-context-window-threshold"] = String(contextWindow.warning.threshold);
+      streamHeaders["x-context-window-managed"] = contextWindow.warning.managed ? "1" : "0";
+      streamHeaders["x-context-window-message"] = contextWindow.warning.message;
+    }
+
+    reply.raw.writeHead(200, streamHeaders);
 
     let assistantBuffer = "";
     let currentAssistantMessageId = crypto.randomUUID();