@kmugalkhod/lightcode 0.1.3 → 0.3.0

package/server.js

@@ -17,6 +17,19 @@ var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // packages/shared/src/data-dir.ts
+import { homedir, platform } from "os";
+import path from "path";
+function getLightcodeDataDir(env = process.env) {
+  const configuredHome = env.LIGHTCODE_HOME?.trim();
+  if (configuredHome) {
+    return path.resolve(configuredHome);
+  }
+  if (platform() === "win32") {
+    const appData = env.APPDATA || env.LOCALAPPDATA;
+    return appData ? path.join(appData, "lightcode") : path.join(homedir(), "AppData", "Roaming", "lightcode");
+  }
+  return path.join(homedir(), ".lightcode");
+}
 var init_data_dir = () => {};
 
 // packages/shared/src/error-utils.ts
@@ -31,6 +44,14 @@ function getErrorMessage(error, fallback = "Unknown error") {
 }
 
 // packages/shared/src/logger.ts
+import {
+  appendFileSync,
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  unlinkSync
+} from "fs";
+import path2 from "path";
 function resolveConfiguredLevel() {
   const raw = process.env.LIGHTCODE_LOG_LEVEL?.trim().toLowerCase();
   if (raw === "debug" || raw === "info" || raw === "warn" || raw === "error") {
@@ -38,6 +59,49 @@ function resolveConfiguredLevel() {
   }
   return "info";
 }
+function getLogDirectory(env = process.env) {
+  return path2.join(getLightcodeDataDir(env), "logs");
+}
+function currentDateStamp() {
+  return new Date().toISOString().slice(0, 10);
+}
+function pruneOldLogFiles(directory) {
+  try {
+    const logFiles = readdirSync(directory).filter((name) => logFilePattern.test(name)).sort();
+    for (const name of logFiles.slice(0, -maxLogFilesKept)) {
+      unlinkSync(path2.join(directory, name));
+    }
+  } catch {}
+}
+function enableFileLogSink(env = process.env) {
+  try {
+    const directory = getLogDirectory(env);
+    mkdirSync(directory, { recursive: true });
+    fileSinkPrefix = directory;
+    pruneOldLogFiles(directory);
+    return directory;
+  } catch {
+    fileSinkPrefix = null;
+    return null;
+  }
+}
+function writeToFileSink(line) {
+  if (!fileSinkPrefix) {
+    return;
+  }
+  try {
+    const date = currentDateStamp();
+    if (!fileSinkState || fileSinkState.date !== date) {
+      fileSinkState = {
+        date,
+        filePath: path2.join(fileSinkPrefix, `server-${date}.log`)
+      };
+      pruneOldLogFiles(fileSinkPrefix);
+    }
+    appendFileSync(fileSinkState.filePath, `${line}
+`);
+  } catch {}
+}
 function createLogger(name) {
   const write = (level, event, fields) => {
     if (levelOrder[level] < levelOrder[resolveConfiguredLevel()]) {
@@ -52,6 +116,7 @@ function createLogger(name) {
     });
     process.stderr.write(`${line}
 `);
+    writeToFileSink(line);
   };
   return {
     debug: (event, fields) => write("debug", event, fields),
@@ -60,14 +125,16 @@ function createLogger(name) {
     error: (event, fields) => write("error", event, fields)
   };
 }
-var levelOrder;
+var levelOrder, maxLogFilesKept = 5, logFilePattern, fileSinkPrefix = null, fileSinkState = null;
 var init_logger = __esm(() => {
+  init_data_dir();
   levelOrder = {
     debug: 10,
     info: 20,
     warn: 30,
     error: 40
   };
+  logFilePattern = /^server-\d{4}-\d{2}-\d{2}\.log$/;
 });
 // packages/shared/src/index.ts
 function createGreeting(target) {
@@ -1486,6 +1553,29 @@ var init_agent_tools = __esm(() => {
   });
 });
 
+// packages/ai/src/chat-error.ts
+function formatChatStreamError(info) {
+  const payload = {
+    ...info,
+    message: info.message.slice(0, maxTransportMessageLength)
+  };
+  return `${chatStreamErrorPrefix}${JSON.stringify(payload)}`;
+}
+var chatStreamErrorPrefix = "LIGHTCODE_ERROR:", maxTransportMessageLength = 500, chatErrorKinds;
+var init_chat_error = __esm(() => {
+  chatErrorKinds = new Set([
+    "auth",
+    "billing",
+    "rate_limit",
+    "invalid_request",
+    "context_overflow",
+    "provider_unavailable",
+    "network",
+    "aborted",
+    "unknown"
+  ]);
+});
+
 // packages/ai/src/context/context-state.ts
 import { z as z22 } from "zod";
 var contextStateTierSchema, sessionContextStateSchema;
@@ -1811,7 +1901,9 @@ var init_coding_agent_prompt = __esm(() => {
   init_coding_agent_modes();
   defaultCodingAgentSystemPrompt = "You are a basic coding agent. Use tools for filesystem and codebase tasks instead of guessing. " + "Respect the user's intent, explain changes clearly, and prefer incremental, auditable actions. " + "You can only interact with files under this working directory: {cwd}. " + "Use glob_search for path discovery, grep for text search, structured git tools for repository inspection, and bash only when dedicated tools are not enough. " + "Use todo_write to keep multi-step implementation work visible and current. " + "For risky or uncertain operations, inspect context first and be explicit about assumptions. " + "While working, emit brief progress notes in natural language before major tool actions and after important findings. " + `Keep them short, human, and concrete. Vary wording naturally and avoid repetitive templates or rigid labels.
 
-` + "You are an agent \u2014 keep working until the user's request is fully resolved before ending your turn. " + "Never stop with a partial answer. If you say you will do something, do it in the same turn by calling a tool. " + "Use todo_write to track multi-step work and do not finish while any todo is pending or in_progress. " + "Only end your turn when the task is complete or you are blocked on input that only the user can provide.";
+` + "You are an agent \u2014 keep working until the user's request is fully resolved before ending your turn. " + "Never stop with a partial answer. If you say you will do something, do it in the same turn by calling a tool. " + "Use todo_write to track multi-step work and do not finish while any todo is pending or in_progress. " + `Only end your turn when the task is complete or you are blocked on input that only the user can provide.
+
+` + "Long-running processes: never run dev servers, watchers, or other non-exiting commands as plain foreground bash \u2014 " + "the bash tool enforces a timeout and the command will be killed. Start them detached with output redirected to a " + 'log file (e.g. on Windows: start /B cmd /c "npm run dev > dev.log 2>&1"; on Unix: nohup npm run dev > dev.log 2>&1 &), ' + "wait briefly, then verify by reading the log file or with a bounded probe like curl --max-time 5. " + "Dev servers do not always get their default port \u2014 read the actual port from the startup log instead of assuming it. " + "Never kill processes or free ports you did not open yourself; other tools (including this agent's own backend) may be using them.";
   toolCallingDisciplineAddendum = "Invoke tools only through the function-calling interface. " + "Never write tool calls as XML or plain text such as <tool_call>, <function_call>, <invoke>, or bare JSON in your message. " + "Tool arguments must be valid JSON matching the tool's schema. " + "Call one tool at a time and wait for its result before deciding the next step.";
 });
 
@@ -2456,6 +2548,7 @@ function createCodingAgent({
   promptOverride,
   maxOutputTokens = 16384,
   maxSteps = 30,
+  maxRetries = 5,
   providerOptions,
   includeToolDiscipline = false
 }) {
@@ -2465,6 +2558,7 @@ function createCodingAgent({
     tools,
     stopWhen: stepCountIs(maxSteps),
     maxOutputTokens,
+    maxRetries,
     providerOptions,
     experimental_repairToolCall: repairCodingAgentToolCall,
     callOptionsSchema: codingAgentCallOptionsSchema,
@@ -2518,20 +2612,20 @@ var init_coding_agent = __esm(() => {
 });
 
 // packages/ai/src/config/credentials.ts
-import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { chmodSync, existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
 import os from "os";
-import path from "path";
+import path3 from "path";
 import { z as z25 } from "zod";
 function getCredentialsPath(env = process.env) {
   const configuredPath = env.LIGHTCODE_CREDENTIALS?.trim();
   if (configuredPath) {
-    return path.resolve(configuredPath);
+    return path3.resolve(configuredPath);
   }
-  return path.join(os.homedir(), ".lightcode", "credentials.json");
+  return path3.join(os.homedir(), ".lightcode", "credentials.json");
 }
 function readStoredCredentials(env = process.env) {
   const credentialsPath = getCredentialsPath(env);
-  if (!existsSync(credentialsPath)) {
+  if (!existsSync2(credentialsPath)) {
     return {};
   }
   try {
@@ -2912,11 +3006,11 @@ function normalizeReadPathKey(input) {
   if (!isRecord3(input)) {
     return null;
   }
-  const path2 = input.path;
-  if (typeof path2 !== "string" || !path2.trim()) {
+  const path4 = input.path;
+  if (typeof path4 !== "string" || !path4.trim()) {
     return null;
   }
-  return path2.trim().replaceAll("\\", "/").toLowerCase();
+  return path4.trim().replaceAll("\\", "/").toLowerCase();
 }
 function getPartState(part) {
   const state = isRecord3(part) ? Reflect.get(part, "state") : undefined;
@@ -3107,6 +3201,40 @@ var init_build_provider_view = __esm(() => {
   init_tier1_prune();
 });
 
+// packages/ai/src/context/normalize-provider-messages.ts
+import { isToolUIPart } from "ai";
+function resolveDanglingToolParts(messages, errorText = interruptedToolErrorText) {
+  return messages.map((message) => {
+    if (message.role !== "assistant") {
+      return message;
+    }
+    let changed = false;
+    const parts = message.parts.map((part) => {
+      if (!isToolUIPart(part) || terminalToolStates.has(part.state)) {
+        return part;
+      }
+      changed = true;
+      return {
+        ...part,
+        state: "output-error",
+        errorText
+      };
+    });
+    return changed ? { ...message, parts } : message;
+  });
+}
+function normalizeProviderMessages(messages) {
+  return resolveDanglingToolParts(messages);
+}
+var terminalToolStates, interruptedToolErrorText = "Tool call was interrupted by a connection retry. Re-issue the tool call if it is still needed.";
+var init_normalize_provider_messages = __esm(() => {
+  terminalToolStates = new Set([
+    "output-available",
+    "output-error",
+    "output-denied"
+  ]);
+});
+
 // packages/ai/src/context/index.ts
 var init_context = __esm(() => {
   init_build_provider_view();
@@ -3115,22 +3243,23 @@ var init_context = __esm(() => {
   init_estimate();
   init_heuristic_summary();
   init_message_parts();
+  init_normalize_provider_messages();
   init_tier1_prune();
 });
 
 // packages/ai/src/config/lightcode-config.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
 import os2 from "os";
-import path2 from "path";
+import path4 from "path";
 import { z as z28 } from "zod";
 function getDefaultUserConfigPath(env) {
   if (env.LIGHTCODE_USER_CONFIG) {
     return env.LIGHTCODE_USER_CONFIG;
   }
-  return path2.join(os2.homedir(), ".lightcode", "settings.json");
+  return path4.join(os2.homedir(), ".lightcode", "settings.json");
 }
 function readConfigFile(scope, configPath) {
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     return {
       config: {},
       file: {
@@ -3213,6 +3342,12 @@ function readEnvConfig(env) {
     summaryMaxChars: parseNumberEnv(env.LIGHTCODE_CONTEXT_SUMMARY_MAX_CHARS, "LIGHTCODE_CONTEXT_SUMMARY_MAX_CHARS")
   };
   const compactContextConfig = Object.fromEntries(Object.entries(contextConfig).filter(([, value]) => value !== undefined));
+  const headroomConfig = {
+    enabled: parseBooleanEnv(env.LIGHTCODE_HEADROOM_ENABLED, "LIGHTCODE_HEADROOM_ENABLED"),
+    proxyUrl: env.LIGHTCODE_HEADROOM_PROXY_URL?.trim() || undefined,
+    failOpen: parseBooleanEnv(env.LIGHTCODE_HEADROOM_FAIL_OPEN, "LIGHTCODE_HEADROOM_FAIL_OPEN")
+  };
+  const compactHeadroomConfig = Object.fromEntries(Object.entries(headroomConfig).filter(([, value]) => value !== undefined));
   const rawConfig = {
     provider: env.LIGHTCODE_PROVIDER,
     model: env.LIGHTCODE_CHAT_MODEL,
@@ -3221,7 +3356,9 @@ function readEnvConfig(env) {
     permissionMode: env.LIGHTCODE_PERMISSION_MODE,
     maxOutputTokens: parseNumberEnv(env.LIGHTCODE_MAX_OUTPUT_TOKENS, "LIGHTCODE_MAX_OUTPUT_TOKENS"),
     maxSteps: parseNumberEnv(env.LIGHTCODE_MAX_STEPS, "LIGHTCODE_MAX_STEPS"),
-    context: Object.keys(compactContextConfig).length > 0 ? compactContextConfig : undefined
+    maxRetries: parseNumberEnv(env.LIGHTCODE_MAX_RETRIES, "LIGHTCODE_MAX_RETRIES"),
+    context: Object.keys(compactContextConfig).length > 0 ? compactContextConfig : undefined,
+    headroom: Object.keys(compactHeadroomConfig).length > 0 ? compactHeadroomConfig : undefined
   };
   const compactConfig = Object.fromEntries(Object.entries(rawConfig).filter(([, value]) => value !== undefined));
   const parsedConfig = lightcodeConfigSchema.safeParse(compactConfig);
@@ -3245,13 +3382,37 @@ function mergeConfig(...configs) {
       ...mergedConfig.autoContinue,
       ...config2.autoContinue
     } : mergedConfig.autoContinue,
+    headroom: config2.headroom ? {
+      ...mergedConfig.headroom,
+      ...config2.headroom
+    } : mergedConfig.headroom,
     allowedTools: config2.allowedTools ?? mergedConfig.allowedTools
   }), {});
 }
+function updateUserSettings(update, env = process.env) {
+  const configPath = getDefaultUserConfigPath(env);
+  const existing = readConfigFile("user", configPath).config;
+  const merged = { ...existing };
+  for (const [key, value] of Object.entries(update)) {
+    if (value === undefined || value === null) {
+      delete merged[key];
+    } else {
+      Reflect.set(merged, key, value);
+    }
+  }
+  const parsed = lightcodeConfigSchema.safeParse(merged);
+  if (!parsed.success) {
+    throw new LightcodeConfigError(`Invalid settings update: ${parsed.error.message}`);
+  }
+  mkdirSync3(path4.dirname(configPath), { recursive: true });
+  writeFileSync2(configPath, `${JSON.stringify(parsed.data, null, 2)}
+`, "utf8");
+  return { path: configPath, config: parsed.data };
+}
 function loadLightcodeConfig({
   cwd = process.cwd(),
   env = process.env,
-  projectConfigPath = path2.join(cwd, ".lightcode", "settings.json"),
+  projectConfigPath = path4.join(cwd, ".lightcode", "settings.json"),
   userConfigPath = getDefaultUserConfigPath(env)
 } = {}) {
   const userConfig = readConfigFile("user", userConfigPath);
@@ -3265,6 +3426,10 @@ function loadLightcodeConfig({
     autoContinue: {
       ...defaultAutoContinueConfig,
       ...mergedConfig.autoContinue
+    },
+    headroom: {
+      ...defaultHeadroomConfig,
+      ...mergedConfig.headroom
     }
   };
   return lightcodeConfigLoadResultSchema.parse({
@@ -3272,7 +3437,7 @@ function loadLightcodeConfig({
     loadedFiles: [userConfig.file, projectConfig.file]
   });
 }
-var lightcodeProviderSchema, autoContinueConfigSchema, resolvedAutoContinueConfigSchema, defaultAutoContinueConfig, lightcodeConfigSchema, lightcodeConfigDefaults, loadedConfigFileSchema, lightcodeResolvedConfigSchema, lightcodeConfigLoadResultSchema, lightcodeConfigStatusSchema, LightcodeConfigError;
+var lightcodeProviderSchema, autoContinueConfigSchema, resolvedAutoContinueConfigSchema, defaultAutoContinueConfig, headroomConfigSchema, resolvedHeadroomConfigSchema, defaultHeadroomConfig, lightcodeConfigSchema, lightcodeConfigDefaults, loadedConfigFileSchema, lightcodeResolvedConfigSchema, lightcodeConfigLoadResultSchema, lightcodeConfigStatusSchema, LightcodeConfigError;
 var init_lightcode_config = __esm(() => {
   init_coding_agent_modes();
   init_coding_agent_modes();
@@ -3302,7 +3467,25 @@ var init_lightcode_config = __esm(() => {
     enabled: true,
     maxAutoContinues: 50,
     maxErrorRetries: 5,
-    stallTimeoutSeconds: 120
+    stallTimeoutSeconds: 180
+  };
+  headroomConfigSchema = z28.object({
+    enabled: z28.boolean().optional(),
+    proxyUrl: z28.string().min(1).max(4096).optional(),
+    providers: z28.array(lightcodeProviderSchema).optional(),
+    failOpen: z28.boolean().optional()
+  }).strict();
+  resolvedHeadroomConfigSchema = z28.object({
+    enabled: z28.boolean(),
+    proxyUrl: z28.string().min(1).max(4096),
+    providers: z28.array(lightcodeProviderSchema).nullable(),
+    failOpen: z28.boolean()
+  });
+  defaultHeadroomConfig = {
+    enabled: false,
+    proxyUrl: "http://127.0.0.1:8787",
+    providers: null,
+    failOpen: true
   };
   lightcodeConfigSchema = z28.object({
     provider: lightcodeProviderSchema.optional(),
@@ -3315,9 +3498,11 @@ var init_lightcode_config = __esm(() => {
     sandbox: sandboxConfigSchema.optional(),
     mcp: mcpConfigSchema.optional(),
     context: contextOptimizerConfigSchema.optional(),
-    maxOutputTokens: z28.number().int().min(1).max(200000).optional(),
+    maxOutputTokens: z28.number().int().min(1).max(1e6).optional(),
     maxSteps: z28.number().int().min(1).max(100).optional(),
-    autoContinue: autoContinueConfigSchema.optional()
+    maxRetries: z28.number().int().min(0).max(10).optional(),
+    autoContinue: autoContinueConfigSchema.optional(),
+    headroom: headroomConfigSchema.optional()
   }).strict();
   lightcodeConfigDefaults = {
     provider: "anthropic",
@@ -3325,7 +3510,9 @@ var init_lightcode_config = __esm(() => {
     context: defaultContextOptimizerConfig,
     maxOutputTokens: 32768,
     maxSteps: 30,
-    autoContinue: defaultAutoContinueConfig
+    maxRetries: 5,
+    autoContinue: defaultAutoContinueConfig,
+    headroom: defaultHeadroomConfig
   };
   loadedConfigFileSchema = z28.object({
     scope: z28.enum(["user", "project"]),
@@ -3337,9 +3524,11 @@ var init_lightcode_config = __esm(() => {
     provider: lightcodeProviderSchema,
     defaultMode: codingAgentModeSchema,
     context: resolvedContextOptimizerConfigSchema,
-    maxOutputTokens: z28.number().int().min(1).max(200000),
+    maxOutputTokens: z28.number().int().min(1).max(1e6),
     maxSteps: z28.number().int().min(1).max(100),
-    autoContinue: resolvedAutoContinueConfigSchema
+    maxRetries: z28.number().int().min(0).max(10),
+    autoContinue: resolvedAutoContinueConfigSchema,
+    headroom: resolvedHeadroomConfigSchema.optional()
   });
   lightcodeConfigLoadResultSchema = z28.object({
     config: lightcodeResolvedConfigSchema,
@@ -3353,10 +3542,15 @@ var init_lightcode_config = __esm(() => {
     baseUrl: z28.string().nullable(),
     defaultMode: codingAgentModeSchema,
     permissionMode: permissionModeSchema.nullable(),
-    maxOutputTokens: z28.number().int().min(1).max(200000),
+    maxOutputTokens: z28.number().int().min(1).max(1e6),
     maxSteps: z28.number().int().min(1).max(100),
     autoContinue: resolvedAutoContinueConfigSchema,
     contextWindow: z28.number().int().positive(),
+    headroom: z28.object({
+      enabled: z28.boolean(),
+      proxyUrl: z28.string().nullable(),
+      routed: z28.boolean()
+    }),
     missingCredentialHints: z28.array(z28.string())
   });
   LightcodeConfigError = class LightcodeConfigError extends Error {
@@ -3596,6 +3790,21 @@ var init_runtime = __esm(() => {
   init_schema13();
 });
 
+// packages/ai/src/providers/clamp-output-tokens.ts
+function clampMaxOutputTokens(configured, modelMaxCompletionTokens) {
+  if (typeof modelMaxCompletionTokens === "number" && Number.isFinite(modelMaxCompletionTokens) && modelMaxCompletionTokens > 0) {
+    return Math.min(configured, modelMaxCompletionTokens);
+  }
+  return configured;
+}
+function resolveMaxOutputTokens(configured, defaultValue, modelMaxCompletionTokens) {
+  const hasModelCap = typeof modelMaxCompletionTokens === "number" && Number.isFinite(modelMaxCompletionTokens) && modelMaxCompletionTokens > 0;
+  if (configured === defaultValue) {
+    return hasModelCap ? modelMaxCompletionTokens : configured;
+  }
+  return clampMaxOutputTokens(configured, modelMaxCompletionTokens);
+}
+
 // packages/ai/src/providers/model-metadata.ts
 function getModelContextWindow(provider, modelId) {
   if (provider === "anthropic") {
@@ -4227,27 +4436,27 @@ var init_schema16 = __esm(() => {
 });
 
 // packages/ai/src/plugins/runtime.ts
-import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync } from "fs";
+import { existsSync as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
 import os3 from "os";
-import path3 from "path";
+import path5 from "path";
 function pluginRoots(cwd) {
   return [
-    path3.join(cwd, ".lightcode", "plugins"),
-    path3.join(os3.homedir(), ".lightcode", "plugins")
+    path5.join(cwd, ".lightcode", "plugins"),
+    path5.join(os3.homedir(), ".lightcode", "plugins")
   ];
 }
 function listPlugins({ cwd = process.cwd() } = {}) {
   const plugins = [];
   for (const root of pluginRoots(cwd)) {
-    if (!existsSync3(root)) {
+    if (!existsSync4(root)) {
       continue;
     }
-    for (const entry of readdirSync(root, { withFileTypes: true })) {
+    for (const entry of readdirSync2(root, { withFileTypes: true })) {
       if (!entry.isDirectory()) {
         continue;
       }
-      const manifestPath = path3.join(root, entry.name, "plugin.json");
-      if (!existsSync3(manifestPath)) {
+      const manifestPath = path5.join(root, entry.name, "plugin.json");
+      if (!existsSync4(manifestPath)) {
         continue;
       }
       const manifest = pluginManifestSchema.parse(JSON.parse(readFileSync3(manifestPath, "utf8")));
@@ -4269,14 +4478,14 @@ var init_runtime2 = __esm(() => {
 });
 
 // packages/ai/src/skills/runtime.ts
-import { existsSync as existsSync4, readFileSync as readFileSync4, readdirSync as readdirSync2, statSync } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync3, statSync } from "fs";
 import os4 from "os";
-import path4 from "path";
+import path6 from "path";
 function defaultSkillRoots(cwd) {
   return [
-    { source: "project", path: path4.join(cwd, ".lightcode", "skills") },
-    { source: "project", path: path4.join(cwd, ".agents", "skills") },
-    { source: "user", path: path4.join(os4.homedir(), ".lightcode", "skills") }
+    { source: "project", path: path6.join(cwd, ".lightcode", "skills") },
+    { source: "project", path: path6.join(cwd, ".agents", "skills") },
+    { source: "user", path: path6.join(os4.homedir(), ".lightcode", "skills") }
   ];
 }
 function normalizeSkillName(value) {
@@ -4298,7 +4507,7 @@ function parseBasicFrontmatter(content) {
   ]));
 }
 function findSkillFiles(root) {
-  if (!existsSync4(root.path)) {
+  if (!existsSync5(root.path)) {
     return [];
   }
   const files = [];
@@ -4306,8 +4515,8 @@ function findSkillFiles(root) {
     if (depth > 4) {
       return;
     }
-    for (const entry of readdirSync2(directory)) {
-      const entryPath = path4.join(directory, entry);
+    for (const entry of readdirSync3(directory)) {
+      const entryPath = path6.join(directory, entry);
       const stat = statSync(entryPath);
       if (stat.isDirectory()) {
         visit(entryPath, depth + 1);
@@ -4328,7 +4537,7 @@ function listSkills({
     for (const skillPath of findSkillFiles(root)) {
       const content = readFileSync4(skillPath, "utf8");
       const frontmatter = parseBasicFrontmatter(content);
-      const fallbackName = path4.basename(path4.dirname(skillPath));
+      const fallbackName = path6.basename(path6.dirname(skillPath));
       const name = normalizeSkillName(frontmatter.name ?? fallbackName);
       if (!name || seen.has(name)) {
         continue;
@@ -4403,6 +4612,7 @@ var init_subagent_schemas = __esm(() => {
 // packages/ai/src/index.ts
 var init_src2 = __esm(() => {
   init_agent_tools();
+  init_chat_error();
   init_chat_interaction_schemas();
   init_plan_block();
   init_chat_schemas();
@@ -4433,20 +4643,20 @@ var init_src2 = __esm(() => {
 
 // packages/db/src/local-database.ts
 import { Database } from "bun:sqlite";
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4 } from "fs";
 import { dirname, isAbsolute, join, resolve } from "path";
 import { fileURLToPath, pathToFileURL } from "url";
-import { homedir, platform } from "os";
+import { homedir as homedir2, platform as platform2 } from "os";
 function getDefaultLightcodeDataDir() {
   const configuredHome = process.env.LIGHTCODE_HOME?.trim();
   if (configuredHome) {
     return resolve(configuredHome);
   }
-  if (platform() === "win32") {
+  if (platform2() === "win32") {
     const appData = process.env.APPDATA || process.env.LOCALAPPDATA;
-    return appData ? join(appData, appDirectoryName) : join(homedir(), "AppData", "Roaming", appDirectoryName);
+    return appData ? join(appData, appDirectoryName) : join(homedir2(), "AppData", "Roaming", appDirectoryName);
   }
-  return join(homedir(), `.${appDirectoryName}`);
+  return join(homedir2(), `.${appDirectoryName}`);
 }
 function getDefaultDatabasePath() {
   const configuredPath = process.env.LIGHTCODE_DATABASE_PATH?.trim();
@@ -4456,11 +4666,9 @@ function getDefaultDatabaseUrl() {
   return pathToFileURL(getDefaultDatabasePath()).href;
 }
 function resolveDatabaseUrl() {
-  const configuredUrl = process.env.DATABASE_URL?.trim();
-  const supportedConfiguredUrl = configuredUrl?.startsWith("file:") || configuredUrl?.startsWith("libsql:") || configuredUrl?.startsWith("http://") || configuredUrl?.startsWith("https://") ? configuredUrl : null;
-  const databaseUrl = supportedConfiguredUrl && supportedConfiguredUrl.length > 0 ? supportedConfiguredUrl : getDefaultDatabaseUrl();
-  process.env.DATABASE_URL = databaseUrl;
-  return databaseUrl;
+  const configuredUrl = process.env.LIGHTCODE_DATABASE_URL?.trim();
+  const supportedConfiguredUrl = configuredUrl && (configuredUrl.startsWith("file:") || configuredUrl.startsWith("libsql:") || configuredUrl.startsWith("http://") || configuredUrl.startsWith("https://")) ? configuredUrl : null;
+  return supportedConfiguredUrl ?? getDefaultDatabaseUrl();
 }
 function filePathFromDatabaseUrl(databaseUrl) {
   if (!databaseUrl.startsWith("file:")) {
@@ -4474,8 +4682,8 @@ function filePathFromDatabaseUrl(databaseUrl) {
 }
 function ensureParentDirectory(filePath) {
   const parentDirectory = dirname(filePath);
-  if (!existsSync5(parentDirectory)) {
-    mkdirSync2(parentDirectory, { recursive: true });
+  if (!existsSync6(parentDirectory)) {
+    mkdirSync4(parentDirectory, { recursive: true });
   }
 }
 function initializeLocalDatabase(databaseUrl) {
@@ -4611,14 +4819,10 @@ var init_local_database = () => {};
 // apps/server/src/lib/chat-interaction-store.ts
 import { Database as Database2 } from "bun:sqlite";
 function getDatabase() {
-  if (!_initialized) {
+  if (!_db) {
     const dbUrl = resolveDatabaseUrl();
     initializeLocalDatabase(dbUrl);
-    _initialized = true;
-  }
-  if (!_db) {
-    const dbUrl = process.env.DATABASE_URL ?? getDefaultDatabasePath();
-    const dbPath = filePathFromDatabaseUrl(dbUrl) ?? (dbUrl.startsWith("file:") ? dbUrl.slice(5) : dbUrl);
+    const dbPath = filePathFromDatabaseUrl(dbUrl) ?? getDefaultDatabasePath();
     _db = new Database2(dbPath);
   }
   return _db;
@@ -4769,7 +4973,7 @@ async function summarizePendingChatInteractions({
     recoverable: total
   };
 }
-var ChatInteractionNotFoundError, _db = null, _initialized = false;
+var ChatInteractionNotFoundError, _db = null;
 var init_chat_interaction_store = __esm(() => {
   init_src2();
   init_local_database();
@@ -4786,6 +4990,28 @@ var init_chat_interaction_store = __esm(() => {
 });
 
 // apps/server/src/lib/chat-observability.ts
+import { APICallError, RetryError } from "ai";
+function chatFailureClassForErrorKind(kind) {
+  switch (kind) {
+    case "auth":
+      return "provider_auth";
+    case "billing":
+      return "provider_billing_quota";
+    case "rate_limit":
+      return "provider_rate_limit";
+    case "invalid_request":
+      return "provider_invalid_request";
+    case "context_overflow":
+      return "context_overflow";
+    case "provider_unavailable":
+      return "provider_unavailable";
+    case "network":
+    case "aborted":
+      return "timeout_disconnect";
+    default:
+      return "provider_unknown";
+  }
+}
 function normalizeErrorMessage(message) {
   return message.toLowerCase();
 }
@@ -4797,6 +5023,76 @@ function isProviderBillingOrQuotaError(error) {
   const message = normalizeErrorMessage(getErrorMessage(error));
   return message.includes("credit balance") || message.includes("insufficient credit") || message.includes("insufficient funds") || message.includes("out of credits") || message.includes("quota") || message.includes("billing") || message.includes("payment required");
 }
+function isContextOverflowMessage(message) {
+  return contextOverflowPattern.test(message);
+}
+function isAbortError(error) {
+  return error instanceof Error && error.name === "AbortError" || normalizeErrorMessage(getErrorMessage(error)).includes("aborted");
+}
+function classifyByStatusCode(statusCode, message) {
+  if (statusCode === 401 || statusCode === 403) {
+    return { kind: "auth", retryable: false };
+  }
+  if (statusCode === 402) {
+    return { kind: "billing", retryable: false };
+  }
+  if (statusCode === 429) {
+    return { kind: "rate_limit", retryable: true };
+  }
+  if (statusCode === 400 || statusCode === 422 || statusCode === 413) {
+    if (isContextOverflowMessage(message)) {
+      return { kind: "context_overflow", retryable: true };
+    }
+    if (isProviderBillingOrQuotaError(message)) {
+      return { kind: "billing", retryable: false };
+    }
+    return { kind: "invalid_request", retryable: false };
+  }
+  if (retryableStatusCodes.has(statusCode) || statusCode >= 500) {
+    return { kind: "provider_unavailable", retryable: true };
+  }
+  return { kind: "unknown", retryable: false };
+}
+function classifyChatError(error) {
+  if (RetryError.isInstance(error) && error.lastError) {
+    return classifyChatError(error.lastError);
+  }
+  if (APICallError.isInstance(error)) {
+    const responseBody = error.responseBody ?? "";
+    const message2 = responseBody.length > 0 ? responseBody : error.message;
+    if (typeof error.statusCode === "number") {
+      const { kind, retryable } = classifyByStatusCode(error.statusCode, message2);
+      return {
+        kind,
+        statusCode: error.statusCode,
+        retryable,
+        message: message2
+      };
+    }
+    return {
+      kind: error.isRetryable ? "network" : "unknown",
+      retryable: error.isRetryable,
+      message: message2
+    };
+  }
+  const message = getErrorMessage(error);
+  if (isAbortError(error)) {
+    return { kind: "aborted", retryable: false, message };
+  }
+  if (isContextOverflowMessage(message)) {
+    return { kind: "context_overflow", retryable: true, message };
+  }
+  if (isProviderBillingOrQuotaError(error)) {
+    return { kind: "billing", retryable: false, message };
+  }
+  if (isProviderSchemaRejectionError(error)) {
+    return { kind: "invalid_request", retryable: false, message };
+  }
+  if (isDisconnectOrTimeoutError(error)) {
+    return { kind: "network", retryable: true, message };
+  }
+  return { kind: "unknown", retryable: false, message };
+}
 function isDisconnectOrTimeoutError(error) {
   const message = normalizeErrorMessage(getErrorMessage(error));
   return message.includes("timed out") || message.includes("timeout") || message.includes("socket") || message.includes("connection") || message.includes("aborted") || message.includes("broken pipe") || message.includes("econnreset");
@@ -4822,6 +5118,22 @@ function incrementChatFailureCounter(failureClass, context2 = {}) {
     ...context2
   });
 }
+function logChatStreamErrorEvent({
+  sessionId,
+  phase,
+  classified,
+  error
+}) {
+  logger2.error("chat_stream_error", {
+    sessionId,
+    phase,
+    kind: classified.kind,
+    statusCode: classified.statusCode,
+    retryable: classified.retryable,
+    message: classified.message,
+    rawMessage: getErrorMessage(error)
+  });
+}
 function logChatDisconnectEvent({
   sessionId,
   phase,
@@ -4834,17 +5146,25 @@ function logChatDisconnectEvent({
     message: getErrorMessage(error)
   });
 }
-var chatFailureCounters, logger2;
+var chatFailureCounters, logger2, retryableStatusCodes, contextOverflowPattern;
 var init_chat_observability = __esm(() => {
   init_src();
   chatFailureCounters = {
     provider_schema_rejection: 0,
     provider_billing_quota: 0,
+    provider_auth: 0,
+    provider_rate_limit: 0,
+    provider_invalid_request: 0,
+    provider_unavailable: 0,
+    context_overflow: 0,
+    provider_unknown: 0,
     timeout_disconnect: 0,
     stale_finish_skip: 0,
     db_unique_conflict: 0
   };
   logger2 = createLogger("chat");
+  retryableStatusCodes = new Set([408, 409, 429, 500, 502, 503, 504]);
+  contextOverflowPattern = /(context window|context length|context_length|maximum context|prompt is too long|input is too long|too many tokens|exceeds? the (?:maximum|model'?s) (?:context|token)|max(?:imum)? input tokens)/i;
 });
 
 // packages/db/generated/prisma/internal/class.ts
@@ -5057,7 +5377,7 @@ var init_prismaNamespace = __esm(() => {
 var init_enums = () => {};
 
 // packages/db/generated/prisma/client.ts
-import * as path5 from "path";
+import * as path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 var PrismaClient;
 var init_client = __esm(() => {
@@ -5065,7 +5385,7 @@ var init_client = __esm(() => {
   init_prismaNamespace();
   init_enums();
   init_enums();
-  globalThis["__dirname"] = path5.dirname(fileURLToPath2(import.meta.url));
+  globalThis["__dirname"] = path7.dirname(fileURLToPath2(import.meta.url));
   PrismaClient = getPrismaClientClass();
 });
 
@@ -5643,28 +5963,28 @@ function mergeFinishedMessagesIntoFullHistory({
 }
 
 // packages/ai/src/common/resolve-within-workspace.ts
-import path6 from "path";
+import path8 from "path";
 import {
-  existsSync as existsSync6,
+  existsSync as existsSync7,
   lstatSync,
   realpathSync,
   statSync as statSync2
 } from "fs";
 function stripTrailingSeparator(value) {
-  const parsed = path6.parse(value);
+  const parsed = path8.parse(value);
   if (value === parsed.root) {
     return value;
   }
   return value.replace(/[\\/]+$/, "");
 }
 function normalizeForComparison(value) {
-  const normalized = stripTrailingSeparator(path6.resolve(value));
+  const normalized = stripTrailingSeparator(path8.resolve(value));
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 function isWithinWorkspace(absolutePath, context2) {
   const workspace = normalizeForComparison(context2.root);
   const target = normalizeForComparison(absolutePath);
-  return target === workspace || target.startsWith(`${workspace}${path6.sep}`);
+  return target === workspace || target.startsWith(`${workspace}${path8.sep}`);
 }
 function assertWithinWorkspace(absolutePath, context2, input) {
   if (!isWithinWorkspace(absolutePath, context2)) {
@@ -5679,17 +5999,17 @@ function getExistingRealPath(absolutePath) {
   }
 }
 function findNearestExistingParent(absolutePath, context2, input) {
-  let currentPath = path6.dirname(absolutePath);
+  let currentPath = path8.dirname(absolutePath);
   while (true) {
     assertWithinWorkspace(currentPath, context2, input);
-    if (existsSync6(currentPath)) {
+    if (existsSync7(currentPath)) {
       const realParentPath = getExistingRealPath(currentPath);
       if (!realParentPath) {
         throw new Error(`Unable to resolve existing parent for path: ${input}`);
       }
       return realParentPath;
     }
-    const parentPath = path6.dirname(currentPath);
+    const parentPath = path8.dirname(currentPath);
     if (parentPath === currentPath) {
       throw new Error(`Unable to find an existing workspace parent for path: ${input}`);
     }
@@ -5709,7 +6029,7 @@ function getDefaultWorkspaceContext() {
 }
 function resolveWithinWorkspace(input, options = {}) {
   const context2 = options.context ?? defaultWorkspaceContext;
-  const resolved = path6.resolve(context2.root, input);
+  const resolved = path8.resolve(context2.root, input);
   assertWithinWorkspace(resolved, context2, input);
   const realPath = getExistingRealPath(resolved);
   if (realPath) {
@@ -5852,7 +6172,7 @@ var init_runtime11 = __esm(() => {
 
 // packages/ai/src/todo-write/runtime.ts
 import { mkdir, readFile, writeFile } from "fs/promises";
-import path7 from "path";
+import path9 from "path";
 import { z as z33 } from "zod";
 function safeTodoSessionId(sessionId) {
   const trimmed = sessionId?.trim();
@@ -5862,7 +6182,7 @@ function safeTodoSessionId(sessionId) {
   return trimmed.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 120);
 }
 function getTodoFilePath(sessionId, workspaceContext) {
-  return resolveWithinWorkspace(path7.join(".lightcode", "todos", `${safeTodoSessionId(sessionId)}.json`), {
+  return resolveWithinWorkspace(path9.join(".lightcode", "todos", `${safeTodoSessionId(sessionId)}.json`), {
     context: workspaceContext,
     allowMissing: true
   });
@@ -6066,6 +6386,7 @@ ${transcript}`
     system: COMPACTION_SYSTEM_PROMPT,
     prompt,
     maxOutputTokens: COMPACTION_MAX_OUTPUT_TOKENS,
+    maxRetries: 2,
     abortSignal: AbortSignal.timeout(COMPACTION_TIMEOUT_MS)
   });
   const text = result.text.trim();
@@ -6114,7 +6435,7 @@ function composeSummary({
 `).trim();
   const bodyBudget = Math.max(MIN_SUMMARY_BODY_CHARS, summaryMaxChars - (pinnedText ? pinnedText.length + 2 : 0));
   const compressedBody = compressSummary(body, bodyBudget);
-  return [compressedBody, pinnedText].filter(Boolean).join(`
+  return [compressedBody, pinnedText, compactionDirectResumeInstruction].filter(Boolean).join(`
 
 `);
 }
@@ -6192,13 +6513,227 @@ Unfinished work, known follow-ups, and the immediate next step.
 ## Tools and commands that mattered
 Important commands run and their relevant outcomes (test results, errors, etc.).
 
-Rules: be specific (real file paths, function names, error messages); never invent details; omit pleasantries; if a "Previously compacted context" section is provided, fold its still-relevant facts into your summary instead of referencing it.`;
+Rules: be specific (real file paths, function names, error messages); never invent details; omit pleasantries; if a "Previously compacted context" section is provided, fold its still-relevant facts into your summary instead of referencing it.`, compactionDirectResumeInstruction;
 var init_context_compaction = __esm(() => {
   init_src2();
   init_runtime17();
   init_src();
   init_context_state_store();
   logger3 = createLogger("context-compaction");
+  compactionDirectResumeInstruction = "Continue the task from where it left off using the summary above. " + "Do not ask for confirmation, do not re-state the plan, and do not repeat completed work.";
+});
+
+// apps/server/src/lib/overflow-recovery.ts
+function noteContextOverflow(sessionId) {
+  overflowRecoveryRounds.set(sessionId, (overflowRecoveryRounds.get(sessionId) ?? 0) + 1);
+}
+function clearContextOverflowRounds(sessionId) {
+  overflowRecoveryRounds.delete(sessionId);
+}
+function getOverflowPreserveRecentMessages(sessionId) {
+  const rounds = overflowRecoveryRounds.get(sessionId) ?? 0;
+  if (rounds === 0) {
+    return null;
+  }
+  return overflowPreserveSchedule[Math.min(rounds, overflowPreserveSchedule.length) - 1];
+}
+var overflowPreserveSchedule, overflowRecoveryRounds;
+var init_overflow_recovery = __esm(() => {
+  overflowPreserveSchedule = [4, 2, 1, 0];
+  overflowRecoveryRounds = new Map;
+});
+
+// apps/server/src/lib/sse-heartbeat.ts
+function endsWithEventBoundary(chunk) {
+  const length = chunk.length;
+  if (length >= 2 && chunk[length - 1] === 10 && chunk[length - 2] === 10) {
+    return true;
+  }
+  return length >= 4 && chunk[length - 1] === 10 && chunk[length - 2] === 13 && chunk[length - 3] === 10 && chunk[length - 4] === 13;
+}
+function withSseHeartbeat(response, intervalMs = defaultHeartbeatIntervalMs) {
+  const body = response.body;
+  if (!body) {
+    return response;
+  }
+  let atEventBoundary = true;
+  let heartbeatTimer = null;
+  let lastChunkAt = Date.now();
+  const stopHeartbeat = () => {
+    if (heartbeatTimer) {
+      clearInterval(heartbeatTimer);
+      heartbeatTimer = null;
+    }
+  };
+  const transform = new TransformStream({
+    start(controller) {
+      heartbeatTimer = setInterval(() => {
+        if (!atEventBoundary || Date.now() - lastChunkAt < intervalMs) {
+          return;
+        }
+        try {
+          controller.enqueue(heartbeatFrame);
+          lastChunkAt = Date.now();
+        } catch {
+          stopHeartbeat();
+        }
+      }, Math.min(intervalMs, 5000));
+    },
+    transform(chunk, controller) {
+      atEventBoundary = endsWithEventBoundary(chunk);
+      lastChunkAt = Date.now();
+      controller.enqueue(chunk);
+    },
+    flush() {
+      stopHeartbeat();
+    }
+  });
+  const heartbeatBody = body.pipeThrough(transform);
+  return new Response(heartbeatBody, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+var encoder, heartbeatFrame, defaultHeartbeatIntervalMs = 15000;
+var init_sse_heartbeat = __esm(() => {
+  encoder = new TextEncoder;
+  heartbeatFrame = encoder.encode(`: heartbeat
+
+`);
+});
+
+// apps/server/src/lib/openrouter-models.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync5, writeFileSync as writeFileSync3 } from "fs";
+import path10 from "path";
+import { z as z34 } from "zod";
+function getCacheFilePath() {
+  return path10.join(getLightcodeDataDir(), "cache", "openrouter-models.json");
+}
+function readCache() {
+  try {
+    const cachePath = getCacheFilePath();
+    if (!existsSync8(cachePath)) {
+      return null;
+    }
+    return modelsCacheSchema.parse(JSON.parse(readFileSync5(cachePath, "utf8")));
+  } catch {
+    return null;
+  }
+}
+function writeCache(cache) {
+  try {
+    const cachePath = getCacheFilePath();
+    mkdirSync5(path10.dirname(cachePath), { recursive: true });
+    writeFileSync3(cachePath, JSON.stringify(cache), "utf8");
+  } catch (error) {
+    logger4.warn("openrouter_models_cache_write_failed", {
+      error: getErrorMessage(error)
+    });
+  }
+}
+function summarizeRawModel(raw2) {
+  if (typeof raw2 !== "object" || raw2 === null) {
+    return null;
+  }
+  const id = Reflect.get(raw2, "id");
+  if (typeof id !== "string" || id.length === 0) {
+    return null;
+  }
+  const name = Reflect.get(raw2, "name");
+  const contextLength = Reflect.get(raw2, "context_length");
+  const topProvider = Reflect.get(raw2, "top_provider");
+  const topProviderMaxCompletion = typeof topProvider === "object" && topProvider !== null ? Reflect.get(topProvider, "max_completion_tokens") : undefined;
+  const rawMaxCompletion = typeof topProviderMaxCompletion === "number" ? topProviderMaxCompletion : Reflect.get(raw2, "max_completion_tokens");
+  const supportedParameters = Reflect.get(raw2, "supported_parameters");
+  const parameterList = Array.isArray(supportedParameters) ? supportedParameters.filter((entry) => typeof entry === "string") : [];
+  const pricingRaw = Reflect.get(raw2, "pricing");
+  const pricing = typeof pricingRaw === "object" && pricingRaw !== null ? {
+    prompt: typeof Reflect.get(pricingRaw, "prompt") === "string" ? Reflect.get(pricingRaw, "prompt") : null,
+    completion: typeof Reflect.get(pricingRaw, "completion") === "string" ? Reflect.get(pricingRaw, "completion") : null
+  } : null;
+  return {
+    id,
+    name: typeof name === "string" && name.length > 0 ? name : id,
+    contextLength: typeof contextLength === "number" && contextLength > 0 ? Math.round(contextLength) : null,
+    maxCompletionTokens: typeof rawMaxCompletion === "number" && rawMaxCompletion > 0 ? Math.round(rawMaxCompletion) : null,
+    supportsTools: parameterList.includes("tools"),
+    supportsReasoning: parameterList.includes("reasoning"),
+    pricing
+  };
+}
+async function fetchModelsFromApi() {
+  const response = await fetch(openRouterModelsUrl, {
+    signal: AbortSignal.timeout(fetchTimeoutMs)
+  });
+  if (!response.ok) {
+    throw new Error(`OpenRouter models API returned HTTP ${response.status}.`);
+  }
+  const payload = await response.json();
+  const models = (payload.data ?? []).map(summarizeRawModel).filter((model) => model !== null);
+  if (models.length === 0) {
+    throw new Error("OpenRouter models API returned no models.");
+  }
+  return models;
+}
+async function listOpenRouterModels({
+  forceRefresh = false
+} = {}) {
+  const cache = readCache();
+  if (!forceRefresh && cache && Date.now() - cache.fetchedAt < cacheTtlMs) {
+    return { models: cache.models, fromCache: true };
+  }
+  try {
+    const models = await fetchModelsFromApi();
+    writeCache({ fetchedAt: Date.now(), models });
+    return { models, fromCache: false };
+  } catch (error) {
+    logger4.warn("openrouter_models_fetch_failed", {
+      error: getErrorMessage(error)
+    });
+    if (cache) {
+      return { models: cache.models, fromCache: true };
+    }
+    throw error;
+  }
+}
+async function getOpenRouterModelCapabilities(modelId) {
+  try {
+    const { models } = await listOpenRouterModels();
+    const model = models.find((entry) => entry.id === modelId);
+    if (!model) {
+      return;
+    }
+    return {
+      supportsNativeTools: model.supportsTools,
+      contextLength: model.contextLength ?? undefined,
+      maxCompletionTokens: model.maxCompletionTokens
+    };
+  } catch {
+    return;
+  }
+}
+var logger4, openRouterModelsUrl = "https://openrouter.ai/api/v1/models", cacheTtlMs, fetchTimeoutMs = 15000, openRouterModelSummarySchema, modelsCacheSchema;
+var init_openrouter_models = __esm(() => {
+  init_src();
+  logger4 = createLogger("openrouter-models");
+  cacheTtlMs = 24 * 60 * 60 * 1000;
+  openRouterModelSummarySchema = z34.object({
+    id: z34.string(),
+    name: z34.string(),
+    contextLength: z34.number().int().positive().nullable(),
+    maxCompletionTokens: z34.number().int().positive().nullable().default(null),
+    supportsTools: z34.boolean(),
+    supportsReasoning: z34.boolean(),
+    pricing: z34.object({
+      prompt: z34.string().nullable(),
+      completion: z34.string().nullable()
+    }).nullable()
+  });
+  modelsCacheSchema = z34.object({
+    fetchedAt: z34.number(),
+    models: z34.array(openRouterModelSummarySchema)
+  });
 });
 
 // apps/server/src/lib/provider-registry.ts
@@ -6233,6 +6768,16 @@ function getAnthropicProviderOptions(modelId) {
     }
   };
 }
+function resolveHeadroomRouting(config5, realBaseUrl) {
+  const headroom = config5.headroom;
+  if (!headroom?.enabled) {
+    return { effectiveBaseUrl: realBaseUrl, headroomRouted: false };
+  }
+  if (headroom.providers && !headroom.providers.includes(config5.provider)) {
+    return { effectiveBaseUrl: realBaseUrl, headroomRouted: false };
+  }
+  return { effectiveBaseUrl: headroom.proxyUrl, headroomRouted: true };
+}
 function resolveAnthropicModel({
   config: config5,
   env,
@@ -6243,19 +6788,22 @@ function resolveAnthropicModel({
   const apiKey = getEnvValue(env, "ANTHROPIC_API_KEY") ?? storedCredentials.anthropicApiKey;
   const authToken = getEnvValue(env, "ANTHROPIC_AUTH_TOKEN");
   const baseUrl = config5.baseUrl ?? getEnvValue(env, "ANTHROPIC_BASE_URL") ?? null;
+  const { effectiveBaseUrl, headroomRouted } = resolveHeadroomRouting(config5, baseUrl);
   const missingCredentialHints = apiKey || authToken ? [] : [
     "Set ANTHROPIC_API_KEY or ANTHROPIC_AUTH_TOKEN to call Anthropic models."
   ];
   const provider = createAnthropic({
     apiKey,
     authToken,
-    baseURL: baseUrl ?? undefined
+    baseURL: effectiveBaseUrl ?? undefined
   });
   return {
     provider: "anthropic",
     configuredModel,
     resolvedModelId: modelId,
     baseUrl,
+    effectiveBaseUrl,
+    headroomRouted,
     model: provider(modelId),
     providerOptions: getAnthropicProviderOptions(modelId),
     contextWindow: getModelContextWindow("anthropic", modelId),
@@ -6265,7 +6813,8 @@ function resolveAnthropicModel({
 function resolveOpenAITransportModel({
   config: config5,
   env,
-  storedCredentials
+  storedCredentials,
+  capabilities
 }) {
   const isOpenCodeZen = config5.provider === "opencode-zen";
   const isOpenRouter = config5.provider === "openrouter";
@@ -6277,6 +6826,7 @@ function resolveOpenAITransportModel({
   if (!baseUrl) {
     throw new Error('OpenAI-compatible provider requires "baseUrl" in config or LIGHTCODE_OPENAI_COMPATIBLE_BASE_URL.');
   }
+  const { effectiveBaseUrl, headroomRouted } = resolveHeadroomRouting(config5, baseUrl);
   const apiKey = isOpenCodeZen ? getEnvValue(env, "OPENCODE_API_KEY", "LIGHTCODE_OPENAI_COMPATIBLE_API_KEY", "OPENAI_API_KEY") ?? storedCredentials.opencodeApiKey : isOpenRouter ? getEnvValue(env, "OPENROUTER_API_KEY", "LIGHTCODE_OPENAI_COMPATIBLE_API_KEY", "OPENAI_API_KEY") ?? storedCredentials.openrouterApiKey : getEnvValue(env, "LIGHTCODE_OPENAI_COMPATIBLE_API_KEY", "OPENAI_API_KEY") ?? storedCredentials.openaiCompatibleApiKey;
   const headers = {};
   if (isOpenRouter) {
@@ -6291,7 +6841,7 @@ function resolveOpenAITransportModel({
   }
   const provider = createOpenAICompatible({
     name: config5.provider,
-    baseURL: baseUrl,
+    baseURL: effectiveBaseUrl ?? baseUrl,
     apiKey,
     headers
   });
@@ -6300,21 +6850,30 @@ function resolveOpenAITransportModel({
     configuredModel,
     resolvedModelId: configuredModel,
     baseUrl,
+    effectiveBaseUrl,
+    headroomRouted,
     model: withXmlToolCallSupport(provider(configuredModel)),
     needsToolCallDiscipline: true,
-    contextWindow: getModelContextWindow(config5.provider, configuredModel),
+    contextWindow: capabilities?.contextLength ?? getModelContextWindow(config5.provider, configuredModel),
     missingCredentialHints: apiKey ? [] : isOpenCodeZen ? ["Set OPENCODE_API_KEY to call OpenCode Zen models."] : isOpenRouter ? ["Set OPENROUTER_API_KEY to call OpenRouter models."] : [
       "Set LIGHTCODE_OPENAI_COMPATIBLE_API_KEY or OPENAI_API_KEY if your OpenAI-compatible endpoint requires authentication."
-    ]
+    ],
+    maxCompletionTokens: capabilities?.maxCompletionTokens ?? null
   };
 }
 function resolveConfiguredProviderModel({
   config: config5,
-  env = Bun.env
+  env = Bun.env,
+  capabilities
 }) {
   const storedCredentials = readStoredCredentials(env);
   if (config5.provider === "openai-compatible" || config5.provider === "opencode-zen" || config5.provider === "openrouter") {
-    return resolveOpenAITransportModel({ config: config5, env, storedCredentials });
+    return resolveOpenAITransportModel({
+      config: config5,
+      env,
+      storedCredentials,
+      capabilities
+    });
   }
   return resolveAnthropicModel({ config: config5, env, storedCredentials });
 }
@@ -6331,13 +6890,18 @@ function createConfigStatus({
     baseUrl: resolvedProviderModel.baseUrl,
     defaultMode: config5.defaultMode,
     permissionMode: config5.permissionMode ?? null,
-    maxOutputTokens: config5.maxOutputTokens,
+    maxOutputTokens: resolveMaxOutputTokens(config5.maxOutputTokens, lightcodeConfigDefaults.maxOutputTokens, resolvedProviderModel.maxCompletionTokens),
     maxSteps: config5.maxSteps,
     autoContinue: config5.autoContinue,
     contextWindow: resolveContextWindowTokens({
       config: config5.context,
       modelContextWindow: resolvedProviderModel.contextWindow
     }),
+    headroom: {
+      enabled: config5.headroom?.enabled ?? false,
+      proxyUrl: config5.headroom?.proxyUrl ?? null,
+      routed: resolvedProviderModel.headroomRouted
+    },
     missingCredentialHints: resolvedProviderModel.missingCredentialHints
   });
 }
@@ -6352,11 +6916,130 @@ var init_provider_registry = __esm(() => {
 });
 
 // apps/server/src/lib/runtime-config.ts
-var lightcodeConfigResult, resolvedProviderModel, configStatus, chatModelId, codingAgentPromptOverride, codingAgent;
+var exports_runtime_config = {};
+__export(exports_runtime_config, {
+  resolvedProviderModel: () => resolvedProviderModel,
+  lightcodeConfigResult: () => lightcodeConfigResult,
+  initializeModelCapabilities: () => initializeModelCapabilities,
+  disableHeadroomRouting: () => disableHeadroomRouting,
+  configStatus: () => configStatus,
+  codingAgent: () => codingAgent,
+  chatModelId: () => chatModelId,
+  applyModelSelection: () => applyModelSelection
+});
+function buildCodingAgent(config5, model) {
+  return createCodingAgent({
+    model: model.model,
+    promptOverride: codingAgentPromptOverride,
+    providerOptions: model.providerOptions,
+    maxSteps: config5.maxSteps,
+    maxRetries: config5.maxRetries,
+    maxOutputTokens: resolveMaxOutputTokens(config5.maxOutputTokens, lightcodeConfigDefaults.maxOutputTokens, model.maxCompletionTokens),
+    includeToolDiscipline: model.needsToolCallDiscipline ?? false
+  });
+}
+function applyModelSelection({
+  provider,
+  model,
+  capabilities,
+  persist = true
+}) {
+  const nextConfig = {
+    ...lightcodeConfigResult.config,
+    provider,
+    model
+  };
+  const nextResolved = resolveConfiguredProviderModel({
+    config: nextConfig,
+    env: Bun.env,
+    capabilities
+  });
+  const nextAgent = buildCodingAgent(nextConfig, nextResolved);
+  if (persist) {
+    const { path: path11 } = updateUserSettings({ provider, model }, Bun.env);
+    logger5.info("model_selection_persisted", { path: path11, provider, model });
+  }
+  lightcodeConfigResult = {
+    ...lightcodeConfigResult,
+    config: nextConfig
+  };
+  resolvedProviderModel = nextResolved;
+  chatModelId = nextResolved.resolvedModelId;
+  codingAgent = nextAgent;
+  configStatus = createConfigStatus({
+    config: nextConfig,
+    loadedFiles: lightcodeConfigResult.loadedFiles,
+    resolvedProviderModel: nextResolved
+  });
+  logger5.info("model_selection_applied", {
+    provider,
+    model,
+    contextWindow: nextResolved.contextWindow,
+    supportsNativeTools: capabilities?.supportsNativeTools ?? null
+  });
+  return configStatus;
+}
+function disableHeadroomRouting() {
+  if (!lightcodeConfigResult.config.headroom?.enabled) {
+    return;
+  }
+  const nextConfig = {
+    ...lightcodeConfigResult.config,
+    headroom: {
+      ...lightcodeConfigResult.config.headroom ?? lightcodeConfigDefaults.headroom,
+      enabled: false
+    }
+  };
+  const nextResolved = resolveConfiguredProviderModel({
+    config: nextConfig,
+    env: Bun.env
+  });
+  const nextAgent = buildCodingAgent(nextConfig, nextResolved);
+  lightcodeConfigResult = {
+    ...lightcodeConfigResult,
+    config: nextConfig
+  };
+  resolvedProviderModel = nextResolved;
+  chatModelId = nextResolved.resolvedModelId;
+  codingAgent = nextAgent;
+  configStatus = createConfigStatus({
+    config: nextConfig,
+    loadedFiles: lightcodeConfigResult.loadedFiles,
+    resolvedProviderModel: nextResolved
+  });
+  logger5.info("headroom_routing_disabled", {
+    provider: nextResolved.provider,
+    model: nextResolved.resolvedModelId
+  });
+}
+async function initializeModelCapabilities() {
+  if (lightcodeConfigResult.config.provider !== "openrouter") {
+    return;
+  }
+  const modelId = lightcodeConfigResult.config.model;
+  if (!modelId) {
+    return;
+  }
+  const capabilities = await getOpenRouterModelCapabilities(modelId);
+  if (!capabilities || chatModelId !== modelId) {
+    return;
+  }
+  applyModelSelection({
+    provider: "openrouter",
+    model: modelId,
+    capabilities,
+    persist: false
+  });
+}
+var logger5, codingAgentPromptOverride, lightcodeConfigResult, resolvedProviderModel, configStatus, chatModelId, codingAgent;
 var init_runtime_config = __esm(() => {
   init_src2();
+  init_src();
+  init_openrouter_models();
   init_provider_registry();
+  logger5 = createLogger("runtime-config");
   assertProviderToolSchemaBudget();
+  codingAgentPromptOverride = Bun.env.LIGHTCODE_CODING_AGENT_SYSTEM_PROMPT;
   lightcodeConfigResult = loadLightcodeConfig({
     cwd: process.cwd(),
     env: Bun.env
@@ -6371,15 +7054,7 @@ var init_runtime_config = __esm(() => {
     resolvedProviderModel
   });
   chatModelId = resolvedProviderModel.resolvedModelId;
-  codingAgentPromptOverride = Bun.env.LIGHTCODE_CODING_AGENT_SYSTEM_PROMPT;
-  codingAgent = createCodingAgent({
-    model: resolvedProviderModel.model,
-    promptOverride: codingAgentPromptOverride,
-    providerOptions: resolvedProviderModel.providerOptions,
-    maxSteps: lightcodeConfigResult.config.maxSteps,
-    maxOutputTokens: lightcodeConfigResult.config.maxOutputTokens,
-    includeToolDiscipline: resolvedProviderModel.needsToolCallDiscipline ?? false
-  });
+  codingAgent = buildCodingAgent(lightcodeConfigResult.config, resolvedProviderModel);
 });
 
 // apps/server/src/lib/session-auto-title.ts
@@ -6415,7 +7090,7 @@ Response: ${firstAssistantText.slice(0, AUTO_TITLE_INPUT_PREVIEW_CHARS)}`,
   });
   const title = sanitizeGeneratedTitle(result.text);
   if (title && await applyGeneratedSessionTitle(sessionId, title)) {
-    logger4.info("session_auto_titled", { sessionId, title, model: chatModelId });
+    logger6.info("session_auto_titled", { sessionId, title, model: chatModelId });
   }
 }
 function maybeScheduleSessionAutoTitle({
@@ -6423,20 +7098,20 @@ function maybeScheduleSessionAutoTitle({
   messages
 }) {
   generateSessionTitle({ sessionId, messages }).catch((error) => {
-    logger4.warn("session_auto_title_failed", {
+    logger6.warn("session_auto_title_failed", {
       sessionId,
       error: getErrorMessage(error)
     });
   });
 }
-var logger4, AUTO_TITLE_TIMEOUT_MS = 15000, AUTO_TITLE_MAX_OUTPUT_TOKENS = 24, AUTO_TITLE_INPUT_PREVIEW_CHARS = 600;
+var logger6, AUTO_TITLE_TIMEOUT_MS = 15000, AUTO_TITLE_MAX_OUTPUT_TOKENS = 24, AUTO_TITLE_INPUT_PREVIEW_CHARS = 600;
 var init_session_auto_title = __esm(() => {
   init_src2();
   init_src();
   init_chat_store();
   init_prisma_client();
   init_runtime_config();
-  logger4 = createLogger("session-auto-title");
+  logger6 = createLogger("session-auto-title");
 });
 
 // apps/server/src/lib/chat-stream.ts
@@ -6485,7 +7160,7 @@ async function countPendingChatInteractions(sessionId) {
     });
     return pendingInteractions.interactions.length;
   } catch (error) {
-    logger5.warn("context_compaction_pending_interactions_unavailable", {
+    logger7.warn("context_compaction_pending_interactions_unavailable", {
       sessionId,
       error: getErrorMessage(error)
     });
@@ -6496,7 +7171,7 @@ async function loadSessionContextStateSafe(sessionId) {
   try {
     return await getSessionContextState(sessionId);
   } catch (error) {
-    logger5.warn("context_state_unavailable", {
+    logger7.warn("context_state_unavailable", {
       sessionId,
       error: getErrorMessage(error)
     });
@@ -6545,7 +7220,7 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
       staleSkip: false
     });
   } catch (error) {
-    logger5.error("chat_pre_stream_persist_failed", {
+    logger7.error("chat_pre_stream_persist_failed", {
       sessionId,
       error: getErrorMessage(error)
     });
@@ -6585,7 +7260,7 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
         modelContextWindow: resolvedProviderModel.contextWindow,
         pendingInteractionCount
       });
-      logger5.info("context_auto_compacted", {
+      logger7.info("context_auto_compacted", {
         sessionId,
         tier: compaction.state.tier,
         usedFallback: compaction.usedFallback,
@@ -6594,13 +7269,70 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
         estimatedTokensAfter: view.estimate.tokens
       });
     } catch (error) {
-      logger5.error("context_compaction_failed", {
+      logger7.error("context_compaction_failed", {
         sessionId,
         error: getErrorMessage(error)
       });
     }
   }
-  const providerMessages = view.providerMessages;
+  const overflowPreserve = getOverflowPreserveRecentMessages(sessionId);
+  if (overflowPreserve !== null) {
+    const overflowConfig = {
+      ...contextConfig,
+      preserveRecentMessages: Math.min(overflowPreserve, contextConfig.preserveRecentMessages)
+    };
+    try {
+      const overflowView = buildProviderView({
+        messages: validatedMessages,
+        contextState,
+        config: overflowConfig,
+        modelContextWindow: resolvedProviderModel.contextWindow,
+        pendingInteractionCount: 0
+      });
+      if (overflowView.coveredMessages.length > 0) {
+        const compaction = await compactSessionContext({
+          sessionId,
+          coveredMessages: overflowView.coveredMessages,
+          previousState: contextState,
+          model: resolvedProviderModel.model,
+          modelId: chatModelId,
+          cwd,
+          config: overflowConfig,
+          estimatedTokens: overflowView.estimate.tokens
+        });
+        contextState = compaction.state;
+      }
+      view = buildProviderView({
+        messages: validatedMessages,
+        contextState,
+        config: overflowConfig,
+        modelContextWindow: resolvedProviderModel.contextWindow,
+        pendingInteractionCount: 0
+      });
+      logger7.info("context_overflow_recovery", {
+        sessionId,
+        preserveRecentMessages: overflowConfig.preserveRecentMessages,
+        estimatedTokens: view.estimate.tokens,
+        contextWindow: view.contextWindow,
+        withinWindow: view.estimate.tokens < view.contextWindow,
+        compactedMessages: view.coveredMessages.length
+      });
+    } catch (error) {
+      logger7.error("context_overflow_recovery_failed", {
+        sessionId,
+        error: getErrorMessage(error)
+      });
+    }
+  }
+  const providerMessages = normalizeProviderMessages(view.providerMessages);
+  let overflowNotedThisRequest = false;
+  const noteOverflowForSession = () => {
+    if (overflowNotedThisRequest) {
+      return;
+    }
+    overflowNotedThisRequest = true;
+    noteContextOverflow(sessionId);
+  };
   const persistFinishedMessages = async ({
     isAborted,
     isContinuation,
@@ -6610,6 +7342,9 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
     if (isAborted) {
       return;
     }
+    if (!overflowNotedThisRequest) {
+      clearContextOverflowRounds(sessionId);
+    }
     const fullHistory = mergeFinishedMessagesIntoFullHistory({
       fullMessages: validatedMessages,
       providerMessageCount: providerMessages.length,
@@ -6619,14 +7354,14 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
     });
     const normalizedMessages = removeTrailingEmptyAssistantMessages(fullHistory);
     if (normalizedMessages.length !== fullHistory.length) {
-      logger5.warn("chat_finish_empty_assistant_skipped", { sessionId });
+      logger7.warn("chat_finish_empty_assistant_skipped", { sessionId });
       return;
     }
     const validatedFinishResult = await safeValidateUIMessages2({
       messages: normalizedMessages
     });
     if (!validatedFinishResult.success) {
-      logger5.warn("chat_invalid_finish_payload", {
+      logger7.warn("chat_invalid_finish_payload", {
         sessionId,
         message: validatedFinishResult.error.message
       });
@@ -6660,7 +7395,7 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
         messages: validatedFinishResult.data
       });
     } catch (error) {
-      logger5.error("chat_finish_persist_failed", {
+      logger7.error("chat_finish_persist_failed", {
         sessionId,
         error: getErrorMessage(error)
       });
@@ -6692,7 +7427,7 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
       mode,
       allowedTools
     })) {
-      logger5.info("chat_fast_path", {
+      logger7.info("chat_fast_path", {
         sessionId,
         model: chatModelId
       });
@@ -6701,6 +7436,7 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
         system: fastChatSystemPrompt,
         messages: buildFastChatModelMessages(providerMessages),
         maxOutputTokens: Math.min(lightcodeConfigResult.config.maxOutputTokens, fastChatMaxOutputTokens),
+        maxRetries: lightcodeConfigResult.config.maxRetries,
         providerOptions: resolvedProviderModel.providerOptions,
         abortSignal: c.req.raw.signal
       });
@@ -6719,50 +7455,46 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
           }
         }
       });
-      return result.toUIMessageStreamResponse({
+      return withSseHeartbeat(result.toUIMessageStreamResponse({
         originalMessages: providerMessages,
         generateMessageId: generateId3,
         sendReasoning: false,
         messageMetadata: buildUsageMessageMetadata,
         onError: (error) => {
-          if (isProviderSchemaRejectionError(error)) {
-            incrementChatFailureCounter("provider_schema_rejection", {
-              sessionId
-            });
+          const classified = classifyChatError(error);
+          if (classified.kind === "context_overflow") {
+            noteOverflowForSession();
           }
-          return genericRecoverableMessage;
+          incrementChatFailureCounter(chatFailureClassForErrorKind(classified.kind), { sessionId, statusCode: classified.statusCode });
+          logChatStreamErrorEvent({
+            sessionId,
+            phase: "stream",
+            classified,
+            error
+          });
+          return formatChatStreamError(classified);
         },
         onFinish: persistFinishedMessages
-      });
+      }));
     }
     const mapStreamError = (error) => {
-      if (isProviderSchemaRejectionError(error)) {
-        incrementChatFailureCounter("provider_schema_rejection", {
-          sessionId
-        });
-        return genericRecoverableMessage;
+      const classified = classifyChatError(error);
+      if (classified.kind === "context_overflow") {
+        noteOverflowForSession();
       }
-      if (isProviderBillingOrQuotaError(error)) {
-        incrementChatFailureCounter("provider_billing_quota", {
-          sessionId
-        });
-        return providerBillingOrQuotaMessage;
-      }
-      if (isDisconnectOrTimeoutError(error)) {
-        incrementChatFailureCounter("timeout_disconnect", {
-          sessionId,
-          phase: "stream"
-        });
-        logChatDisconnectEvent({
-          sessionId,
-          phase: "stream",
-          error
-        });
-        return recoverableDisconnectMessage;
-      }
-      return genericRecoverableMessage;
+      incrementChatFailureCounter(chatFailureClassForErrorKind(classified.kind), {
+        sessionId,
+        statusCode: classified.statusCode
+      });
+      logChatStreamErrorEvent({
+        sessionId,
+        phase: "stream",
+        classified,
+        error
+      });
+      return formatChatStreamError(classified);
     };
-    return await createAgentUIStreamResponse({
+    return withSseHeartbeat(await createAgentUIStreamResponse({
       agent: codingAgent,
       uiMessages: providerMessages,
       options: {
@@ -6797,24 +7529,27 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
       },
       onError: mapStreamError,
       onFinish: persistFinishedMessages
-    });
+    }));
   } catch (error) {
-    if (isProviderSchemaRejectionError(error)) {
-      incrementChatFailureCounter("provider_schema_rejection", {
-        sessionId
-      });
+    const classified = classifyChatError(error);
+    if (classified.kind === "context_overflow") {
+      noteContextOverflow(sessionId);
     }
-    if (isProviderBillingOrQuotaError(error)) {
-      incrementChatFailureCounter("provider_billing_quota", {
-        sessionId
-      });
+    incrementChatFailureCounter(chatFailureClassForErrorKind(classified.kind), {
+      sessionId,
+      phase: "pre-stream",
+      statusCode: classified.statusCode
+    });
+    logChatStreamErrorEvent({
+      sessionId,
+      phase: "pre-stream",
+      classified,
+      error
+    });
+    if (classified.kind === "billing") {
       return c.json({ error: providerBillingOrQuotaMessage }, 402);
     }
-    if (isDisconnectOrTimeoutError(error)) {
-      incrementChatFailureCounter("timeout_disconnect", {
-        sessionId,
-        phase: "pre-stream"
-      });
+    if (classified.kind === "network" || classified.kind === "aborted") {
       logChatDisconnectEvent({
         sessionId,
         phase: "pre-stream",
@@ -6823,12 +7558,12 @@ async function streamSessionChat(c, sessionIdentifier, messagesPayload, cwd, mod
       return c.json({ error: recoverableDisconnectMessage }, 503);
     }
     return c.json({
-      error: "Unable to start chat stream.",
+      error: formatChatStreamError(classified),
       details: Bun.env.NODE_ENV === "production" ? undefined : getErrorMessage(error)
     }, 500);
   }
 }
-var logger5, recoverableDisconnectMessage = "Connection interrupted. Please retry or regenerate your last message.", genericRecoverableMessage = "The response stream was interrupted. Please retry.", providerBillingOrQuotaMessage, fastChatSystemPrompt, fastChatMaxOutputTokens = 512, fastChatRecentMessageCount = 6;
+var logger7, recoverableDisconnectMessage = "Connection interrupted. Please retry or regenerate your last message.", providerBillingOrQuotaMessage, fastChatSystemPrompt, fastChatMaxOutputTokens = 512, fastChatRecentMessageCount = 6;
 var init_chat_stream = __esm(() => {
   init_src2();
   init_src();
@@ -6836,10 +7571,12 @@ var init_chat_stream = __esm(() => {
   init_chat_interaction_store();
   init_chat_store();
   init_context_compaction();
+  init_overflow_recovery();
+  init_sse_heartbeat();
   init_context_state_store();
   init_session_auto_title();
   init_runtime_config();
-  logger5 = createLogger("chat-stream");
+  logger7 = createLogger("chat-stream");
   providerBillingOrQuotaMessage = "The configured model provider rejected this request due to billing or quota limits. " + "Update provider credits/quota and retry.";
   fastChatSystemPrompt = "You are Lightcode's friendly coding assistant. For casual conversation, reply briefly and naturally. " + "If the user asks for coding work, say you can help and ask them what they want to change.";
 });
@@ -6850,16 +7587,16 @@ function internalErrorResponse(c, {
   message,
   error
 }) {
-  logger6.error(event, { error: getErrorMessage(error) });
+  logger8.error(event, { error: getErrorMessage(error) });
   return c.json({
     error: message,
     details: Bun.env.NODE_ENV === "production" ? undefined : getErrorMessage(error)
   }, 500);
 }
-var logger6;
+var logger8;
 var init_route_helpers = __esm(() => {
   init_src();
-  logger6 = createLogger("routes");
+  logger8 = createLogger("routes");
 });
 
 // apps/server/src/routes/chat-routes.ts
@@ -7141,6 +7878,59 @@ var init_chat_routes = __esm(() => {
   });
 });
 
+// apps/server/src/routes/config-routes.ts
+import { Hono as Hono2 } from "hono";
+import { z as z35 } from "zod";
+var selectModelRequestSchema, configRoutes;
+var init_config_routes = __esm(() => {
+  init_src2();
+  init_src();
+  init_openrouter_models();
+  init_runtime_config();
+  selectModelRequestSchema = z35.object({
+    provider: lightcodeProviderSchema,
+    model: z35.string().min(1).max(240)
+  });
+  configRoutes = new Hono2().get("/status", (c) => c.json(configStatus)).get("/models", async (c) => {
+    const provider = c.req.query("provider") ?? "openrouter";
+    if (provider !== "openrouter") {
+      return c.json({ error: `Model listing is not supported for provider "${provider}".` }, 400);
+    }
+    try {
+      const { models, fromCache } = await listOpenRouterModels({
+        forceRefresh: c.req.query("refresh") === "1"
+      });
+      return c.json({
+        generatedAt: new Date().toISOString(),
+        provider,
+        fromCache,
+        models
+      });
+    } catch (error) {
+      return c.json({
+        error: `Unable to load OpenRouter models: ${getErrorMessage(error)}`
+      }, 502);
+    }
+  }).put("/model", async (c) => {
+    const parsed = selectModelRequestSchema.safeParse(await c.req.json().catch(() => null));
+    if (!parsed.success) {
+      return c.json({ error: "Invalid model selection payload." }, 400);
+    }
+    const { provider, model } = parsed.data;
+    try {
+      const capabilities = provider === "openrouter" ? await getOpenRouterModelCapabilities(model) : undefined;
+      const status = applyModelSelection({ provider, model, capabilities });
+      return c.json({
+        ok: true,
+        configStatus: status,
+        capabilities: capabilities ?? null
+      });
+    } catch (error) {
+      return c.json({ error: `Unable to switch model: ${getErrorMessage(error)}` }, 400);
+    }
+  });
+});
+
 // apps/server/src/lib/extension-runtime.ts
 function getExtensionRuntimeStatus() {
   const skills = listSkills({ cwd: process.cwd() });
@@ -7171,8 +7961,9 @@ var init_extension_runtime = __esm(() => {
 });
 
 // apps/server/src/routes/diagnostics-routes.ts
-import { existsSync as existsSync7 } from "fs";
-import { Hono as Hono2 } from "hono";
+import { existsSync as existsSync9, readdirSync as readdirSync4 } from "fs";
+import path11 from "path";
+import { Hono as Hono3 } from "hono";
 function combineStatuses(statuses) {
   if (statuses.includes("error")) {
     return "error";
@@ -7305,8 +8096,8 @@ function checkWorkspace() {
   return {
     id: "workspace",
     label: "Workspace",
-    status: existsSync7(cwd) ? "ok" : "error",
-    summary: existsSync7(cwd) ? `Workspace is accessible: ${cwd}` : `Workspace is missing: ${cwd}`,
+    status: existsSync9(cwd) ? "ok" : "error",
+    summary: existsSync9(cwd) ? `Workspace is accessible: ${cwd}` : `Workspace is missing: ${cwd}`,
     details: []
   };
 }
@@ -7427,7 +8218,83 @@ async function buildPermissionsPayload() {
     notes
   });
 }
-var diagnosticsRoutes;
+async function buildConnectivityPayload() {
+  const baseUrl = resolvedProviderModel.baseUrl ?? (resolvedProviderModel.provider === "anthropic" ? "https://api.anthropic.com/v1" : null);
+  const proxyEnvironment = {
+    httpsProxy: Boolean(Bun.env.HTTPS_PROXY ?? Bun.env.https_proxy),
+    httpProxy: Boolean(Bun.env.HTTP_PROXY ?? Bun.env.http_proxy),
+    noProxy: Boolean(Bun.env.NO_PROXY ?? Bun.env.no_proxy),
+    extraCaCerts: Boolean(Bun.env.NODE_EXTRA_CA_CERTS)
+  };
+  if (!baseUrl) {
+    return {
+      generatedAt: new Date().toISOString(),
+      provider: resolvedProviderModel.provider,
+      target: null,
+      reachable: false,
+      statusCode: null,
+      latencyMs: null,
+      error: "No provider base URL is configured.",
+      proxyEnvironment
+    };
+  }
+  const target = new URL("models", baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+  const startedAt = performance.now();
+  try {
+    const response = await fetch(target, {
+      signal: AbortSignal.timeout(connectivityProbeTimeoutMs)
+    });
+    return {
+      generatedAt: new Date().toISOString(),
+      provider: resolvedProviderModel.provider,
+      target: target.toString(),
+      reachable: true,
+      statusCode: response.status,
+      latencyMs: Math.round(performance.now() - startedAt),
+      error: null,
+      proxyEnvironment
+    };
+  } catch (error) {
+    return {
+      generatedAt: new Date().toISOString(),
+      provider: resolvedProviderModel.provider,
+      target: target.toString(),
+      reachable: false,
+      statusCode: null,
+      latencyMs: Math.round(performance.now() - startedAt),
+      error: getErrorMessage(error),
+      proxyEnvironment
+    };
+  }
+}
+async function buildLogsTailPayload(requestedLines) {
+  const directory = getLogDirectory();
+  const lineCount = Math.min(Math.max(Number.isFinite(requestedLines) ? requestedLines : 200, 1), maxLogTailLines);
+  let latestFile = null;
+  try {
+    const logFiles = readdirSync4(directory).filter((name) => /^server-\d{4}-\d{2}-\d{2}\.log$/.test(name)).sort();
+    latestFile = logFiles.at(-1) ?? null;
+  } catch {
+    latestFile = null;
+  }
+  if (!latestFile) {
+    return {
+      generatedAt: new Date().toISOString(),
+      file: null,
+      lines: []
+    };
+  }
+  const filePath = path11.join(directory, latestFile);
+  const content = await Bun.file(filePath).text();
+  const lines = content.split(`
+`).filter((line) => line.length > 0);
+  return {
+    generatedAt: new Date().toISOString(),
+    file: filePath,
+    lines: lines.slice(-lineCount)
+  };
+}
+var connectivityProbeTimeoutMs = 1e4, maxLogTailLines = 1000, diagnosticsRoutes;
 var init_diagnostics_routes = __esm(() => {
   init_src2();
   init_src();
@@ -7436,7 +8303,7 @@ var init_diagnostics_routes = __esm(() => {
   init_prisma_client();
   init_runtime_config();
   init_extension_runtime();
-  diagnosticsRoutes = new Hono2().get("/status", async (c) => c.json(await buildStatusPayload())).get("/doctor", async (c) => c.json(await buildDoctorPayload())).get("/tools", (c) => {
+  diagnosticsRoutes = new Hono3().get("/status", async (c) => c.json(await buildStatusPayload())).get("/logs/tail", async (c) => c.json(await buildLogsTailPayload(Number(c.req.query("lines") ?? 200)))).get("/connectivity", async (c) => c.json(await buildConnectivityPayload())).get("/doctor", async (c) => c.json(await buildDoctorPayload())).get("/tools", (c) => {
     const toolDiagnostics = getToolDiagnostics();
     return c.json(diagnosticsToolsResponseSchema.parse({
       generatedAt: new Date().toISOString(),
@@ -7448,19 +8315,19 @@ var init_diagnostics_routes = __esm(() => {
 
 // apps/server/src/routes/extension-routes.ts
 import { zValidator as zValidator2 } from "@hono/zod-validator";
-import { Hono as Hono3 } from "hono";
-import { z as z34 } from "zod";
+import { Hono as Hono4 } from "hono";
+import { z as z36 } from "zod";
 var skillParamsSchema, mcpServerParamsSchema, extensionRoutes;
 var init_extension_routes = __esm(() => {
   init_src2();
   init_extension_runtime();
-  skillParamsSchema = z34.object({
-    name: z34.string().min(1).max(160)
+  skillParamsSchema = z36.object({
+    name: z36.string().min(1).max(160)
   });
-  mcpServerParamsSchema = z34.object({
-    name: z34.string().min(1).max(120)
+  mcpServerParamsSchema = z36.object({
+    name: z36.string().min(1).max(120)
   });
-  extensionRoutes = new Hono3().get("/skills", (c) => {
+  extensionRoutes = new Hono4().get("/skills", (c) => {
     return c.json(skillListOutputSchema.parse({
       skills: listSkills({ cwd: process.cwd() })
     }));
@@ -7481,18 +8348,15 @@ var init_extension_routes = __esm(() => {
 });
 
 // apps/server/src/routes/root-routes.ts
-import { Hono as Hono4 } from "hono";
+import { Hono as Hono5 } from "hono";
 var rootRoutes;
 var init_root_routes = __esm(() => {
   init_src();
-  init_runtime_config();
-  rootRoutes = new Hono4().get("/", (c) => {
+  rootRoutes = new Hono5().get("/", (c) => {
     return c.json({
       name: productName,
       message: createGreeting("API client")
     });
-  }).get("/config/status", (c) => {
-    return c.json(configStatus);
   });
 });
 
@@ -7501,24 +8365,78 @@ var exports_app = {};
 __export(exports_app, {
   app: () => app
 });
-import { Hono as Hono5 } from "hono";
+import { Hono as Hono6 } from "hono";
 import { bodyLimit } from "hono/body-limit";
 var maxRequestBodyBytes, app;
 var init_app = __esm(() => {
   init_chat_routes();
+  init_config_routes();
   init_diagnostics_routes();
   init_extension_routes();
   init_root_routes();
   maxRequestBodyBytes = 32 * 1024 * 1024;
-  app = new Hono5().use(bodyLimit({
+  app = new Hono6().use(bodyLimit({
     maxSize: maxRequestBodyBytes,
     onError: (c) => c.json({ error: "Request body too large." }, 413)
-  })).route("/", rootRoutes).route("/diagnostics", diagnosticsRoutes).route("/extensions", extensionRoutes).route("/sessions", sessionRoutes);
+  })).route("/", rootRoutes).route("/config", configRoutes).route("/diagnostics", diagnosticsRoutes).route("/extensions", extensionRoutes).route("/sessions", sessionRoutes);
+});
+
+// apps/server/src/lib/headroom-proxy.ts
+var exports_headroom_proxy = {};
+__export(exports_headroom_proxy, {
+  ensureHeadroomRouting: () => ensureHeadroomRouting,
+  checkHeadroomHealth: () => checkHeadroomHealth
+});
+async function checkHeadroomHealth(proxyUrl) {
+  try {
+    await fetch(new URL("/health", proxyUrl), {
+      signal: AbortSignal.timeout(healthCheckTimeoutMs)
+    });
+    return "healthy";
+  } catch {
+    return "down";
+  }
+}
+async function ensureHeadroomRouting() {
+  const headroom = lightcodeConfigResult.config.headroom;
+  if (!headroom?.enabled) {
+    return;
+  }
+  let health;
+  try {
+    health = await checkHeadroomHealth(headroom.proxyUrl);
+  } catch (error) {
+    health = "down";
+    logger9.warn("headroom_health_probe_failed", {
+      proxyUrl: headroom.proxyUrl,
+      error: getErrorMessage(error)
+    });
+  }
+  if (health === "healthy") {
+    logger9.info("headroom_routing_active", { proxyUrl: headroom.proxyUrl });
+    return;
+  }
+  if (headroom.failOpen) {
+    logger9.warn("headroom_unreachable_failing_open", {
+      proxyUrl: headroom.proxyUrl
+    });
+    disableHeadroomRouting();
+    return;
+  }
+  logger9.error("headroom_unreachable_fail_closed", {
+    proxyUrl: headroom.proxyUrl
+  });
+}
+var logger9, healthCheckTimeoutMs = 1500;
+var init_headroom_proxy = __esm(() => {
+  init_src();
+  init_runtime_config();
+  logger9 = createLogger("headroom-proxy");
 });
 
 // apps/server/src/index.ts
 init_src();
-var logger7 = createLogger("server");
+var logger10 = createLogger("server");
 var httpIdleTimeoutSeconds = 30;
 var shutdownForceExitMs = 5000;
 function isChatStreamingRoute(request) {
@@ -7529,7 +8447,11 @@ function isChatStreamingRoute(request) {
   return /^\/sessions\/[^/]+\/chat$/.test(pathname);
 }
 async function startServer() {
-  const port = Number(Bun.env.PORT ?? 3000);
+  const logDirectory = enableFileLogSink(Bun.env);
+  if (logDirectory) {
+    logger10.info("file_log_sink_enabled", { directory: logDirectory });
+  }
+  const port = Number(Bun.env.PORT ?? 4983);
   const hostname = Bun.env.LIGHTCODE_HOST ?? "127.0.0.1";
   let app2;
   try {
@@ -7547,24 +8469,49 @@ async function startServer() {
 `));
     process.exit(1);
   }
-  const server = Bun.serve({
-    idleTimeout: httpIdleTimeoutSeconds,
-    port,
-    hostname,
-    async fetch(request, bunServer) {
-      if (isChatStreamingRoute(request)) {
-        bunServer.timeout(request, 0);
-      }
-      return app2.fetch(request);
-    }
+  Promise.resolve().then(() => (init_runtime_config(), exports_runtime_config)).then((runtime19) => runtime19.initializeModelCapabilities()).catch((error) => {
+    logger10.warn("model_capability_init_failed", {
+      error: getErrorMessage(error)
+    });
+  });
+  Promise.resolve().then(() => (init_headroom_proxy(), exports_headroom_proxy)).then((headroom) => headroom.ensureHeadroomRouting()).catch((error) => {
+    logger10.warn("headroom_init_failed", {
+      error: getErrorMessage(error)
+    });
   });
+  let server;
+  try {
+    server = Bun.serve({
+      idleTimeout: httpIdleTimeoutSeconds,
+      port,
+      hostname,
+      async fetch(request, bunServer) {
+        if (isChatStreamingRoute(request)) {
+          bunServer.timeout(request, 0);
+        }
+        return app2.fetch(request);
+      }
+    });
+  } catch (error) {
+    process.stderr.write([
+      "",
+      `Lightcode server could not bind ${hostname}:${port}:`,
+      `  ${getErrorMessage(error)}`,
+      "",
+      "Another process is likely using this port. Set PORT (or",
+      "LIGHTCODE_API_URL for the CLI) to a free port and restart.",
+      ""
+    ].join(`
+`));
+    process.exit(1);
+  }
   let shuttingDown = false;
   const shutdown = async (signal) => {
     if (shuttingDown) {
       return;
     }
     shuttingDown = true;
-    logger7.info("server_shutdown", { signal });
+    logger10.info("server_shutdown", { signal });
     const forceExitTimer = setTimeout(() => {
       server.stop(true);
       process.exit(0);